Files
HiveGrid-Wireframes/hivegrid-cloud/apps/web/app/routes/app.$tenant/settings/profile.session.test.tsx
T

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();
});
});