Alfred/tests/web/hooks/use-providers.test.ts

import { describe, expect, test } from "bun:test";

import {
  createProvider,
  deleteProvider,
  fetchProvider,
  fetchProviderList,
  fetchProviderOptions,
  testProviderConfig,
  updateProvider,
} from "../../../src/web/shared/hooks/use-providers";
import { installFetchMock, jsonResponse } from "../test-utils";

const PROVIDER = {
  apiKey: "sk-test",
  baseUrl: "https://api.openai.com/v1",
  createdAt: "2024-01-01T00:00:00.000Z",
  id: "pv1",
  name: "OpenAI",
  type: "openai" as const,
  updatedAt: "2024-01-01T00:00:00.000Z",
};

async function expectRejectsWithMessage(action: () => Promise<unknown>, message: string) {
  try {
    await action();
    throw new Error("expected rejection");
  } catch (error) {
    expect(error).toBeInstanceOf(Error);
    expect((error as Error).message).toBe(message);
  }
}

function jsonBody(body: BodyInit | null | undefined): unknown {
  return JSON.parse(typeof body === "string" ? body : "{}");
}

describe("use-providers request helpers", () => {
  test("fetchProviderList builds correct query params", async () => {
    const calls = installFetchMock(() => jsonResponse({ items: [PROVIDER], page: 1, pageSize: 20, total: 1 }));

    const result = await fetchProviderList({ keyword: "OpenAI", page: 1, pageSize: 20 });

    expect(result.items).toHaveLength(1);
    expect(calls[0]?.method).toBe("GET");
    expect(calls[0]?.url).toBe("/api/providers?page=1&pageSize=20&keyword=OpenAI");
  });

  test("CRUD uses correct method, URL and body", async () => {
    const calls = installFetchMock((call) => {
      if (call.method === "DELETE") return new Response(null, { status: 204 });
      return jsonResponse(
        { provider: PROVIDER },
        { status: call.method === "POST" && call.url === "/api/providers" ? 201 : 200 },
      );
    });

    await createProvider({ apiKey: "sk-test", baseUrl: "https://api.openai.com/v1", name: "OpenAI", type: "openai" });
    await updateProvider("pv1", { name: "New OpenAI" });
    await deleteProvider("pv1");
    await fetchProvider("pv1");

    expect(calls.map((c) => c.method + " " + c.url)).toEqual([
      "POST /api/providers",
      "PATCH /api/providers/pv1",
      "DELETE /api/providers/pv1",
      "GET /api/providers/pv1",
    ]);
    expect(jsonBody(calls[0]?.body)).toEqual({
      apiKey: "sk-test",
      baseUrl: "https://api.openai.com/v1",
      name: "OpenAI",
      type: "openai",
    });
    expect(jsonBody(calls[1]?.body)).toEqual({ name: "New OpenAI" });
  });

  test("fetchProviderOptions uses dedicated minimal endpoint", async () => {
    const calls = installFetchMock(() => jsonResponse({ items: [{ id: "pv1", name: "OpenAI", type: "openai" }] }));

    const result = await fetchProviderOptions();

    expect(result.items).toEqual([{ id: "pv1", name: "OpenAI", type: "openai" }]);
    expect(calls[0]?.method).toBe("GET");
    expect(calls[0]?.url).toBe("/api/providers/options");
  });

  test("testProviderConfig posts form config and parses response", async () => {
    const calls = installFetchMock(() => jsonResponse({ providerTestResponse: { message: "ok", ok: true } }));

    const result = await testProviderConfig({
      apiKey: "sk-test",
      baseUrl: "https://api.openai.com/v1",
      name: "OpenAI",
      type: "openai-compatible",
    });

    expect(result).toEqual({ message: "ok", ok: true });
    expect(calls[0]?.method).toBe("POST");
    expect(calls[0]?.url).toBe("/api/providers/test");
    expect(jsonBody(calls[0]?.body)).toEqual({
      apiKey: "sk-test",
      baseUrl: "https://api.openai.com/v1",
      name: "OpenAI",
      type: "openai-compatible",
    });
  });

  test("error response uses backend error field", async () => {
    installFetchMock(() => jsonResponse({ error: "dup" }, { status: 409 }));

    await expectRejectsWithMessage(
      () => createProvider({ apiKey: "sk", baseUrl: "https://x.com", name: "dup", type: "openai-compatible" }),
      "dup",
    );
  });

  test("non-JSON error falls back to HTTP status", async () => {
    installFetchMock(() => new Response("broken", { status: 500 }));

    await expectRejectsWithMessage(() => fetchProvider("missing"), "HTTP 500");
  });
});