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(); }); });