feat: 添加多个测试用例以增强生成内容的覆盖率，包括回退响应、路由处理和翻译功能

cuipengfei · cuipengfei · commit 141466b99b6f · 2025-09-25T23:12:24.000+08:00
diff --git a/tests/generate-content/fallback-response-no-text.test.ts b/tests/generate-content/fallback-response-no-text.test.ts
@@ -0,0 +1,53 @@
+import { afterEach, expect, test, mock } from "bun:test"
+
+afterEach(() => {
+  mock.restore()
+})
+
+test("streams fallback response when no text content in non-streaming to streaming conversion", async () => {
+  // Mock createChatCompletions to return a non-streaming response with no text content
+  await mock.module("~/services/copilot/create-chat-completions", () => ({
+    createChatCompletions: (_: unknown) => ({
+      id: "res-fallback",
+      choices: [
+        {
+          index: 0,
+          // No content, or content that doesn't have text
+          message: { role: "assistant", content: null },
+          finish_reason: "stop",
+        },
+      ],
+      usage: { prompt_tokens: 1, completion_tokens: 0, total_tokens: 1 },
+    }),
+  }))
+
+  await mock.module("~/lib/rate-limit", () => ({
+    checkRateLimit: () => {},
+  }))
+
+  const { server } = await import("~/server?fallback-response-no-text")
+
+  // Request streaming endpoint, but get non-streaming response with no text
+  const res = await server.request(
+    "/v1beta/models/gemini-pro:streamGenerateContent",
+    {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        contents: [{ role: "user", parts: [{ text: "test" }] }],
+      }),
+    },
+  )
+
+  expect(res.status).toBe(200)
+  const ct = res.headers.get("content-type") || ""
+  expect(ct.includes("text/event-stream")).toBe(true)
+
+  const body = await res.text()
+
+  // Should contain data events
+  expect(body.includes("data:")).toBe(true)
+  // Should have the fallback response structure
+  expect(body.includes('"candidates"')).toBe(true)
+  expect(body.includes('"usageMetadata"')).toBe(true)
+})
diff --git a/tests/generate-content/route-fallthrough.test.ts b/tests/generate-content/route-fallthrough.test.ts
@@ -0,0 +1,29 @@
+import { afterEach, expect, test, mock } from "bun:test"
+
+afterEach(() => {
+  mock.restore()
+})
+
+test("routes fallthrough when URL doesn't match any generate-content patterns", async () => {
+  await mock.module("~/lib/rate-limit", () => ({
+    checkRateLimit: () => {},
+  }))
+
+  const { server } = await import("~/server?route-fallthrough")
+
+  // Test with a URL that doesn't match any of the patterns
+  // Not :streamGenerateContent, not :countTokens, not :generateContent
+  const res = await server.request(
+    "/v1beta/models/gemini-pro:unknownOperation",
+    {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        contents: [{ role: "user", parts: [{ text: "test" }] }],
+      }),
+    },
+  )
+
+  // Should get 404 or similar since no route matches
+  expect(res.status).toBe(404)
+})
diff --git a/tests/generate-content/translation-advanced-coverage.test.ts b/tests/generate-content/translation-advanced-coverage.test.ts
@@ -0,0 +1,160 @@
+import { describe, it, expect } from "bun:test"
+
+import type { GeminiContent } from "~/routes/generate-content/types"
+
+import { translateGeminiContentsToOpenAI } from "~/routes/generate-content/translation"
+
+describe("Translation Advanced Coverage Tests", () => {
+  it("should handle system instruction in contents", () => {
+    const contents: Array<GeminiContent> = [
+      {
+        role: "user",
+        parts: [{ text: "Hello" }],
+      },
+    ]
+    const systemInstruction: GeminiContent = {
+      parts: [{ text: "You are a helpful assistant" }],
+    }
+
+    const messages = translateGeminiContentsToOpenAI(
+      contents,
+      systemInstruction,
+    )
+
+    const systemMessage = messages.find((m) => m.role === "system")
+    expect(systemMessage?.content).toBe("You are a helpful assistant")
+  })
+
+  it("should handle empty user message content with fallback", () => {
+    const contents: Array<GeminiContent> = [
+      {
+        role: "user",
+        parts: [{ text: "   " }], // Only whitespace
+      },
+    ]
+
+    const messages = translateGeminiContentsToOpenAI(contents)
+
+    const userMessage = messages.find((m) => m.role === "user")
+    expect(userMessage?.content).toBe(" ") // Fallback to minimal space
+  })
+
+  it("should handle function responses without matching tool call IDs", () => {
+    const contents: Array<GeminiContent> = [
+      {
+        role: "user",
+        parts: [
+          {
+            functionResponse: {
+              name: "unmatched_function",
+              response: { result: "orphan response" },
+            },
+          },
+        ],
+      },
+    ]
+
+    const messages = translateGeminiContentsToOpenAI(contents)
+
+    // Should not create tool messages for unmatched responses
+    const toolMessages = messages.filter((m) => m.role === "tool")
+    expect(toolMessages).toHaveLength(0)
+  })
+
+  it("should handle complex content that cannot be merged", () => {
+    // Create messages with complex content that can't be string-merged
+    const contents: Array<GeminiContent> = [
+      {
+        role: "user",
+        parts: [
+          {
+            inlineData: {
+              mimeType: "image/png",
+              data: "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg==",
+            },
+          },
+        ],
+      },
+      {
+        role: "user",
+        parts: [
+          {
+            inlineData: {
+              mimeType: "image/jpeg",
+              data: "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAYEBQYFBAYGBQYHBwYIChAKCgkJChQODwwQFxQYGBcUFhYaHSUfGhsjHBYWICwgIyYnKSopGR8tMC0oMCUoKSj/2wBDAQcHBwoIChMKChMoGhYaKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCj/wAARCAABAAEDASIAAhEBAxEB/8QAFQABAQAAAAAAAAAAAAAAAAAAAAv/xAAhEAACAQMDBQAAAAAAAAAAAAABAgMABAUGIWGRkqGx0f/EABUBAQEAAAAAAAAAAAAAAAAAAAMF/8QAGhEAAgMBAQAAAAAAAAAAAAAAAAECEgMRkf/aAAwDAQACEQMRAD8A0XmX5OMlEw==",
+            },
+          },
+        ],
+      },
+    ]
+
+    const messages = translateGeminiContentsToOpenAI(contents)
+
+    // Should create separate messages for complex content
+    const userMessages = messages.filter((m) => m.role === "user")
+    expect(userMessages).toHaveLength(2)
+    expect(Array.isArray(userMessages[0].content)).toBe(true)
+    expect(Array.isArray(userMessages[1].content)).toBe(true)
+  })
+
+  it("should handle media content with mixed text and images", () => {
+    const contents: Array<GeminiContent> = [
+      {
+        role: "user",
+        parts: [
+          { text: "Look at this image:" },
+          {
+            inlineData: {
+              mimeType: "image/png",
+              data: "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg==",
+            },
+          },
+        ],
+      },
+    ]
+
+    const messages = translateGeminiContentsToOpenAI(contents)
+
+    const userMessage = messages[0]
+    expect(Array.isArray(userMessage.content)).toBe(true)
+    const content = userMessage.content as Array<{
+      type: string
+      text?: string
+      image_url?: { url: string }
+    }>
+
+    expect(content).toHaveLength(2)
+    expect(content[0].type).toBe("text")
+    expect(content[0].text).toBe("Look at this image:")
+    expect(content[1].type).toBe("image_url")
+    expect(content[1].image_url?.url).toContain("data:image/png;base64,")
+  })
+
+  it("should handle googleSearch tool", () => {
+    const contents: Array<GeminiContent> = [
+      {
+        role: "user",
+        parts: [{ text: "Search for information" }],
+      },
+    ]
+
+    const messages = translateGeminiContentsToOpenAI(contents)
+
+    // Should be included in the messages array but tools conversion is internal
+    expect(messages).toHaveLength(1)
+  })
+
+  it("should handle NONE tool config mode", () => {
+    const contents: Array<GeminiContent> = [
+      {
+        role: "user",
+        parts: [{ text: "Hello" }],
+      },
+    ]
+
+    const messages = translateGeminiContentsToOpenAI(contents)
+
+    expect(messages).toHaveLength(1)
+    expect(messages[0].content).toBe("Hello")
+  })
+})
diff --git a/tests/generate-content/translation-response-coverage.test.ts b/tests/generate-content/translation-response-coverage.test.ts
@@ -0,0 +1,132 @@
+import { describe, it, expect } from "bun:test"
+
+import type { ChatCompletionResponse } from "~/services/copilot/create-chat-completions"
+
+import { translateOpenAIToGemini } from "~/routes/generate-content/translation"
+
+describe("OpenAI to Gemini Response Translation", () => {
+  it("should handle assistant message with tool calls having arguments", () => {
+    const openAIResponse: ChatCompletionResponse = {
+      id: "chatcmpl-123",
+      object: "chat.completion",
+      created: Date.now(),
+      model: "gpt-4",
+      choices: [
+        {
+          index: 0,
+          message: {
+            role: "assistant",
+            content: "I'll search for that",
+            tool_calls: [
+              {
+                id: "call_123",
+                type: "function",
+                function: {
+                  name: "search",
+                  arguments: '{"query": "test query", "limit": 10}',
+                },
+              },
+            ],
+          },
+          finish_reason: "tool_calls",
+          logprobs: null,
+        },
+      ],
+      usage: {
+        prompt_tokens: 10,
+        completion_tokens: 20,
+        total_tokens: 30,
+      },
+    }
+
+    const result = translateOpenAIToGemini(openAIResponse)
+
+    expect(result.candidates).toHaveLength(1)
+    expect(result.candidates[0]?.content.parts).toHaveLength(2)
+    expect(result.candidates[0]?.content.parts[0]).toEqual({
+      text: "I'll search for that",
+    })
+    expect(result.candidates[0]?.content.parts[1]).toEqual({
+      functionCall: {
+        name: "search",
+        args: { query: "test query", limit: 10 },
+      },
+    })
+  })
+
+  it("should handle assistant message with tool calls having empty arguments", () => {
+    const openAIResponse: ChatCompletionResponse = {
+      id: "chatcmpl-456",
+      object: "chat.completion",
+      created: Date.now(),
+      model: "gpt-4",
+      choices: [
+        {
+          index: 0,
+          message: {
+            role: "assistant",
+            content: "Getting current time",
+            tool_calls: [
+              {
+                id: "call_456",
+                type: "function",
+                function: {
+                  name: "get_current_time",
+                  arguments: "",
+                },
+              },
+            ],
+          },
+          finish_reason: "tool_calls",
+          logprobs: null,
+        },
+      ],
+      usage: {
+        prompt_tokens: 5,
+        completion_tokens: 10,
+        total_tokens: 15,
+      },
+    }
+
+    const result = translateOpenAIToGemini(openAIResponse)
+
+    expect(result.candidates[0]?.content.parts[1]).toEqual({
+      functionCall: {
+        name: "get_current_time",
+        args: {},
+      },
+    })
+  })
+
+  it("should handle assistant message with simple text content", () => {
+    const openAIResponse: ChatCompletionResponse = {
+      id: "chatcmpl-789",
+      object: "chat.completion",
+      created: Date.now(),
+      model: "gpt-4",
+      choices: [
+        {
+          index: 0,
+          message: {
+            role: "assistant",
+            content: "Here's my response",
+          },
+          finish_reason: "stop",
+          logprobs: null,
+        },
+      ],
+      usage: {
+        prompt_tokens: 15,
+        completion_tokens: 5,
+        total_tokens: 20,
+      },
+    }
+
+    const result = translateOpenAIToGemini(openAIResponse)
+
+    expect(result.candidates[0]?.content.parts).toHaveLength(1)
+    expect(result.candidates[0]?.content.parts[0]).toEqual({
+      text: "Here's my response",
+    })
+  })
+})
diff --git a/tests/generate-content/utils-finish-reason-mapping.test.ts b/tests/generate-content/utils-finish-reason-mapping.test.ts
