import assert from "node:assert/strict" import { createHash } from "node:crypto" import { lstat, mkdtemp, readFile, readdir, realpath, rm, writeFile } from "node:fs/promises" import os from "node:os" import path from "node:path" import test from "node:test" import { consumeRestoreCheckpointFile, publishSealedRestoreCheckpointFile, stagePendingRestoreCheckpointFile, } from "./database-restore-checkpoint-operator.js" import { parseDatabaseRestoreCheckpoint, restoreWriterHeadIsCurrent, type RestoreCheckpoint } from "./database-restore-checkpoint.js" const checkpoint: Extract = { format: "database-restore-checkpoint-v1", status: "pending", head: null, runtimeTargetSha256: "a".repeat(64), activationSha256: null, operationId: "00000000-0000-0000-0000-000000000001", archiveSha256: "b".repeat(64), dataSha256: "c".repeat(64), } const claim = "d".repeat(64) const refused = { code: "DATABASE_RESTORE_CHECKPOINT_REFUSED" } test("checkpoint staging requires the exact sealed file and can succeed only once", async (t) => { const directory = await mkdtemp(path.join(await realpath(os.tmpdir()), "restore-checkpoint-")) t.after(() => rm(directory, { recursive: true })) const file = path.join(directory, "checkpoint.json") const { operationId, archiveSha256, dataSha256, ...baseline } = checkpoint const sealed = { ...baseline, status: "sealed" as const, head: { bytes: 50, sha256: claim } } const permit = { operationId, archiveSha256, dataSha256 } const bytes = JSON.stringify(sealed) const sha256 = createHash("sha256").update(bytes).digest("hex") await writeFile(file, bytes + "\n") await assert.rejects(stagePendingRestoreCheckpointFile(file, sealed, permit, sha256), refused) assert.equal(await readFile(file, "utf8"), bytes + "\n") await writeFile(file, bytes) await assert.rejects(stagePendingRestoreCheckpointFile(file, { ...sealed, head: null }, permit, sha256), refused) await assert.rejects(stagePendingRestoreCheckpointFile(file, sealed, { ...permit, dataSha256: "invalid" }, sha256), refused) const permits = [permit, { ...permit, operationId: "00000000-0000-0000-0000-000000000002" }] const outcomes = await Promise.allSettled(permits.map((one) => stagePendingRestoreCheckpointFile(file, sealed, one, sha256))) assert.equal(outcomes.filter((outcome) => outcome.status === "fulfilled").length, 1) const winner = permits[outcomes.findIndex((outcome) => outcome.status === "fulfilled")] await assert.rejects(stagePendingRestoreCheckpointFile(file, sealed, permit, sha256), refused) assert.deepEqual(parseDatabaseRestoreCheckpoint(await readFile(file)), { ...sealed, status: "pending", ...winner }) assert.deepEqual(await readdir(directory), ["checkpoint.json"]) }) test("checkpoint consumption refuses evidence conflicts and can succeed only once", async (t) => { const directory = await mkdtemp(path.join(await realpath(os.tmpdir()), "restore-checkpoint-")) t.after(() => rm(directory, { recursive: true })) const file = path.join(directory, "checkpoint.json") const original = JSON.stringify(checkpoint) await writeFile(file, original, { mode: 0o640 }) const before = await lstat(file) await assert.rejects(consumeRestoreCheckpointFile(file, { ...checkpoint, archiveSha256: "e".repeat(64) }, claim), refused) for (const suffix of [".lock", ".pending"]) { const residue = `${file}${suffix}` await writeFile(residue, "prior attempt", { flag: "wx" }) await assert.rejects(consumeRestoreCheckpointFile(file, checkpoint, claim), refused) assert.equal(await readFile(residue, "utf8"), "prior attempt") assert.equal(await readFile(file, "utf8"), original) await rm(residue) } const outcomes = await Promise.allSettled([claim, "f".repeat(64)].map((id) => consumeRestoreCheckpointFile(file, checkpoint, id))) assert.equal(outcomes.filter((outcome) => outcome.status === "fulfilled").length, 1) const winner = outcomes[0].status === "fulfilled" ? claim : "f".repeat(64) const consumed = { ...checkpoint, status: "consumed", claimId: winner } assert.deepEqual(parseDatabaseRestoreCheckpoint(await readFile(file)), consumed) if (process.platform !== "win32") { const after = await lstat(file) assert.equal(after.mode & 0o777, before.mode & 0o777) assert.equal(after.uid, before.uid) assert.equal(after.gid, before.gid) } await assert.rejects(consumeRestoreCheckpointFile(file, checkpoint, winner), refused) assert.deepEqual(parseDatabaseRestoreCheckpoint(await readFile(file)), consumed) assert.deepEqual(await readdir(directory), ["checkpoint.json"]) }) test("checkpoint sealing requires the exact consumed snapshot and one advancing journal head", async (t) => { const directory = await mkdtemp(path.join(await realpath(os.tmpdir()), "restore-checkpoint-")) t.after(() => rm(directory, { recursive: true })) const file = path.join(directory, "checkpoint.json") const consumed = { ...checkpoint, status: "consumed" as const, claimId: claim, activationSha256: "e".repeat(64), head: { bytes: 50, sha256: "f".repeat(64) }, } const appliedHeads = [{ bytes: 100, sha256: "1".repeat(64) }, { bytes: 110, sha256: "2".repeat(64) }] await writeFile(file, JSON.stringify(consumed)) await assert.rejects(publishSealedRestoreCheckpointFile(file, consumed, consumed.head), refused) await assert.rejects(publishSealedRestoreCheckpointFile(file, { ...consumed, claimId: "a".repeat(64) }, appliedHeads[0]), refused) assert.deepEqual(parseDatabaseRestoreCheckpoint(await readFile(file)), consumed) const outcomes = await Promise.allSettled(appliedHeads.map((head) => publishSealedRestoreCheckpointFile(file, consumed, head))) assert.equal(outcomes.filter((outcome) => outcome.status === "fulfilled").length, 1) const sealed = { format: consumed.format, status: "sealed", runtimeTargetSha256: consumed.runtimeTargetSha256, activationSha256: consumed.activationSha256, head: appliedHeads[outcomes.findIndex((outcome) => outcome.status === "fulfilled")], } await assert.rejects(publishSealedRestoreCheckpointFile(file, consumed, appliedHeads[0]), refused) assert.deepEqual(parseDatabaseRestoreCheckpoint(await readFile(file)), sealed) assert.deepEqual(await readdir(directory), ["checkpoint.json"]) }) test("protected checkpoint requires a newer writer epoch and rejects rollback after sealing", async (t) => { const directory = await mkdtemp(path.join(await realpath(os.tmpdir()), "restore-checkpoint-")) t.after(() => rm(directory, { recursive: true })) const file = path.join(directory, "checkpoint.json") const before = { epoch: "7", sha256: "1".repeat(64) } const after = { epoch: "8", sha256: "2".repeat(64) } const consumed = { ...checkpoint, status: "consumed" as const, claimId: claim, writerHead: before } const applied = { bytes: 100, sha256: "3".repeat(64) } await writeFile(file, JSON.stringify(consumed)) await assert.rejects(publishSealedRestoreCheckpointFile(file, consumed, applied), refused) await assert.rejects(publishSealedRestoreCheckpointFile(file, consumed, applied, before), refused) assert.deepEqual(parseDatabaseRestoreCheckpoint(await readFile(file)), consumed) await publishSealedRestoreCheckpointFile(file, consumed, applied, after) const sealed = parseDatabaseRestoreCheckpoint(await readFile(file)) assert.deepEqual(sealed.writerHead, after) assert.ok(restoreWriterHeadIsCurrent(sealed.writerHead, after)) assert.ok(!restoreWriterHeadIsCurrent(sealed.writerHead, before)) assert.ok(!restoreWriterHeadIsCurrent(sealed.writerHead, { ...after, sha256: before.sha256 })) })