import { beforeEach, describe, expect, it, vi } from "vitest"; import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router"; vi.mock("~/locale/i18next.server", () => ({ getTranslations: vi.fn(async () => ({ t: (key: string) => ({ "settings.profile.mfa.sessionCleared": "Session MFA verification cleared", })[key] ?? key, })), })); vi.mock("~/utils/loaders.middleware", () => ({ requireAuth: vi.fn(), })); vi.mock("~/utils/session.server", () => ({ commitSession: vi.fn(), getUserInfo: vi.fn(), getUserSession: vi.fn(), storage: { destroySession: vi.fn() }, validateCSRFToken: vi.fn(), })); vi.mock("~/utils/auth/mfa/step-up.server", () => ({ checkMfaStepUpState: vi.fn(), clearMfaStepUpState: vi.fn(), })); vi.mock("~/utils/services/.server/urlService", () => ({ getTenantIdFromUrl: vi.fn(), })); vi.mock("~/utils/db/tenants.db.server", () => ({ getTenant: vi.fn(), })); vi.mock("~/utils/db.server", () => ({ db: { user: { findUnique: vi.fn() } }, })); vi.mock("~/utils/db/users.db.server", async (importOriginal) => { const actual = await importOriginal(); return { ...actual, activateUserTotpPendingSecret: vi.fn(), disableUserTotp: vi.fn(), getUserTotpPendingEnrollment: vi.fn(), getUserTotpStatus: vi.fn(), setUserMfaRecoveryCodes: vi.fn(), setUserTotpPendingSecret: vi.fn(), updateUserPassword: vi.fn(), updateUserProfile: vi.fn(), }; }); vi.mock("~/services/auth/totp.server", () => ({ startTotpEnrollment: vi.fn(), verifyTotpCode: vi.fn(), })); vi.mock("~/utils/auth/mfa/recovery-codes.server", () => ({ generateRecoveryCodes: vi.fn(), })); vi.mock("~/modules/events/services/.server/EventsService", () => ({ default: { create: vi.fn() }, })); vi.mock("bcryptjs", () => ({ default: { compare: vi.fn(), hash: vi.fn() }, })); vi.mock("~/utils/integrations/storageService", () => ({ storeFile: vi.fn() })); vi.mock("~/utils/services/userService", () => ({ deleteUserWithItsTenants: vi.fn() })); import { checkMfaStepUpState, clearMfaStepUpState } from "~/utils/auth/mfa/step-up.server"; import { db } from "~/utils/db.server"; import { getUserTotpStatus } from "~/utils/db/users.db.server"; import { getTenant } from "~/utils/db/tenants.db.server"; import { requireAuth } from "~/utils/loaders.middleware"; import { commitSession, getUserInfo, getUserSession, validateCSRFToken } from "~/utils/session.server"; import { getTenantIdFromUrl } from "~/utils/services/.server/urlService"; import { action, loader } from "./profile"; const params = { tenant: "acme" }; const user = { id: "user_1", email: "ada@example.com", passwordHash: "hashed-password", firstName: "Ada", lastName: "Lovelace", admin: null, }; const tenant = { id: "tenant_1", slug: "acme" }; const disabledStatus = { enabled: false, pending: false, enabledAt: null, pendingCreatedAt: null }; type SessionMock = { get: ReturnType; set: ReturnType; unset: ReturnType; }; function sessionMock(): SessionMock { return { get: vi.fn(), set: vi.fn(), unset: vi.fn() }; } function postRequest(actionName: string) { return new Request("https://app.example.test/acme/settings/profile", { method: "POST", headers: { "Content-Type": "application/x-www-form-urlencoded" }, body: new URLSearchParams({ action: actionName, csrf: "csrf-secret" }) }); } async function callLoader() { return loader({ request: new Request("https://app.example.test/acme/settings/profile"), params, context: {}, unstable_pattern: "app.$tenant/settings/profile" } as LoaderFunctionArgs); } async function callAction(actionName: string) { return action({ request: postRequest(actionName), params, context: {}, unstable_pattern: "app.$tenant/settings/profile" } as ActionFunctionArgs) as Promise; } function expectNoSessionLeak(payload: unknown) { const serialized = JSON.stringify(payload); expect(serialized).not.toContain("RJ_session"); expect(serialized).not.toContain("raw-cookie-value"); expect(serialized).not.toContain("csrf-secret"); expect(serialized).not.toContain("adminMfaStepUp"); expect(serialized).not.toContain("redirectTo"); expect(serialized).not.toContain("actor-user-1"); expect(serialized).not.toContain("password"); } describe("profile current-session settings", () => { beforeEach(() => { vi.clearAllMocks(); vi.mocked(requireAuth).mockResolvedValue(undefined as never); vi.mocked(getUserInfo).mockResolvedValue({ userId: user.id, lng: "en", lightOrDarkMode: "dark", theme: "zinc", csrf: "csrf-secret", cookies: [ { category: "REQUIRED", allowed: true }, { category: "ANALYTICS", allowed: false }, { category: "FUNCTIONAL", allowed: true }, ], impersonatingFromUserId: "actor-user-1", impersonatingStartedAt: "2026-05-08T12:00:00.000Z", } as never); vi.mocked(getUserSession).mockResolvedValue(sessionMock() as never); vi.mocked(getTenantIdFromUrl).mockResolvedValue(tenant.id); vi.mocked(getTenant).mockResolvedValue(tenant as never); vi.mocked(db.user.findUnique).mockResolvedValue(user as never); vi.mocked(getUserTotpStatus).mockResolvedValue(disabledStatus); vi.mocked(checkMfaStepUpState).mockReturnValue({ verified: true, state: { userId: user.id, method: "totp", verifiedAt: "2026-05-08T12:00:00.000Z", redirectTo: "/admin" }, ageMs: 10_000, }); vi.mocked(commitSession).mockResolvedValue("RJ_session=updated-cookie; Path=/; HttpOnly" as never); vi.mocked(validateCSRFToken).mockResolvedValue(undefined); }); it("loader exposes only redacted facts for the current cookie session", async () => { const response = await callLoader(); expect(requireAuth).toHaveBeenCalled(); expect(getUserSession).toHaveBeenCalledWith(expect.any(Request)); expect(checkMfaStepUpState).toHaveBeenCalledWith(expect.anything(), user.id); expect(response).toMatchObject({ mfaStatus: disabledStatus, currentSession: { locale: "en", lightOrDarkMode: "dark", theme: "zinc", cookieConsentCount: 2, impersonationActive: true, mfaStepUp: { present: true, verified: true, stale: false, method: "totp" }, }, }); expectNoSessionLeak(response); }); it("marks malformed or stale step-up state as unverified without exposing raw state", async () => { vi.mocked(checkMfaStepUpState).mockReturnValueOnce({ verified: false, reason: "stale" }); const response = await callLoader(); expect(response).toMatchObject({ currentSession: { mfaStepUp: { present: true, verified: false, stale: true, reason: "stale" }, }, }); expectNoSessionLeak(response); }); it("reports absent step-up state without showing a verified session", async () => { vi.mocked(checkMfaStepUpState).mockReturnValueOnce({ verified: false, reason: "missing" }); const response = await callLoader(); expect(response).toMatchObject({ currentSession: { mfaStepUp: { present: false, verified: false, stale: false, reason: "missing" }, }, }); }); it("clears only the current session MFA step-up state and commits an updated cookie", async () => { const session = sessionMock(); vi.mocked(getUserSession).mockResolvedValue(session as never); vi.mocked(checkMfaStepUpState).mockReturnValueOnce({ verified: true, state: { userId: user.id, method: "totp", verifiedAt: "2026-05-08T12:00:00.000Z" }, ageMs: 1_000 }); const response = await callAction("clearMfaStepUp"); const body = await response.json(); expect(response.status).toBe(200); expect(validateCSRFToken).toHaveBeenCalledWith(expect.any(Request)); expect(clearMfaStepUpState).toHaveBeenCalledWith(session); expect(commitSession).toHaveBeenCalledWith(session); expect(response.headers.get("Set-Cookie")).toBe("RJ_session=updated-cookie; Path=/; HttpOnly"); expect(body).toMatchObject({ success: "Session MFA verification cleared", currentSession: { mfaStepUp: { present: true, verified: true } } }); expectNoSessionLeak(body); }); it("propagates unauthenticated rejection before reading or mutating session state", async () => { const rejection = new Response(null, { status: 302, headers: { Location: "/login" } }); vi.mocked(requireAuth).mockRejectedValueOnce(rejection as never); await expect(callAction("clearMfaStepUp")).rejects.toBe(rejection); expect(getUserInfo).not.toHaveBeenCalled(); expect(clearMfaStepUpState).not.toHaveBeenCalled(); expect(commitSession).not.toHaveBeenCalled(); }); });