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

import type Database from "bun:sqlite";

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

import {
  createProvider,
  deleteProvider,
  getProvider,
  listProviderOptions,
  listProviders,
  updateProvider,
} from "../../../src/server/db/providers";
import { createNoopLogger } from "../../../src/server/logger";
import { createMigratedTestDatabase } from "../../helpers";

function withDb(callback: (db: Database) => void): void {
  const handle = createMigratedTestDatabase("providers-test");
  try {
    callback(handle.db);
    handle.close();
  } finally {
    handle.cleanup();
  }
}

describe("供应商数据访问层", () => {
  test("迁移后的供应商和模型表不包含 enabled 字段", () => {
    withDb((db) => {
      const providerColumns = db.query("PRAGMA table_info(providers)").all() as Array<{ name: string }>;
      const modelColumns = db.query("PRAGMA table_info(models)").all() as Array<{ name: string }>;

      expect(providerColumns.map((column) => column.name)).not.toContain("enabled");
      expect(modelColumns.map((column) => column.name)).not.toContain("enabled");
    });
  });

  test("创建供应商", () => {
    withDb((db) => {
      const result = createProvider(
        db,
        {
          apiKey: "sk-test",
          baseUrl: "https://api.openai.com/v1",
          name: "OpenAI",
          type: "openai",
        },
        createNoopLogger(),
      );
      expect("error" in result).toBe(false);
      const provider = (result as { provider: { apiKey: string; baseUrl: string; name: string; type: string } })
        .provider;
      expect(provider.name).toBe("OpenAI");
      expect(provider.type).toBe("openai");
      expect(provider.baseUrl).toBe("https://api.openai.com/v1");
      expect(provider.apiKey).toBe("sk-test");
    });
  });

  test("供应商名称唯一", () => {
    withDb((db) => {
      createProvider(
        db,
        { apiKey: "sk-1", baseUrl: "https://a.com", name: "唯一", type: "openai" },
        createNoopLogger(),
      );
      const result = createProvider(
        db,
        { apiKey: "sk-2", baseUrl: "https://b.com", name: "唯一", type: "openai" },
        createNoopLogger(),
      );
      expect("error" in result).toBe(true);
      expect((result as unknown as { error: string }).error).toContain("已存在");
    });
  });

  test("名称为空时创建失败", () => {
    withDb((db) => {
      const result = createProvider(
        db,
        { apiKey: "sk", baseUrl: "https://a.com", name: "   ", type: "openai" },
        createNoopLogger(),
      );
      expect("error" in result).toBe(true);
      expect((result as unknown as { error: string }).error).toContain("不能为空");
    });
  });

  test("列表查询（分页和关键字）", () => {
    withDb((db) => {
      createProvider(
        db,
        { apiKey: "sk-1", baseUrl: "https://a.com", name: "Alpha", type: "openai" },
        createNoopLogger(),
      );
      createProvider(
        db,
        { apiKey: "sk-2", baseUrl: "https://b.com", name: "Beta", type: "anthropic" },
        createNoopLogger(),
      );
      createProvider(
        db,
        { apiKey: "sk-3", baseUrl: "https://c.com", name: "Gamma", type: "openai-compatible" },
        createNoopLogger(),
      );

      const result1 = listProviders(db, { page: 1, pageSize: 20 });
      expect(result1.total).toBe(3);

      const result2 = listProviders(db, { keyword: "Alpha", page: 1, pageSize: 20 });
      expect(result2.total).toBe(1);
      expect(result2.items[0]!.name).toBe("Alpha");

      const result3 = listProviders(db, { page: 1, pageSize: 2 });
      expect(result3.items.length).toBe(2);
    });
  });

  test("获取供应商详情", () => {
    withDb((db) => {
      const created = createProvider(
        db,
        { apiKey: "sk", baseUrl: "https://a.com", name: "详情", type: "openai" },
        createNoopLogger(),
      );
      const id = (created as { provider: { id: string } }).provider.id;

      const result = getProvider(db, id);
      expect("error" in result).toBe(false);
      expect((result as { provider: { name: string } }).provider.name).toBe("详情");
    });
  });

  test("获取不存在的供应商返回 404", () => {
    withDb((db) => {
      const result = getProvider(db, "nonexistent");
      expect("error" in result).toBe(true);
      expect((result as unknown as { status: number }).status).toBe(404);
    });
  });

  test("更新供应商", () => {
    withDb((db) => {
      const created = createProvider(
        db,
        { apiKey: "sk", baseUrl: "https://a.com", name: "原名", type: "openai" },
        createNoopLogger(),
      );
      const id = (created as { provider: { id: string } }).provider.id;

      const result = updateProvider(db, id, { name: "新名" }, createNoopLogger());
      expect("error" in result).toBe(false);
      expect((result as { provider: { name: string } }).provider.name).toBe("新名");
    });
  });

  test("更新供应商名称重复失败", () => {
    withDb((db) => {
      createProvider(
        db,
        { apiKey: "sk-1", baseUrl: "https://a.com", name: "已存在", type: "openai" },
        createNoopLogger(),
      );
      const created = createProvider(
        db,
        { apiKey: "sk-2", baseUrl: "https://b.com", name: "原名", type: "openai" },
        createNoopLogger(),
      );
      const id = (created as { provider: { id: string } }).provider.id;

      const result = updateProvider(db, id, { name: "已存在" }, createNoopLogger());
      expect("error" in result).toBe(true);
      expect((result as unknown as { error: string }).error).toContain("已存在");
    });
  });

  test("删除供应商", () => {
    withDb((db) => {
      const created = createProvider(
        db,
        { apiKey: "sk", baseUrl: "https://a.com", name: "删除测试", type: "openai" },
        createNoopLogger(),
      );
      const id = (created as { provider: { id: string } }).provider.id;

      const result = deleteProvider(db, id, createNoopLogger());
      expect("error" in result).toBe(false);

      const after = getProvider(db, id);
      expect("error" in after).toBe(true);
    });
  });

  test("删除不存在的供应商返回 404", () => {
    withDb((db) => {
      const result = deleteProvider(db, "nonexistent", createNoopLogger());
      expect("error" in result).toBe(true);
      expect((result as unknown as { status: number }).status).toBe(404);
    });
  });

  test("默认类型为 openai-compatible", () => {
    withDb((db) => {
      createProvider(
        db,
        { apiKey: "sk", baseUrl: "https://a.com", name: "默认类型", type: "openai-compatible" },
        createNoopLogger(),
      );
      const result = createProvider(
        db,
        {
          apiKey: "sk2",
          baseUrl: "https://b.com",
          name: "显式默认",
          type: "openai-compatible",
        },
        createNoopLogger(),
      );
      expect((result as { provider: { type: string } }).provider.type).toBe("openai-compatible");
    });
  });

  test("供应商 options 返回最小字段", () => {
    withDb((db) => {
      createProvider(db, { apiKey: "sk", baseUrl: "https://a.com", name: "选项", type: "openai" }, createNoopLogger());

      const options = listProviderOptions(db);
      expect(options.length).toBe(1);
      expect(typeof options[0]?.id).toBe("string");
      expect(options[0]).toMatchObject({ name: "选项", type: "openai" });
      expect(options[0]).not.toHaveProperty("apiKey");
      expect(options[0]).not.toHaveProperty("enabled");
    });
  });
});