index.test.ts

import { afterEach, describe, expect, it, vi } from "vitest"
import DefaultPlugin, { SerpApiPlugin, SerpApiV2Plugin } from "./index"
import type { Context as V2Context } from "@opencode/plugin/promise/plugin"

const originalApiKey = process.env.SERPAPI_API_KEY

async function pluginHooks() {
  return SerpApiPlugin({} as never)
}

afterEach(() => {
  vi.unstubAllGlobals()
  if (originalApiKey === undefined) delete process.env.SERPAPI_API_KEY
  else process.env.SERPAPI_API_KEY = originalApiKey
})

describe("serpapi_search", () => {
  it("calls the REST API with mapped parameters and the trusted API key", async () => {
    process.env.SERPAPI_API_KEY = "trusted-key"
    const fetchMock = vi.fn(async (_input: string | URL | Request) => new Response('{"ok":true}', { status: 200 }))
    vi.stubGlobal("fetch", fetchMock)
    const search = (await pluginHooks()).tool?.serpapi_search
    if (!search) throw new Error("serpapi_search was not registered")

    const result = await search.execute(
      { engine: "amazon", q: "headphones", params: { api_key: "untrusted-key", page: 2 } },
      {} as never,
    )

    expect(result).toBe('{"ok":true}')
    expect(fetchMock).toHaveBeenCalledOnce()
    const url = new URL(String(fetchMock.mock.calls[0][0]))
    expect(url.origin + url.pathname).toBe("https://serpapi.com/search.json")
    expect(Object.fromEntries(url.searchParams)).toEqual({
      engine: "amazon",
      page: "2",
      k: "headphones",
      api_key: "trusted-key",
    })
  })

  it("returns HTTP failures as tool output", async () => {
    process.env.SERPAPI_API_KEY = "test-key"
    vi.stubGlobal("fetch", vi.fn(async () => new Response("rate limited", { status: 429 })))
    const search = (await pluginHooks()).tool?.serpapi_search
    if (!search) throw new Error("serpapi_search was not registered")

    await expect(search.execute({ engine: "google_light", q: "news" }, {} as never)).resolves.toBe(
      "SerpApi search failed: HTTP 429: rate limited",
    )
  })

  it("does not make a request without an API key", async () => {
    delete process.env.SERPAPI_API_KEY
    const fetchMock = vi.fn()
    vi.stubGlobal("fetch", fetchMock)
    const search = (await pluginHooks()).tool?.serpapi_search
    if (!search) throw new Error("serpapi_search was not registered")

    await expect(search.execute({ q: "news" }, {} as never)).resolves.toBe(
      "SERPAPI_API_KEY is not available to the OpenCode process.",
    )
    expect(fetchMock).not.toHaveBeenCalled()
  })
})

describe("dual-version entrypoint", () => {
  it("keeps the V1 server implementation on the default export", async () => {
    expect(typeof DefaultPlugin.server).toBe("function")
    const hooks = await DefaultPlugin.server({} as never)
    expect(hooks.tool?.serpapi_search).toBeDefined()
  })
})

describe("V1 configuration", () => {
  it("does not auto-register MCP and still registers the bundled skill path", async () => {
    process.env.SERPAPI_API_KEY = "test-key"
    const hooks = await pluginHooks()
    const config = {}

    await hooks.config?.(config)

    expect(config).not.toHaveProperty("mcp")
    expect(config).toMatchObject({ skills: { paths: [expect.any(String)] } })
  })
})

describe("OpenCode V2 adapter", () => {
  it("registers the native search tool and provider, remote MCP server, and bundled skill", async () => {
    const tools: Array<{ name: string; execute: (input: unknown, context: { signal: AbortSignal }) => Promise<{ content: string }> }> = []
    const servers: Record<string, unknown> = {}
    const skills: Array<{ id: string; name: string; description?: string; content: string }> = []
    const providers: Array<{
      id: string
      name: string
      execute: (
        input: { query: string },
        context: { signal: AbortSignal },
      ) => Promise<readonly { url: string; title?: string; content?: string; time: { published?: number } }[]>
    }> = []
    let defaultProvider: string | false | undefined
    const context = {
      mcp: {
        transform: async (transform: (editor: { get: (name: string) => unknown; set: (name: string, config: unknown) => void }) => void) =>
          transform({
            get: (name) => servers[name],
            set: (name, config) => { servers[name] = config },
          }),
      },
      tool: {
        transform: async (transform: (editor: { add: (definition: typeof tools[number]) => void }) => void) =>
          transform({ add: (definition) => tools.push(definition) }),
      },
      websearch: {
        transform: async (transform: (editor: {
          add: (definition: typeof providers[number]) => void
          default: { get: () => string | false | undefined; set: (selection: string | false) => void }
        }) => void) =>
          transform({
            add: (definition) => providers.push(definition),
            default: {
              get: () => defaultProvider,
              set: (selection) => { defaultProvider = selection },
            },
          }),
      },
      skill: {
        transform: async (transform: (editor: { add: (skill: typeof skills[number]) => void }) => void) =>
          transform({ add: (skill) => skills.push(skill) }),
      },
    } as unknown as V2Context

    process.env.SERPAPI_API_KEY = "v2-test-key"
    const searchResponse = JSON.stringify({
      organic_results: [{ title: "Headphones", link: "https://example.com/headphones", snippet: "Top result" }],
    })
    const fetchMock = vi.fn(async () => new Response(searchResponse, { status: 200 }))
    vi.stubGlobal("fetch", fetchMock)

    await SerpApiV2Plugin.setup(context)

    expect(tools.map(({ name }) => name)).toContain("serpapi_rest_search")
    expect(tools.map(({ name }) => name)).not.toContain("serpapi_search")
    expect(providers.map(({ id }) => id)).toContain("serpapi")
    expect(providers[0].name).toBe("SerpApi")
    expect(defaultProvider).toBeUndefined()
    expect(servers.serpapi).toMatchObject({
      type: "remote",
      url: "https://mcp.serpapi.com/mcp",
      oauth: false,
      headers: { Authorization: "Bearer v2-test-key" },
    })
    expect(skills).toHaveLength(1)
    expect(skills[0].name).toBe("serpapi-web-search")
    expect(skills[0].description).toContain("SerpApi provides live web and structured search results")
    expect(skills[0].content).toMatch(/^# SerpApi web search/)
    expect(skills[0].content).not.toContain("description: |")
    const restSearch = tools.find(({ name }) => name === "serpapi_rest_search")
    if (!restSearch) throw new Error("serpapi_rest_search was not registered")

    await expect(restSearch.execute({ engine: "amazon", q: "headphones" }, { signal: new AbortController().signal }))
      .resolves.toEqual({ content: searchResponse })
    await expect(providers[0].execute({ query: "headphones" }, { signal: new AbortController().signal }))
      .resolves.toEqual([{
        url: "https://example.com/headphones",
        title: "Headphones",
        content: "Top result",
        time: {},
      }])
    expect(fetchMock).toHaveBeenCalledTimes(2)

    fetchMock.mockRejectedValueOnce(new TypeError("Failed to fetch https://serpapi.com/search.json?api_key=v2-test-key"))
    await expect(providers[0].execute({ query: "headphones" }, { signal: new AbortController().signal }))
      .rejects.toThrow("SerpApi web search failed: Failed to fetch https://serpapi.com/search.json?api_key=[REDACTED]")
  })
})