Files
clean-architecture-frontend…/tests/platform/release/release-mismatch-recovery.test.ts
T

167 lines
6.2 KiB
TypeScript

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<string, string>();
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<string, string> } {
const values = new Map<string, string>();
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 and scopes it to the mismatch key", () => {
const storage = markerStore();
const recovery = createReleaseMismatchRecovery(storage);
expect(recovery.decide("R10->R11")).toBe("reload-once");
expect(recovery.decide("R11->R12")).toBe("reload-once");
expect(storage.values.size).toBe(1);
expect(recovery.decide("x".repeat(10_000))).toBe("reload-once");
expect([...storage.values.values()][0]?.length).toBeLessThan(300);
});
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");
});
});