351 lines
14 KiB
TypeScript
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();
|
|
});
|
|
});
|