Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/packages/db/src/audit-chain-checkpoint.server.test.ts
T

181 lines
7.3 KiB
TypeScript

import { describe, expect, it, vi } from "vitest";
import { computeAuditHash, type AuditHashPayload } from "./audit-hash.js";
import {
acquireAuditChainLock,
auditChainKey,
computeAuditChainHeadMac,
computeAuditCheckpointMac,
loadAuditVerificationContext,
pruneAuditChainBatch,
verifyAuditCheckpoint,
verifyAuditChainHead,
type AuditChainCheckpointRecord,
} from "./audit-chain-checkpoint.server.js";
const SECRET = "audit-chain-test-secret-32-bytes-minimum";
function payload(id: string, createdAt: Date, previousHash: string | null, action: string): AuditHashPayload & {
previousHash: string | null;
eventHash: string;
} {
const value: AuditHashPayload = {
id,
createdAt: createdAt.toISOString(),
tenantId: null,
actorType: "system",
actorId: null,
actorEmail: null,
actorIp: null,
actorUserAgent: null,
action,
targetType: "AuditEvent",
targetId: null,
requestId: null,
sourceModule: "audit",
outcome: "success",
dataSensitivity: "internal",
regulatoryScope: [],
metadata: null,
};
return {
...value,
previousHash,
eventHash: computeAuditHash({ previousHash, payload: value, secret: SECRET, version: "hmac-v2" }),
};
}
describe("audit checkpoint authentication", () => {
it("casts the advisory-lock result away from PostgreSQL void for Prisma adapters", async () => {
const queryRaw = vi.fn(async <T = unknown>(strings: TemplateStringsArray, ..._values: unknown[]): Promise<T> => {
expect(strings.join("?")).toContain('pg_advisory_xact_lock(hashtextextended(?, 0))::text AS "lock"');
return [{ lock: "" }] as T;
});
await acquireAuditChainLock(
{
$queryRaw: async <T = unknown>(strings: TemplateStringsArray, ...values: unknown[]): Promise<T> =>
queryRaw(strings, ...values) as Promise<T>,
},
"tenant-1",
);
expect(queryRaw).toHaveBeenCalledOnce();
});
it("authenticates the mutable O(1) chain head, including its timestamp", () => {
const headWithoutMac = {
chainKey: "tenant:tenant-1",
tenantId: "tenant-1",
eventId: "event-1",
eventHash: "v2:event",
eventCreatedAt: new Date("2026-01-01T00:00:00.000Z"),
};
const head = { ...headWithoutMac, headMac: computeAuditChainHeadMac(headWithoutMac, SECRET) };
expect(verifyAuditChainHead(head, SECRET)).toBe(true);
expect(verifyAuditChainHead({ ...head, eventCreatedAt: new Date("2099-01-01T00:00:00.000Z") }, SECRET)).toBe(false);
});
it("binds the deletion anchor and checkpoint history with an HMAC", () => {
const withoutMac: Omit<AuditChainCheckpointRecord, "checkpointMac"> = {
id: "checkpoint-1",
createdAt: new Date("2026-01-01T00:00:00.000Z"),
chainKey: auditChainKey(null),
tenantId: null,
deletedThroughAt: new Date("2016-01-01T00:00:00.000Z"),
lastDeletedEventId: "event-1",
lastDeletedEventHash: "v2:abc",
deletedCount: 1_000,
previousCheckpointMac: null,
};
const checkpoint = { ...withoutMac, checkpointMac: computeAuditCheckpointMac(withoutMac, SECRET) };
expect(verifyAuditCheckpoint(checkpoint, SECRET)).toBe(true);
expect(verifyAuditCheckpoint({ ...checkpoint, deletedCount: 999 }, SECRET)).toBe(false);
expect(verifyAuditCheckpoint({ ...checkpoint, lastDeletedEventHash: "v2:forged" }, SECRET)).toBe(false);
});
it("loads one authenticated anchor for retained full-chain verification", async () => {
const withoutMac: Omit<AuditChainCheckpointRecord, "checkpointMac"> = {
id: "checkpoint-1",
createdAt: new Date("2026-01-01T00:00:00.000Z"),
chainKey: auditChainKey("tenant-1"),
tenantId: "tenant-1",
deletedThroughAt: new Date("2016-01-01T00:00:00.000Z"),
lastDeletedEventId: "old",
lastDeletedEventHash: "v2:anchor",
deletedCount: 10,
previousCheckpointMac: null,
};
const checkpoint = { ...withoutMac, checkpointMac: computeAuditCheckpointMac(withoutMac, SECRET) };
const findMany = vi.fn(async () => [checkpoint]);
const findHeads = vi.fn(async () => [{ chainKey: "tenant:tenant-1", checkpointId: checkpoint.id }]);
const context = await loadAuditVerificationContext(
{ auditChainCheckpoint: { findMany }, auditChainCheckpointHead: { findMany: findHeads } },
[{ id: "retained", createdAt: new Date(), tenantId: "tenant-1", previousHash: "v2:anchor", eventHash: "v2:event" }],
{ secret: SECRET },
);
expect(findMany).toHaveBeenCalledTimes(1);
expect(findMany).toHaveBeenCalledWith({ where: { id: { in: [checkpoint.id] } } });
expect(findHeads).toHaveBeenCalledTimes(1);
expect(context.initialPreviousHashes.get("tenant:tenant-1")).toBe("v2:anchor");
expect(context.invalidCheckpointChains.size).toBe(0);
});
});
describe("pruneAuditChainBatch", () => {
it("locks, verifies, checkpoints, and deletes a bounded platform-chain prefix", async () => {
const firstDate = new Date("2010-01-01T00:00:00.000Z");
const secondDate = new Date("2010-01-02T00:00:00.000Z");
const retainedDate = new Date("2020-01-01T00:00:00.000Z");
const first = { ...payload("event-1", firstDate, null, "one"), createdAt: firstDate };
const second = { ...payload("event-2", secondDate, first.eventHash, "two"), createdAt: secondDate };
const retained = { ...payload("event-3", retainedDate, second.eventHash, "three"), createdAt: retainedDate };
const checkpointCreate = vi.fn(async ({ data }) => data);
const deleteMany = vi.fn(async () => ({ count: 2 }));
const queryRaw = vi.fn(async () => []);
let retainedLookup = 0;
const tx = {
$queryRaw: queryRaw,
auditEvent: {
findMany: vi.fn(async () => [first, second]),
findFirst: vi.fn(async () => {
retainedLookup += 1;
return retainedLookup === 1
? { id: retained.id, previousHash: retained.previousHash, eventHash: retained.eventHash }
: null;
}),
deleteMany,
},
auditChainCheckpoint: {
findFirst: vi.fn(async () => null),
findUnique: vi.fn(async () => null),
findMany: vi.fn(async () => []),
create: checkpointCreate,
},
auditChainCheckpointHead: {
findUnique: vi.fn(async () => null),
upsert: vi.fn(async () => undefined),
},
};
const client = { $transaction: async (runner: (value: typeof tx) => Promise<unknown>) => runner(tx) };
const result = await pruneAuditChainBatch(null, new Date("2019-01-01T00:00:00.000Z"), {
client: client as never,
secret: SECRET,
batchSize: 2,
now: new Date("2026-01-01T00:00:00.000Z"),
});
expect(queryRaw).toHaveBeenCalledTimes(1);
expect(tx.auditEvent.findMany).toHaveBeenCalledWith(expect.objectContaining({
take: 2,
select: expect.not.objectContaining({ beforeDiff: expect.anything(), afterDiff: expect.anything() }),
}));
expect(deleteMany).toHaveBeenCalledWith({ where: { id: { in: ["event-1", "event-2"] } } });
expect(result).toMatchObject({ tenantId: null, deletedCount: 2, hasMore: false });
const checkpoint = checkpointCreate.mock.calls[0]?.[0].data as AuditChainCheckpointRecord;
expect(checkpoint.chainKey).toBe("platform");
expect(checkpoint.lastDeletedEventHash).toBe(second.eventHash);
expect(verifyAuditCheckpoint(checkpoint, SECRET)).toBe(true);
});
});