lanyuanxiaoyao/Alfred
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: 全栈 Logger 依赖注入 — DB/Route/AI 层传参 + 前端 Logger + 测试更新 + 归档 add-frontend-logger

Browse Source
This commit is contained in:
兰缘小妖
2026-06-01 20:32:19 +08:00
parent 4c72754739
commit 844562303c
60 changed files with 1648 additions and 778 deletions
Download Patch File Download Diff File Expand all files Collapse all files

119
tests/server/db/models.test.ts
View File

@@ -11,10 +11,15 @@ import {
updateModel,
} from "../../../src/server/db/models";
import { createProvider } from "../../../src/server/db/providers";
import { createNoopLogger } from "../../../src/server/logger";
import { createMigratedTestDatabase } from "../../helpers";
function seedProvider(db: Database, name = "TestProvider"): string {
const result = createProvider(db, { apiKey: "sk-test", baseUrl: "https://api.test.com/v1", name, type: "openai" });
const result = createProvider(
db,
{ apiKey: "sk-test", baseUrl: "https://api.test.com/v1", name, type: "openai" },
createNoopLogger(),
);
return (result as { provider: { id: string } }).provider.id;
}
@@ -32,12 +37,16 @@ describe("模型数据访问层", () => {
test("创建模型", () => {
withDb((db) => {
const providerId = seedProvider(db);
const result = createModel(db, {
capabilities: ["text", "reasoning"],
modelId: "gpt-4o",
name: "GPT-4o",
providerId,
});
const result = createModel(
db,
{
capabilities: ["text", "reasoning"],
modelId: "gpt-4o",
name: "GPT-4o",
providerId,
},
createNoopLogger(),
);
expect("error" in result).toBe(false);
const model = (result as { model: { capabilities: string[]; modelId: string; name: string; providerId: string } })
.model;
@@ -50,12 +59,16 @@ describe("模型数据访问层", () => {
test("供应商不存在时创建失败", () => {
withDb((db) => {
const result = createModel(db, {
capabilities: ["text"],
modelId: "test",
name: "Test",
providerId: "nonexistent",
});
const result = createModel(
db,
{
capabilities: ["text"],
modelId: "test",
name: "Test",
providerId: "nonexistent",
},
createNoopLogger(),
);
expect("error" in result).toBe(true);
expect((result as unknown as { status: number }).status).toBe(400);
});
@@ -64,8 +77,12 @@ describe("模型数据访问层", () => {
test("同一供应商下模型 ID 唯一", () => {
withDb((db) => {
const providerId = seedProvider(db);
createModel(db, { capabilities: ["text"], modelId: "gpt-4o", name: "Model1", providerId });
const result = createModel(db, { capabilities: ["text"], modelId: "gpt-4o", name: "Model2", providerId });
createModel(db, { capabilities: ["text"], modelId: "gpt-4o", name: "Model1", providerId }, createNoopLogger());
const result = createModel(
db,
{ capabilities: ["text"], modelId: "gpt-4o", name: "Model2", providerId },
createNoopLogger(),
);
expect("error" in result).toBe(true);
expect((result as unknown as { error: string }).error).toContain("已存在");
});
@@ -75,8 +92,16 @@ describe("模型数据访问层", () => {
withDb((db) => {
const p1 = seedProvider(db, "P1");
const p2 = seedProvider(db, "P2");
const r1 = createModel(db, { capabilities: ["text"], modelId: "same-id", name: "M1", providerId: p1 });
const r2 = createModel(db, { capabilities: ["text"], modelId: "same-id", name: "M2", providerId: p2 });
const r1 = createModel(
db,
{ capabilities: ["text"], modelId: "same-id", name: "M1", providerId: p1 },
createNoopLogger(),
);
const r2 = createModel(
db,
{ capabilities: ["text"], modelId: "same-id", name: "M2", providerId: p2 },
createNoopLogger(),
);
expect("error" in r1).toBe(false);
expect("error" in r2).toBe(false);
});
@@ -85,7 +110,11 @@ describe("模型数据访问层", () => {
test("能力标签为空时创建失败", () => {
withDb((db) => {
const providerId = seedProvider(db);
const result = createModel(db, { capabilities: [], modelId: "test", name: "Test", providerId });
const result = createModel(
db,
{ capabilities: [], modelId: "test", name: "Test", providerId },
createNoopLogger(),
);
expect("error" in result).toBe(true);
expect((result as unknown as { error: string }).error).toContain("能力标签");
});
@@ -95,9 +124,9 @@ describe("模型数据访问层", () => {
withDb((db) => {
const p1 = seedProvider(db, "P1");
const p2 = seedProvider(db, "P2");
createModel(db, { capabilities: ["text"], modelId: "m1", name: "Alpha", providerId: p1 });
createModel(db, { capabilities: ["text"], modelId: "m2", name: "Beta", providerId: p1 });
createModel(db, { capabilities: ["text"], modelId: "m3", name: "Gamma", providerId: p2 });
createModel(db, { capabilities: ["text"], modelId: "m1", name: "Alpha", providerId: p1 }, createNoopLogger());
createModel(db, { capabilities: ["text"], modelId: "m2", name: "Beta", providerId: p1 }, createNoopLogger());
createModel(db, { capabilities: ["text"], modelId: "m3", name: "Gamma", providerId: p2 }, createNoopLogger());
const all = listModels(db, { page: 1, pageSize: 20 });
expect(all.total).toBe(3);
@@ -113,7 +142,11 @@ describe("模型数据访问层", () => {
test("获取模型详情", () => {
withDb((db) => {
const providerId = seedProvider(db);
const created = createModel(db, { capabilities: ["text"], modelId: "gpt-4o", name: "GPT-4o", providerId });
const created = createModel(
db,
{ capabilities: ["text"], modelId: "gpt-4o", name: "GPT-4o", providerId },
createNoopLogger(),
);
const id = (created as { model: { id: string } }).model.id;
const result = getModel(db, id);
@@ -133,10 +166,14 @@ describe("模型数据访问层", () => {
test("更新模型", () => {
withDb((db) => {
const providerId = seedProvider(db);
const created = createModel(db, { capabilities: ["text"], modelId: "gpt-4o", name: "原名", providerId });
const created = createModel(
db,
{ capabilities: ["text"], modelId: "gpt-4o", name: "原名", providerId },
createNoopLogger(),
);
const id = (created as { model: { id: string } }).model.id;
const result = updateModel(db, id, { capabilities: ["text", "reasoning"], name: "新名" });
const result = updateModel(db, id, { capabilities: ["text", "reasoning"], name: "新名" }, createNoopLogger());
expect("error" in result).toBe(false);
const updated = (result as { model: { capabilities: string[]; name: string } }).model;
expect(updated.name).toBe("新名");
@@ -147,10 +184,14 @@ describe("模型数据访问层", () => {
test("删除模型", () => {
withDb((db) => {
const providerId = seedProvider(db);
const created = createModel(db, { capabilities: ["text"], modelId: "gpt-4o", name: "删除测试", providerId });
const created = createModel(
db,
{ capabilities: ["text"], modelId: "gpt-4o", name: "删除测试", providerId },
createNoopLogger(),
);
const id = (created as { model: { id: string } }).model.id;
const result = deleteModel(db, id);
const result = deleteModel(db, id, createNoopLogger());
expect("error" in result).toBe(false);
const after = getModel(db, id);
@@ -162,9 +203,9 @@ describe("模型数据访问层", () => {
withDb((db) => {
const p1 = seedProvider(db, "P1");
const p2 = seedProvider(db, "P2");
createModel(db, { capabilities: ["text"], modelId: "m1", name: "M1", providerId: p1 });
createModel(db, { capabilities: ["text"], modelId: "m2", name: "M2", providerId: p1 });
createModel(db, { capabilities: ["text"], modelId: "m3", name: "M3", providerId: p2 });
createModel(db, { capabilities: ["text"], modelId: "m1", name: "M1", providerId: p1 }, createNoopLogger());
createModel(db, { capabilities: ["text"], modelId: "m2", name: "M2", providerId: p1 }, createNoopLogger());
createModel(db, { capabilities: ["text"], modelId: "m3", name: "M3", providerId: p2 }, createNoopLogger());
expect(getModelsByProviderId(db, p1)).toBe(2);
expect(getModelsByProviderId(db, p2)).toBe(1);
@@ -174,14 +215,18 @@ describe("模型数据访问层", () => {
test("可选字段 contextLength 和 maxOutputTokens", () => {
withDb((db) => {
const providerId = seedProvider(db);
const result = createModel(db, {
capabilities: ["text"],
contextLength: 128000,
maxOutputTokens: 4096,
modelId: "gpt-4o",
name: "GPT-4o",
providerId,
});
const result = createModel(
db,
{
capabilities: ["text"],
contextLength: 128000,
maxOutputTokens: 4096,
modelId: "gpt-4o",
name: "GPT-4o",
providerId,
},
createNoopLogger(),
);
expect("error" in result).toBe(false);
const model = (result as { model: { contextLength: null | number; maxOutputTokens: null | number } }).model;
expect(model.contextLength).toBe(128000);

69
tests/server/db/projects.test.ts
View File

@@ -11,6 +11,7 @@ import {
restoreProject,
updateProject,
} from "../../../src/server/db/projects";
import { createNoopLogger } from "../../../src/server/logger";
import { createMigratedTestDatabase } from "../../helpers";
function withProjectsDb(callback: (db: Database) => void): void {
@@ -26,7 +27,7 @@ function withProjectsDb(callback: (db: Database) => void): void {
describe("项目数据访问层", () => {
test("创建项目", () => {
withProjectsDb((db) => {
const result = createProject(db, { description: "测试描述", name: "测试项目" });
const result = createProject(db, { description: "测试描述", name: "测试项目" }, createNoopLogger());
expect("error" in result).toBe(false);
expect((result as { project: unknown }).project).toBeDefined();
@@ -43,8 +44,8 @@ describe("项目数据访问层", () => {
test("项目名称全局唯一（含归档项目）", () => {
withProjectsDb((db) => {
createProject(db, { name: "唯一名称" });
const result2 = createProject(db, { name: "唯一名称" });
createProject(db, { name: "唯一名称" }, createNoopLogger());
const result2 = createProject(db, { name: "唯一名称" }, createNoopLogger());
expect("error" in result2).toBe(true);
expect((result2 as unknown as { error: string }).error).toContain("已存在");
});
@@ -52,7 +53,7 @@ describe("项目数据访问层", () => {
test("trim 后名称为空时创建失败", () => {
withProjectsDb((db) => {
const result = createProject(db, { name: " " });
const result = createProject(db, { name: " " }, createNoopLogger());
expect("error" in result).toBe(true);
expect((result as unknown as { error: string }).error).toContain("不能为空");
});
@@ -60,9 +61,9 @@ describe("项目数据访问层", () => {
test("列表查询（分页和关键字）", () => {
withProjectsDb((db) => {
createProject(db, { description: "descA", name: "项目A" });
createProject(db, { description: "descB", name: "项目B" });
createProject(db, { name: "其他" });
createProject(db, { description: "descA", name: "项目A" }, createNoopLogger());
createProject(db, { description: "descB", name: "项目B" }, createNoopLogger());
createProject(db, { name: "其他" }, createNoopLogger());
const result1 = listProjects(db, { page: 1, pageSize: 20 });
expect(result1.total).toBe(3);
@@ -79,7 +80,7 @@ describe("项目数据访问层", () => {
test("获取项目详情", () => {
withProjectsDb((db) => {
const created = createProject(db, { description: "详情", name: "详情项目" });
const created = createProject(db, { description: "详情", name: "详情项目" }, createNoopLogger());
const id = (created as { project: { id: string } }).project.id;
const result = getProject(db, id);
@@ -99,10 +100,10 @@ describe("项目数据访问层", () => {
test("更新项目名称和描述", () => {
withProjectsDb((db) => {
const created = createProject(db, { name: "原名" });
const created = createProject(db, { name: "原名" }, createNoopLogger());
const id = (created as { project: { id: string } }).project.id;
const result = updateProject(db, id, { description: "新描述", name: "新名" });
const result = updateProject(db, id, { description: "新描述", name: "新名" }, createNoopLogger());
expect("error" in result).toBe(false);
const updated = result as { project: { description: string; name: string } };
@@ -113,11 +114,11 @@ describe("项目数据访问层", () => {
test("更新已归档项目失败", () => {
withProjectsDb((db) => {
const created = createProject(db, { name: "待归档" });
const created = createProject(db, { name: "待归档" }, createNoopLogger());
const id = (created as { project: { id: string } }).project.id;
archiveProject(db, id);
archiveProject(db, id, createNoopLogger());
const result = updateProject(db, id, { name: "新名称" });
const result = updateProject(db, id, { name: "新名称" }, createNoopLogger());
expect("error" in result).toBe(true);
expect((result as unknown as { status: number }).status).toBe(409);
});
@@ -125,10 +126,10 @@ describe("项目数据访问层", () => {
test("归档项目", () => {
withProjectsDb((db) => {
const created = createProject(db, { name: "待归档" });
const created = createProject(db, { name: "待归档" }, createNoopLogger());
const id = (created as { project: { id: string } }).project.id;
const result = archiveProject(db, id);
const result = archiveProject(db, id, createNoopLogger());
expect("error" in result).toBe(false);
const archived = (result as { project: { archivedAt: null | string; status: string } }).project;
@@ -146,10 +147,10 @@ describe("项目数据访问层", () => {
test("对已归档项目重复归档失败", () => {
withProjectsDb((db) => {
const created = createProject(db, { name: "测试" });
const created = createProject(db, { name: "测试" }, createNoopLogger());
const id = (created as { project: { id: string } }).project.id;
archiveProject(db, id);
const result = archiveProject(db, id);
archiveProject(db, id, createNoopLogger());
const result = archiveProject(db, id, createNoopLogger());
expect("error" in result).toBe(true);
expect((result as unknown as { status: number }).status).toBe(409);
});
@@ -157,11 +158,11 @@ describe("项目数据访问层", () => {
test("恢复已归档项目", () => {
withProjectsDb((db) => {
const created = createProject(db, { name: "恢复测试" });
const created = createProject(db, { name: "恢复测试" }, createNoopLogger());
const id = (created as { project: { id: string } }).project.id;
archiveProject(db, id);
archiveProject(db, id, createNoopLogger());
const result = restoreProject(db, id);
const result = restoreProject(db, id, createNoopLogger());
expect("error" in result).toBe(false);
const restored = (result as { project: { archivedAt: null | string; status: string } }).project;
@@ -172,9 +173,9 @@ describe("项目数据访问层", () => {
test("恢复 active 项目失败", () => {
withProjectsDb((db) => {
const created = createProject(db, { name: "活跃项目" });
const created = createProject(db, { name: "活跃项目" }, createNoopLogger());
const id = (created as { project: { id: string } }).project.id;
const result = restoreProject(db, id);
const result = restoreProject(db, id, createNoopLogger());
expect("error" in result).toBe(true);
expect((result as unknown as { status: number }).status).toBe(409);
});
@@ -182,11 +183,11 @@ describe("项目数据访问层", () => {
test("永久删除已归档项目", () => {
withProjectsDb((db) => {
const created = createProject(db, { name: "删除测试" });
const created = createProject(db, { name: "删除测试" }, createNoopLogger());
const id = (created as { project: { id: string } }).project.id;
archiveProject(db, id);
archiveProject(db, id, createNoopLogger());
const result = deleteProject(db, id);
const result = deleteProject(db, id, createNoopLogger());
expect("error" in result).toBe(false);
const after = getProject(db, id);
@@ -196,10 +197,10 @@ describe("项目数据访问层", () => {
test("删除 active 项目失败", () => {
withProjectsDb((db) => {
const created = createProject(db, { name: "活跃项目" });
const created = createProject(db, { name: "活跃项目" }, createNoopLogger());
const id = (created as { project: { id: string } }).project.id;
const result = deleteProject(db, id);
const result = deleteProject(db, id, createNoopLogger());
expect("error" in result).toBe(true);
expect((result as unknown as { status: number }).status).toBe(409);
});
@@ -207,7 +208,7 @@ describe("项目数据访问层", () => {
test("创建项目名称超过 10 个字符失败", () => {
withProjectsDb((db) => {
const result = createProject(db, { name: "这是一个非常非常长的名字" });
const result = createProject(db, { name: "这是一个非常非常长的名字" }, createNoopLogger());
expect("error" in result).toBe(true);
expect((result as unknown as { error: string }).error).toContain("不能超过 10 个字符");
});
@@ -215,7 +216,7 @@ describe("项目数据访问层", () => {
test("创建项目名称刚好 10 个字符成功", () => {
withProjectsDb((db) => {
const result = createProject(db, { name: "一二三四五六七八九十" });
const result = createProject(db, { name: "一二三四五六七八九十" }, createNoopLogger());
expect("error" in result).toBe(false);
const project = (result as { project: { name: string } }).project;
expect(project.name).toBe("一二三四五六七八九十");
@@ -224,10 +225,10 @@ describe("项目数据访问层", () => {
test("更新项目名称超过 10 个字符失败", () => {
withProjectsDb((db) => {
const created = createProject(db, { name: "短名" });
const created = createProject(db, { name: "短名" }, createNoopLogger());
const id = (created as { project: { id: string } }).project.id;
const result = updateProject(db, id, { name: "这是一个非常非常长的名字" });
const result = updateProject(db, id, { name: "这是一个非常非常长的名字" }, createNoopLogger());
expect("error" in result).toBe(true);
expect((result as unknown as { error: string }).error).toContain("不能超过 10 个字符");
});
@@ -235,10 +236,10 @@ describe("项目数据访问层", () => {
test("更新项目名称 trim 后为空失败", () => {
withProjectsDb((db) => {
const created = createProject(db, { name: "原名" });
const created = createProject(db, { name: "原名" }, createNoopLogger());
const id = (created as { project: { id: string } }).project.id;
const result = updateProject(db, id, { name: " " });
const result = updateProject(db, id, { name: " " }, createNoopLogger());
expect("error" in result).toBe(true);
expect((result as unknown as { error: string }).error).toContain("不能为空");
});

115
tests/server/db/providers.test.ts
View File

@@ -10,6 +10,7 @@ import {
listProviders,
updateProvider,
} from "../../../src/server/db/providers";
import { createNoopLogger } from "../../../src/server/logger";
import { createMigratedTestDatabase } from "../../helpers";
function withDb(callback: (db: Database) => void): void {
@@ -35,12 +36,16 @@ describe("供应商数据访问层", () => {
test("创建供应商", () => {
withDb((db) => {
const result = createProvider(db, {
apiKey: "sk-test",
baseUrl: "https://api.openai.com/v1",
name: "OpenAI",
type: "openai",
});
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;
@@ -53,8 +58,16 @@ describe("供应商数据访问层", () => {
test("供应商名称唯一", () => {
withDb((db) => {
createProvider(db, { apiKey: "sk-1", baseUrl: "https://a.com", name: "唯一", type: "openai" });
const result = createProvider(db, { apiKey: "sk-2", baseUrl: "https://b.com", name: "唯一", type: "openai" });
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("已存在");
});
@@ -62,7 +75,11 @@ describe("供应商数据访问层", () => {
test("名称为空时创建失败", () => {
withDb((db) => {
const result = createProvider(db, { apiKey: "sk", baseUrl: "https://a.com", name: " ", type: "openai" });
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("不能为空");
});
@@ -70,9 +87,21 @@ describe("供应商数据访问层", () => {
test("列表查询（分页和关键字）", () => {
withDb((db) => {
createProvider(db, { apiKey: "sk-1", baseUrl: "https://a.com", name: "Alpha", type: "openai" });
createProvider(db, { apiKey: "sk-2", baseUrl: "https://b.com", name: "Beta", type: "anthropic" });
createProvider(db, { apiKey: "sk-3", baseUrl: "https://c.com", name: "Gamma", type: "openai-compatible" });
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);
@@ -88,7 +117,11 @@ describe("供应商数据访问层", () => {
test("获取供应商详情", () => {
withDb((db) => {
const created = createProvider(db, { apiKey: "sk", baseUrl: "https://a.com", name: "详情", type: "openai" });
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);
@@ -107,10 +140,14 @@ describe("供应商数据访问层", () => {
test("更新供应商", () => {
withDb((db) => {
const created = createProvider(db, { apiKey: "sk", baseUrl: "https://a.com", name: "原名", type: "openai" });
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: "新名" });
const result = updateProvider(db, id, { name: "新名" }, createNoopLogger());
expect("error" in result).toBe(false);
expect((result as { provider: { name: string } }).provider.name).toBe("新名");
});
@@ -118,11 +155,19 @@ describe("供应商数据访问层", () => {
test("更新供应商名称重复失败", () => {
withDb((db) => {
createProvider(db, { apiKey: "sk-1", baseUrl: "https://a.com", name: "已存在", type: "openai" });
const created = createProvider(db, { apiKey: "sk-2", baseUrl: "https://b.com", name: "原名", type: "openai" });
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: "已存在" });
const result = updateProvider(db, id, { name: "已存在" }, createNoopLogger());
expect("error" in result).toBe(true);
expect((result as unknown as { error: string }).error).toContain("已存在");
});
@@ -130,10 +175,14 @@ describe("供应商数据访问层", () => {
test("删除供应商", () => {
withDb((db) => {
const created = createProvider(db, { apiKey: "sk", baseUrl: "https://a.com", name: "删除测试", type: "openai" });
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);
const result = deleteProvider(db, id, createNoopLogger());
expect("error" in result).toBe(false);
const after = getProvider(db, id);
@@ -143,7 +192,7 @@ describe("供应商数据访问层", () => {
test("删除不存在的供应商返回 404", () => {
withDb((db) => {
const result = deleteProvider(db, "nonexistent");
const result = deleteProvider(db, "nonexistent", createNoopLogger());
expect("error" in result).toBe(true);
expect((result as unknown as { status: number }).status).toBe(404);
});
@@ -151,20 +200,28 @@ describe("供应商数据访问层", () => {
test("默认类型为 openai-compatible", () => {
withDb((db) => {
createProvider(db, { apiKey: "sk", baseUrl: "https://a.com", name: "默认类型", type: "openai-compatible" });
const result = createProvider(db, {
apiKey: "sk2",
baseUrl: "https://b.com",
name: "显式默认",
type: "openai-compatible",
});
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" });
createProvider(db, { apiKey: "sk", baseUrl: "https://a.com", name: "选项", type: "openai" }, createNoopLogger());
const options = listProviderOptions(db);
expect(options.length).toBe(1);