6119
My
mysis / files
mysis / internal / provider / ollama_test.go
12.5 KB
1package provider 2 3import ( 4 "context" 5 "encoding/json" 6 "net/http" 7 "net/http/httptest" 8 "strings" 9 "testing" 10) 11 12// TestOllama_SystemMessagesAnywhere tests that Ollama provider correctly handles 13// system messages anywhere in the conversation (not just at the start). 14func TestOllama_SystemMessagesAnywhere(t *testing.T) { 15 server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 16 var req struct { 17 Messages []struct { 18 Role string `json:"role"` 19 Content string `json:"content"` 20 } `json:"messages"` 21 } 22 if err := json.NewDecoder(r.Body).Decode(&req); err != nil { 23 t.Fatalf("failed to decode request: %v", err) 24 } 25 26 // Verify message order: system, user, system (merged), assistant 27 // Ollama allows system messages anywhere, but consecutive ones should be merged 28 expectedRoles := []string{"system", "user", "system", "assistant"} 29 if len(req.Messages) != len(expectedRoles) { 30 t.Errorf("expected %d messages, got %d", len(expectedRoles), len(req.Messages)) 31 } 32 33 for i, expected := range expectedRoles { 34 if i >= len(req.Messages) { 35 break 36 } 37 if req.Messages[i].Role != expected { 38 t.Errorf("message %d: expected role=%s, got %s", i, expected, req.Messages[i].Role) 39 } 40 } 41 42 // Verify first system message 43 if !strings.Contains(req.Messages[0].Content, "helpful assistant") { 44 t.Error("expected first system message to contain 'helpful assistant'") 45 } 46 47 // Verify third message merges two consecutive system messages 48 if !strings.Contains(req.Messages[2].Content, "Be concise") { 49 t.Error("expected merged system message to contain 'Be concise'") 50 } 51 if !strings.Contains(req.Messages[2].Content, "Use simple language") { 52 t.Error("expected merged system message to contain 'Use simple language'") 53 } 54 55 w.Header().Set("Content-Type", "application/json") 56 _ = json.NewEncoder(w).Encode(map[string]interface{}{ 57 "choices": []map[string]interface{}{ 58 { 59 "message": map[string]interface{}{ 60 "role": "assistant", 61 "content": "Got it!", 62 }, 63 }, 64 }, 65 }) 66 })) 67 defer server.Close() 68 69 // Remove /v1 suffix since NewOllama adds it 70 baseURL := strings.TrimSuffix(server.URL, "/v1") 71 provider := NewOllama(baseURL, "test-model") 72 ctx := context.Background() 73 74 // System messages at different positions, including consecutive ones 75 messages := make([]Message, 0, 5) 76 messages = append(messages, 77 Message{Role: "system", Content: "You are a helpful assistant."}, 78 Message{Role: "user", Content: "Hello"}, 79 Message{Role: "system", Content: "Be concise in your responses."}, 80 Message{Role: "system", Content: "Use simple language."}, 81 Message{Role: "assistant", Content: "Hi there!"}, 82 ) 83 84 _, err := provider.Chat(ctx, messages) 85 if err != nil { 86 t.Fatalf("Chat() error: %v", err) 87 } 88} 89 90// TestOllama_ConsecutiveSystemMessagesMerge tests that consecutive system messages 91// are merged in place (Ollama-specific behavior). 92func TestOllama_ConsecutiveSystemMessagesMerge(t *testing.T) { 93 server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 94 var req struct { 95 Messages []struct { 96 Role string `json:"role"` 97 Content string `json:"content"` 98 } `json:"messages"` 99 } 100 if err := json.NewDecoder(r.Body).Decode(&req); err != nil { 101 t.Fatalf("failed to decode request: %v", err) 102 } 103 104 // Verify: 3 system messages should be merged into 1 105 systemCount := 0 106 for i, msg := range req.Messages { 107 if msg.Role == "system" { 108 systemCount++ 109 // Should be first message 110 if i != 0 { 111 t.Errorf("expected system message at position 0, got %d", i) 112 } 113 // Should contain all three system prompts merged 114 if !strings.Contains(msg.Content, "instruction one") { 115 t.Error("expected merged system to contain 'instruction one'") 116 } 117 if !strings.Contains(msg.Content, "instruction two") { 118 t.Error("expected merged system to contain 'instruction two'") 119 } 120 if !strings.Contains(msg.Content, "instruction three") { 121 t.Error("expected merged system to contain 'instruction three'") 122 } 123 } 124 } 125 126 if systemCount != 1 { 127 t.Errorf("expected 1 system message after merge, got %d", systemCount) 128 } 129 130 // Total messages should be 2 (1 merged system + 1 user) 131 if len(req.Messages) != 2 { 132 t.Errorf("expected 2 messages total, got %d", len(req.Messages)) 133 } 134 135 w.Header().Set("Content-Type", "application/json") 136 _ = json.NewEncoder(w).Encode(map[string]interface{}{ 137 "choices": []map[string]interface{}{ 138 { 139 "message": map[string]interface{}{ 140 "role": "assistant", 141 "content": "Ready.", 142 }, 143 }, 144 }, 145 }) 146 })) 147 defer server.Close() 148 149 baseURL := strings.TrimSuffix(server.URL, "/v1") 150 provider := NewOllama(baseURL, "test-model") 151 ctx := context.Background() 152 153 // Three consecutive system messages followed by user message 154 messages := make([]Message, 0, 4) 155 messages = append(messages, 156 Message{Role: "system", Content: "This is instruction one."}, 157 Message{Role: "system", Content: "This is instruction two."}, 158 Message{Role: "system", Content: "This is instruction three."}, 159 Message{Role: "user", Content: "Hello"}, 160 ) 161 162 _, err := provider.Chat(ctx, messages) 163 if err != nil { 164 t.Fatalf("Chat() error: %v", err) 165 } 166} 167 168// TestOllama_ToolCalls tests that Ollama provider correctly handles 169// messages with tool calls. 170func TestOllama_ToolCalls(t *testing.T) { 171 requestCount := 0 172 server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 173 requestCount++ 174 175 var req struct { 176 Messages []struct { 177 Role string `json:"role"` 178 Content string `json:"content"` 179 ToolCalls []struct { 180 ID string `json:"id"` 181 Function struct { 182 Name string `json:"name"` 183 Arguments string `json:"arguments"` 184 } `json:"function"` 185 } `json:"tool_calls,omitempty"` 186 ToolCallID string `json:"tool_call_id,omitempty"` 187 } `json:"messages"` 188 Tools []map[string]interface{} `json:"tools,omitempty"` 189 } 190 if err := json.NewDecoder(r.Body).Decode(&req); err != nil { 191 t.Fatalf("failed to decode request: %v", err) 192 } 193 194 w.Header().Set("Content-Type", "application/json") 195 196 // First request: return tool call 197 if requestCount == 1 { 198 // Verify tools are present 199 if len(req.Tools) == 0 { 200 t.Error("expected tools in request") 201 } 202 203 // Verify tool structure matches Ollama format 204 tool := req.Tools[0] 205 if tool["type"] != "function" { 206 t.Errorf("expected tool type=function, got %v", tool["type"]) 207 } 208 209 _ = json.NewEncoder(w).Encode(map[string]interface{}{ 210 "choices": []map[string]interface{}{ 211 { 212 "message": map[string]interface{}{ 213 "role": "assistant", 214 "content": "", 215 "tool_calls": []map[string]interface{}{ 216 { 217 "id": "call_abc", 218 "type": "function", 219 "function": map[string]interface{}{ 220 "name": "calculate", 221 "arguments": `{"operation":"add","a":5,"b":3}`, 222 }, 223 }, 224 }, 225 }, 226 }, 227 }, 228 }) 229 return 230 } 231 232 // Second request: verify tool result message 233 if requestCount == 2 { 234 foundToolResult := false 235 for _, msg := range req.Messages { 236 if msg.Role == "tool" && msg.ToolCallID == "call_abc" { 237 foundToolResult = true 238 if msg.Content != "8" { 239 t.Errorf("expected tool result='8', got %q", msg.Content) 240 } 241 } 242 } 243 if !foundToolResult { 244 t.Error("expected tool result message in second request") 245 } 246 247 _ = json.NewEncoder(w).Encode(map[string]interface{}{ 248 "choices": []map[string]interface{}{ 249 { 250 "message": map[string]interface{}{ 251 "role": "assistant", 252 "content": "The result is 8.", 253 }, 254 }, 255 }, 256 }) 257 } 258 })) 259 defer server.Close() 260 261 baseURL := strings.TrimSuffix(server.URL, "/v1") 262 provider := NewOllama(baseURL, "test-model") 263 ctx := context.Background() 264 265 // First call with tools 266 tools := []Tool{ 267 { 268 Name: "calculate", 269 Description: "Perform calculations", 270 Parameters: json.RawMessage(`{"type":"object","properties":{"operation":{"type":"string"},"a":{"type":"number"},"b":{"type":"number"}}}`), 271 }, 272 } 273 274 messages := make([]Message, 0, 1) 275 messages = append(messages, Message{Role: "user", Content: "What is 5 plus 3?"}) 276 277 resp1, err := provider.ChatWithTools(ctx, messages, tools) 278 if err != nil { 279 t.Fatalf("ChatWithTools() error: %v", err) 280 } 281 282 // Verify tool call 283 if len(resp1.ToolCalls) != 1 { 284 t.Fatalf("expected 1 tool call, got %d", len(resp1.ToolCalls)) 285 } 286 if resp1.ToolCalls[0].Name != "calculate" { 287 t.Errorf("expected tool name=calculate, got %s", resp1.ToolCalls[0].Name) 288 } 289 290 // Second call with tool result 291 messages = append(messages, Message{ 292 Role: "assistant", 293 Content: "", 294 ToolCalls: resp1.ToolCalls, 295 }) 296 messages = append(messages, Message{ 297 Role: "tool", 298 Content: "8", 299 ToolCallID: "call_abc", 300 }) 301 302 resp2, err := provider.ChatWithTools(ctx, messages, tools) 303 if err != nil { 304 t.Fatalf("ChatWithTools() error: %v", err) 305 } 306 307 if !strings.Contains(resp2.Content, "8") { 308 t.Errorf("expected response to contain '8', got %q", resp2.Content) 309 } 310} 311 312// TestOllama_ReasoningField tests that Ollama provider extracts reasoning 313// from both "reasoning" and "reasoning_content" fields (Ollama extension). 314func TestOllama_ReasoningField(t *testing.T) { 315 tests := []struct { 316 name string 317 responseField string 318 responseValue string 319 }{ 320 { 321 name: "reasoning field", 322 responseField: "reasoning", 323 responseValue: "I need to think about this...", 324 }, 325 { 326 name: "reasoning_content field", 327 responseField: "reasoning_content", 328 responseValue: "Let me analyze this step by step.", 329 }, 330 } 331 332 for _, tt := range tests { 333 t.Run(tt.name, func(t *testing.T) { 334 server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 335 w.Header().Set("Content-Type", "application/json") 336 337 // Build response with specified reasoning field 338 response := map[string]interface{}{ 339 "choices": []map[string]interface{}{ 340 { 341 "message": map[string]interface{}{ 342 "role": "assistant", 343 "content": "Answer", 344 tt.responseField: tt.responseValue, 345 }, 346 }, 347 }, 348 } 349 350 _ = json.NewEncoder(w).Encode(response) 351 })) 352 defer server.Close() 353 354 baseURL := strings.TrimSuffix(server.URL, "/v1") 355 provider := NewOllama(baseURL, "test-model") 356 ctx := context.Background() 357 358 messages := make([]Message, 0, 1) 359 messages = append(messages, Message{Role: "user", Content: "Question?"}) 360 361 tools := []Tool{ 362 {Name: "dummy", Description: "Dummy tool"}, 363 } 364 365 resp, err := provider.ChatWithTools(ctx, messages, tools) 366 if err != nil { 367 t.Fatalf("ChatWithTools() error: %v", err) 368 } 369 370 if resp.Reasoning != tt.responseValue { 371 t.Errorf("expected reasoning=%q, got %q", tt.responseValue, resp.Reasoning) 372 } 373 }) 374 } 375} 376 377// TestOllama_SystemMessagesAtEnd tests that system messages at the end 378// are preserved (Ollama allows this, unlike OpenAI). 379func TestOllama_SystemMessagesAtEnd(t *testing.T) { 380 server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 381 var req struct { 382 Messages []struct { 383 Role string `json:"role"` 384 Content string `json:"content"` 385 } `json:"messages"` 386 } 387 if err := json.NewDecoder(r.Body).Decode(&req); err != nil { 388 t.Fatalf("failed to decode request: %v", err) 389 } 390 391 // Verify last message is system 392 lastMsg := req.Messages[len(req.Messages)-1] 393 if lastMsg.Role != "system" { 394 t.Errorf("expected last message role=system, got %s", lastMsg.Role) 395 } 396 if !strings.Contains(lastMsg.Content, "final instruction") { 397 t.Error("expected last system message to contain 'final instruction'") 398 } 399 400 w.Header().Set("Content-Type", "application/json") 401 _ = json.NewEncoder(w).Encode(map[string]interface{}{ 402 "choices": []map[string]interface{}{ 403 { 404 "message": map[string]interface{}{ 405 "role": "assistant", 406 "content": "Understood final instruction.", 407 }, 408 }, 409 }, 410 }) 411 })) 412 defer server.Close() 413 414 baseURL := strings.TrimSuffix(server.URL, "/v1") 415 provider := NewOllama(baseURL, "test-model") 416 ctx := context.Background() 417 418 // System message at the end 419 messages := make([]Message, 0, 3) 420 messages = append(messages, 421 Message{Role: "user", Content: "Hello"}, 422 Message{Role: "assistant", Content: "Hi!"}, 423 Message{Role: "system", Content: "Here's a final instruction."}, 424 ) 425 426 resp, err := provider.Chat(ctx, messages) 427 if err != nil { 428 t.Fatalf("Chat() error: %v", err) 429 } 430 431 if !strings.Contains(resp, "final instruction") { 432 t.Errorf("expected response to acknowledge final instruction, got %q", resp) 433 } 434}