135 lines
6.2 KiB
TypeScript
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();
|
|
});
|
|
});
|