168 lines
5.8 KiB
TypeScript
168 lines
5.8 KiB
TypeScript
import { afterEach, describe, expect, it, vi } from "vitest";
|
|
|
|
import {
|
|
__resetMcpReadinessCacheForTests,
|
|
checkCachedMcpReadiness,
|
|
MCP_READINESS_CACHE_TTL_MS,
|
|
MCP_READINESS_DB_MAX_WAIT_MS,
|
|
MCP_READINESS_DB_STATEMENT_TIMEOUT_MS,
|
|
MCP_READINESS_DB_TRANSACTION_TIMEOUT_MS,
|
|
MCP_READINESS_FAILURE_CACHE_TTL_MS,
|
|
MCP_READINESS_PROBE_TIMEOUT_MS,
|
|
type McpReadinessDependencies,
|
|
} from "./readiness.js";
|
|
|
|
afterEach(() => {
|
|
__resetMcpReadinessCacheForTests();
|
|
vi.useRealTimers();
|
|
});
|
|
|
|
describe("MCP readiness", () => {
|
|
it("keeps database cancellation thresholds below the outer probe timeout", () => {
|
|
expect(MCP_READINESS_DB_MAX_WAIT_MS).toBeLessThan(
|
|
MCP_READINESS_PROBE_TIMEOUT_MS,
|
|
);
|
|
expect(MCP_READINESS_DB_STATEMENT_TIMEOUT_MS).toBeLessThan(
|
|
MCP_READINESS_DB_TRANSACTION_TIMEOUT_MS,
|
|
);
|
|
expect(MCP_READINESS_DB_TRANSACTION_TIMEOUT_MS).toBeLessThan(
|
|
MCP_READINESS_PROBE_TIMEOUT_MS,
|
|
);
|
|
});
|
|
|
|
it("probes database and Redis concurrently", async () => {
|
|
let releaseDatabase: (() => void) | undefined;
|
|
let releaseRedis: (() => void) | undefined;
|
|
const dependencies: McpReadinessDependencies = {
|
|
checkDatabase: vi.fn(() => new Promise<void>((resolve) => { releaseDatabase = resolve; })),
|
|
checkRedis: vi.fn(() => new Promise<void>((resolve) => { releaseRedis = resolve; })),
|
|
};
|
|
|
|
const readiness = checkCachedMcpReadiness(dependencies, () => 1_000);
|
|
await Promise.resolve();
|
|
|
|
expect(dependencies.checkDatabase).toHaveBeenCalledTimes(1);
|
|
expect(dependencies.checkRedis).toHaveBeenCalledTimes(1);
|
|
releaseDatabase?.();
|
|
releaseRedis?.();
|
|
await expect(readiness).resolves.toEqual({
|
|
ready: true,
|
|
checks: { database: "ok", redis: "ok" },
|
|
});
|
|
});
|
|
|
|
it.each([
|
|
["database", new Error("postgresql://user:secret@example.invalid/app")],
|
|
["redis", new Error("redis://default:secret@example.invalid/0")],
|
|
] as const)("fails closed and redacts a %s probe error", async (failedDependency, failure) => {
|
|
const dependencies: McpReadinessDependencies = {
|
|
checkDatabase: vi.fn(async () => {
|
|
if (failedDependency === "database") throw failure;
|
|
}),
|
|
checkRedis: vi.fn(async () => {
|
|
if (failedDependency === "redis") throw failure;
|
|
}),
|
|
};
|
|
|
|
const report = await checkCachedMcpReadiness(dependencies);
|
|
|
|
expect(report.ready).toBe(false);
|
|
expect(report.checks[failedDependency]).toBe("error");
|
|
expect(report.diagnostics?.[failedDependency]).toBe(
|
|
failedDependency === "database" ? "DATABASE_READINESS_FAILED" : "REDIS_READINESS_FAILED",
|
|
);
|
|
expect(JSON.stringify(report)).not.toContain("secret");
|
|
});
|
|
|
|
it("only exposes allowlisted dependency error codes", async () => {
|
|
const dependencies: McpReadinessDependencies = {
|
|
checkDatabase: vi.fn(async () => {
|
|
throw {
|
|
code: "token_like_secret_code",
|
|
meta: { code: "nested_secret_code" },
|
|
};
|
|
}),
|
|
checkRedis: vi.fn(async () => {
|
|
throw { code: "ECONNREFUSED" };
|
|
}),
|
|
};
|
|
|
|
const report = await checkCachedMcpReadiness(dependencies);
|
|
|
|
expect(report.diagnostics).toEqual({
|
|
database: "DATABASE_READINESS_FAILED",
|
|
redis: "ECONNREFUSED",
|
|
});
|
|
expect(JSON.stringify(report)).not.toContain("secret_code");
|
|
});
|
|
|
|
it("coalesces probes until settlement and starts the success TTL afterwards", async () => {
|
|
let now = 1_000;
|
|
let releaseDatabase: (() => void) | undefined;
|
|
const dependencies: McpReadinessDependencies = {
|
|
checkDatabase: vi.fn(() => new Promise<void>((resolve) => { releaseDatabase = resolve; })),
|
|
checkRedis: vi.fn(async () => undefined),
|
|
};
|
|
|
|
const clock = () => now;
|
|
const first = checkCachedMcpReadiness(dependencies, clock);
|
|
now += MCP_READINESS_CACHE_TTL_MS * 10;
|
|
const concurrent = checkCachedMcpReadiness(dependencies, clock);
|
|
expect(concurrent).toBe(first);
|
|
await Promise.resolve();
|
|
expect(dependencies.checkDatabase).toHaveBeenCalledTimes(1);
|
|
releaseDatabase?.();
|
|
await first;
|
|
now += MCP_READINESS_CACHE_TTL_MS - 1;
|
|
await checkCachedMcpReadiness(dependencies, clock);
|
|
expect(dependencies.checkDatabase).toHaveBeenCalledTimes(1);
|
|
expect(dependencies.checkRedis).toHaveBeenCalledTimes(1);
|
|
|
|
now += 1;
|
|
const refreshed = checkCachedMcpReadiness(dependencies, clock);
|
|
await Promise.resolve();
|
|
releaseDatabase?.();
|
|
await refreshed;
|
|
expect(dependencies.checkDatabase).toHaveBeenCalledTimes(2);
|
|
expect(dependencies.checkRedis).toHaveBeenCalledTimes(2);
|
|
});
|
|
|
|
it("backs off failed probes from their settlement time", async () => {
|
|
let now = 1_000;
|
|
const clock = () => now;
|
|
const dependencies: McpReadinessDependencies = {
|
|
checkDatabase: vi.fn(async () => {
|
|
throw new Error("unavailable");
|
|
}),
|
|
checkRedis: vi.fn(async () => undefined),
|
|
};
|
|
|
|
await checkCachedMcpReadiness(dependencies, clock);
|
|
now += MCP_READINESS_FAILURE_CACHE_TTL_MS - 1;
|
|
await checkCachedMcpReadiness(dependencies, clock);
|
|
expect(dependencies.checkDatabase).toHaveBeenCalledTimes(1);
|
|
|
|
now += 1;
|
|
await checkCachedMcpReadiness(dependencies, clock);
|
|
expect(dependencies.checkDatabase).toHaveBeenCalledTimes(2);
|
|
});
|
|
|
|
it("bounds a hanging dependency probe", async () => {
|
|
vi.useFakeTimers();
|
|
const dependencies: McpReadinessDependencies = {
|
|
checkDatabase: vi.fn(() => new Promise(() => undefined)),
|
|
checkRedis: vi.fn(async () => undefined),
|
|
};
|
|
|
|
const readiness = checkCachedMcpReadiness(dependencies);
|
|
await vi.advanceTimersByTimeAsync(MCP_READINESS_PROBE_TIMEOUT_MS);
|
|
|
|
await expect(readiness).resolves.toEqual({
|
|
ready: false,
|
|
checks: { database: "error", redis: "ok" },
|
|
diagnostics: { database: "DATABASE_READINESS_FAILED" },
|
|
});
|
|
expect(vi.getTimerCount()).toBe(0);
|
|
});
|
|
});
|