Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/routes/forgot-password.test.tsx
T

292 lines
11 KiB
TypeScript

import { afterEach, 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";
import { loadRequiredWebConfig } from "@hivegrid/config";
import {
AdminFallbackLoginRejected,
assertAdminFallbackLoginAllowedForIdentity,
} from "~/services/auth/admin-fallback.server";
import { writeAdminSsoAuditEvent } from "~/modules/admin-sso/audit.server";
import { checkAuthRateLimit } from "~/services/auth/auth-rate-limit.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/auth-rate-limit.server", () => ({
checkAuthRateLimit: vi.fn().mockResolvedValue({ allowed: true }),
}));
vi.mock("~/services/auth/magic-link.server", () => ({
issueMagicLink: vi.fn(),
}));
vi.mock("@hivegrid/config", () => ({
loadRequiredWebConfig: vi.fn(),
}));
vi.mock("~/services/auth/admin-fallback.server", async () => {
const actual = await vi.importActual<typeof import("~/services/auth/admin-fallback.server")>("~/services/auth/admin-fallback.server");
return {
...actual,
assertAdminFallbackLoginAllowedForIdentity: vi.fn(),
};
});
vi.mock("~/modules/admin-sso/audit.server", () => ({
writeAdminSsoAuditEvent: 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>`,
text: `Reset at ${data.action_url}`,
})),
},
},
}));
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);
const loadRequiredWebConfigMock = vi.mocked(loadRequiredWebConfig);
const assertAdminFallbackLoginAllowedForIdentityMock = vi.mocked(assertAdminFallbackLoginAllowedForIdentity);
const writeAdminSsoAuditEventMock = vi.mocked(writeAdminSsoAuditEvent);
const checkAuthRateLimitMock = vi.mocked(checkAuthRateLimit);
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();
checkAuthRateLimitMock.mockResolvedValue({ allowed: true });
loadRequiredWebConfigMock.mockReturnValue({ magicLink: { enabled: true } } as ReturnType<typeof loadRequiredWebConfig>);
vi.spyOn(globalThis, "setTimeout").mockImplementation(((callback: TimerHandler) => {
if (typeof callback === "function") {
callback();
}
return 0;
}) as typeof setTimeout);
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");
});
afterEach(() => {
vi.useRealTimers();
vi.restoreAllMocks();
});
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: "account.reset.emailSent" });
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>",
text: "Reset at https://example.com/reset?e=ada%40example.com&t=verify-token",
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: "account.reset.emailSent" });
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("does not resolve identities or issue links when magic-link auth is disabled", async () => {
loadRequiredWebConfigMock.mockReturnValue({ magicLink: { enabled: false } } as ReturnType<typeof loadRequiredWebConfig>);
const response = await postForgotPassword("admin@example.com", "magic");
await expect(readJson(response)).resolves.toEqual({ success: "account.reset.emailSent" });
expect(getUserByEmailMock).not.toHaveBeenCalled();
expect(issueMagicLinkMock).not.toHaveBeenCalled();
});
it("does not issue a link for a blocked AdminUser and keeps the generic response", async () => {
getUserByEmailMock.mockResolvedValue({
id: "admin_1",
email: "admin@example.com",
firstName: "Ada",
admin: { userId: "admin_1" },
} as never);
assertAdminFallbackLoginAllowedForIdentityMock.mockImplementationOnce(() => {
throw new AdminFallbackLoginRejected("email-not-allowlisted");
});
const response = await postForgotPassword("admin@example.com", "magic");
await expect(readJson(response)).resolves.toEqual({ success: "account.reset.emailSent" });
expect(issueMagicLinkMock).not.toHaveBeenCalled();
expect(writeAdminSsoAuditEventMock).toHaveBeenCalledWith(
expect.objectContaining({
action: "admin.login.fallback.failure",
actorAdminUserId: "admin_1",
meta: expect.objectContaining({ method: "magic-link", stage: "issue" }),
})
);
});
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: "account.reset.errors.emailRequired" });
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 () => {
getUserByEmailMock.mockResolvedValue(null);
const response = await postForgotPassword("missing@example.com");
await expect(readJson(response)).resolves.toEqual({ success: "account.reset.emailSent" });
expect(setTimeout).toHaveBeenCalledWith(expect.any(Function), expect.any(Number));
expect(updateUserVerifyTokenMock).not.toHaveBeenCalled();
expect(queueTransactionalEmailMock).not.toHaveBeenCalled();
expect(sendEmailMock).not.toHaveBeenCalled();
});
});