Files

142 lines
5.5 KiB
TypeScript

import type { LoaderFunctionArgs } from "react-router";
import { beforeEach, describe, expect, it, vi } from "vitest";
import {
isolationApiKeyLogA,
isolationApiKeyLogB,
isolationTenantA,
isolationTenantB,
makeAdminHostGetRequest,
} from "./fixtures/user-session-isolation";
const globalMockStoreKey = "__adminRoutesIsolationMocks__";
const globalMockStore = globalThis as typeof globalThis & {
__adminRoutesIsolationMocks__?: {
verifyUserHasPermission: ReturnType<typeof vi.fn>;
requireAuth: ReturnType<typeof vi.fn>;
getAllApiKeys: ReturnType<typeof vi.fn>;
getDetails: ReturnType<typeof vi.fn>;
};
};
globalMockStore.__adminRoutesIsolationMocks__ ??= {
verifyUserHasPermission: vi.fn(),
requireAuth: vi.fn(),
getAllApiKeys: vi.fn(),
getDetails: vi.fn(),
};
const mocks = globalMockStore[globalMockStoreKey];
vi.mock("~/components/core/apiKeys/ApiKeysTable", () => ({ default: () => null }));
vi.mock("~/components/ui/layouts/EditPageLayout", () => ({ default: ({ children }: { children: React.ReactNode }) => children }));
vi.mock("~/utils/data/useAdminData", () => ({ useAdminData: vi.fn() }));
vi.mock("~/utils/helpers/PermissionsHelper", () => ({ getUserHasPermission: vi.fn() }));
vi.mock("~/utils/helpers/.server/PermissionsService", () => ({ verifyUserHasPermission: mocks.verifyUserHasPermission }));
vi.mock("~/utils/loaders.middleware", () => ({ requireAuth: mocks.requireAuth }));
vi.mock("~/utils/db/apiKeys.db.server", () => ({ getAllApiKeys: mocks.getAllApiKeys }));
vi.mock("~/utils/session.server", () => ({ validateCSRFToken: vi.fn() }));
vi.mock("~/modules/api/services/ApiKeyLogService", () => ({ default: { getDetails: mocks.getDetails } }));
vi.mock("~/modules/api/components/ApiKeyLogsDetails", () => ({ default: () => null }));
vi.mock("~/application/dtos/data/FilterablePropertyDto", () => ({}));
vi.mock("~/application/dtos/data/PaginationDto", () => ({}));
vi.mock("~/locale/i18next.server", () => ({ getTranslations: vi.fn() }));
const tenantAApiKey = {
id: "api_key_session_iso_a",
tenantId: isolationTenantA.id,
tenant: isolationTenantA,
alias: "Tenant A key",
};
const tenantBApiKey = {
id: "api_key_session_iso_b",
tenantId: isolationTenantB.id,
tenant: isolationTenantB,
alias: "Tenant B key",
};
const tenantALog = {
...isolationApiKeyLogA,
tenantId: isolationTenantA.id,
tenant: isolationTenantA,
endpoint: "/api/parents",
};
const tenantBLog = {
...isolationApiKeyLogB,
tenantId: isolationTenantB.id,
tenant: isolationTenantB,
endpoint: "/api/parents",
};
async function callApiKeysLoader(request = makeAdminHostGetRequest("/api/keys")) {
const { loader } = await import("../../routes/admin/api/keys");
return loader({ request, params: {}, context: {} } as unknown as LoaderFunctionArgs);
}
async function callApiLogsLoader(request = makeAdminHostGetRequest("/api/logs?page=1")) {
const { loader } = await import("../../routes/admin/api/logs");
return loader({ request, params: {}, context: {} } as unknown as LoaderFunctionArgs);
}
describe("admin API route isolation", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.resetModules();
mocks.verifyUserHasPermission.mockResolvedValue(true);
mocks.requireAuth.mockResolvedValue({ userId: "user_session_iso_admin", tenantId: null });
mocks.getAllApiKeys.mockResolvedValue([tenantAApiKey, tenantBApiKey]);
mocks.getDetails.mockResolvedValue({
items: [tenantALog, tenantBLog],
filterableProperties: [{ name: "tenantId", title: "models.tenant.object", options: [] }],
pagination: { page: 1, pageSize: 10, totalItems: 2, totalPages: 1 },
});
});
it("loads tenant A and tenant B API keys only after admin permission", async () => {
const request = makeAdminHostGetRequest("/api/keys");
const data = await callApiKeysLoader(request);
expect(mocks.verifyUserHasPermission).toHaveBeenCalledWith(request, "admin.apiKeys.view");
expect(mocks.getAllApiKeys).toHaveBeenCalledWith();
expect(mocks.getAllApiKeys.mock.calls[0]).toHaveLength(0);
expect(data).toEqual({ apiKeys: [tenantAApiKey, tenantBApiKey] });
}, 60_000);
it("skips cross-tenant API-key access when admin permission is denied", async () => {
const denied = Object.assign(new Error("admin.apiKeys.view denied"), { status: 403 });
mocks.verifyUserHasPermission.mockRejectedValueOnce(denied);
await expect(callApiKeysLoader()).rejects.toBe(denied);
expect(mocks.getAllApiKeys).not.toHaveBeenCalled();
});
it("loads tenant A and tenant B API logs only after admin auth and permission", async () => {
const request = makeAdminHostGetRequest("/api/logs?page=1");
const data = await callApiLogsLoader(request);
expect(mocks.requireAuth).toHaveBeenCalledWith({ request, params: {}, adminOnly: true });
expect(mocks.verifyUserHasPermission).toHaveBeenCalledWith(request, "admin.apiKeys.view");
expect(mocks.getDetails).toHaveBeenCalledWith({ request, params: {} });
expect(data).toEqual({
items: [tenantALog, tenantBLog],
filterableProperties: [{ name: "tenantId", title: "models.tenant.object", options: [] }],
pagination: { page: 1, pageSize: 10, totalItems: 2, totalPages: 1 },
});
});
it("skips cross-tenant API-log access when admin auth is denied", async () => {
const denied = Object.assign(new Error("admin auth denied"), { status: 401 });
mocks.requireAuth.mockRejectedValueOnce(denied);
await expect(callApiLogsLoader()).rejects.toBe(denied);
expect(mocks.verifyUserHasPermission).not.toHaveBeenCalled();
expect(mocks.getDetails).not.toHaveBeenCalled();
});
});