Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/mcp/src/readiness.test.ts
T

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);
});
});