Files
Sybil-2/server/tests/provider-retirement.test.ts
T

81 lines
4.9 KiB
TypeScript

import assert from "node:assert/strict";
import { execFileSync } from "node:child_process";
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { dirname, join, resolve } from "node:path";
import test from "node:test";
import { fileURLToPath } from "node:url";
import Fastify from "fastify";
import sensible from "@fastify/sensible";
import { PROVIDERS } from "../src/llm/types.js";
const serverRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
const databaseDir = mkdtempSync(join(tmpdir(), "sybil-provider-retirement-"));
process.env.DATABASE_URL = `file:${join(databaseDir, "test.db")}`;
process.env.ADMIN_TOKEN = "provider-retirement-test-token";
execFileSync(process.execPath, [join(serverRoot, "node_modules/prisma/build/index.js"), "migrate", "deploy"], {
cwd: serverRoot, env: { ...process.env, PRISMA_HIDE_UPDATE_MESSAGE: "1" }, stdio: "pipe",
});
const [{ registerRoutes }, { prisma }] = await Promise.all([import("../src/routes.js"), import("../src/db.js")]);
const app = Fastify({ logger: false });
await app.register(sensible);
await registerRoutes(app, { agentInlineInvoker: async () => { throw new Error("Unsupported requests must not invoke the Agent"); } });
await app.ready();
const auth = { authorization: "Bearer provider-retirement-test-token" };
test.after(async () => { await app.close(); await prisma.$disconnect(); rmSync(databaseDir, { recursive: true, force: true }); });
test("catalog and request validation expose only the remaining LLM providers", async () => {
const catalog = await app.inject({ method: "GET", url: "/v1/models", headers: auth });
assert.equal(catalog.statusCode, 200);
assert.deepEqual(Object.keys(catalog.json().providers), [...PROVIDERS]);
const before = await prisma.chat.count();
for (const provider of ["retired-provider", "sybil-agent"]) {
for (const url of ["/v1/chats", "/v1/chat-completions", "/v1/chat-completions/stream", "/v1/quick-questions/stream"]) {
const response = await app.inject({ method: "POST", url, headers: auth, payload: {
provider, model: "test-model", messages: [{ role: "user", content: "@sybil test" }], question: "test",
} });
assert.equal(response.statusCode, 400, `${url}: ${response.body}`);
}
}
assert.equal(await prisma.chat.count(), before);
assert.equal(await prisma.llmCall.count(), 0);
for (const provider of PROVIDERS) {
const response = await app.inject({ method: "POST", url: "/v1/chats", headers: auth, payload: { provider, model: "test-model" } });
assert.equal(response.statusCode, 200, response.body);
assert.equal(response.json().chat.lastUsedProvider, provider);
}
});
test("existing text provider IDs remain readable and forkable without relabeling history", async () => {
const chat = await prisma.chat.create({ data: {
title: "Archived provider conversation",
initiatedProvider: "retired-provider", initiatedModel: "archived-model",
lastUsedProvider: "retired-provider", lastUsedModel: "archived-model",
messages: { create: { role: "assistant", content: "Original saved answer", metadata: { clientRequestId: "old-request" } } },
calls: { create: { provider: "retired-provider", model: "archived-model", request: { provider: "retired-provider", clientRequestId: "old-request" }, latencyMs: 1 } },
}, include: { messages: true, calls: true } });
const detail = await app.inject({ method: "GET", url: `/v1/chats/${chat.id}`, headers: auth });
assert.equal(detail.statusCode, 200, detail.body);
const saved = detail.json().chat;
for (const key of ["initiatedProvider", "initiatedModel", "lastUsedProvider", "lastUsedModel"]) assert.equal(saved[key], null);
assert.equal(saved.messages[0].content, "Original saved answer");
assert.equal(saved.messages[0].metadata.generation, undefined);
assert.equal(saved.calls[0].provider, null);
assert.equal(saved.calls[0].request.provider, "retired-provider");
for (const url of ["/v1/chats", "/v1/workspace-items", "/v1/chats?limit=50"]) {
const response = await app.inject({ method: "GET", url, headers: auth });
assert.equal(response.statusCode, 200, `${url}: ${response.body}`);
const rows = response.json().chats ?? response.json().items;
assert.equal(rows.find((row: any) => row.id === chat.id).lastUsedProvider, null);
}
const fork = await app.inject({ method: "POST", url: `/v1/chats/${chat.id}/fork`, headers: auth, payload: {} });
assert.equal(fork.statusCode, 200, fork.body);
const forkDetail = await app.inject({ method: "GET", url: `/v1/chats/${fork.json().chat.id}`, headers: auth });
assert.equal(forkDetail.statusCode, 200, forkDetail.body);
assert.equal(forkDetail.json().chat.lastUsedProvider, null);
assert.equal(forkDetail.json().chat.messages[0].content, "Original saved answer");
const stored = await prisma.chat.findUniqueOrThrow({ where: { id: chat.id }, include: { calls: true } });
assert.equal(stored.lastUsedProvider, "retired-provider");
assert.equal(stored.calls[0]!.provider, "retired-provider");
});