Files
HiveGrid-Wireframes/hivegrid-cloud/apps/web/app/routes/new-account.csrf.test.tsx
T

135 lines
6.2 KiB
TypeScript

import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
import { beforeEach, describe, expect, it, vi } from "vitest";
import { TenantUserType } from "~/application/enums/tenants/TenantUserType";
vi.mock("~/components/core/settings/tenant/TenantNew", () => ({ default: () => null }));
vi.mock("~/components/brand/Logo", () => ({ default: () => null }));
vi.mock("~/utils/session.server", () => ({
getUserInfo: vi.fn(async () => ({ userId: "user_1" })),
validateCSRFToken: vi.fn(),
}));
vi.mock("~/utils/api/.server/TenantsApi", () => ({
TenantsApi: {
create: vi.fn(async () => ({ tenant: { id: "tenant_1", slug: "acme" }, user: { id: "user_1" } })),
},
}));
vi.mock("~/utils/db/permissions/roles.db.server", () => ({ getAllRoles: vi.fn(async () => []) }));
vi.mock("~/utils/db/tenants.db.server", () => ({
createTenantUser: vi.fn(async () => undefined),
getMyTenants: vi.fn(async () => []),
}));
vi.mock("~/utils/db/users.db.server", () => ({ getUser: vi.fn(async () => ({ id: "user_1" })) }));
vi.mock("~/utils/db/entities/entities.db.server", () => ({
findEntityByName: vi.fn(async () => null),
}));
const sessionServer = await import("~/utils/session.server");
const rolesDb = await import("~/utils/db/permissions/roles.db.server");
const tenantsApi = await import("~/utils/api/.server/TenantsApi");
const tenantsDb = await import("~/utils/db/tenants.db.server");
const usersDb = await import("~/utils/db/users.db.server");
const entitiesDb = await import("~/utils/db/entities/entities.db.server");
const { action, loader } = await import("./new-account");
describe("new-account route", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(sessionServer.getUserInfo).mockResolvedValue({ userId: "user_1" } as never);
vi.mocked(sessionServer.validateCSRFToken).mockResolvedValue(undefined as never);
vi.mocked(rolesDb.getAllRoles).mockResolvedValue([] as never);
vi.mocked(tenantsApi.TenantsApi.create).mockResolvedValue({ tenant: { id: "tenant_1", slug: "acme" }, user: { id: "user_1" } } as never);
vi.mocked(tenantsDb.createTenantUser).mockResolvedValue(undefined as never);
vi.mocked(tenantsDb.getMyTenants).mockResolvedValue([] as never);
vi.mocked(usersDb.getUser).mockResolvedValue({ id: "user_1" } as never);
vi.mocked(entitiesDb.findEntityByName).mockResolvedValue(null as never);
});
it("redirects to login when the loader cannot find the user", async () => {
vi.mocked(usersDb.getUser).mockResolvedValueOnce(null as never);
try {
await loader({
request: new Request("https://app.example.com/new-account"),
params: {},
context: {},
} as unknown as LoaderFunctionArgs);
throw new Error("Expected loader to throw a redirect response");
} catch (error) {
expect(error).toBeInstanceOf(Response);
const response = error as Response;
expect(response.status).toBe(302);
expect(response.headers.get("Location")).toBe("/login");
}
expect(sessionServer.getUserInfo).toHaveBeenCalledWith(expect.any(Request));
expect(usersDb.getUser).toHaveBeenCalledWith("user_1");
expect(tenantsDb.getMyTenants).not.toHaveBeenCalled();
expect(entitiesDb.findEntityByName).not.toHaveBeenCalled();
});
it("loads the current user's tenants and tenant settings entity", async () => {
const myTenants = [{ id: "tenant_1", name: "Acme", slug: "acme" }];
const tenantSettingsEntity = { id: "entity_1", name: "tenantSettings" };
vi.mocked(tenantsDb.getMyTenants).mockResolvedValueOnce(myTenants as never);
vi.mocked(entitiesDb.findEntityByName).mockResolvedValueOnce(tenantSettingsEntity as never);
const data = await loader({
request: new Request("https://app.example.com/new-account"),
params: {},
context: {},
} as unknown as LoaderFunctionArgs);
expect(data).toEqual({ myTenants, tenantSettingsEntity });
expect(sessionServer.getUserInfo).toHaveBeenCalledWith(expect.any(Request));
expect(usersDb.getUser).toHaveBeenCalledWith("user_1");
expect(tenantsDb.getMyTenants).toHaveBeenCalledWith("user_1");
expect(entitiesDb.findEntityByName).toHaveBeenCalledWith({ tenantId: null, name: "tenantSettings" });
});
it("validates CSRF before creating a tenant", async () => {
const roles = [{ id: "role_1", type: "app" }];
vi.mocked(rolesDb.getAllRoles).mockResolvedValueOnce(roles as never);
const body = new URLSearchParams({ name: "Acme", slug: "acme", csrf: "csrf-token" });
const request = new Request("https://app.example.com/new-account", { method: "POST", headers: { "Content-Type": "application/x-www-form-urlencoded" }, body });
const response = (await action({
request,
params: {},
context: {},
} as unknown as ActionFunctionArgs)) as Response;
expect(response.status).toBe(302);
expect(response.headers.get("Location")).toBe("/acme/dashboard");
expect(sessionServer.validateCSRFToken).toHaveBeenCalledWith(request);
expect(tenantsApi.TenantsApi.create).toHaveBeenCalledTimes(1);
const createArgs = vi.mocked(tenantsApi.TenantsApi.create).mock.calls[0]?.[0];
expect(createArgs).toMatchObject({ request, name: "Acme", slug: "acme" });
expect(createArgs?.form.get("name")).toBe("Acme");
expect(createArgs?.form.get("slug")).toBe("acme");
expect(rolesDb.getAllRoles).toHaveBeenCalledWith("app");
expect(tenantsDb.createTenantUser).toHaveBeenCalledWith(
{
tenantId: "tenant_1",
userId: "user_1",
type: TenantUserType.OWNER,
},
roles
);
});
it("does not create a tenant when CSRF validation fails", async () => {
vi.mocked(sessionServer.validateCSRFToken).mockRejectedValueOnce(new Error("Invalid CSRF token"));
const response = (await action({
request: new Request("https://app.example.com/new-account", { method: "POST", headers: { "Content-Type": "application/x-www-form-urlencoded" }, body: new URLSearchParams({ name: "Acme" }) }),
params: {},
context: {},
} as unknown as ActionFunctionArgs)) as Response;
expect(response.status).toBe(400);
await expect(response.json()).resolves.toEqual({ error: "Invalid CSRF token" });
expect(tenantsApi.TenantsApi.create).not.toHaveBeenCalled();
expect(tenantsDb.createTenantUser).not.toHaveBeenCalled();
});
});