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}