6119
My
mysis / files
mysis / 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}