6871: Changed to a testable class-based release loader and added tests

Author: tuj

.gitignore

@@ -66,3 +66,5 @@ phpstan.neon
 ###> vincentlanglet/twig-cs-fixer ###
 /.twig-cs-fixer.cache
 ###< vincentlanglet/twig-cs-fixer ###
+
+.claude/

assets/shared/release-loader.js

@@ -1,63 +1,83 @@
-// Only fetch new release.json if more than 5 minutes have passed.
-const configFetchInterval = 5 * 60 * 1000;
+const DEFAULT_FETCH_INTERVAL = 5 * 60 * 1000;
 
-// Fetched release data.
-let releaseData = null;
+const DEFAULT_RELEASE = {
+  releaseTime: null,
+  releaseTimestamp: null,
+  releaseVersion: null,
+};
 
-// Last time the release was fetched.
-let latestFetchTimestamp = 0;
+class ReleaseLoader {
+  #releaseData = null;
+  #latestFetchTimestamp = null;
+  #activePromise = null;
+  #fetchFn;
+  #nowFn;
+  #fetchInterval;
 
-let activePromise = null;
+  /**
+   * @param {object} options
+   * @param {Function} options.fetchFn - Fetch implementation. Defaults to global fetch.
+   * @param {Function} options.nowFn - Returns current time in ms. Defaults to Date.now.
+   * @param {number} options.fetchInterval - Cache lifetime in ms. Defaults to 5 minutes.
+   */
+  constructor({
+    fetchFn = (...args) => fetch(...args),
+    nowFn = () => Date.now(),
+    fetchInterval = DEFAULT_FETCH_INTERVAL,
+  } = {}) {
+    this.#fetchFn = fetchFn;
+    this.#nowFn = nowFn;
+    this.#fetchInterval = fetchInterval;
+  }
 
-const ReleaseLoader = {
   async loadRelease() {
-    if (activePromise !== null) {
-      return activePromise;
+    if (this.#activePromise !== null) {
+      return this.#activePromise;
     }
 
-    const nowTimestamp = new Date().getTime();
+    const nowTimestamp = this.#nowFn();
 
     // Return early without going through activePromise so the caller always
     // receives a real promise, not null.
-    if (latestFetchTimestamp + configFetchInterval >= nowTimestamp) {
-      return Promise.resolve(releaseData);
+    if (
+      this.#latestFetchTimestamp !== null &&
+      this.#latestFetchTimestamp + this.#fetchInterval >= nowTimestamp
+    ) {
+      return Promise.resolve(this.#releaseData);
     }
 
-    activePromise = fetch(`/release.json?t=${nowTimestamp}`)
+    this.#activePromise = this.#fetchFn(`/release.json?t=${nowTimestamp}`)
       .then((response) => response.json())
       .then((data) => {
-        latestFetchTimestamp = nowTimestamp;
-        releaseData = data;
-        return releaseData;
+        this.#latestFetchTimestamp = nowTimestamp;
+        this.#releaseData = data;
+        return this.#releaseData;
       })
       .catch(() => {
-        if (releaseData !== null) {
-          // Bug 3 fix: advance the timestamp so the next call uses the
-          // cache instead of immediately retrying after a failed fetch.
-          latestFetchTimestamp = nowTimestamp;
-          return releaseData;
+        if (this.#releaseData !== null) {
+          // Advance the timestamp so the next call uses the cache instead of
+          // immediately retrying after a failed fetch.
+          this.#latestFetchTimestamp = nowTimestamp;
+          return this.#releaseData;
         }
 
         /* eslint-disable-next-line no-console */
         console.warn("Could not find release.json. Returning defaults.");
 
-        // Return defaults.
-        return {
-          releaseTime: null,
-          releaseTimestamp: null,
-          releaseVersion: null,
-        };
+        return DEFAULT_RELEASE;
       })
       .finally(() => {
         // Always clear activePromise via finally so concurrent callers share a
-        // single in-flight fetch and it is cleared on both success and failure.
-        activePromise = null;
+        // single in-flight fetch. It is cleared on both success and failure.
+        this.#activePromise = null;
       });
 
-    return activePromise;
-  },
-};
+    return this.#activePromise;
+  }
+}
 
-Object.freeze(ReleaseLoader);
+// Default singleton for production use.
+const releaseLoader = new ReleaseLoader();
+export default releaseLoader;
 
-export default ReleaseLoader;
+export { ReleaseLoader };

assets/tests/shared/release-loader.spec.js

@@ -0,0 +1,125 @@
+import { test, expect } from "@playwright/test";
+import { ReleaseLoader } from "../../shared/release-loader.js";
+
+const RELEASE_DATA = {
+  releaseTime: "2024-01-01T00:00:00Z",
+  releaseTimestamp: 1704067200,
+  releaseVersion: "1.0.0",
+};
+
+function createMockFetch(response = RELEASE_DATA) {
+  return () =>
+    Promise.resolve({
+      json: () => Promise.resolve(response),
+    });
+}
+
+function createFailingFetch() {
+  return () => Promise.reject(new Error("Network error"));
+}
+
+test.describe("ReleaseLoader", () => {
+  test("It fetches and returns release data", async () => {
+    const loader = new ReleaseLoader({ fetchFn: createMockFetch() });
+    const result = await loader.loadRelease();
+
+    expect(result).toEqual(RELEASE_DATA);
+  });
+
+  test("It returns cached data within the fetch interval", async () => {
+    let fetchCount = 0;
+    const fetchFn = () => {
+      fetchCount += 1;
+      return createMockFetch()();
+    };
+
+    const loader = new ReleaseLoader({ fetchFn, nowFn: () => 1000 });
+
+    await loader.loadRelease();
+    await loader.loadRelease();
+
+    expect(fetchCount).toBe(1);
+  });
+
+  test("It fetches again after the interval has passed", async () => {
+    let fetchCount = 0;
+    const fetchFn = () => {
+      fetchCount += 1;
+      return createMockFetch()();
+    };
+
+    let now = 0;
+    const loader = new ReleaseLoader({
+      fetchFn,
+      nowFn: () => now,
+      fetchInterval: 1000,
+    });
+
+    await loader.loadRelease();
+    now = 1001;
+    await loader.loadRelease();
+
+    expect(fetchCount).toBe(2);
+  });
+
+  test("It returns defaults when fetch fails and no cached data exists", async () => {
+    const loader = new ReleaseLoader({ fetchFn: createFailingFetch() });
+    const result = await loader.loadRelease();
+
+    expect(result).toEqual({
+      releaseTime: null,
+      releaseTimestamp: null,
+      releaseVersion: null,
+    });
+  });
+
+  test("It returns cached data when fetch fails after a successful fetch", async () => {
+    let shouldFail = false;
+    const fetchFn = () => {
+      if (shouldFail) {
+        return createFailingFetch()();
+      }
+      return createMockFetch()();
+    };
+
+    let now = 0;
+    const loader = new ReleaseLoader({
+      fetchFn,
+      nowFn: () => now,
+      fetchInterval: 1000,
+    });
+
+    await loader.loadRelease();
+
+    shouldFail = true;
+    now = 1001;
+    const result = await loader.loadRelease();
+
+    expect(result).toEqual(RELEASE_DATA);
+  });
+
+  test("It deduplicates concurrent calls", async () => {
+    let fetchCount = 0;
+    let resolveResponse;
+
+    const fetchFn = () => {
+      fetchCount += 1;
+      return new Promise((resolve) => {
+        resolveResponse = resolve;
+      });
+    };
+
+    const loader = new ReleaseLoader({ fetchFn });
+
+    const promise1 = loader.loadRelease();
+    const promise2 = loader.loadRelease();
+
+    resolveResponse({ json: () => Promise.resolve(RELEASE_DATA) });
+
+    const [result1, result2] = await Promise.all([promise1, promise2]);
+
+    expect(fetchCount).toBe(1);
+    expect(result1).toEqual(RELEASE_DATA);
+    expect(result2).toEqual(RELEASE_DATA);
+  });
+});