Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/routes/admin/settings/admin-roles.test.ts
T

142 lines
5.4 KiB
TypeScript

// @vitest-environment node
import type { ActionFunctionArgs } from "react-router";
import { beforeEach, describe, expect, it, vi } from "vitest";
const { adminSession, transaction } = vi.hoisted(() => ({
adminSession: {
adminUserId: "admin-1",
adminUser: { id: "admin-1", email: "admin@example.test" },
},
transaction: {
adminRole: { findUnique: vi.fn() },
adminPermission: { findMany: vi.fn() },
adminRolePermission: { deleteMany: vi.fn(), createMany: vi.fn() },
adminSession: { updateMany: vi.fn() },
},
}));
vi.mock("@hivegrid/db/rls-context.server", () => ({
runWithRlsTransaction: vi.fn(async (_transaction, operation: () => Promise<unknown>) => operation()),
}));
vi.mock("~/components/screens/admin/sales/security/AdminRolesPage", () => ({ AdminRolesPage: () => null }));
vi.mock("~/locale/i18next.server", () => ({ getTranslations: vi.fn() }));
vi.mock("~/services/admin/admin-action-audit.server", async () => {
const actual = await vi.importActual<typeof import("~/services/admin/admin-action-audit.server")>(
"~/services/admin/admin-action-audit.server"
);
return { ...actual, recordAdminAction: vi.fn() };
});
vi.mock("~/services/admin/admin-identity.server", () => ({
runAsAdminIdentity: vi.fn(async (_request, _permission, operation) => operation(adminSession)),
}));
vi.mock("~/utils/data/useRootData", () => ({ useRootData: () => ({ csrf: "csrf" }) }));
vi.mock("~/utils/session.server", () => ({ validateCSRFToken: vi.fn() }));
vi.mock("~/utils/db.server", () => ({
db: { $transaction: vi.fn(async (operation) => operation(transaction)) },
}));
import { recordAdminAction } from "~/services/admin/admin-action-audit.server";
import { runAsAdminIdentity } from "~/services/admin/admin-identity.server";
import { action } from "./admin-roles";
function callAction(values: Array<[string, string]>) {
const body = new URLSearchParams();
for (const [key, value] of values) body.append(key, value);
return action({
request: new Request("https://admin.example.test/settings/admin-roles", { method: "POST", body }),
params: {},
context: {},
unstable_pattern: "admin/settings/admin-roles",
} as ActionFunctionArgs);
}
describe("admin role editor action", () => {
beforeEach(() => {
vi.clearAllMocks();
transaction.adminRole.findUnique.mockResolvedValue({ id: "role-sales", systemKey: "sales" });
transaction.adminPermission.findMany.mockResolvedValue([
{ id: "permission-read", name: "admin_sales.crm.read" },
{ id: "permission-write", name: "admin_sales.crm.write" },
]);
transaction.adminRolePermission.deleteMany.mockResolvedValue({ count: 2 });
transaction.adminRolePermission.createMany.mockResolvedValue({ count: 2 });
transaction.adminSession.updateMany.mockResolvedValue({ count: 3 });
});
it("persists a typed bundle transactionally with reasoned audit", async () => {
const response = await callAction([
["intent", "save-role"],
["roleId", "role-sales"],
["reason", "Sales-Rolle auf Kernzugriff begrenzen"],
["permission", "admin_sales.crm.read"],
["permission", "admin_sales.crm.write"],
["permission", "not.allowed"],
]);
expect(response.status).toBe(200);
expect(runAsAdminIdentity).toHaveBeenCalledWith(
expect.any(Request),
"admin_identity.roles.manage",
expect.any(Function)
);
expect(transaction.adminRolePermission.deleteMany).toHaveBeenCalledWith({
where: { adminRoleId: "role-sales" },
});
expect(transaction.adminRolePermission.createMany).toHaveBeenCalledWith({
data: [
{ adminRoleId: "role-sales", adminPermissionId: "permission-read" },
{ adminRoleId: "role-sales", adminPermissionId: "permission-write" },
],
});
expect(transaction.adminSession.updateMany).toHaveBeenCalledWith({
where: {
revokedAt: null,
adminUser: { roles: { some: { adminRoleId: "role-sales" } } },
},
data: { revokedAt: expect.any(Date) },
});
expect(recordAdminAction).toHaveBeenCalledWith(
expect.objectContaining({
action: "security.adminRolePermissionsChanged",
targetId: "role-sales",
reason: "Sales-Rolle auf Kernzugriff begrenzen",
after: {
permissions: ["admin_sales.crm.read", "admin_sales.crm.write"],
revokedSessions: 3,
},
}),
transaction
);
});
it("keeps the SuperAdmin bundle immutable", async () => {
transaction.adminRole.findUnique.mockResolvedValueOnce({ id: "role-super", systemKey: "super_admin" });
const response = await callAction([
["intent", "save-role"],
["roleId", "role-super"],
["reason", "Superadmin-Rolle ändern"],
["permission", "admin_sales.crm.read"],
]);
expect(response.status).toBe(400);
expect(transaction.adminRolePermission.deleteMany).not.toHaveBeenCalled();
expect(recordAdminAction).not.toHaveBeenCalled();
});
it("rejects legacy or freely created roles", async () => {
transaction.adminRole.findUnique.mockResolvedValueOnce({ id: "role-custom", systemKey: null });
const response = await callAction([
["intent", "save-role"],
["roleId", "role-custom"],
["reason", "Freie Rolle ändern"],
["permission", "admin_sales.crm.read"],
]);
expect(response.status).toBe(400);
expect(transaction.adminRolePermission.deleteMany).not.toHaveBeenCalled();
expect(transaction.adminSession.updateMany).not.toHaveBeenCalled();
});
});