223 lines
8.5 KiB
TypeScript
223 lines
8.5 KiB
TypeScript
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<typeof import("~/utils/db/users.db.server")>();
|
|
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<typeof vi.fn>;
|
|
set: ReturnType<typeof vi.fn>;
|
|
unset: ReturnType<typeof vi.fn>;
|
|
};
|
|
|
|
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<Response>;
|
|
}
|
|
|
|
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();
|
|
});
|
|
});
|