import { test } from "node:test";import assert from "node:assert/strict";import { h, load } from "../../lib/harness.mjs";const { createCache } = await load();const deferred = () => { let resolve; const promise = new Promise((r) => { resolve = r; }); return { promise, resolve };};// A loader whose calls the test settles by hand, plus an injected clock.const setup = (ttlMs = 100) => { const calls = []; const loader = (key) => { const d = deferred(); calls.push({ key, d }); return d.promise; }; const clock = { t: 0 }; const created = h.res(() => createCache(loader, ttlMs, () => clock.t)); const cache = h.okOf(created); const succeed = (i, value) => calls[i].d.resolve(h.okValue(value)); const fail = (i, reason) => calls[i].d.resolve(h.resolveErr({ kind: "load_failed", reason })); const get = (key) => h.resAsync(() => cache.get(key)); return { calls, clock, cache, succeed, fail, get };};const ok = (value) => ({ ok: true, value });const failed = (reason) => ({ ok: false, error: { kind: "load_failed", reason } });const tick = () => new Promise((r) => setImmediate(r));test("ttl must be a positive integer", () => { for (const ttl of [0, -1, 1.5, Number.NaN, Number.POSITIVE_INFINITY]) { assert.deepEqual(h.res(() => createCache(async () => h.okValue(1), ttl, () => 0)), { ok: false, error: { kind: "invalid_ttl" } }, String(ttl)); } assert.equal(h.res(() => createCache(async () => h.okValue(1), 1, () => 0)).ok, true);});test("loads once and serves the cached value", async () => { const s = setup(); const first = s.get("a"); assert.equal(s.calls.length, 1); assert.equal(s.calls[0].key, "a"); s.succeed(0, "A"); assert.deepEqual(await first, ok("A")); s.clock.t = 50; assert.deepEqual(await s.get("a"), ok("A")); assert.equal(s.calls.length, 1);});test("freshness is measured from when the load finished", async () => { const s = setup(100); const first = s.get("a"); s.clock.t = 40; s.succeed(0, 1); assert.deepEqual(await first, ok(1)); s.clock.t = 139; assert.deepEqual(await s.get("a"), ok(1)); assert.equal(s.calls.length, 1); s.clock.t = 140; const again = s.get("a"); await tick(); assert.equal(s.calls.length, 2); s.succeed(1, 2); assert.deepEqual(await again, ok(2));});test("concurrent gets share one load", async () => { const s = setup(); const a = s.get("k"); const b = s.get("k"); const c = s.get("k"); await tick(); assert.equal(s.calls.length, 1); s.succeed(0, "v"); assert.deepEqual(await Promise.all([a, b, c]), [ok("v"), ok("v"), ok("v")]);});test("different keys load separately", async () => { const s = setup(); const a = s.get("a"); const b = s.get("b"); await tick(); assert.deepEqual(s.calls.map((c) => c.key), ["a", "b"]); s.succeed(1, "B"); s.succeed(0, "A"); assert.deepEqual(await a, ok("A")); assert.deepEqual(await b, ok("B"));});test("falsy values are cached like any other", async () => { const s = setup(); for (const [i, [key, value]] of [["zero", 0], ["empty", ""], ["no", false]].entries()) { const p = s.get(key); await tick(); s.succeed(i, value); assert.deepEqual(await p, ok(value)); assert.deepEqual(await s.get(key), ok(value)); } assert.equal(s.calls.length, 3);});test("a failure reaches every waiter and is not cached", async () => { const s = setup(); const a = s.get("k"); const b = s.get("k"); await tick(); s.fail(0, "timeout"); assert.deepEqual(await a, failed("timeout")); assert.deepEqual(await b, failed("timeout")); const c = s.get("k"); await tick(); assert.equal(s.calls.length, 2); s.succeed(1, "ok now"); assert.deepEqual(await c, ok("ok now")); assert.deepEqual(await s.get("k"), ok("ok now")); assert.equal(s.calls.length, 2);});test("an expired value is not served when the reload fails", async () => { const s = setup(10); const a = s.get("k"); s.succeed(0, "old"); await a; s.clock.t = 10; const b = s.get("k"); await tick(); s.fail(1, "down"); assert.deepEqual(await b, failed("down"));});test("invalidate drops the cached value", async () => { const s = setup(); const a = s.get("k"); s.succeed(0, 1); await a; s.cache.invalidate("k"); s.cache.invalidate("never-loaded"); const b = s.get("k"); await tick(); assert.equal(s.calls.length, 2); s.succeed(1, 2); assert.deepEqual(await b, ok(2));});test("invalidate during a load: callers get it, cache does not keep it", async () => { const s = setup(); const a = s.get("k"); await tick(); s.cache.invalidate("k"); s.succeed(0, "stale"); assert.deepEqual(await a, ok("stale")); const b = s.get("k"); await tick(); assert.equal(s.calls.length, 2); s.succeed(1, "fresh"); assert.deepEqual(await b, ok("fresh"));});test("a get after invalidate starts a new load; the old one cannot overwrite it", async () => { const s = setup(); const a = s.get("k"); await tick(); s.cache.invalidate("k"); const b = s.get("k"); await tick(); assert.equal(s.calls.length, 2); s.succeed(1, "new"); assert.deepEqual(await b, ok("new")); s.succeed(0, "old"); assert.deepEqual(await a, ok("old")); assert.deepEqual(await s.get("k"), ok("new")); assert.equal(s.calls.length, 2);});test("keys that exist on Object.prototype", async () => { const s = setup(); const a = s.get("constructor"); const b = s.get("__proto__"); await tick(); assert.deepEqual(s.calls.map((c) => c.key), ["constructor", "__proto__"]); s.succeed(0, "c"); s.succeed(1, "p"); assert.deepEqual(await a, ok("c")); assert.deepEqual(await b, ok("p")); assert.deepEqual(await s.get("__proto__"), ok("p")); assert.equal(s.calls.length, 2);});