// @vitest-environment node import { beforeEach, describe, expect, it, vi } from "vitest"; vi.mock("~/utils/app/UserValidationUtils", () => ({ default: { validatePasswords: vi.fn() } })); vi.mock("~/locale/i18next.server", () => ({ getTranslations: vi.fn(async () => ({ t: (key: string) => key })), })); vi.mock("~/utils/db/users.db.server", () => ({ consumePasswordResetTokenAndUpdatePassword: vi.fn(), getUserByEmail: vi.fn(), })); vi.mock("~/utils/auth/passwordHasher.server", () => ({ hashPassword: vi.fn() })); vi.mock("~/modules/ipAddress/services/IpAddressService.server", () => ({ default: { log: vi.fn() } })); vi.mock("~/modules/users/components/ResetPasswordScreen", () => ({ default: () => null })); vi.mock("~/utils/session.server", () => ({ createUserSession: vi.fn(), getUserInfo: vi.fn(), validateCSRFToken: vi.fn(), })); vi.mock("@hivegrid/config", () => ({ loadRequiredWebConfig: vi.fn(() => ({ routing: {} })) })); vi.mock("~/utils/app/CrossHostUrls", () => ({ absoluteAppRootPath: vi.fn(() => "https://app.example.test/") })); vi.mock("~/services/auth/password-reset-token.server", () => ({ isPasswordResetTokenValid: vi.fn(), PASSWORD_RESET_TOKEN_TTL_MS: 60 * 60 * 1000, })); vi.mock("~/services/auth/auth-rate-limit.server", () => ({ checkAuthRateLimit: vi.fn().mockResolvedValue({ allowed: true }), })); vi.mock("~/services/auth/alternative-login-mfa.server", () => ({ beginAlternativeLoginMfa: vi.fn(), LOGIN_MFA_CHALLENGE_PATH: "/login-mfa", })); vi.mock("~/services/auth/admin-fallback.server", async () => { const actual = await vi.importActual("~/services/auth/admin-fallback.server"); return { ...actual, assertAdminFallbackLoginAllowedForIdentity: vi.fn(), }; }); vi.mock("~/modules/admin-sso/audit.server", () => ({ writeAdminSsoAuditEvent: vi.fn() })); vi.mock("~/services/auth/sessionStore.server", () => ({ revokeAllUserSessionsForUser: vi.fn() })); import UserValidationUtils from "~/utils/app/UserValidationUtils"; import { consumePasswordResetTokenAndUpdatePassword, getUserByEmail } from "~/utils/db/users.db.server"; import { hashPassword } from "~/utils/auth/passwordHasher.server"; import IpAddressServiceServer from "~/modules/ipAddress/services/IpAddressService.server"; import { createUserSession, getUserInfo, validateCSRFToken } from "~/utils/session.server"; import { isPasswordResetTokenValid } from "~/services/auth/password-reset-token.server"; import { beginAlternativeLoginMfa } from "~/services/auth/alternative-login-mfa.server"; import { AdminFallbackLoginRejected, assertAdminFallbackLoginAllowedForIdentity } from "~/services/auth/admin-fallback.server"; import { writeAdminSsoAuditEvent } from "~/modules/admin-sso/audit.server"; import { revokeAllUserSessionsForUser } from "~/services/auth/sessionStore.server"; import { action } from "./reset"; describe("password-reset session issuance", () => { beforeEach(() => { vi.clearAllMocks(); vi.mocked(UserValidationUtils.validatePasswords).mockResolvedValue(undefined); vi.mocked(IpAddressServiceServer.log).mockResolvedValue(undefined as never); vi.mocked(getUserByEmail).mockResolvedValue({ id: "user_1", email: "ada@example.test", locale: "de", verifyToken: "reset-token", verifyTokenCreatedAt: new Date(), } as never); vi.mocked(isPasswordResetTokenValid).mockReturnValue(true); vi.mocked(hashPassword).mockResolvedValue("password-hash"); vi.mocked(consumePasswordResetTokenAndUpdatePassword).mockResolvedValue({ id: "user_1" } as never); vi.mocked(getUserInfo).mockResolvedValue({ userId: null, lng: "en" } as never); vi.mocked(createUserSession).mockResolvedValue(new Response(null, { status: 302 }) as never); vi.mocked(beginAlternativeLoginMfa).mockResolvedValue({ required: false }); }); it("rotates into a server-backed session after consuming the reset token", async () => { const request = new Request("https://app.example.test/reset", { method: "POST", body: new URLSearchParams({ email: "ada@example.test", "verify-token": "reset-token", password: "NewPassword123!", "password-confirm": "NewPassword123!", }), }); await action({ request, params: {}, context: {} } as never); expect(validateCSRFToken).toHaveBeenCalledWith(request); expect(consumePasswordResetTokenAndUpdatePassword).toHaveBeenCalledWith( expect.objectContaining({ userId: "user_1", passwordHash: "password-hash", expectedVerifyToken: "reset-token" }) ); expect(revokeAllUserSessionsForUser).toHaveBeenCalledWith("user_1"); expect(vi.mocked(revokeAllUserSessionsForUser).mock.invocationCallOrder[0]).toBeLessThan( vi.mocked(consumePasswordResetTokenAndUpdatePassword).mock.invocationCallOrder[0]! ); expect(vi.mocked(consumePasswordResetTokenAndUpdatePassword).mock.invocationCallOrder[0]).toBeLessThan( vi.mocked(beginAlternativeLoginMfa).mock.invocationCallOrder[0]! ); expect(createUserSession).toHaveBeenCalledWith({ userId: "user_1", lng: "de" }, "https://app.example.test/", { request, rotate: true }); }); it("requires pending MFA instead of logging in a TOTP user", async () => { vi.mocked(beginAlternativeLoginMfa).mockResolvedValue({ required: true, setCookie: "hivegrid_session=pending; HttpOnly", }); const request = new Request("https://app.example.test/reset", { method: "POST", body: new URLSearchParams({ email: "ada@example.test", "verify-token": "reset-token", password: "NewPassword123!", "password-confirm": "NewPassword123!", }), }); const response = (await action({ request, params: {}, context: {} } as never)) as Response; expect(response.status).toBe(302); expect(response.headers.get("Location")).toBe("/login-mfa"); expect(response.headers.get("Set-Cookie")).toContain("hivegrid_session=pending"); expect(beginAlternativeLoginMfa).toHaveBeenCalledWith({ request, userId: "user_1", redirectTo: "https://app.example.test/", primaryMethod: "password-reset", }); expect(revokeAllUserSessionsForUser).toHaveBeenCalledWith("user_1"); expect(getUserInfo).not.toHaveBeenCalled(); expect(createUserSession).not.toHaveBeenCalled(); }); it("rejects an AdminUser reset token before changing the password when fallback policy is disabled", async () => { vi.mocked(getUserByEmail).mockResolvedValue({ id: "admin_1", email: "admin@example.test", locale: "de", verifyToken: "reset-token", verifyTokenCreatedAt: new Date(), admin: { userId: "admin_1" }, } as never); vi.mocked(assertAdminFallbackLoginAllowedForIdentity).mockImplementationOnce(() => { throw new AdminFallbackLoginRejected("disabled"); }); const request = new Request("https://app.example.test/reset", { method: "POST", body: new URLSearchParams({ email: "admin@example.test", "verify-token": "reset-token", password: "NewPassword123!", "password-confirm": "NewPassword123!", }), }); const response = (await action({ request, params: {}, context: {} } as never)) as Response; expect(response.status).toBe(400); expect(hashPassword).not.toHaveBeenCalled(); expect(consumePasswordResetTokenAndUpdatePassword).not.toHaveBeenCalled(); expect(beginAlternativeLoginMfa).not.toHaveBeenCalled(); expect(createUserSession).not.toHaveBeenCalled(); expect(writeAdminSsoAuditEvent).toHaveBeenCalledWith( expect.objectContaining({ action: "admin.login.fallback.failure", actorAdminUserId: "admin_1", meta: expect.objectContaining({ method: "password-reset", stage: "primary", reason: "disabled" }), }) ); }); it("does not expose an unexpected IP logging error to the user", async () => { vi.mocked(IpAddressServiceServer.log).mockRejectedValueOnce(new Error("database connection details")); const request = new Request("https://app.example.test/reset", { method: "POST", body: new URLSearchParams({ email: "ada@example.test", "verify-token": "reset-token", password: "NewPassword123!", "password-confirm": "NewPassword123!", }), }); const response = (await action({ request, params: {}, context: {} } as never)) as Response; expect(response.status).toBe(400); await expect(response.json()).resolves.toEqual({ error: "shared.unexpectedError" }); }); });