import { describe, expect, it } from "vitest"; import { createReleaseMismatchRecovery, type RecoveryMarkerStore, } from "../../../src/platform/release/release-mismatch-recovery.ts"; import { createBootReleaseRecovery, decideBootFailure, releaseMismatchKey, } from "../../../src/bootstrap/boot-release-recovery.ts"; import { ReleaseManifestError } from "../../../src/bootstrap/load-release-manifest.ts"; import { BootConfigError } from "../../../src/bootstrap/load-runtime-config.ts"; import { STORAGE_REGISTRY } from "../../../src/contracts/storage-keys.ts"; /** A Web Storage stand-in for the host's `sessionStorage`. */ function sessionStorageLike() { const values = new Map(); return { values, getItem: (key: string) => values.get(key) ?? null, setItem: (key: string, value: string) => void values.set(key, value), removeItem: (key: string) => void values.delete(key), }; } function markerStore(): RecoveryMarkerStore & { values: Map } { const values = new Map(); return { values, read: () => values.get("marker") ?? null, write: (value) => void values.set("marker", value), clear: () => void values.delete("marker"), }; } describe("release mismatch recovery", () => { it("allows at most one automatic recovery attempt per release mismatch key", () => { const recovery = createReleaseMismatchRecovery(markerStore()); expect(recovery.decide("R10->R11")).toBe("reload-once"); expect(recovery.decide("R10->R11")).toBe("show-failure"); }); it("never reloads more than once however often the same mismatch repeats", () => { const recovery = createReleaseMismatchRecovery(markerStore()); const decisions = Array.from({ length: 50 }, () => recovery.decide("R10->R11")); expect(decisions.filter((decision) => decision === "reload-once")).toHaveLength(1); }); it("clears the marker after a coherent boot", () => { const storage = markerStore(); const recovery = createReleaseMismatchRecovery(storage); recovery.decide("R10->R11"); recovery.markCoherentBoot(); expect(storage.values.size).toBe(0); expect(recovery.decide("R10->R11")).toBe("reload-once"); }); it("keeps a single bounded marker", () => { const storage = markerStore(); const recovery = createReleaseMismatchRecovery(storage); expect(recovery.decide("x".repeat(10_000))).toBe("reload-once"); expect(storage.values.size).toBe(1); expect([...storage.values.values()][0]?.length).toBeLessThan(300); }); it("allows one automatic reload per session within the TTL whatever the key", () => { const recovery = createReleaseMismatchRecovery(markerStore()); expect(recovery.decide("A")).toBe("reload-once"); expect(recovery.decide("B")).toBe("show-failure"); expect(recovery.decide("A")).toBe("show-failure"); }); it("cannot loop when a load balancer alternates the mismatch key", () => { const recovery = createReleaseMismatchRecovery(markerStore()); const decisions = Array.from({ length: 20 }, (_, boot) => recovery.decide(boot % 2 === 0 ? "build-R10:X:R11" : "build-R11:X:R10"), ); expect(decisions.filter((decision) => decision === "reload-once")).toHaveLength(1); }); it("lets an expired marker recover again instead of blocking forever", () => { let now = 0; const recovery = createReleaseMismatchRecovery(markerStore(), { now: () => now, ttlMs: 1_000, }); expect(recovery.decide("k")).toBe("reload-once"); now = 500; expect(recovery.decide("k")).toBe("show-failure"); now = 5_000; expect(recovery.decide("k")).toBe("reload-once"); }); it("fails closed without working storage", () => { expect(createReleaseMismatchRecovery(null).decide("k")).toBe("show-failure"); const throwing: RecoveryMarkerStore = { read: () => { throw new Error("denied"); }, write: () => { throw new Error("denied"); }, clear: () => { throw new Error("denied"); }, }; const recovery = createReleaseMismatchRecovery(throwing); expect(recovery.decide("k")).toBe("show-failure"); expect(() => recovery.markCoherentBoot()).not.toThrow(); const dropping: RecoveryMarkerStore = { read: () => null, write: () => {}, clear: () => {}, }; expect(createReleaseMismatchRecovery(dropping).decide("k")).toBe("show-failure"); }); }); describe("boot release recovery wiring", () => { it("keys only release mismatches, never other boot failures", () => { const mismatch = new ReleaseManifestError("MANIFEST_RELEASE_MISMATCH", { buildId: "build-R10", releaseId: "release-R11", }); expect(releaseMismatchKey(mismatch)).toBe( "build-R10:MANIFEST_RELEASE_MISMATCH:release-R11", ); expect( releaseMismatchKey(new BootConfigError("CONFIG_BUILD_MISMATCH", { buildId: "build-R10" })), ).toBe("build-R10:CONFIG_BUILD_MISMATCH:-"); expect( releaseMismatchKey(new ReleaseManifestError("MANIFEST_TIMEOUT", { buildId: "b" })), ).toBeNull(); expect( releaseMismatchKey(new BootConfigError("CONFIG_FETCH_FAILED", { buildId: "b" })), ).toBeNull(); expect(releaseMismatchKey(new Error("boom"))).toBeNull(); }); it("uses the registered RELEASE_MISMATCH_RECOVERY session key", () => { const storage = sessionStorageLike(); const recovery = createBootReleaseRecovery({ sessionStorage: storage }); const mismatch = new ReleaseManifestError("MANIFEST_BUILD_MISMATCH", { buildId: "build-R10" }); expect(decideBootFailure(mismatch, recovery)).toBe("reload-once"); expect([...storage.values.keys()]).toEqual([ STORAGE_REGISTRY.RELEASE_MISMATCH_RECOVERY.physicalKey, ]); expect(decideBootFailure(mismatch, recovery)).toBe("show-failure"); expect( decideBootFailure(new ReleaseManifestError("MANIFEST_TIMEOUT", { buildId: "b" }), recovery), ).toBe("show-failure"); }); it("remembers the attempt across the reload itself (a fresh boot, same session)", () => { const storage = sessionStorageLike(); const mismatch = new ReleaseManifestError("MANIFEST_BUILD_MISMATCH", { buildId: "build-R10" }); expect(decideBootFailure(mismatch, createBootReleaseRecovery({ sessionStorage: storage }))).toBe( "reload-once", ); const afterReload = createBootReleaseRecovery({ sessionStorage: storage }); expect(decideBootFailure(mismatch, afterReload)).toBe("show-failure"); afterReload.markCoherentBoot(); expect(storage.values.size).toBe(0); }); it("degrades to show-failure when the host has no session storage", () => { const recovery = createBootReleaseRecovery({}); expect( decideBootFailure( new ReleaseManifestError("MANIFEST_BUILD_MISMATCH", { buildId: "b" }), recovery, ), ).toBe("show-failure"); }); });