Files

111 lines
4.7 KiB
TypeScript

import type { LoaderFunctionArgs } from "react-router";
import { beforeEach, describe, expect, it, vi } from "vitest";
vi.mock("~/locale/i18next.server", () => ({ getTranslations: vi.fn(async () => ({ t: (key: string) => key })) }));
vi.mock("~/utils/db/tenants.db.server", () => ({ getTenantSessionIdentityForUser: vi.fn() }));
vi.mock("~/utils/session.server", () => ({ requireUserId: vi.fn() }));
vi.mock("~/utils/helpers/.server/PermissionsService", () => ({ verifyUserHasPermission: vi.fn() }));
vi.mock("~/components/brand/Logo", () => ({ default: () => null }));
vi.mock("~/components/pages/PagePlanRequired", () => ({ default: () => null }));
vi.mock("@hivegrid/config", () => ({
loadRequiredWebConfig: vi.fn(() => ({
routing: {
appBaseDomain: "example.test",
protocol: "https",
webAppHost: "app.example.test",
adminAppHost: "admin.example.test",
apiHost: "api.example.test",
},
})),
}));
const tenantDb = await import("~/utils/db/tenants.db.server");
const sessionServer = await import("~/utils/session.server");
const permissions = await import("~/utils/helpers/.server/PermissionsService");
const rlsContext = await import("@hivegrid/db/rls-context.server");
const deactivatedRoute = await import("./deactivated.$tenant");
const planRequiredRoute = await import("./plan-required.$tenant");
const activeTenant = {
id: "tenant_1",
name: "Acme",
slug: "acme",
active: true,
deactivatedReason: null,
};
function loaderArgs(path: string, tenant = "acme") {
return {
request: new Request(`https://app.example.test/${path}/${tenant}`),
params: { tenant },
context: {},
} as unknown as LoaderFunctionArgs;
}
describe("tenant status route RLS boundaries", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(sessionServer.requireUserId).mockResolvedValue("user_1");
vi.mocked(tenantDb.getTenantSessionIdentityForUser).mockResolvedValue(activeTenant);
vi.mocked(permissions.verifyUserHasPermission).mockResolvedValue(undefined as never);
});
it("authenticates before resolving a deactivated tenant through membership", async () => {
vi.mocked(tenantDb.getTenantSessionIdentityForUser).mockResolvedValueOnce({
...activeTenant,
active: false,
deactivatedReason: "billing",
});
const data = await deactivatedRoute.loader(loaderArgs("deactivated"));
expect(sessionServer.requireUserId).toHaveBeenCalledOnce();
expect(tenantDb.getTenantSessionIdentityForUser).toHaveBeenCalledWith({
userId: "user_1",
tenant: "acme",
allowInactiveTenant: true,
});
expect(vi.mocked(sessionServer.requireUserId).mock.invocationCallOrder[0]).toBeLessThan(
vi.mocked(tenantDb.getTenantSessionIdentityForUser).mock.invocationCallOrder[0]!
);
expect(data.currentTenant).toEqual({ name: "Acme", slug: "acme", deactivatedReason: "billing" });
});
it("hides a deactivated tenant when no membership-proven identity exists", async () => {
vi.mocked(tenantDb.getTenantSessionIdentityForUser).mockResolvedValueOnce(null);
const response = await deactivatedRoute.loader(loaderArgs("deactivated", "other-tenant")).catch((error: Response) => error);
expect(response).toBeInstanceOf(Response);
expect(response.status).toBe(302);
expect(response.headers.get("Location")).toBe("https://app.example.test/");
});
it("runs the plan permission check only after membership and inside the exact tenant/user context", async () => {
vi.mocked(permissions.verifyUserHasPermission).mockImplementationOnce(async () => {
expect(rlsContext.getRlsExecutionContext()).toMatchObject({ tenantId: "tenant_1", userId: "user_1" });
});
const data = await planRequiredRoute.loader(loaderArgs("plan-required"));
expect(tenantDb.getTenantSessionIdentityForUser).toHaveBeenCalledWith({ userId: "user_1", tenant: "acme" });
expect(permissions.verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.subscription.view", "tenant_1");
expect(data).toMatchObject({ tenantSlug: "acme" });
expect(rlsContext.getRlsExecutionContext()).toBeNull();
});
it("does not expose an English fallback title before localized loader data exists", () => {
expect(planRequiredRoute.meta({ data: undefined } as never)).toEqual([{ title: undefined }]);
});
it("never checks permissions for a cross-tenant slug", async () => {
vi.mocked(tenantDb.getTenantSessionIdentityForUser).mockResolvedValueOnce(null);
const response = await planRequiredRoute.loader(loaderArgs("plan-required", "other-tenant")).catch((error: Response) => error);
expect(response).toBeInstanceOf(Response);
expect(response.status).toBe(302);
expect(permissions.verifyUserHasPermission).not.toHaveBeenCalled();
});
});