Files
HiveGrid-Wireframes/hivegrid-cloud/apps/web/app/routes/app.$tenant/settings/roles-and-permissions/roles.test.tsx
T

326 lines
14 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) => key })),
}));
vi.mock("~/utils/services/.server/urlService", () => ({
getTenantIdFromUrl: vi.fn(),
}));
vi.mock("~/utils/services/workspaceRoles.server", () => ({
createWorkspaceRole: vi.fn(),
deleteWorkspaceRole: vi.fn(),
requireWorkspaceRolesBuilderAccess: vi.fn(),
updateWorkspaceRole: vi.fn(),
}));
vi.mock("~/utils/db/permissions/roles.db.server", () => ({
getAllRolesWithUsers: vi.fn(),
getTenantMutableAppRole: vi.fn(),
}));
vi.mock("~/utils/db/permissions/permissions.db.server", () => ({
getAllPermissions: vi.fn(),
}));
vi.mock("~/utils/app/UrlUtils", () => ({
default: {
currentTenantUrl: vi.fn((_params: Record<string, string | undefined>, path: string) => `/acme/${path}`),
slugify: vi.fn((value: string) => value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "")),
},
}));
vi.mock("~/utils/session.server", () => ({
validateCSRFToken: vi.fn(),
}));
import { getAllPermissions } from "~/utils/db/permissions/permissions.db.server";
import { getAllRolesWithUsers, getTenantMutableAppRole } from "~/utils/db/permissions/roles.db.server";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { createWorkspaceRole, deleteWorkspaceRole, requireWorkspaceRolesBuilderAccess, updateWorkspaceRole } from "~/utils/services/workspaceRoles.server";
import { action as editAction, loader as editLoader } from "./roles/$id";
import { loader as listLoader } from "./roles";
import { action as newAction, loader as newLoader } from "./roles/new";
const params = { tenant: "acme", id: "role_1" };
const request = new Request("https://app.example.test/acme/settings/roles-and-permissions/roles");
const now = new Date("2026-01-01T00:00:00.000Z");
const appPermission = {
id: "perm_1",
name: "app.settings.members.view",
type: "app",
description: "View members",
order: 1,
inRoles: [],
createdAt: now,
updatedAt: now,
entityId: null,
isDefault: false,
};
const adminPermission = {
id: "perm_2",
name: "admin.roles.delete",
type: "admin",
description: "Delete admin roles",
order: 2,
inRoles: [],
createdAt: now,
updatedAt: now,
entityId: null,
isDefault: false,
};
const role = {
id: "role_1",
name: "Workspace editor",
description: "Can edit workspace data",
type: "app",
isDefault: false,
assignToNewUsers: false,
order: 1,
createdAt: now,
updatedAt: now,
permissions: [{ id: "role_perm_1", roleId: "role_1", permissionId: "perm_1", permission: appPermission }],
users: [],
};
async function callListLoader() {
return listLoader({ request, params, context: {}, unstable_pattern: "app.$tenant/settings/roles-and-permissions/roles" } as LoaderFunctionArgs);
}
async function callNewLoader() {
return newLoader({ request, params, context: {}, unstable_pattern: "app.$tenant/settings/roles-and-permissions/roles/new" } as LoaderFunctionArgs);
}
async function callNewAction(form: FormData) {
return newAction({
request: new Request(request.url, { method: "POST", headers: { "Content-Type": "application/x-www-form-urlencoded" }, body: new URLSearchParams(form as unknown as Record<string, string>) }),
params,
context: {},
unstable_pattern: "app.$tenant/settings/roles-and-permissions/roles/new",
} as ActionFunctionArgs);
}
async function callEditAction(form: FormData) {
return editAction({
request: new Request(`${request.url}/role_1`, { method: "POST", headers: { "Content-Type": "application/x-www-form-urlencoded" }, body: new URLSearchParams(form as unknown as Record<string, string>) }),
params,
context: {},
unstable_pattern: "app.$tenant/settings/roles-and-permissions/roles/$id",
} as ActionFunctionArgs);
}
async function callEditLoader() {
return editLoader({ request, params, context: {}, unstable_pattern: "app.$tenant/settings/roles-and-permissions/roles/$id" } as LoaderFunctionArgs);
}
function roleForm(overrides?: Record<string, string>) {
const form = new FormData();
form.set("action", "edit");
form.set("name", "Workspace editor");
form.set("description", "Can edit workspace data");
form.set("type", "app");
form.append("permissions[]", "app.settings.members.view");
Object.entries(overrides ?? {}).forEach(([key, value]) => form.set(key, value));
return form;
}
async function responseJson(result: unknown) {
expect(result).toBeInstanceOf(Response);
return (result as Response).json();
}
describe("tenant workspace role routes", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(getTenantIdFromUrl).mockResolvedValue("tenant_1");
vi.mocked(requireWorkspaceRolesBuilderAccess).mockResolvedValue({ tenantId: "tenant_1" });
vi.mocked(getAllRolesWithUsers).mockResolvedValue([role] as Awaited<ReturnType<typeof getAllRolesWithUsers>>);
vi.mocked(getAllPermissions).mockResolvedValue([appPermission] as Awaited<ReturnType<typeof getAllPermissions>>);
vi.mocked(getTenantMutableAppRole).mockResolvedValue(role as Awaited<ReturnType<typeof getTenantMutableAppRole>>);
});
it("blocks the list loader through the workspace-role feature gate", async () => {
const disabled = new Response("Workspace roles are not enabled", { status: 404 });
vi.mocked(requireWorkspaceRolesBuilderAccess).mockRejectedValueOnce(disabled);
await expect(callListLoader()).rejects.toBe(disabled);
expect(getAllRolesWithUsers).not.toHaveBeenCalled();
});
it("uses global default and tenant-owned app roles for the list loader after requiring builder access", async () => {
const defaultRole = { ...role, id: "role_default", isDefault: true };
vi.mocked(getAllRolesWithUsers).mockResolvedValueOnce([role, defaultRole] as Awaited<ReturnType<typeof getAllRolesWithUsers>>);
const data = await callListLoader();
expect(requireWorkspaceRolesBuilderAccess).toHaveBeenCalledWith({ request, params, tenantId: "tenant_1" });
expect(getAllRolesWithUsers).toHaveBeenCalledWith("app", undefined, "tenant_1");
expect(data).toMatchObject({ items: [role, defaultRole] });
});
it("new role loader exposes only app permissions", async () => {
vi.mocked(getAllPermissions).mockResolvedValueOnce([appPermission, adminPermission] as Awaited<ReturnType<typeof getAllPermissions>>);
const data = await callNewLoader();
expect(getAllPermissions).toHaveBeenCalledWith("app");
expect(JSON.stringify(data)).not.toContain("admin.roles.delete");
});
it("create action delegates mutation to the workspace role service", async () => {
const form = new FormData();
form.set("action", "create");
form.set("name", " Workspace editor ");
form.set("description", "Can edit workspace data");
form.set("type", "app");
form.append("permissions[]", "app.settings.members.view");
const result = await callNewAction(form);
expect(createWorkspaceRole).toHaveBeenCalledWith({
request: expect.any(Request),
tenantId: "tenant_1",
data: {
name: " Workspace editor ",
description: "Can edit workspace data",
assignToNewUsers: false,
type: "app",
permissionNames: ["app.settings.members.view"],
},
});
expect(result).toBeInstanceOf(Response);
expect((result as Response).status).toBe(302);
});
it("create action returns bounded 400 JSON for service-denied admin type tampering", async () => {
vi.mocked(createWorkspaceRole).mockRejectedValueOnce(new Response("Workspace roles cannot grant admin capabilities", { status: 400 }));
const form = new FormData();
form.set("action", "create");
form.set("name", "Escalate");
form.set("description", "Tampered payload");
form.set("type", "admin");
form.append("permissions[]", "app.settings.members.view");
const result = await callNewAction(form);
expect(createWorkspaceRole).toHaveBeenCalledWith(expect.objectContaining({ data: expect.objectContaining({ type: "admin" }) }));
expect((result as Response).status).toBe(400);
await expect(responseJson(result)).resolves.toEqual({ error: "Workspace roles cannot grant admin capabilities" });
});
it("create action returns bounded 400 JSON for service-denied admin permission tampering", async () => {
vi.mocked(createWorkspaceRole).mockRejectedValueOnce(new Response("Workspace roles cannot grant admin permissions", { status: 400 }));
const form = new FormData();
form.set("action", "create");
form.set("name", "Escalate");
form.set("description", "Tampered payload");
form.set("type", "app");
form.append("permissions[]", "admin.roles.delete");
const result = await callNewAction(form);
expect(createWorkspaceRole).toHaveBeenCalledWith(expect.objectContaining({ data: expect.objectContaining({ permissionNames: ["admin.roles.delete"] }) }));
expect((result as Response).status).toBe(400);
await expect(responseJson(result)).resolves.toEqual({ error: "Workspace roles cannot grant admin permissions" });
});
it("create action propagates access denial before parsing or mutating", async () => {
const denied = new Response(null, { status: 302, headers: { Location: "/login?redirectTo=%2Facme%2Fsettings%2Froles" } });
vi.mocked(requireWorkspaceRolesBuilderAccess).mockRejectedValueOnce(denied);
const form = new FormData();
form.set("action", "create");
form.set("name", "No access");
form.set("type", "admin");
await expect(callNewAction(form)).rejects.toBe(denied);
expect(createWorkspaceRole).not.toHaveBeenCalled();
});
it("edit action returns bounded 400 responses for service validation errors", async () => {
vi.mocked(updateWorkspaceRole).mockRejectedValueOnce(new Response("Default roles cannot be changed", { status: 400 }));
const result = await callEditAction(roleForm({ name: "Default", description: "Protected" }));
expect((result as Response).status).toBe(400);
await expect(responseJson(result)).resolves.toEqual({ error: "Default roles cannot be changed" });
});
it("edit action returns bounded 400 JSON for service-denied admin type tampering", async () => {
vi.mocked(updateWorkspaceRole).mockRejectedValueOnce(new Response("Workspace roles cannot grant admin capabilities", { status: 400 }));
const result = await callEditAction(roleForm({ type: "admin" }));
expect(updateWorkspaceRole).toHaveBeenCalledWith(expect.objectContaining({ data: expect.objectContaining({ type: "admin" }) }));
expect((result as Response).status).toBe(400);
await expect(responseJson(result)).resolves.toEqual({ error: "Workspace roles cannot grant admin capabilities" });
});
it("edit action returns bounded 400 JSON for service-denied admin permission tampering", async () => {
vi.mocked(updateWorkspaceRole).mockRejectedValueOnce(new Response("Workspace roles cannot grant admin permissions", { status: 400 }));
const form = roleForm();
form.delete("permissions[]");
form.append("permissions[]", "admin.roles.delete");
const result = await callEditAction(form);
expect(updateWorkspaceRole).toHaveBeenCalledWith(expect.objectContaining({ data: expect.objectContaining({ permissionNames: ["admin.roles.delete"] }) }));
expect((result as Response).status).toBe(400);
await expect(responseJson(result)).resolves.toEqual({ error: "Workspace roles cannot grant admin permissions" });
});
it("edit action propagates access denial before mutation", async () => {
const denied = new Response("Forbidden", { status: 403 });
vi.mocked(requireWorkspaceRolesBuilderAccess).mockRejectedValueOnce(denied);
await expect(callEditAction(roleForm({ type: "admin" }))).rejects.toBe(denied);
expect(updateWorkspaceRole).not.toHaveBeenCalled();
});
it("delete action propagates access denial before mutation", async () => {
const denied = new Response("Forbidden", { status: 403 });
vi.mocked(requireWorkspaceRolesBuilderAccess).mockRejectedValueOnce(denied);
const form = new FormData();
form.set("action", "delete");
await expect(callEditAction(form)).rejects.toBe(denied);
expect(deleteWorkspaceRole).not.toHaveBeenCalled();
});
it("edit loader exposes only app permissions", async () => {
vi.mocked(getAllPermissions).mockResolvedValueOnce([appPermission, adminPermission] as Awaited<ReturnType<typeof getAllPermissions>>);
const data = await callEditLoader();
expect(getTenantMutableAppRole).toHaveBeenCalledWith("role_1", "tenant_1");
expect(getAllPermissions).toHaveBeenCalledWith("app");
expect(JSON.stringify(data)).not.toContain("admin.roles.delete");
});
it("edit loader redirects guessed roles outside the tenant scope", async () => {
vi.mocked(getTenantMutableAppRole).mockResolvedValueOnce(null);
await expect(callEditLoader()).rejects.toMatchObject({ status: 302 });
expect(getAllPermissions).not.toHaveBeenCalled();
});
it("edit loader rejects default roles before exposing permission data", async () => {
vi.mocked(getTenantMutableAppRole).mockResolvedValueOnce({ ...role, isDefault: true } as Awaited<ReturnType<typeof getTenantMutableAppRole>>);
const result = callEditLoader();
await expect(result).rejects.toMatchObject({ status: 400 });
await result.catch(async (response: Response) => {
await expect(response.text()).resolves.toBe("settings.rolesAndPermissions.errors.onlyNonDefaultAppRolesEditable");
});
expect(getAllPermissions).not.toHaveBeenCalled();
});
it("edit loader rejects non-app roles before exposing permission data", async () => {
vi.mocked(getTenantMutableAppRole).mockResolvedValueOnce({ ...role, type: "admin" } as Awaited<ReturnType<typeof getTenantMutableAppRole>>);
const result = callEditLoader();
await expect(result).rejects.toMatchObject({ status: 400 });
await result.catch(async (response: Response) => {
await expect(response.text()).resolves.toBe("settings.rolesAndPermissions.errors.onlyNonDefaultAppRolesEditable");
});
expect(getAllPermissions).not.toHaveBeenCalled();
});
});