@raketa-cloud/admin 1.8.17 → 1.8.19

package/src/tests/localCache.test.js

@@ -0,0 +1,236 @@
+import localCache from "../localCache";
+
+// The module keeps one LRU on globalThis; going through the public API keeps
+// the tests honest about that shared instance.
+const keys = () => {
+  const collected = [];
+  localCache.forEach((_value, key) => collected.push(key));
+  return collected;
+};
+
+describe("localCache", () => {
+  beforeEach(() => {
+    localCache.clear();
+    jest.spyOn(console, "error").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+    jest.useRealTimers();
+    localCache.clear();
+  });
+
+  test("calls the fetcher on a miss and returns its value", async () => {
+    const fetcher = jest.fn(async () => ({ id: "1" }));
+
+    expect(await localCache.fetch("resource:1", fetcher)).toEqual({ id: "1" });
+    expect(fetcher).toHaveBeenCalledTimes(1);
+  });
+
+  test("serves the second read from the cache", async () => {
+    const fetcher = jest.fn(async () => ({ id: "1" }));
+
+    await localCache.fetch("resource:1", fetcher);
+    const cached = await localCache.fetch("resource:1", fetcher);
+
+    expect(cached).toEqual({ id: "1" });
+    expect(fetcher).toHaveBeenCalledTimes(1);
+  });
+
+  test("caches a missing resource so the miss is not re-fetched", async () => {
+    const fetcher = jest.fn(async () => null);
+
+    expect(await localCache.fetch("resource:missing", fetcher)).toBeNull();
+    expect(await localCache.fetch("resource:missing", fetcher)).toBeNull();
+    expect(fetcher).toHaveBeenCalledTimes(1);
+  });
+
+  // Only undefined means "nothing here" — 0, false and "" are answers.
+  test.each([
+    ["a zero", 0],
+    ["false", false],
+    ["an empty string", ""],
+    ["an empty object", {}],
+  ])("round-trips %s through the cache", async (_label, value) => {
+    const fetcher = jest.fn(async () => value);
+
+    expect(await localCache.fetch("resource:falsy", fetcher)).toEqual(value);
+    expect(await localCache.fetch("resource:falsy", fetcher)).toEqual(value);
+    expect(fetcher).toHaveBeenCalledTimes(1);
+  });
+
+  // JSON.stringify(undefined) is undefined and sizeCalculation would throw on
+  // it, taking the whole request with it.
+  test("caches an undefined result as a miss", async () => {
+    const fetcher = jest.fn(async () => undefined);
+
+    expect(await localCache.fetch("resource:undefined", fetcher)).toBeNull();
+    expect(await localCache.fetch("resource:undefined", fetcher)).toBeNull();
+    expect(fetcher).toHaveBeenCalledTimes(1);
+  });
+
+  test("logs and returns null when the fetcher throws on a miss", async () => {
+    const error = new Error("cloud down");
+    const fetcher = jest.fn(async () => {
+      throw error;
+    });
+
+    expect(await localCache.fetch("resource:1", fetcher)).toBeNull();
+    expect(console.error).toHaveBeenCalledWith(error);
+    // Nothing was stored, so the next caller retries straight away.
+    expect(keys()).toEqual([]);
+  });
+
+  test("honours a per-entry ttl", async () => {
+    await localCache.fetch("resource:1", async () => ({ id: "1" }), {
+      ttl: 50_000,
+    });
+
+    expect(localCache.getRemainingTTL("resource:1")).toBeGreaterThan(40_000);
+  });
+
+  test("clear empties the cache", async () => {
+    await localCache.fetch("resource:1", async () => ({ id: "1" }));
+
+    localCache.clear();
+
+    expect(keys()).toEqual([]);
+  });
+
+  test("reuses the single cache instance across module loads", async () => {
+    await localCache.fetch("resource:1", async () => ({ id: "1" }));
+
+    let reloaded;
+    jest.isolateModules(() => {
+      reloaded = require("../localCache").default;
+    });
+
+    const seen = [];
+    reloaded.forEach((_value, key) => seen.push(key));
+
+    expect(seen).toEqual(["resource:1"]);
+  });
+
+  test("forEach walks the cached entries", async () => {
+    await localCache.fetch("resource:1", async () => ({ id: "1" }));
+    await localCache.fetch("resource:2", async () => ({ id: "2" }));
+
+    expect(keys().sort()).toEqual(["resource:1", "resource:2"]);
+  });
+
+  describe("stale entries", () => {
+    // lru-cache captures its own clock at import time, so fake timers do not
+    // reach it — expire for real with a throwaway ttl instead. The cache keeps
+    // stale entries around (allowStale + noDeleteOnStaleGet), so the next read
+    // is a "stale" hit rather than a miss.
+    const TTL = 20;
+    const expire = () => new Promise((resolve) => setTimeout(resolve, TTL * 2));
+
+    test("refreshes a stale entry", async () => {
+      const fetcher = jest
+        .fn()
+        .mockResolvedValueOnce({ id: "1", v: 1 })
+        .mockResolvedValueOnce({ id: "1", v: 2 });
+
+      await localCache.fetch("resource:1", fetcher, { ttl: TTL });
+      await expire();
+
+      expect(
+        await localCache.fetch("resource:1", fetcher, { ttl: TTL }),
+      ).toEqual({ id: "1", v: 2 });
+      expect(fetcher).toHaveBeenCalledTimes(2);
+    });
+
+    test("serves the stale value once more when the refresh fails", async () => {
+      const error = new Error("cloud down");
+      const fetcher = jest
+        .fn()
+        .mockResolvedValueOnce({ id: "1", v: 1 })
+        .mockRejectedValueOnce(error);
+
+      await localCache.fetch("resource:1", fetcher, { ttl: TTL });
+      await expire();
+
+      expect(
+        await localCache.fetch("resource:1", fetcher, { ttl: TTL }),
+      ).toEqual({ id: "1", v: 1 });
+      expect(console.error).toHaveBeenCalledWith(error);
+    });
+
+    test("resets the ttl after a failed refresh so the stale value survives", async () => {
+      const fetcher = jest
+        .fn()
+        .mockResolvedValueOnce({ id: "1", v: 1 })
+        .mockRejectedValueOnce(new Error("cloud down"));
+
+      await localCache.fetch("resource:1", fetcher, { ttl: TTL });
+      await expire();
+      await localCache.fetch("resource:1", fetcher, { ttl: 60_000 });
+
+      expect(localCache.getRemainingTTL("resource:1")).toBeGreaterThan(50_000);
+    });
+
+    test("keeps returning null for a stale missing resource", async () => {
+      const fetcher = jest.fn(async () => {
+        throw new Error("cloud down");
+      });
+
+      await localCache.fetch("resource:missing", async () => null, {
+        ttl: TTL,
+      });
+      await expire();
+
+      expect(
+        await localCache.fetch("resource:missing", fetcher, { ttl: TTL }),
+      ).toBeNull();
+    });
+
+    // The sentinel is what "nothing here" looks like in the cache; a failed
+    // refresh resets the ttl and must put back what it found, not the null the
+    // reader was handed.
+    test("keeps a stale undefined entry as undefined after a failed refresh", async () => {
+      const stored = () => {
+        let found;
+        localCache.forEach((value) => {
+          found = value;
+        });
+        return found;
+      };
+
+      await localCache.fetch("resource:undefined", async () => undefined, {
+        ttl: TTL,
+      });
+      const sentinel = stored();
+      await expire();
+
+      await localCache.fetch(
+        "resource:undefined",
+        async () => {
+          throw new Error("cloud down");
+        },
+        { ttl: TTL },
+      );
+
+      expect(stored()).toBe(sentinel);
+      expect(typeof sentinel).toBe("symbol");
+    });
+
+    test("stores a fresh miss found while refreshing a stale entry", async () => {
+      const fetcher = jest
+        .fn()
+        .mockResolvedValueOnce({ id: "1" })
+        .mockResolvedValueOnce(null);
+
+      await localCache.fetch("resource:1", fetcher, { ttl: TTL });
+      await expire();
+
+      expect(
+        await localCache.fetch("resource:1", fetcher, { ttl: 60_000 }),
+      ).toBeNull();
+      expect(
+        await localCache.fetch("resource:1", fetcher, { ttl: 60_000 }),
+      ).toBeNull();
+      expect(fetcher).toHaveBeenCalledTimes(2);
+    });
+  });
+});

package/src/tests/report/analytics.test.js

@@ -0,0 +1,230 @@
+import { createDom, el, installDom, uninstallDom } from "../support/fakeDom";
+
+// The script is an IIFE that wires itself to the globals on import, so every
+// test re-requires it with a fresh DOM.
+function loadScript() {
+  jest.isolateModules(() => {
+    require("../../report/analytics");
+  });
+}
+
+function buildChartStub() {
+  const instances = [];
+
+  class Chart {
+    constructor(ctx, config) {
+      this.ctx = ctx;
+      this.config = config;
+      this.destroy = jest.fn();
+      instances.push(this);
+    }
+  }
+
+  return { Chart, instances };
+}
+
+function canvas() {
+  const context = { createLinearGradient: jest.fn() };
+  const element = el("canvas", { id: "ga-traffic-chart" });
+  element.getContext = jest.fn(() => context);
+  return { element, context };
+}
+
+const CONFIG = {
+  series: {
+    dates: ["2026-07-04", "2026-07-05", "2026-07-06"],
+    labels: ["July 4", "July 5", "July 6"],
+    data: [10, 20, 30],
+  },
+  publishDates: ["2026-07-05"],
+};
+
+describe("report/analytics.js", () => {
+  let chartStub;
+
+  beforeEach(() => {
+    chartStub = buildChartStub();
+    globalThis.Chart = chartStub.Chart;
+  });
+
+  afterEach(() => {
+    uninstallDom();
+    delete globalThis.Chart;
+    jest.restoreAllMocks();
+  });
+
+  test("draws the inlined Insights data on load", () => {
+    const target = canvas();
+    const dom = createDom([target.element]);
+    dom.window.GA_ANALYTICS = CONFIG;
+    installDom(dom);
+
+    loadScript();
+
+    expect(chartStub.instances).toHaveLength(1);
+
+    const { config } = chartStub.instances[0];
+    expect(target.element.getContext).toHaveBeenCalledWith("2d");
+    expect(config.type).toEqual("line");
+    expect(config.data.labels).toEqual(CONFIG.series.labels);
+    expect(config.data.datasets[0].data).toEqual(CONFIG.series.data);
+  });
+
+  test("waits for DOMContentLoaded while the document is still loading", () => {
+    const dom = createDom([canvas().element], { readyState: "loading" });
+    dom.window.GA_ANALYTICS = CONFIG;
+    installDom(dom);
+
+    loadScript();
+
+    expect(chartStub.instances).toHaveLength(0);
+
+    dom.document.dispatchEvent("DOMContentLoaded");
+
+    expect(chartStub.instances).toHaveLength(1);
+  });
+
+  test("draws nothing when no data is inlined", () => {
+    installDom(createDom([canvas().element]));
+
+    loadScript();
+
+    expect(chartStub.instances).toHaveLength(0);
+  });
+
+  test("exposes gaRenderTrafficChart for reports.js", () => {
+    const dom = createDom([canvas().element]);
+    installDom(dom);
+
+    loadScript();
+
+    expect(typeof dom.window.gaRenderTrafficChart).toEqual("function");
+
+    dom.window.gaRenderTrafficChart(CONFIG);
+
+    expect(chartStub.instances).toHaveLength(1);
+  });
+
+  test("replaces the previous chart instead of stacking a second one", () => {
+    const dom = createDom([canvas().element]);
+    dom.window.GA_ANALYTICS = CONFIG;
+    installDom(dom);
+
+    loadScript();
+    dom.window.gaRenderTrafficChart(CONFIG);
+
+    expect(chartStub.instances).toHaveLength(2);
+    expect(chartStub.instances[0].destroy).toHaveBeenCalled();
+  });
+
+  // Chart.js refuses a canvas it still has a chart registered against, and the
+  // local handle goes stale the moment the canvas is replaced.
+  test("destroys whatever chart owns the canvas, not just its own handle", () => {
+    const target = canvas();
+    const dom = createDom([target.element]);
+    dom.window.GA_ANALYTICS = CONFIG;
+    installDom(dom);
+
+    const orphan = { destroy: jest.fn() };
+    chartStub.Chart.getChart = jest.fn(() => orphan);
+
+    loadScript();
+    dom.window.gaRenderTrafficChart(CONFIG);
+
+    expect(chartStub.Chart.getChart).toHaveBeenCalledWith(target.element);
+    expect(orphan.destroy).toHaveBeenCalled();
+  });
+
+  test("does nothing without a canvas", () => {
+    const dom = createDom([]);
+    dom.window.GA_ANALYTICS = CONFIG;
+    installDom(dom);
+
+    loadScript();
+
+    expect(chartStub.instances).toHaveLength(0);
+  });
+
+  test("does nothing when Chart.js has not loaded", () => {
+    delete globalThis.Chart;
+    const dom = createDom([canvas().element]);
+    dom.window.GA_ANALYTICS = CONFIG;
+    installDom(dom);
+
+    expect(() => loadScript()).not.toThrow();
+  });
+
+  test("falls back to empty series when the config is missing pieces", () => {
+    const dom = createDom([canvas().element]);
+    installDom(dom);
+
+    loadScript();
+    dom.window.gaRenderTrafficChart();
+
+    const { config } = chartStub.instances[0];
+    expect(config.data.labels).toEqual([]);
+    expect(config.data.datasets[0].data).toEqual([]);
+  });
+
+  describe("dataset callbacks", () => {
+    let dataset;
+    let options;
+    let context;
+
+    beforeEach(() => {
+      const target = canvas();
+      const dom = createDom([target.element]);
+      dom.window.GA_ANALYTICS = CONFIG;
+      installDom(dom);
+      loadScript();
+
+      context = target.context;
+      dataset = chartStub.instances[0].config.data.datasets[0];
+      options = chartStub.instances[0].config.options;
+    });
+
+    test("builds a vertical gradient from the chart area", () => {
+      const gradient = { addColorStop: jest.fn() };
+      context.createLinearGradient.mockReturnValue(gradient);
+
+      const result = dataset.backgroundColor({
+        chart: { ctx: context, chartArea: { top: 0, bottom: 200 } },
+      });
+
+      expect(context.createLinearGradient).toHaveBeenCalledWith(0, 200, 0, 0);
+      expect(gradient.addColorStop).toHaveBeenCalledTimes(2);
+      expect(result).toBe(gradient);
+    });
+
+    test("skips the gradient before the chart area is measured", () => {
+      const result = dataset.backgroundColor({
+        chart: { ctx: context, chartArea: null },
+      });
+
+      expect(result).toBeNull();
+      expect(context.createLinearGradient).not.toHaveBeenCalled();
+    });
+
+    test("highlights points that land on a publish date", () => {
+      expect(dataset.pointRadius({ dataIndex: 1 })).toEqual(6);
+      expect(dataset.pointHoverRadius({ dataIndex: 1 })).toEqual(10);
+      expect(dataset.pointBackgroundColor({ dataIndex: 1 })).toEqual("#facc15");
+      expect(dataset.pointBorderColor({ dataIndex: 1 })).toEqual("#eab308");
+    });
+
+    test("leaves ordinary points unhighlighted", () => {
+      expect(dataset.pointRadius({ dataIndex: 0 })).toEqual(4);
+      expect(dataset.pointHoverRadius({ dataIndex: 0 })).toEqual(8);
+      expect(dataset.pointBackgroundColor({ dataIndex: 0 })).toEqual("#fff");
+      expect(dataset.pointBorderColor({ dataIndex: 0 })).toEqual("#6366f1");
+    });
+
+    test("annotates tooltips with the publish state", () => {
+      const { label, afterLabel } = options.plugins.tooltip.callbacks;
+
+      expect(label({ raw: 42 })).toEqual(" Views: 42");
+      expect(afterLabel({ dataIndex: 1 })).toEqual("Revision published");
+      expect(afterLabel({ dataIndex: 0 })).toEqual("");
+    });
+  });
+});