Files
MikrotikManager/backend/src/services/database-restore-checkpoint-operator.test.ts
T

123 lines
7.5 KiB
TypeScript

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<RestoreCheckpoint, { status: "pending" }> = {
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 }))
})