Skip to content

A one-of-a-kind resume builder that keeps your privacy in mind. Completely secure, customizable, portable, open-source and free forever. Try it out today!

8.1 KB
Raw Blame
import type { RequestAuthentication } from "@reactive-resume/api/context";
import { Socket } from "node:net";
import { setImmediate } from "node:timers/promises";
import { afterEach, beforeEach, expect, it, vi } from "vite-plus/test";
import { Pool } from "pg";
import z from "zod";

const mocks = vi.hoisted(() => ({
	authentication: vi.fn(),
	limit: vi.fn(),
	call: vi.fn(),
	execute: vi.fn(),
	healthcheck: vi.fn(),
}));
vi.mock("@reactive-resume/db/client", async (original) => {
	const actual = await original<typeof import("@reactive-resume/db/client")>();
	return {
		...actual,
		db: new Proxy(actual.db, {
			get: (target, property) => (property === "execute" ? mocks.execute : Reflect.get(target, property)),
		}),
	};
});
vi.mock("@reactive-resume/db/redis", async (original) => ({
	...(await original<typeof import("@reactive-resume/db/redis")>()),
	getRedis: () => null,
}));
vi.mock("@reactive-resume/api/features/storage", async (original) => ({
	...(await original<typeof import("@reactive-resume/api/features/storage")>()),
	getStorageService: () => ({ healthcheck: mocks.healthcheck }),
}));
vi.mock("@reactive-resume/api/context", async (original) => ({
	...(await original<typeof import("@reactive-resume/api/context")>()),
	resolveAuthenticationFromRequestHeaders: mocks.authentication,
}));
vi.mock("@reactive-resume/api/features/mcp/transport", () => ({
	consumeMcpRequestLimit: mocks.limit,
	consumeMcpUserLimit: mocks.limit,
}));
vi.mock("@orpc/server", async (original) => ({
	...(await original<typeof import("@orpc/server")>()),
	createRouterClient: (_router: unknown, options: { context: () => unknown }) => ({
		resume: {
			listVersions: (input: unknown) => mocks.call("listVersions", input, options.context()),
			deleteVersion: (input: unknown) => mocks.call("deleteVersion", input, options.context()),
		},
	}),
}));

function authentication(id: string, permissions: RequestAuthentication["permissions"]): RequestAuthentication {
	return {
		user: {
			id,
			name: id,
			email: `${id}@example.test`,
			emailVerified: true,
			createdAt: new Date(0),
			updatedAt: new Date(0),
		},
		method: "bearer",
		permissions,
	};
}

function request(method = "tools/list", token = "reader", params: object = {}) {
	return new Request("http://localhost:3000/mcp", {
		method: "POST",
		headers: {
			"Content-Type": "application/json",
			Accept: "application/json, text/event-stream",
			Authorization: `Bearer ${token}`,
			Cookie: `session=${token}; locale=en-US`,
		},
		body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
	});
}

beforeEach(() => {
	vi.clearAllMocks();
	mocks.execute.mockImplementation(async () => {
		await setImmediate();
		return [];
	});
	mocks.healthcheck.mockImplementation(async () => {
		await setImmediate();
		return { status: "healthy" };
	});
	mocks.authentication.mockImplementation((headers: Headers) => {
		const token = headers.get("authorization")?.slice(7);
		return token === "reader"
			? authentication("reader", ["read"])
			: token === "writer"
				? authentication("writer", ["read", "write", "delete"])
				: null;
	});
	mocks.call.mockImplementation(
		(
			method: string,
			_input: unknown,
			context: {
				authentication: RequestAuthentication;
				resHeaders: Headers;
			},
		) => {
			context.resHeaders.set("X-MCP-User", context.authentication.user.id);
			return method === "listVersions"
				? [{ id: context.authentication.user.id, kind: "named", name: "Saved", createdAt: new Date(0) }]
				: undefined;
		},
	);
});
afterEach(() => vi.restoreAllMocks());

it("precomputes discovery before the first request without user queries or network calls", async () => {
	const query = vi.spyOn(Pool.prototype, "query").mockImplementation(() => {
		throw new Error("Unexpected database query");
	});
	const connect = vi.spyOn(Pool.prototype, "connect").mockImplementation(() => {
		throw new Error("Unexpected database connection");
	});
	const socket = vi.spyOn(Socket.prototype, "connect").mockImplementation(() => {
		throw new Error("Unexpected network connection");
	});
	const fetch = vi.spyOn(globalThis, "fetch").mockRejectedValue(new Error("Unexpected network call"));
	// Import under the guards: parity contracts are also built during module initialization.
	const { createApp } = await import("../http/app");
	createApp({ serveStatic: false });
	expect(query.mock.calls.length).toBe(0);
	expect(connect.mock.calls.length).toBe(0);
	expect(socket.mock.calls.length).toBe(0);
	expect(fetch.mock.calls.length).toBe(0);
	for (const mock of [mocks.authentication, mocks.call, mocks.execute, mocks.healthcheck, mocks.limit]) {
		expect(mock.mock.calls.length).toBe(0);
	}
	const conversions = vi.spyOn(z.globalRegistry, "get");
	const { handleMcp } = await import("./handler");
	const response = await handleMcp(request());
	expect(response.status).toBe(200);
	// The default credential is read-only, so it lists the read-only tools.
	expect((await response.json()).result.tools.length).toBeGreaterThan(40);
	expect(conversions.mock.calls.length).toBe(0);
}, 30_000);

it("reuses static schema conversions across separate authenticated discovery requests", async () => {
	const { handleMcp } = await import("./handler");
	// Warm-up models startup. Conversion metadata lookups expose both Zod and SDK conversion work.
	await handleMcp(request());
	const conversions = vi.spyOn(z.globalRegistry, "get");
	const durations: number[] = [];
	for (const token of ["reader", "writer", "reader"]) {
		const started = performance.now();
		const response = await handleMcp(request("tools/list", token));
		expect(response.status).toBe(200);
		expect((await response.json()).result.tools.length).toBeGreaterThan(token === "writer" ? 70 : 40);
		durations.push(performance.now() - started);
	}
	console.info("MCP tools/list milliseconds", durations.map(Math.round));
	expect(mocks.authentication).toHaveBeenCalledTimes(4);
	expect(conversions.mock.calls.length).toBe(0);
}, 30_000);

it("keeps credentials, permissions, headers and callbacks isolated between requests", async () => {
	const { handleMcp } = await import("./handler");
	for (const token of ["reader", "writer", "reader"]) {
		const response = await handleMcp(
			request("tools/call", token, {
				name: "api_resume_list_versions",
				arguments: { resumeId: "resume-1" },
			}),
		);
		expect(response.headers.get("x-mcp-user")).toBe(token);
		expect((await response.json()).result.structuredContent.items[0].id).toBe(token);
	}
	const params = { name: "api_resume_delete_version", arguments: { resumeId: "resume-1", versionId: "version-1" } };
	for (const token of ["reader", "writer", "reader"]) {
		const response = await handleMcp(request("tools/call", token, params));
		const result = (await response.json()).result;
		expect(result.isError === true).toBe(token === "reader");
	}
	expect(mocks.call.mock.calls.filter(([method]) => method === "deleteVersion")).toHaveLength(1);
	const contexts = mocks.call.mock.calls.map(
		([, , context]) =>
			context as {
				reqHeaders: Headers;
				resHeaders: Headers;
				authentication: RequestAuthentication;
			},
	);
	expect(new Set(contexts.map((context) => context.resHeaders)).size).toBe(contexts.length);
	for (const context of contexts) {
		expect(context.reqHeaders.has("cookie")).toBe(false);
		expect(context.reqHeaders.get("authorization")).toBe(`Bearer ${context.authentication.user.id}`);
	}
	expect((await handleMcp(request("tools/list", "invalid"))).status).toBe(401);
	expect(mocks.authentication.mock.calls.every(([headers]) => !(headers as Headers).has("cookie"))).toBe(true);
	const beforeInvalidInput = mocks.call.mock.calls.length;
	const invalid = await handleMcp(
		request("tools/call", "reader", {
			name: "api_resume_list_versions",
			arguments: { resumeId: 123 },
		}),
	);
	expect((await invalid.json()).result.isError).toBe(true);
	expect(mocks.call.mock.calls.length).toBe(beforeInvalidInput);
	mocks.call.mockResolvedValueOnce([{ createdAt: "not-a-date" }]);
	const invalidOutput = await handleMcp(
		request("tools/call", "reader", {
			name: "api_resume_list_versions",
			arguments: { resumeId: "resume-1" },
		}),
	);
	expect((await invalidOutput.json()).result).toMatchObject({
		isError: true,
		content: [{ type: "text", text: expect.stringContaining("Output validation error") }],
	});
}, 30_000);