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((resolve) => { releaseDatabase = resolve; })), checkRedis: vi.fn(() => new Promise((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((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); }); });