Spaces:
Paused
Paused
File size: 5,210 Bytes
8ae8438 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 | import { test } from "node:test";
import assert from "node:assert/strict";
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { computeProbeResult, readPreviousMarker, writeCurrentMarker, runProbe } from "../tools/dataProbe.js";
// computeProbeResult is the pure core (docs/adr/0012-crash-tolerant-matches.md, TASKS.md T-008a):
// given whatever marker THIS boot found on disk (or null), does that prove storage survived a
// restart? It answers that from data alone, so it's tested without touching a filesystem — the
// same idiom test/serve.test.js uses for resolveSafePath.
test("computeProbeResult reports no persistence on a genuinely first boot (no previous marker)", () => {
const r = computeProbeResult(null, "boot-b", "2026-08-31T00:00:00.000Z");
assert.equal(r.persisted, false);
assert.equal(r.previousMarker, null);
assert.deepEqual(r.currentMarker, { bootId: "boot-b", writtenAt: "2026-08-31T00:00:00.000Z" });
});
test("computeProbeResult reports persistence when a DIFFERENT boot's marker survived", () => {
const previous = { bootId: "boot-a", writtenAt: "2026-08-30T23:00:00.000Z" };
const r = computeProbeResult(previous, "boot-b", "2026-08-31T00:00:00.000Z");
assert.equal(r.persisted, true, "a marker from an earlier boot proves the disk survived the restart");
assert.deepEqual(r.previousMarker, previous);
});
test("computeProbeResult does not mistake THIS boot's own marker for a survived restart", () => {
// A caller re-reading the marker this SAME process just wrote (identical bootId) must not
// register as persistence — that is the same process, not a marker that survived anything.
const same = { bootId: "boot-b", writtenAt: "2026-08-31T00:00:00.000Z" };
const r = computeProbeResult(same, "boot-b", "2026-08-31T00:05:00.000Z");
assert.equal(r.persisted, false);
});
test("computeProbeResult treats a malformed previous marker as no marker at all", () => {
assert.equal(computeProbeResult({ garbage: true }, "boot-b", "now").persisted, false);
assert.equal(computeProbeResult({ bootId: 42 }, "boot-b", "now").persisted, false, "bootId must be a string");
assert.equal(computeProbeResult(undefined, "boot-b", "now").persisted, false);
});
// readPreviousMarker / writeCurrentMarker / runProbe touch a REAL filesystem — a temp directory
// standing in for DATA_DIR — so these are the integration layer around the pure core above.
test("readPreviousMarker returns null when nothing has been written yet", () => {
const dir = mkdtempSync(join(tmpdir(), "spacecities-probe-"));
try {
assert.equal(readPreviousMarker(dir), null);
} finally {
rmSync(dir, { recursive: true, force: true });
}
});
test("readPreviousMarker returns null for a corrupt marker file rather than throwing", () => {
const dir = mkdtempSync(join(tmpdir(), "spacecities-probe-"));
try {
writeCurrentMarker(dir, "not valid json {{{"); // simulate a truncated/corrupt write
assert.equal(readPreviousMarker(dir), null);
} finally {
rmSync(dir, { recursive: true, force: true });
}
});
test("writeCurrentMarker then readPreviousMarker round-trips the marker", () => {
const dir = mkdtempSync(join(tmpdir(), "spacecities-probe-"));
try {
const marker = { bootId: "boot-x", writtenAt: "2026-08-31T00:00:00.000Z" };
writeCurrentMarker(dir, marker);
assert.deepEqual(readPreviousMarker(dir), marker);
} finally {
rmSync(dir, { recursive: true, force: true });
}
});
test("runProbe: first call in a fresh directory reports not-persisted and leaves a marker behind", () => {
const dir = mkdtempSync(join(tmpdir(), "spacecities-probe-"));
try {
const r = runProbe(dir, "boot-1", "2026-08-31T00:00:00.000Z");
assert.equal(r.persisted, false);
assert.equal(r.writable, true);
assert.deepEqual(readPreviousMarker(dir), { bootId: "boot-1", writtenAt: "2026-08-31T00:00:00.000Z" });
} finally {
rmSync(dir, { recursive: true, force: true });
}
});
test("runProbe: a second call with a different bootId against the SAME directory reports persisted", () => {
// This is the actual test T-008a runs against the live Space: boot once, redeploy (a fresh
// process, fresh bootId), boot again against the same DATA_DIR, and ask whether the first
// boot's marker was still there to find.
const dir = mkdtempSync(join(tmpdir(), "spacecities-probe-"));
try {
runProbe(dir, "boot-1", "2026-08-31T00:00:00.000Z");
const r2 = runProbe(dir, "boot-2", "2026-08-31T00:10:00.000Z");
assert.equal(r2.persisted, true);
assert.equal(r2.previousMarker.bootId, "boot-1");
} finally {
rmSync(dir, { recursive: true, force: true });
}
});
test("runProbe reports writable:false rather than throwing when the directory doesn't exist", () => {
const missing = join(tmpdir(), "spacecities-probe-does-not-exist-" + Date.now());
const r = runProbe(missing, "boot-1", "2026-08-31T00:00:00.000Z");
assert.equal(r.writable, false);
assert.equal(typeof r.writeError, "string");
// Reading is still attempted and still degrades to "no marker found", not a throw.
assert.equal(r.persisted, false);
});
|