Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/routes/forgot-password.test.tsx
T
2026-07-08 16:15:37 +02:00

215 lines
8.1 KiB
TypeScript

import { beforeEach, describe, expect, it, vi } from "vitest";
import { action } from "./forgot-password";
import { getUserByEmail, updateUserVerifyToken } from "~/utils/db/users.db.server";
import { getAppConfiguration } from "~/utils/db/appConfiguration.db.server";
import { queueTransactionalEmail } from "~/modules/emails/services/TransactionalEmailQueue.server";
import EmailTemplates from "~/modules/emails/utils/EmailTemplates";
import { issueMagicLink } from "~/services/auth/magic-link.server";
import { createPasswordResetVerifyToken, hashPasswordResetToken } from "~/services/auth/password-reset-token.server";
const sendEmailMock = vi.fn();
vi.mock("~/utils/db/users.db.server", () => ({
getUserByEmail: vi.fn(),
updateUserVerifyToken: vi.fn(),
}));
vi.mock("~/utils/db/appConfiguration.db.server", () => ({
getAppConfiguration: vi.fn(),
}));
vi.mock("~/modules/emails/services/TransactionalEmailQueue.server", () => ({
queueTransactionalEmail: vi.fn(),
}));
vi.mock("~/modules/emails/services/EmailService", () => ({
sendEmail: sendEmailMock,
}));
vi.mock("~/utils/url.server", () => ({
getAbsoluteUrl: vi.fn((_request: Request, path: string) => `https://example.com${path}`),
}));
vi.mock("~/utils/session.server", () => ({
validateCSRFToken: vi.fn(),
}));
vi.mock("~/services/auth/magic-link.server", () => ({
issueMagicLink: vi.fn(),
}));
vi.mock("~/services/auth/password-reset-token.server", async () => {
const actual = await vi.importActual<typeof import("~/services/auth/password-reset-token.server")>("~/services/auth/password-reset-token.server");
return {
...actual,
createPasswordResetVerifyToken: vi.fn(() => "verify-token"),
};
});
vi.mock("~/modules/emails/utils/EmailTemplates", () => ({
default: {
PASSWORD_RESET_EMAIL: {
parse: vi.fn(({ data }) => ({
subject: "Reset your password",
body: `<p>Reset at ${data.action_url}</p>`,
})),
},
},
}));
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 () => "de"),
},
}));
vi.mock("~/locale/mail-translator.server", () => ({
getMailTranslator: vi.fn(async () => ({ t: (key: string) => key, locale: "de" })),
getMailTranslatorFromRequest: vi.fn(async () => ({ t: (key: string) => key, locale: "de" })),
resolveMailLocale: vi.fn((locale: string | null | undefined) => locale ?? "de"),
}));
vi.mock("~/utils/seo/defaultSiteTags", () => ({
getDefaultSiteTags: vi.fn(() => ({ title: "HiveGrid" })),
}));
vi.mock("~/utils/seo/linkTags.server", () => ({
getLinkTags: vi.fn(() => []),
}));
const getUserByEmailMock = vi.mocked(getUserByEmail);
const updateUserVerifyTokenMock = vi.mocked(updateUserVerifyToken);
const getAppConfigurationMock = vi.mocked(getAppConfiguration);
const queueTransactionalEmailMock = vi.mocked(queueTransactionalEmail);
const passwordResetParseMock = vi.mocked(EmailTemplates.PASSWORD_RESET_EMAIL.parse);
const issueMagicLinkMock = vi.mocked(issueMagicLink);
const createPasswordResetVerifyTokenMock = vi.mocked(createPasswordResetVerifyToken);
async function postForgotPassword(email?: string, mode?: "magic" | "reset") {
const form = new FormData();
if (email !== undefined) {
form.set("email", email);
}
if (mode !== undefined) {
form.set("mode", mode);
}
return action({
request: new Request("https://example.com/forgot-password", {
method: "POST",
headers: { "Content-Type": "application/x-www-form-urlencoded" },
body: new URLSearchParams(form as unknown as Record<string, string>),
}),
params: {},
context: {},
} as Parameters<typeof action>[0]);
}
async function readJson(response: unknown) {
expect(response).toBeInstanceOf(Response);
return (response as Response).json();
}
describe("forgot password action", () => {
beforeEach(() => {
vi.clearAllMocks();
getAppConfigurationMock.mockResolvedValue({ appName: "Example" } as unknown as Awaited<ReturnType<typeof getAppConfiguration>>);
updateUserVerifyTokenMock.mockResolvedValue({ id: "user_1" } as Awaited<ReturnType<typeof updateUserVerifyToken>>);
queueTransactionalEmailMock.mockResolvedValue({ enqueued: true, jobId: "job_1" });
getUserByEmailMock.mockResolvedValue({ id: "user_1", firstName: "Ada" } as Awaited<ReturnType<typeof getUserByEmail>>);
issueMagicLinkMock.mockResolvedValue(undefined);
createPasswordResetVerifyTokenMock.mockReturnValue("verify-token");
});
it("enqueues password reset email after updating the user token", async () => {
const response = await postForgotPassword("ada@example.com");
await expect(readJson(response)).resolves.toEqual({ success: "Email sent" });
expect(updateUserVerifyTokenMock).toHaveBeenCalledWith(
{
verifyToken: hashPasswordResetToken("verify-token"),
verifyTokenCreatedAt: expect.any(Date),
},
"user_1"
);
expect(passwordResetParseMock).toHaveBeenCalledWith(
expect.objectContaining({
appConfiguration: { appName: "Example" },
data: {
name: "Ada",
action_url: "https://example.com/reset?e=ada%40example.com&t=verify-token",
},
t: expect.any(Function),
locale: expect.any(String),
})
);
expect(queueTransactionalEmailMock).toHaveBeenCalledWith({
to: "ada@example.com",
alias: "password-reset",
subject: "Reset your password",
body: "<p>Reset at https://example.com/reset?e=ada%40example.com&t=verify-token</p>",
userId: "user_1",
data: {
name: "Ada",
action_url: "https://example.com/reset?e=ada%40example.com&t=verify-token",
},
priorityOverride: "critical",
});
expect(queueTransactionalEmailMock.mock.invocationCallOrder[0]).toBeGreaterThan(updateUserVerifyTokenMock.mock.invocationCallOrder[0]);
expect(sendEmailMock).not.toHaveBeenCalled();
});
it("issues a login magic link when magic mode is requested", async () => {
const response = await postForgotPassword("Ada@Example.com ", "magic");
await expect(readJson(response)).resolves.toEqual({ success: "Email sent" });
expect(issueMagicLinkMock).toHaveBeenCalledWith({
request: expect.any(Request),
userId: "user_1",
email: "ada@example.com",
name: "Ada",
purpose: "login",
});
expect(updateUserVerifyTokenMock).not.toHaveBeenCalled();
expect(passwordResetParseMock).not.toHaveBeenCalled();
expect(queueTransactionalEmailMock).not.toHaveBeenCalled();
expect(sendEmailMock).not.toHaveBeenCalled();
});
it("fails closed when the transactional email cannot be queued", async () => {
queueTransactionalEmailMock.mockRejectedValue(new Error("Redis connection required to enqueue transactional email."));
await expect(postForgotPassword("ada@example.com")).rejects.toThrow("Redis connection required to enqueue transactional email.");
expect(queueTransactionalEmailMock).toHaveBeenCalledOnce();
expect(sendEmailMock).not.toHaveBeenCalled();
});
it("returns 400 when email is missing", async () => {
const response = await postForgotPassword();
expect((response as Response).status).toBe(400);
await expect(readJson(response)).resolves.toEqual({ error: "Email required" });
expect(getUserByEmailMock).not.toHaveBeenCalled();
expect(updateUserVerifyTokenMock).not.toHaveBeenCalled();
expect(queueTransactionalEmailMock).not.toHaveBeenCalled();
expect(sendEmailMock).not.toHaveBeenCalled();
});
it("returns delayed success for unknown users without queueing", async () => {
vi.useFakeTimers();
getUserByEmailMock.mockResolvedValue(null);
const responsePromise = postForgotPassword("missing@example.com");
await vi.advanceTimersByTimeAsync(1500);
const response = await responsePromise;
await expect(readJson(response)).resolves.toEqual({ success: "Email sent" });
expect(updateUserVerifyTokenMock).not.toHaveBeenCalled();
expect(queueTransactionalEmailMock).not.toHaveBeenCalled();
expect(sendEmailMock).not.toHaveBeenCalled();
vi.useRealTimers();
});
});