119 lines
5.0 KiB
TypeScript
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);
|
|
});
|
|
});
|