Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/utils/helpers/.server/PermissionsService.billing-readonly.test.ts
T

139 lines
6.4 KiB
TypeScript

// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
import { TenantUserStatus } from "~/application/enums/tenants/TenantUserStatus";
vi.mock("~/utils/session.server", () => ({
getUserInfo: vi.fn(),
}));
vi.mock("~/utils/db/permissions/permissions.db.server", () => ({
getPermissionName: vi.fn(),
}));
vi.mock("~/utils/db/permissions/userRoles.db.server", () => ({
findPermissionByUser: vi.fn(),
getUserRoleInAdmin: vi.fn(),
userHasPermission: vi.fn(),
}));
vi.mock("~/utils/db/tenants.db.server", () => ({
getTenantMember: vi.fn(),
}));
vi.mock("~/utils/loaders.middleware", () => ({
getIsSuperAdminByUserId: vi.fn(),
}));
vi.mock("@hivegrid/db/auth-boundary.server", () => ({
getAuthUserWithoutPasswordById: vi.fn(),
}));
vi.mock("~/utils/services/.server/billingStatusService", () => ({
getTenantBillingReadOnlyState: vi.fn(),
}));
vi.mock("~/utils/services/.server/tenantDeletionStatusService", () => ({
getTenantDeletionReadOnlyState: vi.fn(),
}));
import { getPermissionName } from "~/utils/db/permissions/permissions.db.server";
import { getTenantMember } from "~/utils/db/tenants.db.server";
import { getIsSuperAdminByUserId } from "~/utils/loaders.middleware";
import { getUserInfo } from "~/utils/session.server";
import { getTenantBillingReadOnlyState } from "~/utils/services/.server/billingStatusService";
import { getTenantDeletionReadOnlyState } from "~/utils/services/.server/tenantDeletionStatusService";
import { getAuthUserWithoutPasswordById as getUser } from "@hivegrid/db/auth-boundary.server";
import { getUserRoleInAdmin, userHasPermission } from "~/utils/db/permissions/userRoles.db.server";
import { verifyUserHasPermission } from "./PermissionsService";
const userInfo = { userId: "user-1", lightOrDarkMode: "light", lng: "en", cookies: [] };
function request(method: string, path: string) {
return new Request(`https://app.example.test${path}`, { method });
}
async function expectStatus(promise: Promise<unknown>, status: number) {
try {
await promise;
throw new Error(`Expected response status ${status}`);
} catch (error) {
expect(error).toBeInstanceOf(Response);
expect((error as Response).status).toBe(status);
}
}
describe("verifyUserHasPermission billing read-only guard", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(getUserInfo).mockResolvedValue(userInfo);
vi.mocked(getUser).mockResolvedValue(null);
vi.mocked(getIsSuperAdminByUserId).mockResolvedValue(false);
vi.mocked(getUserRoleInAdmin).mockResolvedValue(null);
vi.mocked(getPermissionName).mockResolvedValue({ id: "perm-1", name: "tasks.create" } as never);
vi.mocked(getTenantMember).mockResolvedValue({ status: TenantUserStatus.ACTIVE } as never);
vi.mocked(userHasPermission).mockResolvedValue(true);
vi.mocked(getTenantBillingReadOnlyState).mockResolvedValue({ readOnly: false, status: null });
vi.mocked(getTenantDeletionReadOnlyState).mockResolvedValue({ readOnly: false, status: "none" });
});
it("blocks mutating tenant requests when billing is read-only", async () => {
vi.mocked(getTenantBillingReadOnlyState).mockResolvedValueOnce({ readOnly: true, status: "frozen" });
await expectStatus(verifyUserHasPermission(request("POST", "/acme/tasks/new"), "tasks.create", "tenant-1"), 423);
expect(getTenantBillingReadOnlyState).toHaveBeenCalledWith("tenant-1");
expect(userHasPermission).not.toHaveBeenCalled();
});
it("allows read-only GET requests without checking the billing write guard", async () => {
await expect(verifyUserHasPermission(request("GET", "/acme/tasks"), "tasks.create", "tenant-1")).resolves.toBe(true);
expect(getTenantBillingReadOnlyState).not.toHaveBeenCalled();
expect(userHasPermission).toHaveBeenCalledWith("user-1", "tenant-1", "tasks.create");
});
it("allows subscription actions so tenants can recover billing", async () => {
vi.mocked(getTenantBillingReadOnlyState).mockResolvedValueOnce({ readOnly: true, status: "frozen" });
await expect(verifyUserHasPermission(request("POST", "/acme/settings/subscription"), "app.settings.subscription.update", "tenant-1")).resolves.toBe(true);
expect(getTenantBillingReadOnlyState).not.toHaveBeenCalled();
expect(userHasPermission).toHaveBeenCalledWith("user-1", "tenant-1", "app.settings.subscription.update");
});
});
describe("verifyUserHasPermission deletion_pending read-only guard (AK-P21)", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(getUserInfo).mockResolvedValue(userInfo);
vi.mocked(getUser).mockResolvedValue(null);
vi.mocked(getIsSuperAdminByUserId).mockResolvedValue(false);
vi.mocked(getUserRoleInAdmin).mockResolvedValue(null);
vi.mocked(getPermissionName).mockResolvedValue({ id: "perm-1", name: "tasks.create" } as never);
vi.mocked(getTenantMember).mockResolvedValue({ status: TenantUserStatus.ACTIVE } as never);
vi.mocked(userHasPermission).mockResolvedValue(true);
// mockReset also drops un-consumed mockResolvedValueOnce queues from the
// billing describe above (clearAllMocks alone keeps them).
vi.mocked(getTenantBillingReadOnlyState).mockReset().mockResolvedValue({ readOnly: false, status: null });
vi.mocked(getTenantDeletionReadOnlyState).mockReset().mockResolvedValue({ readOnly: false, status: "none" });
});
it("blocks mutating tenant requests during the deletion grace window", async () => {
vi.mocked(getTenantDeletionReadOnlyState).mockResolvedValueOnce({ readOnly: true, status: "pending" });
await expectStatus(verifyUserHasPermission(request("POST", "/acme/tasks/new"), "tasks.create", "tenant-1"), 423);
expect(getTenantDeletionReadOnlyState).toHaveBeenCalledWith("tenant-1");
expect(userHasPermission).not.toHaveBeenCalled();
});
it("keeps the privacy area writable so the deletion can be withdrawn", async () => {
vi.mocked(getTenantDeletionReadOnlyState).mockResolvedValueOnce({ readOnly: true, status: "pending" });
await expect(
verifyUserHasPermission(request("POST", "/acme/settings/privacy/deletion"), "privacy.tenant_deletion", "tenant-1")
).resolves.toBe(true);
expect(getTenantDeletionReadOnlyState).not.toHaveBeenCalled();
});
it("does not run the deletion guard on read-only requests", async () => {
await expect(verifyUserHasPermission(request("GET", "/acme/tasks"), "tasks.create", "tenant-1")).resolves.toBe(true);
expect(getTenantDeletionReadOnlyState).not.toHaveBeenCalled();
});
});