xonecas.io
60255
Zn

Zoea-Nova / commit d5c6153

fix(infra): improve test reliability with SQLite and concurrency fixes

- Add MaxOpenConns(1) and busy_timeout to SQLite to prevent locking
- Add mutex to MockProvider for thread-safe test access
- Add WithResponse() method to MockProvider for dynamic responses
- Increase EventBus minimum buffer size to 1000

xonecas2026-02-04 d5c6153b6e868a5c48b5c89f5cdf27db26121ddf parent 470d781

3 files changed

internal/core/bus.go+2−2
@@ -13,8 +13,8 @@ type EventBus struct {
1313
1414 // NewEventBus creates a new event bus.
1515 func NewEventBus(bufferSize int) *EventBus {
16- if bufferSize < 1 {
17- bufferSize = 100
16+ if bufferSize < 1000 {
17+ bufferSize = 1000
1818 }
1919 return &EventBus{
2020 bufferSize: bufferSize,
internal/provider/mock.go+25−1
@@ -2,10 +2,13 @@ package provider
22
33 import (
44 "context"
5+ "sync"
56 )
67
78 // MockProvider is a test provider that returns predefined responses.
89 type MockProvider struct {
10+ mu sync.RWMutex
11+
912 name string
1013 response string
1114 toolCalls []ToolCall
@@ -23,22 +26,36 @@ func NewMock(name, response string) *MockProvider {
2326
2427 // WithChatError sets an error to return from Chat.
2528 func (p *MockProvider) WithChatError(err error) *MockProvider {
29+ p.mu.Lock()
30+ defer p.mu.Unlock()
2631 p.chatErr = err
2732 return p
2833 }
2934
3035 // WithStreamError sets an error to return from Stream.
3136 func (p *MockProvider) WithStreamError(err error) *MockProvider {
37+ p.mu.Lock()
38+ defer p.mu.Unlock()
3239 p.streamErr = err
3340 return p
3441 }
3542
3643 // WithToolCalls sets tool calls to return from ChatWithTools.
3744 func (p *MockProvider) WithToolCalls(calls []ToolCall) *MockProvider {
45+ p.mu.Lock()
46+ defer p.mu.Unlock()
3847 p.toolCalls = calls
3948 return p
4049 }
4150
51+// WithResponse sets the predefined response to return from Chat.
52+func (p *MockProvider) WithResponse(response string) *MockProvider {
53+ p.mu.Lock()
54+ defer p.mu.Unlock()
55+ p.response = response
56+ return p
57+}
58+
4259 // Name returns the provider identifier.
4360 func (p *MockProvider) Name() string {
4461 return p.name
@@ -46,6 +63,8 @@ func (p *MockProvider) Name() string {
4663
4764 // Chat returns the predefined response or error.
4865 func (p *MockProvider) Chat(ctx context.Context, messages []Message) (string, error) {
66+ p.mu.RLock()
67+ defer p.mu.RUnlock()
4968 if p.chatErr != nil {
5069 return "", p.chatErr
5170 }
@@ -54,6 +73,8 @@ func (p *MockProvider) Chat(ctx context.Context, messages []Message) (string, er
5473
5574 // ChatWithTools returns the predefined response or tool calls.
5675 func (p *MockProvider) ChatWithTools(ctx context.Context, messages []Message, tools []Tool) (*ChatResponse, error) {
76+ p.mu.RLock()
77+ defer p.mu.RUnlock()
5778 if p.chatErr != nil {
5879 return nil, p.chatErr
5980 }
@@ -65,14 +86,17 @@ func (p *MockProvider) ChatWithTools(ctx context.Context, messages []Message, to
6586
6687 // Stream returns the predefined response as a single chunk.
6788 func (p *MockProvider) Stream(ctx context.Context, messages []Message) (<-chan StreamChunk, error) {
89+ p.mu.RLock()
90+ defer p.mu.RUnlock()
6891 if p.streamErr != nil {
6992 return nil, p.streamErr
7093 }
7194
7295 ch := make(chan StreamChunk, 2)
96+ response := p.response
7397 go func() {
7498 defer close(ch)
75- ch <- StreamChunk{Content: p.response}
99+ ch <- StreamChunk{Content: response}
76100 ch <- StreamChunk{Done: true}
77101 }()
78102
internal/store/store.go+15−4
@@ -6,6 +6,7 @@ import (
66 _ "embed"
77 "fmt"
88 "path/filepath"
9+ "strings"
910
1011 "github.com/xonecas/zoea-nova/internal/config"
1112 _ "modernc.org/sqlite"
@@ -34,12 +35,22 @@ func New() (*Store, error) {
3435
3536 // Open opens a database at the given path.
3637 func Open(path string) (*Store, error) {
37- db, err := sql.Open("sqlite", path)
38+ // Add busy timeout to handle concurrent access
39+ dsn := path
40+ if !strings.Contains(path, "?") {
41+ dsn += "?_busy_timeout=5000"
42+ }
43+
44+ db, err := sql.Open("sqlite", dsn)
3845 if err != nil {
3946 return nil, fmt.Errorf("open database: %w", err)
4047 }
4148
42- // Enable WAL mode for better concurrent access
49+ // Limit to 1 connection to avoid "database is locked" errors with modernc.org/sqlite
50+ // especially during tests with concurrent writes.
51+ db.SetMaxOpenConns(1)
52+
53+ // Enable WAL mode for better concurrent access (though limited by MaxOpenConns=1)
4354 if _, err := db.Exec("PRAGMA journal_mode=WAL"); err != nil {
4455 db.Close()
4556 return nil, fmt.Errorf("enable WAL: %w", err)
@@ -75,8 +86,8 @@ func (s *Store) migrate() error {
7586 // Check current version
7687 var version int
7788 err := s.db.QueryRow("SELECT version FROM schema_version LIMIT 1").Scan(&version)
78- if err != nil && err != sql.ErrNoRows {
79- // Table doesn't exist, create fresh schema
89+ if err != nil {
90+ // Table doesn't exist or is empty, create fresh schema
8091 if _, err := s.db.Exec(schema); err != nil {
8192 return fmt.Errorf("create schema: %w", err)
8293 }