Alfred/tests/server/routes/providers.test.ts

import type Database from "bun:sqlite";

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

import type { Provider, RuntimeMode } from "../../../src/shared/api";

import { createModel } from "../../../src/server/db/models";
import { createProvider } from "../../../src/server/db/providers";
import { createMigratedMemoryTestDatabase } from "../../helpers";

const MODE: RuntimeMode = "test";

let generateTextImpl: (_opts: unknown) => unknown = () => ({});

void mock.module("ai", () => ({
  createProviderRegistry: () => ({
    languageModel: () => ({}),
  }),
  generateText: mock((opts: unknown) => generateTextImpl(opts)),
}));

async function createProviderViaHandler(req: Request, db: Database): Promise<Response> {
  const { handleCreateProvider: h } = await import("../../../src/server/routes/providers/create");
  return h(req, db, MODE);
}

function createTestProvider(db: Database, name = "测试供应商"): Provider {
  const result = createProvider(db, {
    apiKey: "sk-test",
    baseUrl: "https://api.test.com/v1",
    name,
    type: "openai",
  });
  if ("error" in result) throw new Error(result.error);
  return result.provider;
}

async function deleteProviderViaHandler(req: Request, db: Database): Promise<Response> {
  const { handleDeleteProvider: h } = await import("../../../src/server/routes/providers/delete");
  return h(req, db, MODE);
}

async function disableProviderViaHandler(req: Request, db: Database): Promise<Response> {
  const { handleDisableProvider: h } = await import("../../../src/server/routes/providers/disable");
  return h(req, db, MODE);
}

async function enableProviderViaHandler(req: Request, db: Database): Promise<Response> {
  const { handleEnableProvider: h } = await import("../../../src/server/routes/providers/enable");
  return h(req, db, MODE);
}

async function getProviderViaHandler(req: Request, db: Database): Promise<Response> {
  const { handleGetProvider: h } = await import("../../../src/server/routes/providers/get");
  return h(req, db, MODE);
}

async function listProvidersViaHandler(req: Request, db: Database): Promise<Response> {
  const { handleListProviders: h } = await import("../../../src/server/routes/providers/list");
  return h(req, db, MODE);
}

async function testProviderConfigViaHandler(req: Request, db: Database): Promise<Response> {
  const { handleTestProviderConfig: h } = await import("../../../src/server/routes/providers/test");
  return h(req, db, MODE);
}

async function testProviderViaHandler(req: Request, db: Database): Promise<Response> {
  const { handleTestProvider: h } = await import("../../../src/server/routes/providers/test");
  return h(req, db, MODE);
}

async function updateProviderViaHandler(req: Request, db: Database): Promise<Response> {
  const { handleUpdateProvider: h } = await import("../../../src/server/routes/providers/update");
  return h(req, db, MODE);
}

async function withRouteDb(callback: (db: Database) => Promise<void>): Promise<void> {
  const handle = createMigratedMemoryTestDatabase("route-provider-test");
  try {
    await callback(handle.db);
    handle.close();
  } finally {
    handle.cleanup();
  }
}

describe("供应商 API 路由", () => {
  test("POST /api/providers 创建供应商", async () => {
    await withRouteDb(async (db) => {
      const req = new Request("http://localhost/api/providers", {
        body: JSON.stringify({
          apiKey: "sk-test",
          baseUrl: "https://api.openai.com/v1",
          name: "OpenAI",
          type: "openai",
        }),
        headers: { "Content-Type": "application/json" },
        method: "POST",
      });
      const res = await createProviderViaHandler(req, db);
      expect(res.status).toBe(201);
      const body = (await res.json()) as { provider: Provider };
      expect(body.provider.name).toBe("OpenAI");
      expect(body.provider.type).toBe("openai");
    });
  });

  test("GET /api/providers 列表查询", async () => {
    await withRouteDb(async (db) => {
      createTestProvider(db, "A供应商");
      createTestProvider(db, "B供应商");

      const req = new Request("http://localhost/api/providers?page=1&pageSize=20");
      const res = await listProvidersViaHandler(req, db);
      expect(res.status).toBe(200);
      const body = (await res.json()) as { items: Provider[]; total: number };
      expect(body.total).toBe(2);
      expect(body.items.length).toBe(2);
    });
  });

  test("GET /api/providers/:id 获取详情", async () => {
    await withRouteDb(async (db) => {
      const provider = createTestProvider(db, "详情路由");

      const req = new Request(`http://localhost/api/providers/${provider.id}`);
      const res = await getProviderViaHandler(req, db);
      expect(res.status).toBe(200);
      const body = (await res.json()) as { provider: Provider };
      expect(body.provider.name).toBe("详情路由");
    });
  });

  test("PATCH /api/providers/:id 更新供应商", async () => {
    await withRouteDb(async (db) => {
      const provider = createTestProvider(db, "更新路由");

      const req = new Request(`http://localhost/api/providers/${provider.id}`, {
        body: JSON.stringify({ name: "已更新" }),
        headers: { "Content-Type": "application/json" },
        method: "PATCH",
      });
      const res = await updateProviderViaHandler(req, db);
      expect(res.status).toBe(200);
      const body = (await res.json()) as { provider: Provider };
      expect(body.provider.name).toBe("已更新");
    });
  });

  test("POST /api/providers/:id/enable 启用", async () => {
    await withRouteDb(async (db) => {
      const provider = createTestProvider(db, "启用测试");
      await disableProviderViaHandler(
        new Request(`http://localhost/api/providers/${provider.id}/disable`, { method: "POST" }),
        db,
      );

      const req = new Request(`http://localhost/api/providers/${provider.id}/enable`, { method: "POST" });
      const res = await enableProviderViaHandler(req, db);
      expect(res.status).toBe(200);
      const body = (await res.json()) as { provider: Provider };
      expect(body.provider.enabled).toBe(true);
    });
  });

  test("POST /api/providers/:id/disable 禁用", async () => {
    await withRouteDb(async (db) => {
      const provider = createTestProvider(db, "禁用测试");

      const req = new Request(`http://localhost/api/providers/${provider.id}/disable`, { method: "POST" });
      const res = await disableProviderViaHandler(req, db);
      expect(res.status).toBe(200);
      const body = (await res.json()) as { provider: Provider };
      expect(body.provider.enabled).toBe(false);
    });
  });

  test("DELETE /api/providers/:id 删除供应商", async () => {
    await withRouteDb(async (db) => {
      const provider = createTestProvider(db, "删除路由");

      const req = new Request(`http://localhost/api/providers/${provider.id}`, { method: "DELETE" });
      const res = await deleteProviderViaHandler(req, db);
      expect(res.status).toBe(204);
    });
  });

  test("DELETE /api/providers/:id 存在关联模型时返回 409", async () => {
    await withRouteDb(async (db) => {
      const provider = createTestProvider(db, "有关联模型");
      const modelResult = createModel(db, {
        capabilities: ["text"],
        modelId: "gpt-4o",
        name: "GPT-4o",
        providerId: provider.id,
      });
      if ("error" in modelResult) throw new Error(modelResult.error);

      const req = new Request(`http://localhost/api/providers/${provider.id}`, { method: "DELETE" });
      const res = await deleteProviderViaHandler(req, db);
      expect(res.status).toBe(409);
      const body = (await res.json()) as { error: string };
      expect(body.error).toContain("存在模型");
    });
  });

  test("POST /api/providers/:id/test 返回连通性失败结果", async () => {
    await withRouteDb(async (db) => {
      generateTextImpl = () => {
        throw new Error("bad key");
      };
      const provider = createTestProvider(db, "测试失败供应商");

      const req = new Request(`http://localhost/api/providers/${provider.id}/test`, { method: "POST" });
      const res = await testProviderViaHandler(req, db);
      expect(res.status).toBe(200);
      const body = (await res.json()) as { providerTestResponse: { message: string; ok: boolean } };
      expect(body.providerTestResponse.ok).toBe(false);
      expect(body.providerTestResponse.message).toContain("连接失败");
      generateTextImpl = () => ({});
    });
  });

  test("POST /api/providers/test 使用表单配置测试连通性", async () => {
    await withRouteDb(async (db) => {
      generateTextImpl = () => ({});
      const req = new Request("http://localhost/api/providers/test", {
        body: JSON.stringify({
          apiKey: "sk-test",
          baseUrl: "https://api.openai.com/v1",
          name: "OpenAI",
          type: "openai",
        }),
        headers: { "Content-Type": "application/json" },
        method: "POST",
      });
      const res = await testProviderConfigViaHandler(req, db);
      expect(res.status).toBe(200);
      const body = (await res.json()) as { providerTestResponse: { message: string; ok: boolean } };
      expect(body.providerTestResponse).toEqual({ message: "连接成功", ok: true });
    });
  });

  test("创建同名供应商返回 409", async () => {
    await withRouteDb(async (db) => {
      const req1 = new Request("http://localhost/api/providers", {
        body: JSON.stringify({
          apiKey: "sk-a",
          baseUrl: "https://a.com",
          name: "重复名",
          type: "openai",
        }),
        headers: { "Content-Type": "application/json" },
        method: "POST",
      });
      await createProviderViaHandler(req1, db);

      const req2 = new Request("http://localhost/api/providers", {
        body: JSON.stringify({
          apiKey: "sk-b",
          baseUrl: "https://b.com",
          name: "重复名",
          type: "openai",
        }),
        headers: { "Content-Type": "application/json" },
        method: "POST",
      });
      const res = await createProviderViaHandler(req2, db);
      expect(res.status).toBe(409);
    });
  });
});