xonecas.io
6119
My

mysis / files

mysis / internal / provider / provider_test.go

15.2 KB
1package provider
2
3import (
4	"context"
5	"encoding/json"
6	"errors"
7	"strings"
8	"testing"
9	"time"
10)
11
12func TestRegistry(t *testing.T) {
13	reg := NewRegistry()
14
15	// Register mock providers
16	reg.RegisterFactory("provider1", NewMockFactory("provider1", "response1"))
17	reg.RegisterFactory("provider2", NewMockFactory("provider2", "response2"))
18
19	// Get existing provider
20	p, err := reg.Create("provider1", "model", 0.7)
21	if err != nil {
22		t.Fatalf("Create() error: %v", err)
23	}
24	if p.Name() != "provider1" {
25		t.Errorf("expected name=provider1, got %s", p.Name())
26	}
27
28	// Get non-existent provider
29	_, err = reg.Create("nonexistent", "model", 0.7)
30	if !errors.Is(err, ErrProviderNotFound) {
31		t.Errorf("expected ErrProviderNotFound, got %v", err)
32	}
33
34	// List providers
35	names := reg.List()
36	if len(names) != 2 {
37		t.Errorf("expected 2 providers, got %d", len(names))
38	}
39}
40
41func TestMockProviderChat(t *testing.T) {
42	mock := NewMock("test", "Hello, World!")
43
44	ctx := context.Background()
45	messages := make([]Message, 0, 1)
46	messages = append(messages, Message{Role: "user", Content: "Hi"})
47
48	response, err := mock.Chat(ctx, messages)
49	if err != nil {
50		t.Fatalf("Chat() error: %v", err)
51	}
52	if response != "Hello, World!" {
53		t.Errorf("expected 'Hello, World!', got %s", response)
54	}
55}
56
57func TestMockProviderChatDelay(t *testing.T) {
58	delay := 30 * time.Millisecond
59	mock := NewMock("test", "ok").SetDelay(delay)
60
61	ctx := context.Background()
62	messages := make([]Message, 0, 1)
63	messages = append(messages, Message{Role: "user", Content: "Hi"})
64
65	start := time.Now()
66	_, err := mock.Chat(ctx, messages)
67	if err != nil {
68		t.Fatalf("Chat() error: %v", err)
69	}
70	elapsed := time.Since(start)
71	if elapsed < delay {
72		t.Fatalf("expected delay >= %v, got %v", delay, elapsed)
73	}
74}
75
76func TestMockProviderChatWithToolsDelay(t *testing.T) {
77	delay := 25 * time.Millisecond
78	mock := NewMock("test", "ok").SetDelay(delay)
79
80	ctx := context.Background()
81	messages := make([]Message, 0, 1)
82	messages = append(messages, Message{Role: "user", Content: "Hi"})
83
84	start := time.Now()
85	_, err := mock.ChatWithTools(ctx, messages, nil)
86	if err != nil {
87		t.Fatalf("ChatWithTools() error: %v", err)
88	}
89	elapsed := time.Since(start)
90	if elapsed < delay {
91		t.Fatalf("expected delay >= %v, got %v", delay, elapsed)
92	}
93}
94
95func TestMockProviderChatDelayContextCancel(t *testing.T) {
96	mock := NewMock("test", "ok").SetDelay(100 * time.Millisecond)
97
98	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Millisecond)
99	defer cancel()
100
101	messages := make([]Message, 0, 1)
102	messages = append(messages, Message{Role: "user", Content: "Hi"})
103	_, err := mock.Chat(ctx, messages)
104	if err == nil {
105		t.Fatal("expected context deadline error")
106	}
107}
108
109func TestMockProviderChatError(t *testing.T) {
110	expectedErr := errors.New("chat error")
111	mock := NewMock("test", "").WithChatError(expectedErr)
112
113	ctx := context.Background()
114	messages := make([]Message, 0, 1)
115	messages = append(messages, Message{Role: "user", Content: "Hi"})
116
117	_, err := mock.Chat(ctx, messages)
118	if !errors.Is(err, expectedErr) {
119		t.Errorf("expected %v, got %v", expectedErr, err)
120	}
121}
122
123func TestMockProviderStream(t *testing.T) {
124	mock := NewMock("test", "Streamed response")
125
126	ctx := context.Background()
127	messages := make([]Message, 0, 1)
128	messages = append(messages, Message{Role: "user", Content: "Hi"})
129
130	ch, err := mock.Stream(ctx, messages)
131	if err != nil {
132		t.Fatalf("Stream() error: %v", err)
133	}
134
135	var content string
136	var done bool
137	for chunk := range ch {
138		if chunk.Err != nil {
139			t.Fatalf("Stream chunk error: %v", chunk.Err)
140		}
141		if chunk.Done {
142			done = true
143			continue
144		}
145		content += chunk.Content
146	}
147
148	if content != "Streamed response" {
149		t.Errorf("expected 'Streamed response', got %s", content)
150	}
151	if !done {
152		t.Error("expected done=true")
153	}
154}
155
156func TestMockProviderStreamError(t *testing.T) {
157	expectedErr := errors.New("stream error")
158	mock := NewMock("test", "").WithStreamError(expectedErr)
159
160	ctx := context.Background()
161	messages := make([]Message, 0, 1)
162	messages = append(messages, Message{Role: "user", Content: "Hi"})
163
164	_, err := mock.Stream(ctx, messages)
165	if !errors.Is(err, expectedErr) {
166		t.Errorf("expected %v, got %v", expectedErr, err)
167	}
168}
169
170func TestOllamaProviderName(t *testing.T) {
171	p := NewOllama("http://localhost:11434", "llama3")
172	if p.Name() != "ollama" {
173		t.Errorf("expected name=ollama, got %s", p.Name())
174	}
175}
176
177func TestOpenCodeProviderName(t *testing.T) {
178	p := NewOpenCode("https://api.opencode.ai/v1", "zen-default", "test-key")
179	if p.Name() != "opencode_zen" {
180		t.Errorf("expected name=opencode_zen, got %s", p.Name())
181	}
182}
183
184func TestToOpenAIMessages(t *testing.T) {
185	messages := make([]Message, 0, 3)
186	messages = append(messages,
187		Message{Role: "system", Content: "You are helpful."},
188		Message{Role: "user", Content: "Hello"},
189		Message{Role: "assistant", Content: "Hi there!"},
190	)
191
192	result := toOpenAIMessages(messages)
193
194	if len(result) != 3 {
195		t.Fatalf("expected 3 messages, got %d", len(result))
196	}
197	if result[0].Role != "system" {
198		t.Errorf("expected role=system, got %s", result[0].Role)
199	}
200	if result[1].Content != "Hello" {
201		t.Errorf("expected content=Hello, got %s", result[1].Content)
202	}
203}
204
205func TestToOpenAIMessagesWithToolCalls(t *testing.T) {
206	messages := make([]Message, 0, 3)
207	messages = append(messages,
208		Message{Role: "user", Content: "What's the weather?"},
209		Message{
210			Role:    "assistant",
211			Content: "",
212			ToolCalls: []ToolCall{
213				{ID: "call_123", Name: "get_weather", Arguments: json.RawMessage(`{"location":"NYC"}`)},
214			},
215		},
216		Message{Role: "tool", Content: `{"temp": 72}`, ToolCallID: "call_123"},
217	)
218
219	result := toOpenAIMessages(messages)
220
221	if len(result) != 3 {
222		t.Fatalf("expected 3 messages, got %d", len(result))
223	}
224
225	// Check assistant message has tool calls
226	assistantMsg := result[1]
227	if len(assistantMsg.ToolCalls) != 1 {
228		t.Fatalf("expected 1 tool call, got %d", len(assistantMsg.ToolCalls))
229	}
230	if assistantMsg.ToolCalls[0].ID != "call_123" {
231		t.Errorf("expected tool call ID=call_123, got %s", assistantMsg.ToolCalls[0].ID)
232	}
233	if assistantMsg.ToolCalls[0].Function.Name != "get_weather" {
234		t.Errorf("expected function name=get_weather, got %s", assistantMsg.ToolCalls[0].Function.Name)
235	}
236
237	// Check tool result message has ToolCallID
238	toolMsg := result[2]
239	if toolMsg.ToolCallID != "call_123" {
240		t.Errorf("expected ToolCallID=call_123, got %s", toolMsg.ToolCallID)
241	}
242}
243
244func TestMockProviderChatWithTools(t *testing.T) {
245	toolCalls := []ToolCall{
246		{ID: "call_abc", Name: "test_tool", Arguments: json.RawMessage(`{}`)},
247	}
248	mock := NewMock("test", "thinking...").WithToolCalls(toolCalls)
249
250	ctx := context.Background()
251	messages := make([]Message, 0, 1)
252	messages = append(messages, Message{Role: "user", Content: "Do something"})
253	tools := []Tool{{Name: "test_tool", Description: "A test tool"}}
254
255	resp, err := mock.ChatWithTools(ctx, messages, tools)
256	if err != nil {
257		t.Fatalf("ChatWithTools() error: %v", err)
258	}
259
260	if resp.Content != "thinking..." {
261		t.Errorf("expected content='thinking...', got %s", resp.Content)
262	}
263	if len(resp.ToolCalls) != 1 {
264		t.Fatalf("expected 1 tool call, got %d", len(resp.ToolCalls))
265	}
266	if resp.ToolCalls[0].Name != "test_tool" {
267		t.Errorf("expected tool name=test_tool, got %s", resp.ToolCalls[0].Name)
268	}
269}
270
271func TestMockProviderChatWithToolsError(t *testing.T) {
272	expectedErr := errors.New("tools error")
273	mock := NewMock("test", "").WithChatError(expectedErr)
274
275	ctx := context.Background()
276	messages := make([]Message, 0, 1)
277	messages = append(messages, Message{Role: "user", Content: "Do something"})
278	tools := []Tool{{Name: "test_tool", Description: "A test tool"}}
279
280	_, err := mock.ChatWithTools(ctx, messages, tools)
281	if !errors.Is(err, expectedErr) {
282		t.Errorf("expected %v, got %v", expectedErr, err)
283	}
284}
285
286func TestMockProviderWithResponse(t *testing.T) {
287	mock := NewMock("test", "initial")
288
289	ctx := context.Background()
290	messages := make([]Message, 0, 1)
291	messages = append(messages, Message{Role: "user", Content: "Hi"})
292
293	// Initial response
294	resp, _ := mock.Chat(ctx, messages)
295	if resp != "initial" {
296		t.Errorf("expected 'initial', got %s", resp)
297	}
298
299	// Change response
300	mock.WithResponse("updated")
301	resp, _ = mock.Chat(ctx, messages)
302	if resp != "updated" {
303		t.Errorf("expected 'updated', got %s", resp)
304	}
305}
306
307func TestMockProviderWithReasoning(t *testing.T) {
308	reasoning := "thinking..."
309	mock := NewMock("test", "response").WithReasoning(reasoning)
310
311	ctx := context.Background()
312	messages := make([]Message, 0, 1)
313	messages = append(messages, Message{Role: "user", Content: "Hi"})
314	tools := []Tool{{Name: "test_tool", Description: "A test tool"}}
315
316	resp, err := mock.ChatWithTools(ctx, messages, tools)
317	if err != nil {
318		t.Fatalf("ChatWithTools() error: %v", err)
319	}
320	if resp.Reasoning != reasoning {
321		t.Errorf("expected reasoning=%q, got %q", reasoning, resp.Reasoning)
322	}
323}
324
325func TestMockProviderConcurrentAccess(t *testing.T) {
326	mock := NewMock("test", "response")
327	ctx := context.Background()
328	messages := make([]Message, 0, 1)
329	messages = append(messages, Message{Role: "user", Content: "Hi"})
330
331	// Run concurrent reads and writes
332	done := make(chan bool)
333	for i := 0; i < 10; i++ {
334		go func() {
335			_, _ = mock.Chat(ctx, messages)
336			done <- true
337		}()
338		go func() {
339			mock.WithResponse("new response")
340			done <- true
341		}()
342	}
343
344	// Wait for all goroutines
345	for i := 0; i < 20; i++ {
346		<-done
347	}
348}
349
350func TestToOpenAIMessagesEmpty(t *testing.T) {
351	result := toOpenAIMessages([]Message{})
352	if len(result) != 0 {
353		t.Errorf("expected empty slice, got %d messages", len(result))
354	}
355}
356
357func TestToOpenAIMessagesMultipleToolCalls(t *testing.T) {
358	messages := make([]Message, 0, 1)
359	messages = append(messages, Message{
360		Role:    "assistant",
361		Content: "",
362		ToolCalls: []ToolCall{
363			{ID: "call_1", Name: "tool_a", Arguments: json.RawMessage(`{"a":1}`)},
364			{ID: "call_2", Name: "tool_b", Arguments: json.RawMessage(`{"b":2}`)},
365		},
366	})
367
368	result := toOpenAIMessages(messages)
369
370	if len(result[0].ToolCalls) != 2 {
371		t.Fatalf("expected 2 tool calls, got %d", len(result[0].ToolCalls))
372	}
373	if result[0].ToolCalls[0].Function.Arguments != `{"a":1}` {
374		t.Errorf("expected arguments={\"a\":1}, got %s", result[0].ToolCalls[0].Function.Arguments)
375	}
376	if result[0].ToolCalls[1].Function.Arguments != `{"b":2}` {
377		t.Errorf("expected arguments={\"b\":2}, got %s", result[0].ToolCalls[1].Function.Arguments)
378	}
379}
380
381func TestToOllamaMessagesSerializesEmptyContent(t *testing.T) {
382	messages := make([]Message, 0, 1)
383	messages = append(messages, Message{Role: "assistant", Content: ""})
384
385	result := toOllamaMessages(messages)
386	if len(result) != 1 {
387		t.Fatalf("expected 1 message, got %d", len(result))
388	}
389
390	data, err := json.Marshal(result[0])
391	if err != nil {
392		t.Fatalf("marshal error: %v", err)
393	}
394
395	if !strings.Contains(string(data), `"content":""`) {
396		t.Fatalf("expected content field to be serialized, got %s", string(data))
397	}
398}
399
400func TestRegistry_MultipleProvidersWithSameFactory(t *testing.T) {
401	registry := NewRegistry()
402
403	// Register two providers using same factory type
404	factory1 := NewMockFactory("mock1", "response1")
405	factory2 := NewMockFactory("mock2", "response2")
406
407	registry.RegisterFactory("provider-one", factory1)
408	registry.RegisterFactory("provider-two", factory2)
409
410	// Should be able to create both
411	p1, err := registry.Create("provider-one", "model1", 0.7)
412	if err != nil {
413		t.Fatalf("Create provider-one failed: %v", err)
414	}
415
416	p2, err := registry.Create("provider-two", "model2", 0.7)
417	if err != nil {
418		t.Fatalf("Create provider-two failed: %v", err)
419	}
420
421	// Should be different instances
422	if p1 == p2 {
423		t.Error("Expected different provider instances")
424	}
425
426	// Verify correct responses
427	ctx := context.Background()
428	messages := make([]Message, 0, 1)
429	messages = append(messages, Message{Role: "user", Content: "Hi"})
430
431	resp1, err := p1.Chat(ctx, messages)
432	if err != nil {
433		t.Fatalf("p1.Chat() error: %v", err)
434	}
435	if resp1 != "response1" {
436		t.Errorf("expected response1, got %s", resp1)
437	}
438
439	resp2, err := p2.Chat(ctx, messages)
440	if err != nil {
441		t.Fatalf("p2.Chat() error: %v", err)
442	}
443	if resp2 != "response2" {
444		t.Errorf("expected response2, got %s", resp2)
445	}
446}
447
448func TestRegistry_ConfigKeyOverridesFactoryName(t *testing.T) {
449	registry := NewRegistry()
450
451	// Factory has internal name "ollama", but register it with config key "ollama-llama"
452	factory := NewMockFactory("ollama", "llama-response")
453	registry.RegisterFactory("ollama-llama", factory)
454
455	// Should be accessible by config key, not factory name
456	p, err := registry.Create("ollama-llama", "llama3.1:8b", 0.7)
457	if err != nil {
458		t.Fatalf("Create ollama-llama failed: %v", err)
459	}
460
461	ctx := context.Background()
462	messages := make([]Message, 0, 1)
463	messages = append(messages, Message{Role: "user", Content: "Hi"})
464	resp, err := p.Chat(ctx, messages)
465	if err != nil {
466		t.Fatalf("Chat() error: %v", err)
467	}
468	if resp != "llama-response" {
469		t.Errorf("expected llama-response, got %s", resp)
470	}
471
472	// Should NOT be accessible by factory name
473	_, err = registry.Create("ollama", "model", 0.7)
474	if !errors.Is(err, ErrProviderNotFound) {
475		t.Errorf("expected ErrProviderNotFound for factory name, got %v", err)
476	}
477}
478
479func TestRegistry_ListReturnsConfigKeys(t *testing.T) {
480	registry := NewRegistry()
481
482	// Register with config keys
483	registry.RegisterFactory("zen-nano", NewMockFactory("opencode_zen", "nano"))
484	registry.RegisterFactory("zen-pickle", NewMockFactory("opencode_zen", "pickle"))
485	registry.RegisterFactory("ollama-llama", NewMockFactory("ollama", "llama"))
486	registry.RegisterFactory("ollama-qwen", NewMockFactory("ollama", "qwen"))
487
488	names := registry.List()
489	if len(names) != 4 {
490		t.Fatalf("expected 4 providers, got %d", len(names))
491	}
492
493	// Should contain config keys, not factory names
494	expectedKeys := map[string]bool{
495		"zen-nano":     false,
496		"zen-pickle":   false,
497		"ollama-llama": false,
498		"ollama-qwen":  false,
499	}
500
501	for _, name := range names {
502		if _, ok := expectedKeys[name]; ok {
503			expectedKeys[name] = true
504		} else {
505			t.Errorf("unexpected provider name: %s", name)
506		}
507	}
508
509	for key, found := range expectedKeys {
510		if !found {
511			t.Errorf("expected config key %s not found in list", key)
512		}
513	}
514}
515
516// TestMockProviderClose verifies Close() is idempotent and returns nil.
517func TestMockProviderClose(t *testing.T) {
518	mock := NewMock("test", "response")
519
520	// First close should succeed
521	if err := mock.Close(); err != nil {
522		t.Errorf("first Close() error: %v", err)
523	}
524
525	// Second close should also succeed (idempotent)
526	if err := mock.Close(); err != nil {
527		t.Errorf("second Close() error: %v", err)
528	}
529}
530
531// TestOllamaProviderClose verifies Close() is idempotent and returns nil.
532func TestOllamaProviderClose(t *testing.T) {
533	provider := NewOllama("http://localhost:11434", "llama3")
534
535	// First close should succeed
536	if err := provider.Close(); err != nil {
537		t.Errorf("first Close() error: %v", err)
538	}
539
540	// Second close should also succeed (idempotent)
541	if err := provider.Close(); err != nil {
542		t.Errorf("second Close() error: %v", err)
543	}
544}
545
546// TestOpenCodeProviderClose verifies Close() is idempotent and returns nil.
547func TestOpenCodeProviderClose(t *testing.T) {
548	provider := NewOpenCode("https://api.test.com", "model", "key")
549
550	// First close should succeed
551	if err := provider.Close(); err != nil {
552		t.Errorf("first Close() error: %v", err)
553	}
554
555	// Second close should also succeed (idempotent)
556	if err := provider.Close(); err != nil {
557		t.Errorf("second Close() error: %v", err)
558	}
559}