// @vitest-environment node import { beforeEach, describe, expect, it, vi } from "vitest"; import type { ActionFunctionArgs } from "react-router"; vi.mock("react-i18next", () => ({ useTranslation: () => ({ t: (key: string) => key }), })); vi.mock("react-router", async () => { const actual = await vi.importActual("react-router"); return { ...actual, useActionData: () => undefined, useLoaderData: () => ({}), useNavigate: () => vi.fn(), useOutlet: () => null, useParams: () => ({}), useSubmit: () => vi.fn(), }; }); vi.mock("~/components/core/roles/GroupsTable", () => ({ default: () => null })); vi.mock("~/components/core/roles/RoleBadge", () => ({ default: () => null })); vi.mock("~/components/core/roles/RolesAndPermissionsMatrix", () => ({ default: () => null })); vi.mock("~/components/core/roles/UserRolesTable", () => ({ default: () => null })); vi.mock("~/components/core/settings/members/MemberInvitationsListAndTable", () => ({ default: () => null })); vi.mock("~/components/ui/input/InputSearch", () => ({ default: () => null })); vi.mock("~/components/ui/layouts/EditPageLayout", () => ({ default: () => null })); vi.mock("~/components/ui/modals/ActionResultModal", () => ({ default: () => null })); vi.mock("~/components/ui/modals/ConfirmModal", () => ({ default: () => null })); vi.mock("~/components/ui/modals/ErrorModal", () => ({ default: () => null })); vi.mock("~/components/ui/modals/Modal", () => ({ default: () => null })); vi.mock("~/components/ui/sections/SettingSection", () => ({ default: () => null })); vi.mock("~/components/ui/slideOvers/SlideOverWideEmpty", () => ({ default: () => null })); vi.mock("~/components/ui/tables/TableSimple", () => ({ default: () => null })); vi.mock("~/utils/app/UrlUtils", () => ({ default: { currentTenantUrl: vi.fn(() => "/acme/settings/subscription") } })); vi.mock("~/utils/data/useAppData", () => ({ useAppData: () => ({}) })); vi.mock("~/utils/data/useRootData", () => ({ useRootData: () => ({}) })); vi.mock("~/utils/db/logs.db.server", () => ({ createAdminLog: vi.fn() })); vi.mock("~/utils/db/permissions/groups.db.server", () => ({ getAllGroups: vi.fn(), getMyGroups: vi.fn() })); vi.mock("~/utils/db/permissions/permissions.db.server", () => ({ getAllPermissions: vi.fn() })); vi.mock("~/utils/db/permissions/roles.db.server", () => ({ getAllRoles: vi.fn(), getTenantAssignableAppRole: vi.fn() })); vi.mock("~/utils/db/permissions/userRoles.db.server", () => ({ createUserRole: vi.fn(), deleteUserRole: vi.fn() })); vi.mock("~/utils/db/tenantUserInvitations.db.server", () => ({ deleteUserInvitation: vi.fn(), getUserInvitation: vi.fn(), getUserInvitations: vi.fn() })); vi.mock("~/utils/db/tenants.db.server", () => ({ getTenant: vi.fn(), getTenantMember: vi.fn(), getTenantUsers: vi.fn() })); vi.mock("~/utils/helpers/PermissionsHelper", () => ({ getUserHasPermission: vi.fn() })); vi.mock("~/utils/helpers/.server/PermissionsService", () => ({ getUserPermission: vi.fn(), verifyUserHasPermission: vi.fn() })); vi.mock("~/locale/i18next.server", () => ({ getTranslations: vi.fn(async () => ({ t: (key: string) => key })) })); vi.mock("~/modules/events/services/.server/EventsService", () => ({ default: { create: vi.fn() } })); vi.mock("~/utils/services/.server/urlService", () => ({ getTenantIdFromUrl: vi.fn() })); vi.mock("~/utils/auth/mfa/enforcement.server", () => ({ enforceAdminMfa: vi.fn() })); vi.mock("~/utils/auth/mfa/step-up.server", () => ({ checkMfaStepUpState: vi.fn() })); vi.mock("~/utils/db/users.db.server", () => ({ getUser: vi.fn(), getUserTotpStatus: vi.fn() })); vi.mock("~/utils/session.server", () => ({ createImpersonationStartedAt: vi.fn(() => "2026-05-08T17:00:00.000Z"), createUserSession: vi.fn(), getUserInfo: vi.fn(), getUserSession: vi.fn(), setLoggedUser: vi.fn(), validateCSRFToken: vi.fn(), })); vi.mock("@toolctrl/config", () => ({ loadRequiredWebConfig: () => ({ routing: { protocol: "https", webAppHost: "app.example.test", adminAppHost: "admin.example.test", apiHost: "api.example.test", appBaseDomain: "example.test", }, }), })); import { enforceAdminMfa } from "~/utils/auth/mfa/enforcement.server"; import { checkMfaStepUpState } from "~/utils/auth/mfa/step-up.server"; import { getAllRoles, getTenantAssignableAppRole } from "~/utils/db/permissions/roles.db.server"; import { getAllGroups, getMyGroups } from "~/utils/db/permissions/groups.db.server"; import { getAllPermissions } from "~/utils/db/permissions/permissions.db.server"; import { createUserRole } from "~/utils/db/permissions/userRoles.db.server"; import { deleteUserInvitation, getUserInvitation, getUserInvitations } from "~/utils/db/tenantUserInvitations.db.server"; import { getTenant, getTenantMember, getTenantUsers } from "~/utils/db/tenants.db.server"; import { getUser, getUserTotpStatus } from "~/utils/db/users.db.server"; import { getUserPermission, verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService"; import { getTenantIdFromUrl } from "~/utils/services/.server/urlService"; import { createUserSession, getUserInfo, getUserSession, setLoggedUser, validateCSRFToken } from "~/utils/session.server"; import { action, loader } from "./members"; import { TenantUserStatus } from "~/application/enums/tenants/TenantUserStatus"; const actor = { id: "admin-1", admin: true, email: "admin@example.test" }; const targetUser = { id: "user-1", admin: false, email: "user@example.test" }; const actorInfo = { userId: actor.id, lightOrDarkMode: "light", lng: "en", cookies: [], }; const enabledTotpStatus = { enabled: true, pending: false, enabledAt: new Date("2026-05-08T12:00:00.000Z"), pendingCreatedAt: null }; const freshStepUp = { verified: true, state: { userId: actor.id, method: "totp", verifiedAt: "2026-05-08T16:59:00.000Z" }, ageMs: 60_000 }; function postRequest(form: Record = { action: "impersonate", "user-id": targetUser.id }) { return new Request("https://app.example.test/acme/settings/members?tab=active", { method: "POST", headers: { "Content-Type": "application/x-www-form-urlencoded" }, body: new URLSearchParams(form), }); } async function callAction(form?: Record) { try { const response = await action({ request: postRequest(form), params: { tenant: "acme" }, context: {}, unstable_pattern: "app/$tenant/settings/members", } as ActionFunctionArgs); return { thrown: false, response: response as Response }; } catch (error) { return { thrown: true, response: error as Response, error }; } } async function callLoader() { return loader({ request: new Request("https://app.example.test/acme/settings/members"), params: { tenant: "acme" }, context: {}, }); } describe("workspace members impersonation MFA guard", () => { beforeEach(() => { vi.clearAllMocks(); vi.mocked(getTenantIdFromUrl).mockResolvedValue("tenant-1" as never); vi.mocked(verifyUserHasPermission).mockResolvedValue(undefined as never); vi.mocked(validateCSRFToken).mockResolvedValue(undefined as never); vi.mocked(getUserInfo).mockResolvedValue(actorInfo as never); vi.mocked(getUserSession).mockResolvedValue({ get: vi.fn() } as never); vi.mocked(getUser).mockImplementation(async (id?: string) => (id === actor.id ? actor : id === targetUser.id ? targetUser : null) as never); vi.mocked(getUserTotpStatus).mockResolvedValue(enabledTotpStatus as never); vi.mocked(checkMfaStepUpState).mockReturnValue(freshStepUp as never); vi.mocked(enforceAdminMfa).mockReturnValue({ allowed: true, reason: "allowed", redirectTo: "/acme/settings/members" } as never); vi.mocked(setLoggedUser).mockResolvedValue({ userId: targetUser.id, defaultTenantId: "tenant-1" } as never); vi.mocked(getTenant).mockResolvedValue({ id: "tenant-1", slug: "acme" } as never); vi.mocked(getTenantMember).mockResolvedValue({ user: targetUser } as never); vi.mocked(createUserSession).mockResolvedValue(new Response(null, { status: 302, headers: { Location: "/acme/dashboard" } }) as never); }); it("requires fresh admin MFA step-up before creating a workspace member impersonation session", async () => { const result = await callAction(); expect(result.thrown).toBe(false); expect(result.response.status).toBe(302); expect(validateCSRFToken).toHaveBeenCalledWith(expect.any(Request)); expect(verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.members.impersonate", "tenant-1"); expect(getUserTotpStatus).toHaveBeenCalledWith(actor.id); expect(checkMfaStepUpState).toHaveBeenCalledWith(expect.anything(), actor.id); expect(enforceAdminMfa).toHaveBeenCalledWith({ requestUrl: "https://app.example.test/acme/settings/members?tab=active", userId: actor.id, isAdmin: true, totpStatus: enabledTotpStatus, stepUp: freshStepUp, redirectMode: "host-aware", appFallbackPath: "/acme/settings/members", }); expect(setLoggedUser).toHaveBeenCalledWith(targetUser); expect(createUserSession).toHaveBeenCalledWith( expect.objectContaining({ userId: targetUser.id, impersonatingFromUserId: actor.id, impersonatingStartedAt: "2026-05-08T17:00:00.000Z", }), "/acme/dashboard" ); expect(result.response.headers.get("Location")).toBe("/acme/dashboard"); }); it("redirects to the MFA challenge and does not switch sessions when step-up is missing", async () => { vi.mocked(checkMfaStepUpState).mockReturnValue({ verified: false, reason: "missing" } as never); vi.mocked(enforceAdminMfa).mockReturnValue({ allowed: false, reason: "step-up-missing", redirectTo: "/mfa-challenge?redirectTo=%2Facme%2Fsettings%2Fmembers%3Ftab%3Dactive", } as never); const result = await callAction(); expect(result.thrown).toBe(true); expect(result.response.status).toBe(302); expect(result.response.headers.get("Location")).toBe("https://admin.example.test/mfa-challenge?redirectTo=%2Facme%2Fsettings%2Fmembers%3Ftab%3Dactive"); expect(setLoggedUser).not.toHaveBeenCalled(); expect(createUserSession).not.toHaveBeenCalled(); }); it("keeps non-admin impersonation fallback on the app host", async () => { vi.mocked(enforceAdminMfa).mockReturnValue({ allowed: false, reason: "missing-admin", redirectTo: "/acme/settings/members", } as never); const result = await callAction(); expect(result.thrown).toBe(true); expect(result.response.status).toBe(302); expect(result.response.headers.get("Location")).toBe("https://app.example.test/acme/settings/members"); expect(setLoggedUser).not.toHaveBeenCalled(); expect(createUserSession).not.toHaveBeenCalled(); }); it("requires role-set permission before assigning workspace roles", async () => { vi.mocked(getTenantMember).mockResolvedValue({ user: targetUser } as never); vi.mocked(getTenantAssignableAppRole).mockResolvedValue({ id: "role-1", name: "User", description: "User", type: "app" } as never); vi.mocked(createUserRole).mockResolvedValue({ id: "user-role-1" } as never); const result = await callAction({ action: "edit", "user-id": targetUser.id, "role-id": "role-1", add: "true" }); expect(result.thrown).toBe(false); expect(verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.members.update", "tenant-1"); expect(verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.roles.set", "tenant-1"); expect(getTenantAssignableAppRole).toHaveBeenCalledWith("role-1", "tenant-1"); expect(createUserRole).toHaveBeenCalledWith(targetUser.id, "role-1", "tenant-1"); }); it("requires delete permission before revoking pending invitations", async () => { vi.mocked(getUserInvitation).mockResolvedValue({ id: "invitation-1" } as never); vi.mocked(deleteUserInvitation).mockResolvedValue({ count: 1 } as never); const result = await callAction({ action: "delete-invitation", "invitation-id": "invitation-1" }); expect(result.thrown).toBe(false); expect(verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.members.update", "tenant-1"); expect(verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.members.delete", "tenant-1"); expect(deleteUserInvitation).toHaveBeenCalledWith("invitation-1", "tenant-1"); await expect(result.response.json()).resolves.toEqual({ success: "settings.members.success.invitationDeleted" }); }); it("localizes the last-super-admin removal guard response", async () => { vi.mocked(getTenantMember).mockResolvedValue({ user: targetUser } as never); vi.mocked(getTenantAssignableAppRole).mockResolvedValue({ id: "role-super", name: "SuperUser", description: "Super User", type: "app" } as never); vi.mocked(getTenantUsers).mockResolvedValue([ { status: TenantUserStatus.ACTIVE, user: { id: targetUser.id, roles: [{ tenantId: "tenant-1", role: { name: "SuperUser" } }] }, }, ] as never); const result = await callAction({ action: "edit", "user-id": targetUser.id, "role-id": "role-super", add: "false" }); expect(result.thrown).toBe(false); expect(result.response.status).toBe(400); await expect(result.response.json()).resolves.toEqual({ error: "settings.members.errors.atLeastOneSuperAdmin" }); }); it("localizes the own super-admin role removal guard response", async () => { vi.mocked(getTenantMember).mockResolvedValue({ user: actor } as never); vi.mocked(getTenantAssignableAppRole).mockResolvedValue({ id: "role-super", name: "SuperUser", description: "Super User", type: "app" } as never); vi.mocked(getTenantUsers).mockResolvedValue([ { status: TenantUserStatus.ACTIVE, user: { id: actor.id, roles: [{ tenantId: "tenant-1", role: { name: "SuperUser" } }] }, }, { status: TenantUserStatus.ACTIVE, user: { id: targetUser.id, roles: [{ tenantId: "tenant-1", role: { name: "SuperUser" } }] }, }, ] as never); const result = await callAction({ action: "edit", "user-id": actor.id, "role-id": "role-super", add: "false" }); expect(result.thrown).toBe(false); expect(result.response.status).toBe(400); await expect(result.response.json()).resolves.toEqual({ error: "settings.members.errors.cannotRemoveOwnSuperAdminRole" }); }); it("localizes the super-admin impersonation guard response", async () => { const superAdminUser = { ...targetUser, admin: true }; vi.mocked(getUser).mockImplementation(async (id?: string) => (id === actor.id ? actor : id === targetUser.id ? superAdminUser : null) as never); const result = await callAction(); expect(result.thrown).toBe(false); expect(result.response.status).toBe(400); await expect(result.response.json()).resolves.toEqual({ error: "settings.members.errors.cannotImpersonateSuperAdmin" }); expect(setLoggedUser).not.toHaveBeenCalled(); }); }); describe("workspace members loader", () => { beforeEach(() => { vi.clearAllMocks(); vi.mocked(getTenantIdFromUrl).mockResolvedValue("tenant-1" as never); vi.mocked(verifyUserHasPermission).mockResolvedValue(undefined as never); vi.mocked(getUserInfo).mockResolvedValue(actorInfo as never); vi.mocked(getTenantUsers).mockResolvedValue([{ id: "member-1", user: { id: "user-1" } }] as never); vi.mocked(getUserInvitations).mockResolvedValue([{ id: "invite-1" }] as never); vi.mocked(getAllRoles).mockResolvedValue([{ id: "role-1" }] as never); vi.mocked(getAllPermissions).mockResolvedValue([{ name: "app.settings.members.view" }] as never); vi.mocked(getUserPermission).mockResolvedValue({ permission: null, userPermission: null } as never); vi.mocked(getAllGroups).mockResolvedValue([{ id: "group-1" }] as never); vi.mocked(getMyGroups).mockResolvedValue([{ id: "my-group-1" }] as never); }); it("loads independent members settings data in parallel before resolving groups", async () => { const started: string[] = []; vi.mocked(getTenantUsers).mockImplementation(async () => { started.push("users"); return [{ id: "member-1", user: { id: "user-1" } }] as never; }); vi.mocked(getUserInvitations).mockImplementation(async () => { started.push("invitations"); return [{ id: "invite-1" }] as never; }); vi.mocked(getAllRoles).mockImplementation(async () => { started.push("roles"); return [{ id: "role-1" }] as never; }); vi.mocked(getAllPermissions).mockImplementation(async () => { started.push("permissions"); return [{ name: "app.settings.members.view" }] as never; }); vi.mocked(getUserPermission).mockImplementation(async () => { started.push("group-access"); return { permission: null, userPermission: null } as never; }); const data = await callLoader(); expect(started).toEqual(["users", "invitations", "roles", "permissions", "group-access"]); expect(getAllGroups).toHaveBeenCalledWith("tenant-1"); expect(getMyGroups).not.toHaveBeenCalled(); expect(data).toEqual( expect.objectContaining({ users: [{ id: "member-1", user: { id: "user-1" } }], pendingInvitations: [{ id: "invite-1" }], roles: [{ id: "role-1" }], permissions: [{ name: "app.settings.members.view" }], groups: [{ id: "group-1" }], }) ); }); it("loads only my groups when the current user lacks full group access", async () => { vi.mocked(getUserPermission).mockResolvedValue({ permission: { name: "app.settings.groups.full" }, userPermission: null } as never); const data = await callLoader(); expect(getAllGroups).not.toHaveBeenCalled(); expect(getMyGroups).toHaveBeenCalledWith(actor.id, "tenant-1"); expect(data).toEqual(expect.objectContaining({ groups: [{ id: "my-group-1" }] })); }); });