Rebasely Beta: data may be purged

justintypescript-ultra-strict Public

JavaScript · 191 lines · 5.6 KiB · at 8b87e58

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);});