| package responses |
|
|
| import ( |
| "strings" |
| "testing" |
| "time" |
|
|
| "ds2api/internal/httpapi/openai/embeddings" |
| "ds2api/internal/promptcompat" |
| ) |
|
|
| func TestNormalizeResponsesInputAsMessagesString(t *testing.T) { |
| msgs := promptcompat.NormalizeResponsesInputAsMessages("hello") |
| if len(msgs) != 1 { |
| t.Fatalf("expected one message, got %d", len(msgs)) |
| } |
| m, _ := msgs[0].(map[string]any) |
| if m["role"] != "user" || m["content"] != "hello" { |
| t.Fatalf("unexpected message: %#v", m) |
| } |
| } |
|
|
| func TestResponsesMessagesFromRequestWithInstructions(t *testing.T) { |
| req := map[string]any{ |
| "model": "gpt-4.1", |
| "input": "ping", |
| "instructions": "system text", |
| } |
| msgs := promptcompat.ResponsesMessagesFromRequest(req) |
| if len(msgs) != 2 { |
| t.Fatalf("expected two messages, got %d", len(msgs)) |
| } |
| sys, _ := msgs[0].(map[string]any) |
| if sys["role"] != "system" { |
| t.Fatalf("unexpected first message: %#v", sys) |
| } |
| } |
|
|
| func TestNormalizeResponsesInputAsMessagesObjectRoleContentBlocks(t *testing.T) { |
| msgs := promptcompat.NormalizeResponsesInputAsMessages(map[string]any{ |
| "role": "user", |
| "content": []any{ |
| map[string]any{"type": "input_text", "text": "line-1"}, |
| map[string]any{"type": "input_text", "text": "line-2"}, |
| }, |
| }) |
| if len(msgs) != 1 { |
| t.Fatalf("expected one message, got %d", len(msgs)) |
| } |
| m, _ := msgs[0].(map[string]any) |
| if m["role"] != "user" { |
| t.Fatalf("unexpected role: %#v", m) |
| } |
| if strings.TrimSpace(promptcompat.NormalizeOpenAIContentForPrompt(m["content"])) != "line-1\nline-2" { |
| t.Fatalf("unexpected content: %#v", m["content"]) |
| } |
| } |
|
|
| func TestNormalizeResponsesInputAsMessagesFunctionCallOutput(t *testing.T) { |
| msgs := promptcompat.NormalizeResponsesInputAsMessages([]any{ |
| map[string]any{ |
| "type": "function_call_output", |
| "call_id": "call_123", |
| "output": map[string]any{"ok": true}, |
| }, |
| }) |
| if len(msgs) != 1 { |
| t.Fatalf("expected one message, got %d", len(msgs)) |
| } |
| m, _ := msgs[0].(map[string]any) |
| if m["role"] != "tool" { |
| t.Fatalf("expected tool role, got %#v", m) |
| } |
| if m["tool_call_id"] != "call_123" { |
| t.Fatalf("expected tool_call_id propagated, got %#v", m) |
| } |
| } |
|
|
| func TestNormalizeResponsesInputAsMessagesBackfillsToolResultNameFromCallID(t *testing.T) { |
| msgs := promptcompat.NormalizeResponsesInputAsMessages([]any{ |
| map[string]any{ |
| "type": "function_call", |
| "call_id": "call_999", |
| "name": "search", |
| "arguments": `{"q":"golang"}`, |
| }, |
| map[string]any{ |
| "type": "function_call_output", |
| "call_id": "call_999", |
| "output": map[string]any{"ok": true}, |
| }, |
| }) |
| if len(msgs) != 2 { |
| t.Fatalf("expected two messages, got %d", len(msgs)) |
| } |
| toolMsg, _ := msgs[1].(map[string]any) |
| if toolMsg["role"] != "tool" { |
| t.Fatalf("expected tool role, got %#v", toolMsg) |
| } |
| if toolMsg["name"] != "search" { |
| t.Fatalf("expected tool name backfilled from call_id, got %#v", toolMsg["name"]) |
| } |
| } |
|
|
| func TestNormalizeResponsesInputAsMessagesFunctionCallItem(t *testing.T) { |
| msgs := promptcompat.NormalizeResponsesInputAsMessages([]any{ |
| map[string]any{ |
| "type": "function_call", |
| "call_id": "call_456", |
| "name": "search", |
| "arguments": `{"q":"golang"}`, |
| }, |
| }) |
| if len(msgs) != 1 { |
| t.Fatalf("expected one message, got %d", len(msgs)) |
| } |
| m, _ := msgs[0].(map[string]any) |
| if m["role"] != "assistant" { |
| t.Fatalf("expected assistant role, got %#v", m["role"]) |
| } |
| toolCalls, _ := m["tool_calls"].([]any) |
| if len(toolCalls) != 1 { |
| t.Fatalf("expected one tool_call, got %#v", m["tool_calls"]) |
| } |
| call, _ := toolCalls[0].(map[string]any) |
| if call["id"] != "call_456" { |
| t.Fatalf("expected call id preserved, got %#v", call) |
| } |
| if call["type"] != "function" { |
| t.Fatalf("expected function type, got %#v", call) |
| } |
| fn, _ := call["function"].(map[string]any) |
| if fn["name"] != "search" { |
| t.Fatalf("expected call name preserved, got %#v", call) |
| } |
| if fn["arguments"] != `{"q":"golang"}` { |
| t.Fatalf("expected call arguments preserved, got %#v", call) |
| } |
| } |
|
|
| func TestNormalizeResponsesInputAsMessagesFunctionCallItemPreservesConcatenatedArguments(t *testing.T) { |
| msgs := promptcompat.NormalizeResponsesInputAsMessages([]any{ |
| map[string]any{ |
| "type": "function_call", |
| "call_id": "call_456", |
| "name": "search", |
| "arguments": `{}{"q":"golang"}`, |
| }, |
| }) |
| if len(msgs) != 1 { |
| t.Fatalf("expected one message, got %d", len(msgs)) |
| } |
| m, _ := msgs[0].(map[string]any) |
| toolCalls, _ := m["tool_calls"].([]any) |
| call, _ := toolCalls[0].(map[string]any) |
| fn, _ := call["function"].(map[string]any) |
| if fn["arguments"] != `{}{"q":"golang"}` { |
| t.Fatalf("expected original concatenated call arguments preserved, got %#v", fn["arguments"]) |
| } |
| } |
|
|
| func TestCollectOpenAIRefFileIDs(t *testing.T) { |
| got := promptcompat.CollectOpenAIRefFileIDs(map[string]any{ |
| "ref_file_ids": []any{"file-top", "file-dup"}, |
| "attachments": []any{ |
| map[string]any{"file_id": "file-attachment"}, |
| }, |
| "input": []any{ |
| map[string]any{ |
| "type": "message", |
| "content": []any{ |
| map[string]any{"type": "input_file", "file_id": "file-input"}, |
| map[string]any{"type": "input_file", "id": "file-dup"}, |
| }, |
| }, |
| }, |
| }) |
| want := []string{"file-top", "file-dup", "file-attachment", "file-input"} |
| if len(got) != len(want) { |
| t.Fatalf("expected %d file ids, got %#v", len(want), got) |
| } |
| for i, id := range want { |
| if got[i] != id { |
| t.Fatalf("unexpected file ids at %d: got=%#v want=%#v", i, got, want) |
| } |
| } |
| } |
|
|
| func TestExtractEmbeddingInputs(t *testing.T) { |
| got := embeddings.ExtractEmbeddingInputs([]any{"a", "b"}) |
| if len(got) != 2 || got[0] != "a" || got[1] != "b" { |
| t.Fatalf("unexpected inputs: %#v", got) |
| } |
| } |
|
|
| func TestDeterministicEmbeddingStable(t *testing.T) { |
| a := embeddings.DeterministicEmbedding("hello") |
| b := embeddings.DeterministicEmbedding("hello") |
| if len(a) != 64 || len(b) != 64 { |
| t.Fatalf("expected 64 dims, got %d and %d", len(a), len(b)) |
| } |
| for i := range a { |
| if a[i] != b[i] { |
| t.Fatalf("expected stable embedding at %d: %v != %v", i, a[i], b[i]) |
| } |
| } |
| } |
|
|
| func TestResponseStorePutGet(t *testing.T) { |
| st := newResponseStore(100 * time.Millisecond) |
| st.put("owner_1", "resp_1", map[string]any{"id": "resp_1"}) |
| got, ok := st.get("owner_1", "resp_1") |
| if !ok { |
| t.Fatal("expected stored response") |
| } |
| if got["id"] != "resp_1" { |
| t.Fatalf("unexpected response payload: %#v", got) |
| } |
| } |
|
|
| func TestResponseStoreTenantIsolation(t *testing.T) { |
| st := newResponseStore(100 * time.Millisecond) |
| st.put("owner_a", "resp_1", map[string]any{"id": "resp_1"}) |
| if _, ok := st.get("owner_b", "resp_1"); ok { |
| t.Fatal("expected owner_b to be isolated from owner_a response") |
| } |
| } |
|
|
