292 lines
11 KiB
TypeScript
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();
|
|
});
|
|
});
|