| package translator |
|
|
| import ( |
| "strings" |
| "testing" |
| ) |
|
|
| func TestStreamState(t *testing.T) { |
| t.Run("Reset clears all fields", func(t *testing.T) { |
| s := StreamState{ |
| ResponseID: "test-id", |
| CreatedAt: 12345, |
| Model: "gpt-4", |
| SequenceNum: 10, |
| FinishReason: "stop", |
| NativeFinishReason: "end_turn", |
| InputTokens: 100, |
| OutputTokens: 50, |
| UsageSeen: true, |
| } |
|
|
| s.Reset() |
|
|
| if s.ResponseID != "" { |
| t.Errorf("Expected ResponseID to be empty, got %s", s.ResponseID) |
| } |
| if s.CreatedAt != 0 { |
| t.Errorf("Expected CreatedAt to be 0, got %d", s.CreatedAt) |
| } |
| if s.Model != "" { |
| t.Errorf("Expected Model to be empty, got %s", s.Model) |
| } |
| if s.SequenceNum != 0 { |
| t.Errorf("Expected SequenceNum to be 0, got %d", s.SequenceNum) |
| } |
| if s.FinishReason != "" { |
| t.Errorf("Expected FinishReason to be empty, got %s", s.FinishReason) |
| } |
| if s.NativeFinishReason != "" { |
| t.Errorf("Expected NativeFinishReason to be empty, got %s", s.NativeFinishReason) |
| } |
| if s.InputTokens != 0 { |
| t.Errorf("Expected InputTokens to be 0, got %d", s.InputTokens) |
| } |
| if s.OutputTokens != 0 { |
| t.Errorf("Expected OutputTokens to be 0, got %d", s.OutputTokens) |
| } |
| if s.UsageSeen { |
| t.Error("Expected UsageSeen to be false") |
| } |
| }) |
|
|
| t.Run("NextSequence increments correctly", func(t *testing.T) { |
| s := StreamState{} |
|
|
| if s.NextSequence() != 1 { |
| t.Errorf("Expected first sequence to be 1, got %d", s.SequenceNum) |
| } |
| if s.NextSequence() != 2 { |
| t.Errorf("Expected second sequence to be 2, got %d", s.SequenceNum) |
| } |
| if s.NextSequence() != 3 { |
| t.Errorf("Expected third sequence to be 3, got %d", s.SequenceNum) |
| } |
| }) |
|
|
| t.Run("EnsureTimestamp sets timestamp when zero", func(t *testing.T) { |
| s := StreamState{} |
|
|
| ts := s.EnsureTimestamp() |
| if ts == 0 { |
| t.Error("Expected timestamp to be set") |
| } |
| if s.CreatedAt != ts { |
| t.Errorf("Expected CreatedAt to match returned timestamp, got %d vs %d", s.CreatedAt, ts) |
| } |
| }) |
|
|
| t.Run("EnsureTimestamp preserves existing timestamp", func(t *testing.T) { |
| s := StreamState{CreatedAt: 12345} |
|
|
| ts := s.EnsureTimestamp() |
| if ts != 12345 { |
| t.Errorf("Expected timestamp to remain 12345, got %d", ts) |
| } |
| }) |
| } |
|
|
| func TestToolCallState(t *testing.T) { |
| t.Run("GetArguments returns empty object when no arguments", func(t *testing.T) { |
| tc := &ToolCallState{} |
| args := tc.GetArguments() |
| if args != "{}" { |
| t.Errorf("Expected '{}', got %s", args) |
| } |
| }) |
|
|
| t.Run("GetArguments returns accumulated arguments", func(t *testing.T) { |
| tc := &ToolCallState{} |
| tc.Arguments.WriteString(`{"key": "value"}`) |
| args := tc.GetArguments() |
| if args != `{"key": "value"}` { |
| t.Errorf("Expected '{\"key\": \"value\"}', got %s", args) |
| } |
| }) |
|
|
| t.Run("WriteArguments appends content", func(t *testing.T) { |
| tc := &ToolCallState{} |
| tc.WriteArguments(`{"a":`) |
| tc.WriteArguments(`1}`) |
|
|
| expected := `{"a":1}` |
| if tc.Arguments.String() != expected { |
| t.Errorf("Expected '%s', got %s", expected, tc.Arguments.String()) |
| } |
| }) |
| } |
|
|
| func TestToolCallAccumulator(t *testing.T) { |
| t.Run("NewToolCallAccumulator creates empty accumulator", func(t *testing.T) { |
| a := NewToolCallAccumulator() |
| if a == nil { |
| t.Fatal("Expected non-nil accumulator") |
| } |
| if a.HasAny() { |
| t.Error("Expected HasAny to be false for new accumulator") |
| } |
| if a.Count() != 0 { |
| t.Errorf("Expected Count to be 0, got %d", a.Count()) |
| } |
| }) |
|
|
| t.Run("Get returns nil for non-existent index", func(t *testing.T) { |
| a := NewToolCallAccumulator() |
| if a.Get(0) != nil { |
| t.Error("Expected Get to return nil for non-existent index") |
| } |
| }) |
|
|
| t.Run("GetOrCreate creates new tool call", func(t *testing.T) { |
| a := NewToolCallAccumulator() |
| tc := a.GetOrCreate(0) |
| if tc == nil { |
| t.Fatal("Expected non-nil tool call") |
| } |
| if tc.Index != 0 { |
| t.Errorf("Expected index 0, got %d", tc.Index) |
| } |
| if !a.HasAny() { |
| t.Error("Expected HasAny to be true after creating tool call") |
| } |
| if a.Count() != 1 { |
| t.Errorf("Expected Count to be 1, got %d", a.Count()) |
| } |
| }) |
|
|
| t.Run("GetOrCreate returns existing tool call", func(t *testing.T) { |
| a := NewToolCallAccumulator() |
| tc1 := a.GetOrCreate(0) |
| tc1.Name = "test-function" |
|
|
| tc2 := a.GetOrCreate(0) |
| if tc2.Name != "test-function" { |
| t.Error("Expected to get existing tool call") |
| } |
| if a.Count() != 1 { |
| t.Errorf("Expected Count to still be 1, got %d", a.Count()) |
| } |
| }) |
|
|
| t.Run("CreateNext assigns incremental indices", func(t *testing.T) { |
| a := NewToolCallAccumulator() |
|
|
| tc1 := a.CreateNext("id1", "func1") |
| tc2 := a.CreateNext("id2", "func2") |
|
|
| if tc1.Index != 0 { |
| t.Errorf("Expected first index to be 0, got %d", tc1.Index) |
| } |
| if tc2.Index != 1 { |
| t.Errorf("Expected second index to be 1, got %d", tc2.Index) |
| } |
| if tc1.ID != "id1" || tc1.Name != "func1" { |
| t.Error("Expected first tool call to have correct ID and Name") |
| } |
| if tc2.ID != "id2" || tc2.Name != "func2" { |
| t.Error("Expected second tool call to have correct ID and Name") |
| } |
| }) |
|
|
| t.Run("MarkComplete marks tool call as complete", func(t *testing.T) { |
| a := NewToolCallAccumulator() |
| a.CreateNext("id1", "func1") |
|
|
| tc := a.MarkComplete(0) |
| if tc == nil { |
| t.Fatal("Expected non-nil tool call") |
| } |
| if !tc.Complete { |
| t.Error("Expected tool call to be marked complete") |
| } |
| }) |
|
|
| t.Run("MarkComplete returns nil for non-existent index", func(t *testing.T) { |
| a := NewToolCallAccumulator() |
| if a.MarkComplete(0) != nil { |
| t.Error("Expected MarkComplete to return nil for non-existent index") |
| } |
| }) |
|
|
| t.Run("Remove deletes tool call", func(t *testing.T) { |
| a := NewToolCallAccumulator() |
| a.CreateNext("id1", "func1") |
| a.CreateNext("id2", "func2") |
|
|
| a.Remove(0) |
|
|
| if a.Count() != 1 { |
| t.Errorf("Expected Count to be 1 after removal, got %d", a.Count()) |
| } |
| if a.Get(0) != nil { |
| t.Error("Expected Get(0) to return nil after removal") |
| } |
| if a.Get(1) == nil { |
| t.Error("Expected Get(1) to still exist") |
| } |
| }) |
|
|
| t.Run("GetOrdered returns tool calls in creation order", func(t *testing.T) { |
| a := NewToolCallAccumulator() |
| a.CreateNext("id1", "func1") |
| a.CreateNext("id2", "func2") |
| a.CreateNext("id3", "func3") |
|
|
| ordered := a.GetOrdered() |
| if len(ordered) != 3 { |
| t.Fatalf("Expected 3 ordered tool calls, got %d", len(ordered)) |
| } |
| if ordered[0].ID != "id1" || ordered[1].ID != "id2" || ordered[2].ID != "id3" { |
| t.Error("Expected tool calls in creation order") |
| } |
| }) |
|
|
| t.Run("Reset clears all state", func(t *testing.T) { |
| a := NewToolCallAccumulator() |
| a.CreateNext("id1", "func1") |
| a.CreateNext("id2", "func2") |
|
|
| a.Reset() |
|
|
| if a.HasAny() { |
| t.Error("Expected HasAny to be false after reset") |
| } |
| if a.Count() != 0 { |
| t.Errorf("Expected Count to be 0 after reset, got %d", a.Count()) |
| } |
| }) |
| } |
|
|
| func TestContentBuffer(t *testing.T) { |
| t.Run("HasContent returns false for empty buffer", func(t *testing.T) { |
| cb := ContentBuffer{} |
| if cb.HasContent() { |
| t.Error("Expected HasContent to be false for empty buffer") |
| } |
| }) |
|
|
| t.Run("HasContent returns true with text", func(t *testing.T) { |
| cb := ContentBuffer{} |
| cb.Text.WriteString("hello") |
| if !cb.HasContent() { |
| t.Error("Expected HasContent to be true with text") |
| } |
| }) |
|
|
| t.Run("HasContent returns true with reasoning", func(t *testing.T) { |
| cb := ContentBuffer{} |
| cb.Reasoning.WriteString("thinking...") |
| if !cb.HasContent() { |
| t.Error("Expected HasContent to be true with reasoning") |
| } |
| }) |
|
|
| t.Run("Reset clears both buffers", func(t *testing.T) { |
| cb := ContentBuffer{} |
| cb.Text.WriteString("text") |
| cb.Reasoning.WriteString("reasoning") |
|
|
| cb.Reset() |
|
|
| if cb.Text.Len() != 0 { |
| t.Error("Expected Text to be empty after reset") |
| } |
| if cb.Reasoning.Len() != 0 { |
| t.Error("Expected Reasoning to be empty after reset") |
| } |
| if cb.HasContent() { |
| t.Error("Expected HasContent to be false after reset") |
| } |
| }) |
| } |
|
|
| func TestStreamingState(t *testing.T) { |
| t.Run("NewStreamingState creates initialized state", func(t *testing.T) { |
| s := NewStreamingState() |
| if s == nil { |
| t.Fatal("Expected non-nil state") |
| } |
| if s.ToolCalls == nil { |
| t.Error("Expected ToolCalls to be initialized") |
| } |
| }) |
|
|
| t.Run("Reset clears all fields", func(t *testing.T) { |
| s := NewStreamingState() |
| s.ResponseID = "test-id" |
| s.InTextBlock = true |
| s.InToolBlock = true |
| s.InReasoningBlock = true |
| s.CurrentMessageID = "msg-id" |
| s.CurrentToolCallID = "tool-id" |
| s.CurrentReasoningID = "reasoning-id" |
| s.ToolCalls.CreateNext("id", "func") |
| s.Content.Text.WriteString("text") |
|
|
| s.Reset() |
|
|
| if s.ResponseID != "" { |
| t.Error("Expected ResponseID to be cleared") |
| } |
| if s.InTextBlock || s.InToolBlock || s.InReasoningBlock { |
| t.Error("Expected block flags to be false") |
| } |
| if s.CurrentMessageID != "" || s.CurrentToolCallID != "" || s.CurrentReasoningID != "" { |
| t.Error("Expected current IDs to be cleared") |
| } |
| if s.ToolCalls.HasAny() { |
| t.Error("Expected ToolCalls to be cleared") |
| } |
| if s.Content.HasContent() { |
| t.Error("Expected Content to be cleared") |
| } |
| }) |
| } |
|
|
| func TestFinishReasonMapper(t *testing.T) { |
| t.Run("ToOpenAI maps known reasons", func(t *testing.T) { |
| m := NewFinishReasonMapper() |
|
|
| testCases := []struct { |
| input string |
| expected string |
| }{ |
| {"end_turn", "stop"}, |
| {"tool_use", "tool_calls"}, |
| {"max_tokens", "length"}, |
| {"STOP", "stop"}, |
| {"MAX_TOKENS", "length"}, |
| {"SAFETY", "content_filter"}, |
| {"completed", "stop"}, |
| } |
|
|
| for _, tc := range testCases { |
| result := m.ToOpenAI(tc.input) |
| if result != tc.expected { |
| t.Errorf("ToOpenAI(%s) = %s, expected %s", tc.input, result, tc.expected) |
| } |
| } |
| }) |
|
|
| t.Run("ToOpenAI returns default for unknown reasons", func(t *testing.T) { |
| m := NewFinishReasonMapper() |
| result := m.ToOpenAI("unknown_reason") |
| if result != "stop" { |
| t.Errorf("Expected default 'stop', got %s", result) |
| } |
| }) |
|
|
| t.Run("FromOpenAI maps known reasons", func(t *testing.T) { |
| m := NewFinishReasonMapper() |
|
|
| testCases := []struct { |
| input string |
| expected string |
| }{ |
| {"stop", "end_turn"}, |
| {"tool_calls", "tool_use"}, |
| {"length", "max_tokens"}, |
| {"content_filter", "SAFETY"}, |
| } |
|
|
| for _, tc := range testCases { |
| result := m.FromOpenAI(tc.input) |
| if result != tc.expected { |
| t.Errorf("FromOpenAI(%s) = %s, expected %s", tc.input, result, tc.expected) |
| } |
| } |
| }) |
|
|
| t.Run("FromOpenAI returns default for unknown reasons", func(t *testing.T) { |
| m := NewFinishReasonMapper() |
| result := m.FromOpenAI("unknown") |
| if result != "STOP" { |
| t.Errorf("Expected default 'STOP', got %s", result) |
| } |
| }) |
|
|
| t.Run("RegisterMapping adds new mapping", func(t *testing.T) { |
| m := NewFinishReasonMapper() |
| m.RegisterMapping("custom_reason", "custom_openai") |
|
|
| if m.ToOpenAI("custom_reason") != "custom_openai" { |
| t.Error("Expected new mapping to work in ToOpenAI direction") |
| } |
| if m.FromOpenAI("custom_openai") != "custom_reason" { |
| t.Error("Expected new mapping to work in FromOpenAI direction") |
| } |
| }) |
| } |
|
|
| func TestGenerateResponseID(t *testing.T) { |
| t.Run("generates unique IDs", func(t *testing.T) { |
| id1 := GenerateResponseID("") |
| id2 := GenerateResponseID("") |
|
|
| if id1 == id2 { |
| t.Error("Expected unique IDs") |
| } |
| }) |
|
|
| t.Run("includes prefix when provided", func(t *testing.T) { |
| id := GenerateResponseID("chatcmpl") |
| if !strings.HasPrefix(id, "chatcmpl_") { |
| t.Errorf("Expected ID to start with 'chatcmpl_', got %s", id) |
| } |
| }) |
|
|
| t.Run("default prefix is resp_", func(t *testing.T) { |
| id := GenerateResponseID("") |
| if !strings.HasPrefix(id, "resp_") { |
| t.Errorf("Expected ID to start with 'resp_', got %s", id) |
| } |
| }) |
| } |
|
|
| func TestGenerateFunctionCallID(t *testing.T) { |
| t.Run("generates unique IDs", func(t *testing.T) { |
| id1 := GenerateFunctionCallID("") |
| id2 := GenerateFunctionCallID("") |
|
|
| if id1 == id2 { |
| t.Error("Expected unique IDs") |
| } |
| }) |
|
|
| t.Run("includes name when provided", func(t *testing.T) { |
| id := GenerateFunctionCallID("get_weather") |
| if !strings.Contains(id, "get_weather") { |
| t.Errorf("Expected ID to contain 'get_weather', got %s", id) |
| } |
| }) |
| } |
|
|
