Files
HiveGrid-Wireframes/hivegrid-cloud/apps/worker/src/jobs/dsgvo-deletion.test.ts
T

119 lines
5.0 KiB
TypeScript

import { describe, expect, it, vi } from "vitest";
import { USER_FK_MAP } from "@toolctrl/db/dsgvo/user-fk-map";
import { runDsgvoDeletion, type DsgvoDeletionDependencies, type DsgvoDeletionJobInput } from "./dsgvo-deletion.js";
function makeDeps(overrides?: Partial<DsgvoDeletionDependencies>): {
deps: DsgvoDeletionDependencies;
audits: Array<Parameters<DsgvoDeletionDependencies["writeAuditEvent"]>[0]>;
hardDeletes: string[];
pseudoTables: Array<{ model: string; column: string }>;
tombstones: Array<{ model: string; column: string }>;
hardDeleteUserCalls: string[];
pseudonymizeUserCalls: string[];
} {
const audits: Array<Parameters<DsgvoDeletionDependencies["writeAuditEvent"]>[0]> = [];
const hardDeletes: string[] = [];
const pseudoTables: Array<{ model: string; column: string }> = [];
const tombstones: Array<{ model: string; column: string }> = [];
const hardDeleteUserCalls: string[] = [];
const pseudonymizeUserCalls: string[] = [];
const deps: DsgvoDeletionDependencies = {
tableClient: {
hardDelete: vi.fn().mockImplementation(async (entry: { model: string; column: string }) => {
hardDeletes.push(`${entry.model}.${entry.column}`);
return 1;
}),
pseudonymize: vi.fn().mockImplementation(async (entry: { model: string; column: string }) => {
pseudoTables.push({ model: entry.model, column: entry.column });
return 2;
}),
retainTombstone: vi.fn().mockImplementation(async (entry: { model: string; column: string }) => {
tombstones.push({ model: entry.model, column: entry.column });
return 3;
}),
},
userClient: {
hardDeleteUser: vi.fn().mockImplementation(async (userId: string) => {
hardDeleteUserCalls.push(userId);
}),
pseudonymizeUser: vi.fn().mockImplementation(async (userId: string) => {
pseudonymizeUserCalls.push(userId);
}),
},
writeAuditEvent: vi.fn().mockImplementation(async (input) => {
audits.push(input);
}),
logger: { info: vi.fn(), error: vi.fn() },
...overrides,
};
return { deps, audits, hardDeletes, pseudoTables, tombstones, hardDeleteUserCalls, pseudonymizeUserCalls };
}
const baseJob: DsgvoDeletionJobInput = {
userId: "u1",
tenantId: "t1",
requestId: "req-1",
actorType: "system",
actorId: "system",
mode: "delete",
};
describe("runDsgvoDeletion", () => {
it("applies hard-delete, pseudonymize and retain-tombstone strategies across the user-fk-map", async () => {
const { deps, audits, hardDeletes, pseudoTables, tombstones, hardDeleteUserCalls } = makeDeps();
const result = await runDsgvoDeletion(deps, baseJob);
const expectedHardDelete = USER_FK_MAP.filter((e) => e.strategy === "hard-delete").length;
const expectedPseudo = USER_FK_MAP.filter((e) => e.strategy === "pseudonymize").length;
const expectedTombstone = USER_FK_MAP.filter((e) => e.strategy === "retain-tombstone").length;
expect(hardDeletes).toHaveLength(expectedHardDelete);
expect(pseudoTables).toHaveLength(expectedPseudo);
expect(tombstones).toHaveLength(expectedTombstone);
expect(hardDeleteUserCalls).toEqual(["u1"]);
expect(result.tables).toHaveLength(USER_FK_MAP.length);
expect(result.userOutcome).toBe("deleted");
expect(audits).toHaveLength(1);
expect(audits[0]?.action).toBe("DELETE_USER");
expect(audits[0]?.outcome).toBe("success");
expect(audits[0]?.regulatoryScope).toEqual(["gdpr"]);
});
it("pseudonymizes the user when mode=pseudonymize", async () => {
const { deps, audits, pseudonymizeUserCalls, hardDeleteUserCalls } = makeDeps();
const result = await runDsgvoDeletion(deps, { ...baseJob, mode: "pseudonymize", actorType: "admin", actorId: "admin-1", reason: "court order" });
expect(pseudonymizeUserCalls).toEqual(["u1"]);
expect(hardDeleteUserCalls).toEqual([]);
expect(result.userOutcome).toBe("pseudonymized");
expect(audits[0]?.action).toBe("PSEUDONYMIZE_USER");
expect(audits[0]?.metadata).toMatchObject({ mode: "pseudonymize", reason: "court order" });
});
it("audits failure and rethrows when a table strategy errors mid-run", async () => {
const { deps, audits } = makeDeps({
tableClient: {
hardDelete: vi.fn().mockRejectedValue(new Error("db lock")),
pseudonymize: vi.fn().mockResolvedValue(0),
retainTombstone: vi.fn().mockResolvedValue(0),
},
});
await expect(runDsgvoDeletion(deps, baseJob)).rejects.toThrow(/db lock/);
expect(audits.at(-1)?.outcome).toBe("failure");
expect(audits.at(-1)?.metadata).toMatchObject({ error: expect.stringContaining("db lock") });
});
it("never deletes the AuditEvent rows even when mode=delete (SOC2-CC6.1 audit-trail integrity)", async () => {
const { deps, hardDeletes, pseudoTables } = makeDeps();
await runDsgvoDeletion(deps, baseJob);
expect(hardDeletes).not.toContain("AuditEvent.actorId");
expect(pseudoTables.some((t) => t.model === "AuditEvent" && t.column === "actorId")).toBe(true);
});
});