382 lines
19 KiB
TypeScript
382 lines
19 KiB
TypeScript
// @vitest-environment node
|
|
import { beforeEach, describe, expect, it, vi } from "vitest";
|
|
import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
|
|
|
|
vi.mock("react-i18next", () => ({
|
|
useTranslation: () => ({ t: (key: string) => key }),
|
|
}));
|
|
vi.mock("react-router", async () => {
|
|
const actual = await vi.importActual<typeof import("react-router")>("react-router");
|
|
return {
|
|
...actual,
|
|
useActionData: () => undefined,
|
|
useLoaderData: () => ({}),
|
|
useNavigate: () => vi.fn(),
|
|
useNavigation: () => ({ state: "idle" }),
|
|
useOutlet: () => null,
|
|
useParams: () => ({}),
|
|
useSubmit: () => vi.fn(),
|
|
};
|
|
});
|
|
vi.mock("react-hot-toast", () => ({ default: { success: vi.fn(), error: vi.fn() } }));
|
|
vi.mock("~/components/screens/users/MembersPage", () => ({ MembersPage: () => null }));
|
|
vi.mock("~/ui/components/Dialog", () => ({ Dialog: Object.assign(() => null, { Content: () => null }) }));
|
|
vi.mock("~/components/ui/layouts/EditPageLayout", () => ({ default: () => null }));
|
|
vi.mock("~/utils/app/UrlUtils", () => ({ default: { currentTenantUrl: vi.fn(() => "/acme/settings/members") } }));
|
|
vi.mock("~/utils/data/useRootData", () => ({ useRootData: () => ({}) }));
|
|
vi.mock("~/utils/db/logs.db.server", () => ({ createAdminLog: vi.fn() }));
|
|
vi.mock("~/utils/db/permissions/roles.db.server", () => ({ getTenantAssignableAppRole: vi.fn(), getTenantAssignableAppRoles: 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/.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/services/tenantUserLifecycle.server", () => ({ deactivateTenantUser: vi.fn(), reactivateTenantUser: 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(), getEnabledTotpUserIds: 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("@hivegrid/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 { getTenantAssignableAppRole, getTenantAssignableAppRoles } from "~/utils/db/permissions/roles.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 { getEnabledTotpUserIds, getUser, getUserTotpStatus } from "~/utils/db/users.db.server";
|
|
import { getUserPermission, verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
|
|
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
|
|
import { deactivateTenantUser, reactivateTenantUser } from "~/utils/services/tenantUserLifecycle.server";
|
|
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<string, string> = { 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<string, string>) {
|
|
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: {},
|
|
} as LoaderFunctionArgs);
|
|
}
|
|
|
|
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 with the V01 code", 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", code: "last-admin" });
|
|
});
|
|
|
|
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 member lifecycle intents (R-P2b M03/V01)", () => {
|
|
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(getUser).mockResolvedValue(actor as never);
|
|
vi.mocked(getTenant).mockResolvedValue({ id: "tenant-1", name: "Acme", slug: "acme" } as never);
|
|
vi.mocked(getTenantMember).mockResolvedValue({ user: targetUser } as never);
|
|
});
|
|
|
|
it("deactivates a member through the lifecycle service without reassign", async () => {
|
|
vi.mocked(deactivateTenantUser).mockResolvedValue({ ok: true } as never);
|
|
|
|
const result = await callAction({ action: "deactivate", "user-id": targetUser.id });
|
|
|
|
expect(result.thrown).toBe(false);
|
|
expect(deactivateTenantUser).toHaveBeenCalledWith({ tenantId: "tenant-1", targetUserId: targetUser.id });
|
|
await expect(result.response.json()).resolves.toEqual({ success: "settings.members.success.deactivated" });
|
|
});
|
|
|
|
it("maps the last-admin guard to the V01 blocker code", async () => {
|
|
vi.mocked(deactivateTenantUser).mockResolvedValue({ ok: false, reason: "last-admin" } as never);
|
|
|
|
const result = await callAction({ action: "deactivate", "user-id": targetUser.id });
|
|
|
|
expect(result.thrown).toBe(false);
|
|
expect(result.response.status).toBe(400);
|
|
await expect(result.response.json()).resolves.toEqual({ error: "settings.members.errors.lastAdminBody", code: "last-admin" });
|
|
});
|
|
|
|
it("rejects other deactivation failures with a plain error", async () => {
|
|
vi.mocked(deactivateTenantUser).mockResolvedValue({ ok: false, reason: "already-inactive" } as never);
|
|
|
|
const result = await callAction({ action: "deactivate", "user-id": targetUser.id });
|
|
|
|
expect(result.response.status).toBe(400);
|
|
await expect(result.response.json()).resolves.toEqual({ error: "shared.invalidForm" });
|
|
});
|
|
|
|
it("reactivates a member through the lifecycle service", async () => {
|
|
vi.mocked(reactivateTenantUser).mockResolvedValue({ ok: true } as never);
|
|
|
|
const result = await callAction({ action: "reactivate", "user-id": targetUser.id });
|
|
|
|
expect(result.thrown).toBe(false);
|
|
expect(reactivateTenantUser).toHaveBeenCalledWith({ tenantId: "tenant-1", targetUserId: targetUser.id });
|
|
await expect(result.response.json()).resolves.toEqual({ success: "settings.members.success.reactivated" });
|
|
});
|
|
});
|
|
|
|
describe("workspace members loader (MembersListVM)", () => {
|
|
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(getUserPermission).mockResolvedValue({ permission: null, userPermission: null } as never);
|
|
vi.mocked(getEnabledTotpUserIds).mockResolvedValue(["user-1"] as never);
|
|
vi.mocked(getUserInvitations).mockResolvedValue([{ id: "invite-1", email: "new@example.test", firstName: "New", lastName: "Person" }] as never);
|
|
// The helper already scopes to assignable defaults + the tenant's own roles.
|
|
vi.mocked(getTenantAssignableAppRoles).mockResolvedValue([
|
|
{ id: "role-1", name: "SuperUser", description: "", tenantId: null },
|
|
{ id: "role-shk", name: "Monteur", description: "", tenantId: "tenant-1" },
|
|
] as never);
|
|
vi.mocked(getTenantUsers).mockResolvedValue([
|
|
{
|
|
id: "member-1",
|
|
userId: "user-1",
|
|
status: TenantUserStatus.ACTIVE,
|
|
user: {
|
|
id: "user-1",
|
|
firstName: "Ada",
|
|
lastName: "Lovelace",
|
|
email: "ada@example.test",
|
|
phone: "+49 1",
|
|
roles: [{ tenantId: "tenant-1", role: { id: "role-1", name: "SuperUser", description: "" } }],
|
|
},
|
|
},
|
|
{
|
|
id: "member-2",
|
|
userId: "user-2",
|
|
status: TenantUserStatus.INACTIVE,
|
|
user: { id: "user-2", firstName: "Grace", lastName: "Hopper", email: "grace@example.test", phone: null, roles: [] },
|
|
},
|
|
] as never);
|
|
});
|
|
|
|
it("builds the VM including deactivated members and the tenant's assignable roles", async () => {
|
|
const data = (await callLoader()) as { vm: { status: string; data?: any }; canViewRoles: boolean };
|
|
|
|
expect(getTenantUsers).toHaveBeenCalledWith("tenant-1", { includeInactive: true });
|
|
expect(getTenantAssignableAppRoles).toHaveBeenCalledWith("tenant-1");
|
|
expect(data.vm.status).toBe("ready");
|
|
const rows = data.vm.data.rows;
|
|
expect(rows).toHaveLength(2);
|
|
expect(rows[0]).toMatchObject({ name: "Ada Lovelace", status: "active", mfaEnabled: true, roles: [{ id: "role-1" }] });
|
|
expect(rows[1]).toMatchObject({ name: "Grace Hopper", status: "inactive", mfaEnabled: false, canReactivate: true });
|
|
// Defaults AND the tenant's own custom/SHK roles feed the D01 dropdown.
|
|
expect(data.vm.data.assignableRoles).toEqual([
|
|
{ id: "role-1", name: "SuperUser", description: "" },
|
|
{ id: "role-shk", name: "Monteur", description: "" },
|
|
]);
|
|
expect(data.vm.data.pendingInvitations).toEqual([{ id: "invite-1", email: "new@example.test", name: "New Person", createdAtIso: null }]);
|
|
expect(data.canViewRoles).toBe(true);
|
|
});
|
|
});
|