mirror of
https://github.com/CJackHwang/ds2api.git
synced 2026-05-05 00:45:29 +08:00
439 lines
12 KiB
Go
439 lines
12 KiB
Go
package claude
|
|
|
|
import (
|
|
"testing"
|
|
)
|
|
|
|
// ─── normalizeClaudeMessages ─────────────────────────────────────────
|
|
|
|
func TestNormalizeClaudeMessagesSimpleString(t *testing.T) {
|
|
msgs := []any{
|
|
map[string]any{"role": "user", "content": "Hello"},
|
|
}
|
|
got := normalizeClaudeMessages(msgs)
|
|
if len(got) != 1 {
|
|
t.Fatalf("expected 1 message, got %d", len(got))
|
|
}
|
|
m := got[0].(map[string]any)
|
|
if m["content"] != "Hello" {
|
|
t.Fatalf("expected 'Hello', got %v", m["content"])
|
|
}
|
|
}
|
|
|
|
func TestNormalizeClaudeMessagesArrayContent(t *testing.T) {
|
|
msgs := []any{
|
|
map[string]any{
|
|
"role": "user",
|
|
"content": []any{
|
|
map[string]any{"type": "text", "text": "line1"},
|
|
map[string]any{"type": "text", "text": "line2"},
|
|
},
|
|
},
|
|
}
|
|
got := normalizeClaudeMessages(msgs)
|
|
m := got[0].(map[string]any)
|
|
if m["content"] != "line1\nline2" {
|
|
t.Fatalf("expected joined text, got %q", m["content"])
|
|
}
|
|
}
|
|
|
|
func TestNormalizeClaudeMessagesToolResult(t *testing.T) {
|
|
msgs := []any{
|
|
map[string]any{
|
|
"role": "user",
|
|
"content": []any{
|
|
map[string]any{"type": "tool_result", "content": "tool output"},
|
|
},
|
|
},
|
|
}
|
|
got := normalizeClaudeMessages(msgs)
|
|
if len(got) != 1 {
|
|
t.Fatalf("expected one normalized message, got %d", len(got))
|
|
}
|
|
m := got[0].(map[string]any)
|
|
if m["role"] != "tool" {
|
|
t.Fatalf("expected tool role preserved, got %#v", m["role"])
|
|
}
|
|
content, _ := m["content"].(string)
|
|
if content != "tool output" {
|
|
t.Fatalf("expected raw tool output content preserved, got %q", content)
|
|
}
|
|
}
|
|
|
|
func TestNormalizeClaudeMessagesToolUseToAssistantToolCalls(t *testing.T) {
|
|
msgs := []any{
|
|
map[string]any{
|
|
"role": "assistant",
|
|
"content": []any{
|
|
map[string]any{
|
|
"type": "tool_use",
|
|
"id": "call_1",
|
|
"name": "search_web",
|
|
"input": map[string]any{"query": "latest"},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
got := normalizeClaudeMessages(msgs)
|
|
if len(got) != 1 {
|
|
t.Fatalf("expected one normalized tool-call message, got %d", len(got))
|
|
}
|
|
m := got[0].(map[string]any)
|
|
if m["role"] != "assistant" {
|
|
t.Fatalf("expected assistant role, got %#v", m["role"])
|
|
}
|
|
tc, _ := m["tool_calls"].([]any)
|
|
if len(tc) != 1 {
|
|
t.Fatalf("expected one tool call, got %#v", m["tool_calls"])
|
|
}
|
|
call, _ := tc[0].(map[string]any)
|
|
if call["id"] != "call_1" {
|
|
t.Fatalf("expected call id preserved, got %#v", call)
|
|
}
|
|
}
|
|
|
|
func TestNormalizeClaudeMessagesSkipsNonMap(t *testing.T) {
|
|
msgs := []any{"not a map", 42}
|
|
got := normalizeClaudeMessages(msgs)
|
|
if len(got) != 0 {
|
|
t.Fatalf("expected 0 messages for non-map items, got %d", len(got))
|
|
}
|
|
}
|
|
|
|
func TestNormalizeClaudeMessagesEmpty(t *testing.T) {
|
|
got := normalizeClaudeMessages(nil)
|
|
if len(got) != 0 {
|
|
t.Fatalf("expected 0, got %d", len(got))
|
|
}
|
|
}
|
|
|
|
func TestNormalizeClaudeMessagesPreservesRole(t *testing.T) {
|
|
msgs := []any{
|
|
map[string]any{"role": "assistant", "content": "response"},
|
|
}
|
|
got := normalizeClaudeMessages(msgs)
|
|
m := got[0].(map[string]any)
|
|
if m["role"] != "assistant" {
|
|
t.Fatalf("expected 'assistant', got %q", m["role"])
|
|
}
|
|
}
|
|
|
|
func TestNormalizeClaudeMessagesMixedContentBlocks(t *testing.T) {
|
|
msgs := []any{
|
|
map[string]any{
|
|
"role": "user",
|
|
"content": []any{
|
|
map[string]any{"type": "text", "text": "Hello"},
|
|
map[string]any{"type": "image", "source": "data:..."},
|
|
map[string]any{"type": "text", "text": "World"},
|
|
},
|
|
},
|
|
}
|
|
got := normalizeClaudeMessages(msgs)
|
|
m := got[0].(map[string]any)
|
|
content, _ := m["content"].(string)
|
|
if !containsStr(content, "Hello") || !containsStr(content, "World") || !containsStr(content, `"type":"image"`) {
|
|
t.Fatalf("expected text plus raw non-text block preserved, got %q", content)
|
|
}
|
|
}
|
|
|
|
// ─── buildClaudeToolPrompt ───────────────────────────────────────────
|
|
|
|
func TestBuildClaudeToolPromptSingleTool(t *testing.T) {
|
|
tools := []any{
|
|
map[string]any{
|
|
"name": "search",
|
|
"description": "Search the web",
|
|
"input_schema": map[string]any{
|
|
"type": "object",
|
|
"properties": map[string]any{
|
|
"query": map[string]any{"type": "string"},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
prompt := buildClaudeToolPrompt(tools)
|
|
if prompt == "" {
|
|
t.Fatal("expected non-empty prompt")
|
|
}
|
|
// Should contain tool name and description
|
|
if !containsStr(prompt, "search") {
|
|
t.Fatalf("expected 'search' in prompt")
|
|
}
|
|
if !containsStr(prompt, "Search the web") {
|
|
t.Fatalf("expected description in prompt")
|
|
}
|
|
if !containsStr(prompt, "tool_use") {
|
|
t.Fatalf("expected tool_use instruction in prompt")
|
|
}
|
|
if containsStr(prompt, "TOOL_CALL_HISTORY") || containsStr(prompt, "TOOL_RESULT_HISTORY") {
|
|
t.Fatalf("expected legacy tool history markers removed from prompt")
|
|
}
|
|
if !containsStr(prompt, "Do not print tool-call JSON in text") {
|
|
t.Fatalf("expected prompt to keep no tool-call-json instruction")
|
|
}
|
|
}
|
|
|
|
func TestBuildClaudeToolPromptMultipleTools(t *testing.T) {
|
|
tools := []any{
|
|
map[string]any{"name": "tool1", "description": "desc1"},
|
|
map[string]any{"name": "tool2", "description": "desc2"},
|
|
}
|
|
prompt := buildClaudeToolPrompt(tools)
|
|
if !containsStr(prompt, "tool1") || !containsStr(prompt, "tool2") {
|
|
t.Fatalf("expected both tools in prompt")
|
|
}
|
|
}
|
|
|
|
func TestBuildClaudeToolPromptSupportsOpenAIStyleFunctionTool(t *testing.T) {
|
|
tools := []any{
|
|
map[string]any{
|
|
"type": "function",
|
|
"function": map[string]any{
|
|
"name": "search",
|
|
"description": "Search via function tool",
|
|
"parameters": map[string]any{
|
|
"type": "object",
|
|
"properties": map[string]any{
|
|
"q": map[string]any{"type": "string"},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
prompt := buildClaudeToolPrompt(tools)
|
|
if !containsStr(prompt, "Tool: search") {
|
|
t.Fatalf("expected OpenAI-style function tool name in prompt, got: %q", prompt)
|
|
}
|
|
if !containsStr(prompt, "Search via function tool") {
|
|
t.Fatalf("expected OpenAI-style function tool description in prompt, got: %q", prompt)
|
|
}
|
|
if !containsStr(prompt, "\"q\"") {
|
|
t.Fatalf("expected parameters schema serialized in prompt, got: %q", prompt)
|
|
}
|
|
}
|
|
|
|
func TestBuildClaudeToolPromptSkipsNonMap(t *testing.T) {
|
|
tools := []any{"not a map"}
|
|
prompt := buildClaudeToolPrompt(tools)
|
|
if prompt == "" {
|
|
t.Fatal("expected non-empty prompt even with invalid tools")
|
|
}
|
|
// Should still contain the intro and instruction
|
|
if !containsStr(prompt, "You are Claude") {
|
|
t.Fatalf("expected intro in prompt")
|
|
}
|
|
}
|
|
|
|
// ─── hasSystemMessage ────────────────────────────────────────────────
|
|
|
|
func TestHasSystemMessageTrue(t *testing.T) {
|
|
msgs := []any{
|
|
map[string]any{"role": "system", "content": "You are a helper"},
|
|
map[string]any{"role": "user", "content": "Hi"},
|
|
}
|
|
if !hasSystemMessage(msgs) {
|
|
t.Fatal("expected true")
|
|
}
|
|
}
|
|
|
|
func TestHasSystemMessageFalse(t *testing.T) {
|
|
msgs := []any{
|
|
map[string]any{"role": "user", "content": "Hi"},
|
|
map[string]any{"role": "assistant", "content": "Hello"},
|
|
}
|
|
if hasSystemMessage(msgs) {
|
|
t.Fatal("expected false")
|
|
}
|
|
}
|
|
|
|
func TestHasSystemMessageEmpty(t *testing.T) {
|
|
if hasSystemMessage(nil) {
|
|
t.Fatal("expected false for nil")
|
|
}
|
|
}
|
|
|
|
func TestHasSystemMessageNonMap(t *testing.T) {
|
|
msgs := []any{"not a map"}
|
|
if hasSystemMessage(msgs) {
|
|
t.Fatal("expected false for non-map")
|
|
}
|
|
}
|
|
|
|
// ─── extractClaudeToolNames ──────────────────────────────────────────
|
|
|
|
func TestExtractClaudeToolNamesSingle(t *testing.T) {
|
|
tools := []any{
|
|
map[string]any{"name": "search"},
|
|
}
|
|
names := extractClaudeToolNames(tools)
|
|
if len(names) != 1 || names[0] != "search" {
|
|
t.Fatalf("expected [search], got %v", names)
|
|
}
|
|
}
|
|
|
|
func TestExtractClaudeToolNamesMultiple(t *testing.T) {
|
|
tools := []any{
|
|
map[string]any{"name": "search"},
|
|
map[string]any{"name": "calculate"},
|
|
}
|
|
names := extractClaudeToolNames(tools)
|
|
if len(names) != 2 {
|
|
t.Fatalf("expected 2 names, got %v", names)
|
|
}
|
|
}
|
|
|
|
func TestExtractClaudeToolNamesSkipsEmptyName(t *testing.T) {
|
|
tools := []any{
|
|
map[string]any{"name": ""},
|
|
map[string]any{"name": "valid"},
|
|
}
|
|
names := extractClaudeToolNames(tools)
|
|
if len(names) != 1 || names[0] != "valid" {
|
|
t.Fatalf("expected [valid], got %v", names)
|
|
}
|
|
}
|
|
|
|
func TestExtractClaudeToolNamesSkipsNonMap(t *testing.T) {
|
|
tools := []any{"not a map", 42}
|
|
names := extractClaudeToolNames(tools)
|
|
if len(names) != 0 {
|
|
t.Fatalf("expected 0, got %v", names)
|
|
}
|
|
}
|
|
|
|
func TestExtractClaudeToolNamesNil(t *testing.T) {
|
|
names := extractClaudeToolNames(nil)
|
|
if len(names) != 0 {
|
|
t.Fatalf("expected 0, got %v", names)
|
|
}
|
|
}
|
|
|
|
func TestExtractClaudeToolNamesSupportsOpenAIStyleFunctionTool(t *testing.T) {
|
|
tools := []any{
|
|
map[string]any{
|
|
"type": "function",
|
|
"function": map[string]any{
|
|
"name": "search",
|
|
},
|
|
},
|
|
}
|
|
names := extractClaudeToolNames(tools)
|
|
if len(names) != 1 || names[0] != "search" {
|
|
t.Fatalf("expected [search], got %v", names)
|
|
}
|
|
}
|
|
|
|
// ─── toMessageMaps ───────────────────────────────────────────────────
|
|
|
|
func TestToMessageMapsNormal(t *testing.T) {
|
|
input := []any{
|
|
map[string]any{"role": "user", "content": "Hello"},
|
|
}
|
|
got := toMessageMaps(input)
|
|
if len(got) != 1 {
|
|
t.Fatalf("expected 1, got %d", len(got))
|
|
}
|
|
}
|
|
|
|
func TestToMessageMapsNonSlice(t *testing.T) {
|
|
got := toMessageMaps("not a slice")
|
|
if got != nil {
|
|
t.Fatalf("expected nil, got %v", got)
|
|
}
|
|
}
|
|
|
|
func TestToMessageMapsSkipsNonMap(t *testing.T) {
|
|
input := []any{"string", map[string]any{"role": "user"}, 42}
|
|
got := toMessageMaps(input)
|
|
if len(got) != 1 {
|
|
t.Fatalf("expected 1 map, got %d", len(got))
|
|
}
|
|
}
|
|
|
|
func TestToMessageMapsNil(t *testing.T) {
|
|
got := toMessageMaps(nil)
|
|
if got != nil {
|
|
t.Fatalf("expected nil, got %v", got)
|
|
}
|
|
}
|
|
|
|
// ─── extractMessageContent ──────────────────────────────────────────
|
|
|
|
func TestExtractMessageContentString(t *testing.T) {
|
|
if got := extractMessageContent("hello"); got != "hello" {
|
|
t.Fatalf("expected 'hello', got %q", got)
|
|
}
|
|
}
|
|
|
|
func TestExtractMessageContentArray(t *testing.T) {
|
|
input := []any{"part1", "part2"}
|
|
got := extractMessageContent(input)
|
|
if got != "part1\npart2" {
|
|
t.Fatalf("expected joined, got %q", got)
|
|
}
|
|
}
|
|
|
|
func TestExtractMessageContentOther(t *testing.T) {
|
|
got := extractMessageContent(42)
|
|
if got != "42" {
|
|
t.Fatalf("expected '42', got %q", got)
|
|
}
|
|
}
|
|
|
|
func TestExtractMessageContentNil(t *testing.T) {
|
|
got := extractMessageContent(nil)
|
|
if got != "<nil>" {
|
|
t.Fatalf("expected '<nil>', got %q", got)
|
|
}
|
|
}
|
|
|
|
// ─── cloneMap ────────────────────────────────────────────────────────
|
|
|
|
func TestCloneMapBasic(t *testing.T) {
|
|
original := map[string]any{"a": 1, "b": "hello"}
|
|
clone := cloneMap(original)
|
|
original["a"] = 999
|
|
if clone["a"] != 1 {
|
|
t.Fatalf("expected 1, got %v", clone["a"])
|
|
}
|
|
if clone["b"] != "hello" {
|
|
t.Fatalf("expected 'hello', got %v", clone["b"])
|
|
}
|
|
}
|
|
|
|
func TestCloneMapEmpty(t *testing.T) {
|
|
clone := cloneMap(map[string]any{})
|
|
if len(clone) != 0 {
|
|
t.Fatalf("expected empty, got %v", clone)
|
|
}
|
|
}
|
|
|
|
func TestCloneMapNested(t *testing.T) {
|
|
// cloneMap is shallow, so nested maps share references
|
|
inner := map[string]any{"key": "value"}
|
|
original := map[string]any{"nested": inner}
|
|
clone := cloneMap(original)
|
|
// Shallow clone means inner is shared
|
|
inner["key"] = "modified"
|
|
cloneNested := clone["nested"].(map[string]any)
|
|
if cloneNested["key"] != "modified" {
|
|
t.Fatal("expected shallow clone to share nested references")
|
|
}
|
|
}
|
|
|
|
// helper
|
|
func containsStr(s, sub string) bool {
|
|
return len(s) >= len(sub) && (s == sub || len(s) > 0 && findSubstring(s, sub))
|
|
}
|
|
|
|
func findSubstring(s, sub string) bool {
|
|
for i := 0; i <= len(s)-len(sub); i++ {
|
|
if s[i:i+len(sub)] == sub {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|