xonecas.io
60255
Zn

Zoea-Nova / files

Zoea-Nova / internal / provider / mock.go

3.5 KB
1package provider
2
3import (
4	"context"
5	"sync"
6	"time"
7)
8
9// MockProvider is a test provider that returns predefined responses.
10type MockProvider struct {
11	mu sync.RWMutex
12
13	name      string
14	response  string
15	toolCalls []ToolCall
16	streamErr error
17	chatErr   error
18	reasoning string
19	delay     time.Duration
20}
21
22// NewMock creates a new mock provider.
23func NewMock(name, response string) *MockProvider {
24	return &MockProvider{
25		name:     name,
26		response: response,
27	}
28}
29
30type MockFactory struct {
31	name     string
32	response string
33}
34
35func NewMockFactory(name, response string) *MockFactory {
36	return &MockFactory{name: name, response: response}
37}
38
39func (f *MockFactory) Name() string { return f.name }
40
41func (f *MockFactory) Create(model string, temperature float64) Provider {
42	return NewMock(f.name, f.response)
43}
44
45// WithChatError sets an error to return from Chat.
46func (p *MockProvider) WithChatError(err error) *MockProvider {
47	p.mu.Lock()
48	defer p.mu.Unlock()
49	p.chatErr = err
50	return p
51}
52
53// WithStreamError sets an error to return from Stream.
54func (p *MockProvider) WithStreamError(err error) *MockProvider {
55	p.mu.Lock()
56	defer p.mu.Unlock()
57	p.streamErr = err
58	return p
59}
60
61// WithToolCalls sets tool calls to return from ChatWithTools.
62func (p *MockProvider) WithToolCalls(calls []ToolCall) *MockProvider {
63	p.mu.Lock()
64	defer p.mu.Unlock()
65	p.toolCalls = calls
66	return p
67}
68
69func (p *MockProvider) WithReasoning(reasoning string) *MockProvider {
70	p.mu.Lock()
71	defer p.mu.Unlock()
72	p.reasoning = reasoning
73	return p
74}
75
76func (p *MockProvider) SetDelay(delay time.Duration) *MockProvider {
77	p.mu.Lock()
78	defer p.mu.Unlock()
79	p.delay = delay
80	return p
81}
82
83// WithResponse sets the predefined response to return from Chat.
84func (p *MockProvider) WithResponse(response string) *MockProvider {
85	p.mu.Lock()
86	defer p.mu.Unlock()
87	p.response = response
88	return p
89}
90
91// Name returns the provider identifier.
92func (p *MockProvider) Name() string {
93	return p.name
94}
95
96// Chat returns the predefined response or error.
97func (p *MockProvider) Chat(ctx context.Context, messages []Message) (string, error) {
98	if err := p.waitDelay(ctx); err != nil {
99		return "", err
100	}
101
102	p.mu.RLock()
103	defer p.mu.RUnlock()
104	if p.chatErr != nil {
105		return "", p.chatErr
106	}
107	return p.response, nil
108}
109
110// ChatWithTools returns the predefined response or tool calls.
111func (p *MockProvider) ChatWithTools(ctx context.Context, messages []Message, tools []Tool) (*ChatResponse, error) {
112	if err := p.waitDelay(ctx); err != nil {
113		return nil, err
114	}
115
116	p.mu.RLock()
117	defer p.mu.RUnlock()
118	if p.chatErr != nil {
119		return nil, p.chatErr
120	}
121	return &ChatResponse{
122		Content:   p.response,
123		ToolCalls: p.toolCalls,
124		Reasoning: p.reasoning,
125	}, nil
126}
127
128// Stream returns the predefined response as a single chunk.
129func (p *MockProvider) Stream(ctx context.Context, messages []Message) (<-chan StreamChunk, error) {
130	if err := p.waitDelay(ctx); err != nil {
131		return nil, err
132	}
133
134	p.mu.RLock()
135	defer p.mu.RUnlock()
136	if p.streamErr != nil {
137		return nil, p.streamErr
138	}
139
140	ch := make(chan StreamChunk, 2)
141	response := p.response
142	go func() {
143		defer close(ch)
144		ch <- StreamChunk{Content: response}
145		ch <- StreamChunk{Done: true}
146	}()
147
148	return ch, nil
149}
150
151func (p *MockProvider) waitDelay(ctx context.Context) error {
152	p.mu.RLock()
153	delay := p.delay
154	p.mu.RUnlock()
155	if delay <= 0 {
156		return nil
157	}
158
159	timer := time.NewTimer(delay)
160	defer timer.Stop()
161
162	select {
163	case <-ctx.Done():
164		return ctx.Err()
165	case <-timer.C:
166		return nil
167	}
168}
169
170// Close is a no-op for mock provider (no resources to clean up).
171func (p *MockProvider) Close() error {
172	return nil
173}