Files

151 lines
5.4 KiB
TypeScript

import { beforeEach, describe, expect, it, vi } from "vitest";
type TokenRow = {
clientId: string;
tenantId: string;
userId: string;
revokedAt: Date | null;
scopes: string[];
createdAt: Date;
expiresAt: Date;
client: { clientName: string };
};
const mocks = vi.hoisted(() => ({
accessRows: [] as TokenRow[],
refreshRows: [] as TokenRow[],
audit: vi.fn(),
boundTenantIds: [] as string[],
}));
/**
* The fake transaction mirrors the policy instead of answering every query:
* a mock that returns rows regardless of the bound tenant/user would hide
* exactly the cross-tenant bug this suite is here to catch (AGENTS.md, RLS).
*/
function matches(row: TokenRow, where: Record<string, unknown>, boundTenantId: string): boolean {
if (row.tenantId !== boundTenantId) return false;
for (const [key, value] of Object.entries(where)) {
if (key === "revokedAt") {
if (value === null && row.revokedAt !== null) return false;
continue;
}
if ((row as unknown as Record<string, unknown>)[key] !== value) return false;
}
return true;
}
vi.mock("~/utils/db/.server/tenantRls.server", () => ({
withTenantRLS: (tenantId: string, callback: (tx: unknown) => unknown) => {
mocks.boundTenantIds.push(tenantId);
const model = (rows: TokenRow[]) => ({
findMany: async ({ where }: { where: Record<string, unknown> }) => rows.filter((row) => matches(row, where, tenantId)),
count: async ({ where }: { where: Record<string, unknown> }) => rows.filter((row) => matches(row, where, tenantId)).length,
updateMany: async ({ where, data }: { where: Record<string, unknown>; data: { revokedAt: Date } }) => {
const hits = rows.filter((row) => matches(row, where, tenantId));
for (const row of hits) row.revokedAt = data.revokedAt;
return { count: hits.length };
},
});
return callback({
mcpOAuthAccessToken: model(mocks.accessRows),
mcpOAuthRefreshToken: model(mocks.refreshRows),
tenant: { findUnique: async () => ({ name: "Acme", slug: "acme" }) },
});
},
}));
vi.mock("@hivegrid/db/audit-events.server", () => ({
createAuditEventInExistingTransaction: (input: unknown) => {
mocks.audit(input);
return Promise.resolve({});
},
}));
vi.mock("~/services/mcp/oauth.server", () => ({
getMcpOAuthPublicUrls: () => ({ resource: "https://staging-mcp.hivegrid.de" }),
}));
vi.mock("~/utils/connector/tenantConnector.server", () => ({ tenantHasModule: vi.fn() }));
vi.mock("~/utils/loaders.middleware", () => ({ requireAuth: vi.fn() }));
vi.mock("~/utils/services/.server/urlService", () => ({ getTenantIdFromUrl: vi.fn() }));
vi.mock("~/utils/session.server", () => ({ getUserInfo: vi.fn() }));
import { loadMcpConnectVM, revokeMcpConnection } from "./connect.server";
const CTX = { tenantId: "tenant-1", tenantSlug: "acme", tenantName: "Acme", userId: "user-1" };
function row(overrides: Partial<TokenRow> = {}): TokenRow {
return {
clientId: "client-1",
tenantId: "tenant-1",
userId: "user-1",
revokedAt: null,
scopes: ["mcp:read"],
createdAt: new Date("2026-07-20T08:00:00.000Z"),
expiresAt: new Date("2026-07-28T18:00:00.000Z"),
client: { clientName: "Claude" },
...overrides,
};
}
beforeEach(() => {
mocks.accessRows = [];
mocks.refreshRows = [];
mocks.boundTenantIds = [];
mocks.audit.mockClear();
});
describe("loadMcpConnectVM", () => {
it("lists the current user's own connections only", async () => {
mocks.accessRows = [row(), row({ clientId: "client-2", userId: "user-2", client: { clientName: "Fremd" } })];
const vm = await loadMcpConnectVM(CTX, new Date("2026-07-28T12:00:00.000Z"));
expect(vm.status).toBe("ready");
expect(vm.data?.connections.map((connection) => connection.id)).toEqual(["client-1"]);
});
it("reads inside the tenant's RLS context", async () => {
await loadMcpConnectVM(CTX, new Date("2026-07-28T12:00:00.000Z"));
expect(mocks.boundTenantIds).toEqual(["tenant-1"]);
});
it("hands the environment connector URL to the view-model", async () => {
const vm = await loadMcpConnectVM(CTX, new Date("2026-07-28T12:00:00.000Z"));
expect(vm.data?.connectorUrl).toBe("https://staging-mcp.hivegrid.de");
});
});
describe("revokeMcpConnection", () => {
it("cuts access and refresh tokens together", async () => {
mocks.accessRows = [row()];
mocks.refreshRows = [row()];
const result = await revokeMcpConnection(CTX, "client-1", new Date("2026-07-28T12:00:00.000Z"));
expect(result.revokedTokens).toBe(1);
// A live refresh token would mint a new access token minutes later.
expect(mocks.refreshRows[0]?.revokedAt).not.toBeNull();
});
it("refuses to revoke another user's connection", async () => {
mocks.accessRows = [row({ userId: "user-2" })];
await expect(revokeMcpConnection(CTX, "client-1")).rejects.toMatchObject({ name: "CatalogError" });
expect(mocks.accessRows[0]?.revokedAt).toBeNull();
});
it("refuses an unknown client id", async () => {
await expect(revokeMcpConnection(CTX, "does-not-exist")).rejects.toMatchObject({ name: "CatalogError" });
});
it("writes the audit record in the same transaction", async () => {
mocks.accessRows = [row()];
await revokeMcpConnection(CTX, "client-1");
expect(mocks.audit).toHaveBeenCalledWith(expect.objectContaining({ action: "mcp.connection.revoke", actorId: "user-1", targetId: "client-1" }));
});
});