Files
HiveGrid-Wireframes/hivegrid-cloud/apps/web/app/routes/invitation.$id.transactional-email.test.tsx
T

351 lines
14 KiB
TypeScript

import { beforeEach, describe, expect, it, vi } from "vitest";
import { action, loader } from "./invitation.$id";
import { getAppConfiguration } from "~/utils/db/appConfiguration.db.server";
import { queueTransactionalEmail } from "~/modules/emails/services/TransactionalEmailQueue.server";
import { sendEmail } from "~/modules/emails/services/EmailService";
import EmailTemplates from "~/modules/emails/utils/EmailTemplates";
import { getUser, getUserByEmail, register } from "~/utils/db/users.db.server";
import { createTenantUser, getTenant } from "~/utils/db/tenants.db.server";
import { getAllRoles } from "~/utils/db/permissions/roles.db.server";
import { createUserSession, getUserInfo, setLoggedUser } from "~/utils/session.server";
import EventsService from "~/modules/events/services/.server/EventsService";
import { acceptWorkspaceInvite, getWorkspaceInviteByToken } from "@toolctrl/db/workspace-invites.server";
import { loadRequiredWebConfig } from "@toolctrl/config";
vi.mock("~/utils/db/appConfiguration.db.server", () => ({
getAppConfiguration: vi.fn(),
}));
vi.mock("@toolctrl/config", () => ({
loadRequiredWebConfig: vi.fn(() => ({
routing: {
adminAppHost: "admin.example.test",
apiHost: "api.example.test",
appBaseDomain: "example.test",
protocol: "https",
webAppHost: "app.example.test",
},
})),
}));
vi.mock("~/services/auth/password-policy.server", () => ({
validatePassword: vi.fn(async () => ({ valid: true, errors: [] })),
loadPasswordPolicy: vi.fn(() => ({
minLength: 1,
requireUpper: false,
requireLower: false,
requireDigit: false,
requireSpecial: false,
hibpCheck: false,
hibpMaxOccurrences: 0,
})),
MIN_PASSWORD_LENGTH: 12,
}));
vi.mock("~/services/auth/invitation-password.server", () => ({
createInvitationMagicLinkPassword: vi.fn(() => "generated-magic-link-password"),
}));
vi.mock("~/modules/emails/services/TransactionalEmailQueue.server", () => ({
queueTransactionalEmail: vi.fn(),
}));
vi.mock("~/modules/emails/services/EmailService", () => ({
sendEmail: vi.fn(),
}));
vi.mock("~/modules/emails/utils/EmailTemplates", () => ({
default: {
WELCOME_EMAIL: {
parse: vi.fn(({ data }) => ({
subject: "Welcome to Example",
body: `<p>Welcome ${data.name} at ${data.action_url}</p>`,
})),
},
},
}));
vi.mock("~/utils/url.server", () => ({
getAbsoluteUrl: vi.fn((_request: Request, path: string) => `https://example.com${path}`),
}));
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(async () => ({ t: (key: string) => key })),
remixI18Next: {
getFixedT: vi.fn(async () => (key: string) => key),
getLocale: vi.fn(async () => "en"),
},
}));
vi.mock("~/components/brand/Logo", () => ({ default: () => null }));
vi.mock("~/components/ui/buttons/LoadingButton", () => ({ default: () => null }));
vi.mock("~/components/ui/modals/ErrorModal", () => ({ default: () => null }));
vi.mock("~/components/ui/banners/SuccessBanner", () => ({ default: () => null }));
vi.mock("~/components/ui/button", () => ({ Button: ({ children }: { children: React.ReactNode }) => <>{children}</> }));
vi.mock("~/utils/db/users.db.server", () => ({
getUser: vi.fn(),
getUserByEmail: vi.fn(),
register: vi.fn(),
}));
vi.mock("@toolctrl/db/workspace-invites.server", () => ({
acceptWorkspaceInvite: vi.fn(),
getWorkspaceInviteByToken: vi.fn(),
WorkspaceInviteError: class WorkspaceInviteError extends Error {
code: string;
constructor(code: string) {
super(code);
this.code = code;
}
},
}));
vi.mock("~/utils/db/tenants.db.server", () => ({
createTenantUser: vi.fn(),
getTenant: vi.fn(),
}));
vi.mock("~/utils/db/permissions/roles.db.server", () => ({
getAllRoles: vi.fn(),
}));
vi.mock("~/utils/session.server", () => ({
createUserSession: vi.fn(),
getUserInfo: vi.fn(),
setLoggedUser: vi.fn(),
}));
vi.mock("~/modules/events/services/.server/EventsService", () => ({
default: {
create: vi.fn(),
},
}));
const appConfiguration = { app: { name: "Example" } } as Awaited<ReturnType<typeof getAppConfiguration>>;
const invitation = {
id: "invitation_1",
email: "invitee@example.com",
firstName: "Ada",
lastName: "Lovelace",
tenantId: "tenant_1",
type: 2,
fromUserId: "from_user_1",
tenant: { id: "tenant_1", name: "Example Co", slug: "example-co" },
};
const workspaceInvite = {
id: invitation.id,
email: invitation.email,
firstName: invitation.firstName,
lastName: invitation.lastName,
tenantId: invitation.tenantId,
type: invitation.type,
fromUserId: invitation.fromUserId,
pending: true,
status: "pending",
tokenPrefix: "invite-token".slice(0, 12),
createdUserId: null,
acceptedByUserId: null,
revokedByUserId: null,
expiresAt: new Date("2030-01-01T00:00:00.000Z"),
acceptedAt: null,
revokedAt: null,
} as Awaited<ReturnType<typeof getWorkspaceInviteByToken>>;
const role = { id: "role_1", assignToNewUsers: true, isDefault: true } as Awaited<ReturnType<typeof getAllRoles>>[number];
const tenantScopedRole = { id: "role_tenant", assignToNewUsers: true, isDefault: false } as Awaited<ReturnType<typeof getAllRoles>>[number];
const getAppConfigurationMock = vi.mocked(getAppConfiguration);
const queueTransactionalEmailMock = vi.mocked(queueTransactionalEmail);
const sendEmailMock = vi.mocked(sendEmail);
const welcomeParseMock = vi.mocked(EmailTemplates.WELCOME_EMAIL.parse);
const getUserMock = vi.mocked(getUser);
const getUserByEmailMock = vi.mocked(getUserByEmail);
const registerMock = vi.mocked(register);
const acceptWorkspaceInviteMock = vi.mocked(acceptWorkspaceInvite);
const getWorkspaceInviteByTokenMock = vi.mocked(getWorkspaceInviteByToken);
const createTenantUserMock = vi.mocked(createTenantUser);
const getTenantMock = vi.mocked(getTenant);
const getAllRolesMock = vi.mocked(getAllRoles);
const createUserSessionMock = vi.mocked(createUserSession);
const getUserInfoMock = vi.mocked(getUserInfo);
const setLoggedUserMock = vi.mocked(setLoggedUser);
const eventsCreateMock = vi.mocked(EventsService.create);
const loadRequiredWebConfigMock = vi.mocked(loadRequiredWebConfig);
async function postInvitation(intent = "set-password") {
const form = new FormData();
form.set("intent", intent);
form.set("password", "password");
form.set("password-confirm", "password");
return action({
request: new Request("https://example.com/invitation/invite-token", {
method: "POST",
headers: { "Content-Type": "application/x-www-form-urlencoded" },
body: new URLSearchParams(form as unknown as Record<string, string>),
}),
params: { id: "invite-token" },
context: {},
} as unknown as Parameters<typeof action>[0]);
}
async function readJson(response: unknown) {
expect(response).toBeInstanceOf(Response);
return (response as Response).json();
}
describe("invitation action transactional welcome email", () => {
beforeEach(() => {
vi.clearAllMocks();
getAppConfigurationMock.mockResolvedValue(appConfiguration);
queueTransactionalEmailMock.mockResolvedValue({ enqueued: true, jobId: "job_1" });
getWorkspaceInviteByTokenMock.mockResolvedValue(workspaceInvite);
acceptWorkspaceInviteMock.mockResolvedValue({ ...workspaceInvite!, pending: false, status: "accepted" } as Awaited<
ReturnType<typeof acceptWorkspaceInvite>
>);
getUserMock.mockResolvedValue({ id: "from_user_1", email: "owner@example.com" } as Awaited<ReturnType<typeof getUser>>);
getUserByEmailMock.mockResolvedValue(null);
registerMock.mockResolvedValue({ id: "user_1", email: "invitee@example.com", locale: "en" } as Awaited<ReturnType<typeof register>>);
getAllRolesMock.mockResolvedValue([role] as Awaited<ReturnType<typeof getAllRoles>>);
createTenantUserMock.mockResolvedValue({ id: "tenant_user_1" } as Awaited<ReturnType<typeof createTenantUser>>);
eventsCreateMock.mockResolvedValue({} as Awaited<ReturnType<typeof EventsService.create>>);
getUserInfoMock.mockResolvedValue({ lng: "en", lightOrDarkMode: "light" } as Awaited<ReturnType<typeof getUserInfo>>);
setLoggedUserMock.mockResolvedValue({ userId: "user_1", defaultTenantId: "tenant_1", lng: "en" } as Awaited<ReturnType<typeof setLoggedUser>>);
getTenantMock.mockResolvedValue({ id: "tenant_1", slug: "example-co" } as Awaited<ReturnType<typeof getTenant>>);
createUserSessionMock.mockResolvedValue(
new Response(null, { status: 302, headers: { Location: "/example-co/dashboard" } }) as Awaited<ReturnType<typeof createUserSession>>
);
loadRequiredWebConfigMock.mockReturnValue({
routing: {
adminAppHost: "admin.example.test",
apiHost: "api.example.test",
appBaseDomain: "example.test",
protocol: "https",
webAppHost: "app.example.test",
},
} as ReturnType<typeof loadRequiredWebConfig>);
});
it("precomputes the accepted-invitation sign-in path in the loader", async () => {
const response = await loader({
request: new Request("https://example.com/invitation/invite-token"),
params: { id: "invite-token" },
context: {},
} as unknown as Parameters<typeof loader>[0]);
expect(response).toMatchObject({
appRootPath: "https://app.example.test/",
existingUser: null,
invitation: expect.objectContaining({
email: "invitee@example.com",
tenant: expect.objectContaining({ slug: "example-co" }),
}),
});
});
it("enqueues welcome email only after persisting a new invited user", async () => {
const response = await postInvitation();
expect(response).toBeInstanceOf(Response);
expect((response as Response).status).toBe(302);
expect(registerMock).toHaveBeenCalledWith({
email: "invitee@example.com",
password: "password",
firstName: "Ada",
lastName: "Lovelace",
locale: "en",
request: expect.any(Request),
});
expect(createTenantUserMock).toHaveBeenCalledWith({ tenantId: "tenant_1", userId: "user_1", type: 2 }, [role]);
expect(welcomeParseMock).toHaveBeenCalledWith({
appConfiguration,
data: {
action_url: "https://example.com/login",
name: "Ada",
},
t: expect.any(Function),
locale: "en",
});
expect(queueTransactionalEmailMock).toHaveBeenCalledWith({
to: "invitee@example.com",
alias: "welcome",
tenantId: "tenant_1",
userId: "user_1",
subject: "Welcome to Example",
body: "<p>Welcome Ada at https://example.com/login</p>",
data: {
action_url: "https://example.com/login",
name: "Ada",
},
});
expect(acceptWorkspaceInviteMock).toHaveBeenCalledWith({
tenantId: "tenant_1",
inviteId: "invitation_1",
token: "invite-token",
acceptedByUserId: "user_1",
});
expect(queueTransactionalEmailMock.mock.invocationCallOrder[0]).toBeGreaterThan(acceptWorkspaceInviteMock.mock.invocationCallOrder[0]);
expect(queueTransactionalEmailMock.mock.invocationCallOrder[0]).toBeGreaterThan(createTenantUserMock.mock.invocationCallOrder[0]);
expect(queueTransactionalEmailMock.mock.invocationCallOrder[0]).toBeGreaterThan(eventsCreateMock.mock.invocationCallOrder[0]);
expect(sendEmailMock).not.toHaveBeenCalled();
});
it("generates a server-only throwaway password for magic-link invitations", async () => {
const response = await postInvitation("magic-link");
expect(response).toBeInstanceOf(Response);
expect((response as Response).status).toBe(302);
expect(registerMock).toHaveBeenCalledWith(
expect.objectContaining({
email: "invitee@example.com",
password: "generated-magic-link-password",
})
);
});
it("does not grant tenant-specific app roles from other tenants to invited users", async () => {
getAllRolesMock.mockResolvedValue([role, tenantScopedRole] as Awaited<ReturnType<typeof getAllRoles>>);
const response = await postInvitation();
expect(response).toBeInstanceOf(Response);
expect(createTenantUserMock).toHaveBeenCalledWith({ tenantId: "tenant_1", userId: "user_1", type: 2 }, [role]);
});
it("accepts existing-user invitations without enqueueing a welcome email", async () => {
getUserByEmailMock.mockResolvedValue({ id: "existing_user_1", email: "invitee@example.com", firstName: "Ada", lastName: "Lovelace" } as Awaited<
ReturnType<typeof getUserByEmail>
>);
getUserInfoMock.mockResolvedValue({ userId: "existing_user_1", lng: "en", lightOrDarkMode: "light" } as Awaited<ReturnType<typeof getUserInfo>>);
const response = await postInvitation();
expect(response).toEqual({ invitationAccepted: true });
expect(registerMock).not.toHaveBeenCalled();
expect(acceptWorkspaceInviteMock).toHaveBeenCalledWith({
tenantId: "tenant_1",
inviteId: "invitation_1",
token: "invite-token",
acceptedByUserId: "existing_user_1",
});
expect(createTenantUserMock).toHaveBeenCalledWith({ tenantId: "tenant_1", userId: "existing_user_1", type: 2 }, [role]);
expect(queueTransactionalEmailMock).not.toHaveBeenCalled();
expect(sendEmailMock).not.toHaveBeenCalled();
});
it("returns 400 for invalid invitations without enqueueing", async () => {
getWorkspaceInviteByTokenMock.mockResolvedValue(null);
const response = await postInvitation();
expect((response as Response).status).toBe(400);
await expect(readJson(response)).resolves.toEqual({ error: "auth:invitation.errors.invalid" });
expect(registerMock).not.toHaveBeenCalled();
expect(acceptWorkspaceInviteMock).not.toHaveBeenCalled();
expect(createTenantUserMock).not.toHaveBeenCalled();
expect(queueTransactionalEmailMock).not.toHaveBeenCalled();
expect(sendEmailMock).not.toHaveBeenCalled();
});
});