Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/scripts/lib/portal-app-worker-policy-parity.test.ts
T

232 lines
11 KiB
TypeScript

import { readFile } from "node:fs/promises";
import { join } from "node:path";
import { beforeAll, describe, expect, it, vi } from "vitest";
import {
PORTAL_APP_WORKER_DELTA_TABLES,
assertPortalAppWorkerPolicyParity,
normalizePolicyExpression,
parsePortalAppWorkerPolicyContract,
readPortalAppWorkerPolicyState,
type PortalAppWorkerPolicyContract,
type PortalAppWorkerPolicyState,
} from "./portal-app-worker-policy-parity.js";
const CANONICAL_ARTIFACT = join(process.cwd(), "prisma/rls/tenant-policy-contract-isolation.sql");
const APP_WORKER_ROLES = ["hivegrid_app", "hivegrid_worker"] as const;
const PRIVILEGES = ["SELECT", "INSERT", "UPDATE", "DELETE", "TRUNCATE", "REFERENCES", "TRIGGER"] as const;
let canonicalSql: string;
let contract: PortalAppWorkerPolicyContract;
beforeAll(async () => {
canonicalSql = await readFile(CANONICAL_ARTIFACT, "utf8");
contract = parsePortalAppWorkerPolicyContract(canonicalSql);
});
describe("portal app/worker policy contract parser", () => {
it("derives the complete portal delta contract from the generated artifact", () => {
expect(contract.tables.map(({ table }) => table)).toEqual(PORTAL_APP_WORKER_DELTA_TABLES);
expect(contract.policies).toHaveLength(69);
expect(contract.grants).toHaveLength(144);
expect(contract.tables).toEqual(
PORTAL_APP_WORKER_DELTA_TABLES.map((table) => ({
table,
rowSecurity: true,
forceRowSecurity: true,
}))
);
const portalPolicy = contract.policies.find(({ table, policy }) => table === "Portal" && policy === "hg_Portal_all");
expect(portalPolicy).toMatchObject({
permissive: true,
command: "*",
roles: ["hivegrid_app", "hivegrid_worker"],
});
expect(portalPolicy?.usingExpression).not.toBeNull();
expect(portalPolicy?.usingExpression).toBe(portalPolicy?.withCheckExpression);
});
it("fails closed when ENABLE/FORCE, grants, or SQL structure are malformed", () => {
expect(() => parsePortalAppWorkerPolicyContract(canonicalSql.replace('ALTER TABLE "Portal" FORCE ROW LEVEL SECURITY;', ""))).toThrow(
"must ENABLE and FORCE RLS exactly once for Portal"
);
expect(() => parsePortalAppWorkerPolicyContract(`${canonicalSql}\nGRANT SELECT ON "Portal" TO hivegrid_app;`)).toThrow(
"duplicates SELECT on Portal to hivegrid_app"
);
expect(() => parsePortalAppWorkerPolicyContract(`${canonicalSql}\nGRANT TRUNCATE ON "Portal" TO hivegrid_app;`)).toThrow(
"grants forbidden TRUNCATE on Portal to hivegrid_app"
);
expect(() =>
parsePortalAppWorkerPolicyContract(
canonicalSql.replace('CREATE POLICY "hg_Portal_all" ON "Portal"', 'CREATE POLICY "hg_Portal_all" ON "Portal" AS MAYBE')
)
).toThrow("invalid AS mode");
});
it("normalizes PostgreSQL deparser casts and aliases without erasing subquery boundaries", () => {
const artifactExpression = "\"tenantId\" = NULLIF(current_setting('app.tenant_id', true), '')";
const postgresExpression = "(\"tenantId\" = NULLIF(current_setting('app.tenant_id'::text, true), ''::text))";
expect(normalizePolicyExpression(postgresExpression)).toBe(normalizePolicyExpression(artifactExpression));
const artifactExistsExpression =
'("tenantId" = NULLIF(current_setting(\'app.tenant_id\', true), \'\') AND EXISTS (SELECT 1 FROM "Portal" AS "owner_0" WHERE "owner_0"."id" = "PortalUser"."portalId" AND "owner_0"."tenantId" = NULLIF(current_setting(\'app.tenant_id\', true), \'\')))';
const postgresExistsExpression =
'(("tenantId" = NULLIF(current_setting(\'app.tenant_id\'::text, true), \'\'::text)) AND (EXISTS ( SELECT 1 FROM "Portal" owner_0 WHERE ((owner_0.id = "PortalUser"."portalId") AND (owner_0."tenantId" = NULLIF(current_setting(\'app.tenant_id\'::text, true), \'\'::text))))))';
expect(normalizePolicyExpression(postgresExistsExpression)).toBe(normalizePolicyExpression(artifactExistsExpression));
const artifactNullableRelation =
'"PortalServiceInboxItem"."routingRuleId" IS NULL OR EXISTS (SELECT 1 FROM "PortalActivityRoutingRule" AS "owner_0" WHERE "owner_0"."id" = "PortalServiceInboxItem"."routingRuleId")';
const postgresNullableRelation =
'"routingRuleId" IS NULL OR EXISTS (SELECT 1 FROM "PortalActivityRoutingRule" owner_0 WHERE owner_0.id = "PortalServiceInboxItem"."routingRuleId")';
expect(normalizePolicyExpression(postgresNullableRelation, "PortalServiceInboxItem")).toBe(
normalizePolicyExpression(artifactNullableRelation, "PortalServiceInboxItem")
);
expect(normalizePolicyExpression('"wrong_alias"."routingRuleId" IS NULL', "PortalServiceInboxItem")).not.toBe(
normalizePolicyExpression('"routingRuleId" IS NULL', "PortalServiceInboxItem")
);
const siblingSubqueries =
'EXISTS (SELECT 1 FROM "Portal" AS "owner_0" WHERE "owner_0"."id" = "PortalUser"."portalId") AND EXISTS (SELECT 1 FROM "Portal" AS "owner_1" WHERE "owner_1"."id" = "PortalUser"."portalId")';
const nestedSubquery =
'EXISTS (SELECT 1 FROM "Portal" AS "owner_0" WHERE "owner_0"."id" = "PortalUser"."portalId" AND EXISTS (SELECT 1 FROM "Portal" AS "owner_1" WHERE "owner_1"."id" = "PortalUser"."portalId"))';
expect(normalizePolicyExpression(siblingSubqueries)).not.toBe(normalizePolicyExpression(nestedSubquery));
});
});
describe("portal app/worker exact database-state parity", () => {
it("accepts only the exact state derived from the canonical artifact", () => {
expect(() => assertPortalAppWorkerPolicyParity(contract, stateFromContract(contract))).not.toThrow();
});
it("rejects permissive true expressions, missing/extra policies, and role or command drift", () => {
const state = stateFromContract(contract);
const policy = state.policies.find(({ table, policy: name }) => table === "PortalEmailTemplate" && name === "hg_PortalEmailTemplate_update");
if (!policy) throw new Error("test fixture policy missing");
policy.usingExpression = normalizePolicyExpression("true");
policy.command = "*";
policy.roles = ["PUBLIC"];
state.policies.pop();
state.policies.push({
table: "Portal",
policy: "allow_everything",
permissive: true,
command: "*",
roles: ["hivegrid_app", "hivegrid_worker"],
usingExpression: normalizePolicyExpression("true"),
withCheckExpression: normalizePolicyExpression("true"),
});
expect(() => assertPortalAppWorkerPolicyParity(contract, state)).toThrow(
/using_expression_mismatch.*command_mismatch|command_mismatch.*using_expression_mismatch/
);
expect(() => assertPortalAppWorkerPolicyParity(contract, state)).toThrow("roles_mismatch");
expect(() => assertPortalAppWorkerPolicyParity(contract, state)).toThrow("unexpected_policy");
expect(() => assertPortalAppWorkerPolicyParity(contract, state)).toThrow("policy_missing");
});
it("rejects missing FORCE RLS, a missing required grant, and every extra table privilege", () => {
const state = stateFromContract(contract);
const portal = state.tables.find(({ table }) => table === "Portal");
if (!portal) throw new Error("test fixture table missing");
portal.forceRowSecurity = false;
state.grants = state.grants.filter(({ table, role, privilege }) => !(table === "Portal" && role === "hivegrid_app" && privilege === "DELETE"));
state.grants.push({
table: "Portal",
role: "hivegrid_worker",
privilege: "TRUNCATE",
});
state.columnGrants.push({
table: "PortalUser",
column: "passwordHash",
role: "hivegrid_app",
privilege: "UPDATE",
});
expect(() => assertPortalAppWorkerPolicyParity(contract, state)).toThrow("Portal:rls_not_forced");
expect(() => assertPortalAppWorkerPolicyParity(contract, state)).toThrow("Portal:hivegrid_app:DELETE:grant_missing");
expect(() => assertPortalAppWorkerPolicyParity(contract, state)).toThrow("Portal:hivegrid_worker:TRUNCATE:unexpected_grant");
expect(() => assertPortalAppWorkerPolicyParity(contract, state)).toThrow("PortalUser.passwordHash:hivegrid_app:UPDATE:unexpected_column_grant");
});
it("reads table flags, all app/worker-affecting policies, and the full effective privilege matrix", async () => {
const queries: string[] = [];
const queryRawUnsafe = vi.fn(async (query: string): Promise<unknown[]> => {
queries.push(query);
if (query.includes(":tables */")) {
return PORTAL_APP_WORKER_DELTA_TABLES.map((table) => ({
table_name: table,
row_security: true,
force_row_security: true,
}));
}
if (query.includes(":policies */")) {
return [
{
table_name: "Portal",
policy_name: "hg_Portal_all",
permissive: true,
command: "*",
roles: ["hivegrid_app", "hivegrid_worker"],
using_expression: "(\"tenantId\" = NULLIF(current_setting('app.tenant_id'::text, true), ''::text))",
with_check_expression: "(\"tenantId\" = NULLIF(current_setting('app.tenant_id'::text, true), ''::text))",
},
];
}
if (query.includes(":privileges */")) {
return PORTAL_APP_WORKER_DELTA_TABLES.flatMap((table) =>
APP_WORKER_ROLES.flatMap((role) =>
PRIVILEGES.map((privilege) => ({
table_name: table,
role_name: role,
privilege_type: privilege,
granted: ["SELECT", "INSERT", "UPDATE", "DELETE"].includes(privilege),
}))
)
);
}
if (query.includes(":column-grants */")) return [];
throw new Error("unexpected test query");
});
const state = await readPortalAppWorkerPolicyState({ $queryRawUnsafe: queryRawUnsafe });
expect(queryRawUnsafe).toHaveBeenCalledTimes(4);
expect(queries[0]).toContain("class.relrowsecurity");
expect(queries[0]).toContain("class.relforcerowsecurity");
expect(queries[1]).toContain("pg_get_expr(policy.polqual");
expect(queries[1]).toContain("policy_role.role_oid = 0");
expect(queries[1]).toContain("pg_has_role(runtime_role.oid, role.oid, 'MEMBER')");
expect(queries[1]).toContain("hivegrid_app");
expect(queries[1]).toContain("hivegrid_worker");
expect(queries[2]).toContain("has_table_privilege");
expect(queries[2]).toContain("TRUNCATE");
expect(queries[2]).toContain("REFERENCES");
expect(queries[2]).toContain("TRIGGER");
expect(queries[3]).toContain("attribute.attacl");
expect(queries[3]).toContain("aclexplode");
expect(queries[3]).toContain("access.grantee = 0");
expect(state.tables).toHaveLength(18);
expect(state.policies).toHaveLength(1);
expect(state.grants).toHaveLength(144);
expect(state.columnGrants).toEqual([]);
expect(state.policies[0]?.usingExpression).toBe(contract.policies.find(({ policy }) => policy === "hg_Portal_all")?.usingExpression);
});
});
function stateFromContract(source: PortalAppWorkerPolicyContract): PortalAppWorkerPolicyState {
return {
tables: source.tables.map((table) => ({ ...table })),
policies: source.policies.map((policy) => ({
...policy,
roles: [...policy.roles],
})),
grants: source.grants.map((grant) => ({ ...grant })),
columnGrants: [],
};
}