test(domformat): replace threadpool-racing turn spins with real signal waits

Author: apresmoi

packages/domformat/test/alternate-viewer.test.js

@@ -139,6 +139,30 @@ async function waitForScheduledWork(fake, predicate, message) {
   while (!predicate()) await whenSchedulerRearms(fake, message);
 }
 
+// A page load only becomes observable once a shell actually calls its loader, and a shell reaches
+// that call behind a libuv-threadpool SHA-256 digest of the page it verified first. Load-count
+// assertions therefore wait on the loader itself; a fixed spin of event-loop turns settles in
+// microseconds and would race that wall-clock work.
+function createLoadSignal() {
+  let notify = null;
+  return {
+    record() {
+      const resume = notify;
+      notify = null;
+      resume?.();
+    },
+    async until(predicate, message) {
+      while (!predicate()) {
+        await new Promise((resolve, reject) => {
+          const guard = setTimeout(() => { notify = null; reject(new Error(message)); }, 30_000);
+          guard.unref?.();
+          notify = () => { clearTimeout(guard); resolve(); };
+        });
+      }
+    },
+  };
+}
+
 async function mountedPair(input, options = {}) {
   const built = buildDom(input);
   const externalResources = builtExternalResources(built);
@@ -150,13 +174,16 @@ async function mountedPair(input, options = {}) {
   const alternatePhases = [];
   const referencePageLoads = [];
   const alternatePageLoads = [];
+  const loads = createLoadSignal();
   const eagerResources = new Map(externalResources);
   for (const record of built.document.resources.resources) if (record.kind === "state-page") eagerResources.delete(record.id);
   const result = await readDomBrowser(built.bytes, {
     externalResources: eagerResources,
     loadExternalResource(record, signal) {
       referencePageLoads.push([record.id, signal, referenceHost.childNodes.length]);
-      return options.loadStatePage?.("reference", record, signal, externalResources) ?? externalResources.get(record.id);
+      const loaded = options.loadStatePage?.("reference", record, signal, externalResources) ?? externalResources.get(record.id);
+      loads.record();
+      return loaded;
     },
   });
   const referenceRuntime = await mountDom(result, referenceHost, {
@@ -169,7 +196,9 @@ async function mountedPair(input, options = {}) {
     mode: options.mode,
     loadStatePage(record, signal) {
       alternatePageLoads.push([record.id, signal, alternateHost.childNodes.length]);
-      return options.loadStatePage?.("alternate", record, signal, externalResources) ?? externalResources.get(record.id);
+      const loaded = options.loadStatePage?.("alternate", record, signal, externalResources) ?? externalResources.get(record.id);
+      loads.record();
+      return loaded;
     },
     onLifecyclePhase: (phase) => alternatePhases.push(phase),
   });
@@ -185,6 +214,7 @@ async function mountedPair(input, options = {}) {
     alternatePageLoads,
     referenceRuntime,
     alternateRuntime,
+    whenLoaded: loads.until,
   };
 }
 
@@ -309,7 +339,7 @@ test("alternate and public viewers agree on deferred paged variants, readiness,
   assertEquivalent(value, "paged initial readiness");
   const initialSourceFrame = value.referenceRuntime.sourceFrame;
   assert.equal(value.alternateRuntime.sourceFrame, initialSourceFrame);
-  await flushAsyncWork();
+  await value.whenLoaded(() => value.alternatePageLoads.length >= 2, "The alternate viewer never started its lookahead page load.");
   assert.deepEqual(value.alternatePageLoads.map(([id]) => id), ["variant-page-1", "variant-page-2"]);
 
   clearWrites(value.reference, value.alternate);
@@ -413,10 +443,11 @@ test("alternate and public interaction schedulers wait at paged animator boundar
   assert.doesNotThrow(() => value.alternate.frame(267));
   assert.equal(value.referenceRuntime.lifecycle.phase, "publish");
   assert.equal(value.alternateRuntime.lifecycle.phase, "publish");
-  await flushAsyncWork();
+  const leafIndex = value.result.document.tree.nodes.findIndex((node) => node.id === "synthetic/leaf");
+  await waitForScheduledWork(value.reference, () => value.reference.namespaced[leafIndex].classes.includes("material-b"), "The reference viewer never resumed past its paged animator boundary.");
+  await waitForScheduledWork(value.alternate, () => value.alternateRuntime.node("synthetic/leaf").classes.includes("material-b"), "The alternate viewer never resumed past its paged animator boundary.");
   assert.equal(value.referenceRuntime.lifecycle.phase, "publish");
   assert.equal(value.alternateRuntime.lifecycle.phase, "publish");
-  const leafIndex = value.result.document.tree.nodes.findIndex((node) => node.id === "synthetic/leaf");
   assert.equal(value.reference.namespaced[leafIndex].classes.includes("material-b"), true);
   assert.equal(value.alternateRuntime.node("synthetic/leaf").classes.includes("material-b"), true);
   assertEquivalent(value, "paged interaction boundary readiness");
@@ -794,10 +825,10 @@ test("alternate and public viewers replace a stale page wait before responsive r
   delayPageTwo = true;
   assert.equal(value.referenceRuntime.seek(1), 1);
   assert.equal(value.alternateRuntime.seek(1), 1);
-  await flushAsyncWork();
+  await value.whenLoaded(() => pending.reference.length >= 1 && pending.alternate.length >= 1, "A viewer never started its opportunistic preload after seeking back.");
   value.reference.frame(34);
   value.alternate.frame(34);
-  await flushAsyncWork();
+  await value.whenLoaded(() => pending.reference.length >= 2 && pending.alternate.length >= 2, "A viewer never started both its opportunistic preload and its scheduler wait generation.");
   assert.equal(pending.reference.length, 2);
   assert.equal(pending.alternate.length, 2);
 
@@ -807,18 +838,18 @@ test("alternate and public viewers replace a stale page wait before responsive r
   }
   value.reference.observers[0].callback();
   value.alternate.observers[0].callback();
-  await flushAsyncWork();
   for (const path of ["reference", "alternate"]) {
+    await value.whenLoaded(() => pending[path].length >= 3, `${path} never started its replacement preload`);
     assert.equal(pending[path].length, 3, `${path} starts one replacement preload`);
     assert.equal(pending[path][0].signal.aborted, true, `${path} cancels the superseded opportunistic preload`);
     assert.equal(pending[path][1].signal.aborted, true, `${path} cancels the stale scheduler wait generation`);
     assert.equal(pending[path][2].signal.aborted, false, `${path} keeps the post-reschedule preload live`);
     pending[path][2].resolve();
   }
-  await flushAsyncWork();
   value.reference.frame(68);
   value.alternate.frame(68);
-  await flushAsyncWork();
+  await waitForScheduledWork(value.reference, () => value.referenceRuntime.sourceFrame === 3, "The reference viewer never published the replacement preload frame.");
+  await waitForScheduledWork(value.alternate, () => value.alternateRuntime.sourceFrame === 3, "The alternate viewer never published the replacement preload frame.");
   assert.equal(value.referenceRuntime.lifecycle.phase, "publish");
   assert.equal(value.alternateRuntime.lifecycle.phase, "publish");
   assert.equal(value.referenceRuntime.sourceFrame, 3);

packages/domformat/test/browser-reader.test.js

@@ -66,6 +66,30 @@ async function waitForScheduledWork(fake, predicate, message) {
   while (!predicate()) await whenSchedulerRearms(fake, message);
 }
 
+// A page load only becomes observable once the runtime actually calls its loader, and the runtime
+// reaches that call behind a libuv-threadpool SHA-256 digest of the page it verified first.
+// Load-count assertions therefore wait on the loader itself; a fixed spin of event-loop turns
+// settles in microseconds and would race that wall-clock work.
+function createLoadSignal() {
+  let notify = null;
+  return {
+    record() {
+      const resume = notify;
+      notify = null;
+      resume?.();
+    },
+    async until(predicate, message) {
+      while (!predicate()) {
+        await new Promise((resolve, reject) => {
+          const guard = setTimeout(() => { notify = null; reject(new Error(message)); }, 30_000);
+          guard.unref?.();
+          notify = () => { clearTimeout(guard); resolve(); };
+        });
+      }
+    },
+  };
+}
+
 function routeFetch(routes, calls = []) {
   return async (input, options) => {
     const url = String(input);
@@ -775,10 +799,12 @@ test("paged variants load the initial page before attach and retain the current/
   const eager = new Map(all);
   for (const record of built.document.resources.resources) if (record.kind === "state-page") eager.delete(record.id);
   const calls = [];
+  const loads = createLoadSignal();
   const result = await readDomBrowser(built.bytes, {
     externalResources: eager,
     async loadExternalResource(record, signal) {
       calls.push([record.id, signal]);
+      loads.record();
       return all.get(record.id);
     },
   });
@@ -792,7 +818,7 @@ test("paged variants load the initial page before attach and retain the current/
   const leaf = namespaced[leafIndex];
   assert.equal(calls[0][0], "variant-page-1");
   assert.equal(leaf.classes.includes("material-a"), true);
-  await flushAsyncWork();
+  await loads.until(() => calls.length >= 3, "The mount never started its retained lookahead page loads.");
   assert.deepEqual(calls.map(([id]) => id), ["variant-page-1", "variant-page-2", "variant-page-3"]);
 
   assert.equal(await runtime.seekAsync(7), 7);
@@ -1231,18 +1257,20 @@ test("superseding an in-progress page load preserves the currently published fra
     return [node.id, element];
   })) };
   const calls = [];
+  const loads = createLoadSignal();
   let releasePage7;
   const page7 = new Promise((resolve) => { releasePage7 = resolve; });
   const pagedState = createPolycssPagedState(built.document, mounted, DEFAULT_LIMITS, async (record) => {
     calls.push(record.id);
+    loads.record();
     if (record.id === "playback-page-7") return page7;
     return all.get(record.id);
   });
   await pagedState.prepareInitial();
   await pagedState.ensureFrame(2);
   pagedState.commit(pagedState.stage(2));
   const stale = pagedState.ensureFrame(7);
-  await flushAsyncWork(2);
+  await loads.until(() => calls.includes("playback-page-7"), "The superseded frame never started its page load.");
   assert.equal(calls.filter((id) => id === "playback-page-7").length, 1);
   await pagedState.ensureFrame(3);
   releasePage7(all.get("playback-page-7"));
@@ -1325,9 +1353,9 @@ test("paged interaction backpressures at a page boundary before mutating or dest
   browser.frame(0);
   assert.doesNotThrow(() => browser.frame(267));
   assert.equal(runtime.lifecycle.phase, "publish");
-  await flushAsyncWork();
-  assert.equal(runtime.lifecycle.phase, "publish");
   const leafIndex = result.document.tree.nodes.findIndex((node) => node.id === "synthetic/leaf");
+  await waitForScheduledWork(browser, () => browser.namespaced[leafIndex].classes.includes("material-b"), "The runtime never resumed past its paged animator boundary.");
+  assert.equal(runtime.lifecycle.phase, "publish");
   assert.equal(browser.namespaced[leafIndex].classes.includes("material-b"), true);
   runtime.destroy();
 });
@@ -1341,16 +1369,18 @@ test("paged variants pin the fixed interaction page so a synchronous mode switch
   const eager = new Map(all);
   for (const record of built.document.resources.resources) if (record.kind === "state-page") eager.delete(record.id);
   const calls = [];
+  const loads = createLoadSignal();
   const result = await readDomBrowser(built.bytes, {
     externalResources: eager,
     loadExternalResource(record) {
       calls.push(record.id);
+      loads.record();
       return all.get(record.id);
     },
   });
   const { document } = fakeBrowserDocument();
   const runtime = await mountDom(result, new FakeElement(document, "main"), { animate: false, mode: "animation" });
-  await new Promise((resolve) => setImmediate(resolve));
+  await loads.until(() => calls.length >= 3, "The mount never started its pinned and lookahead page loads.");
   assert.deepEqual(calls.slice(0, 3), ["variant-page-1", "variant-page-4", "variant-page-2"]);
   assert.equal(await runtime.seekAsync(3), 3);
   const callsBeforeSwitch = calls.length;
@@ -1376,6 +1406,8 @@ test("paged variant requests cancel stale generations and fail closed on late pa
   });
   const firstBrowser = fakeBrowserDocument();
   const runtime = await mountDom(result, new FakeElement(firstBrowser.document, "main"), { animate: false });
+  // Not a load-count gate: variant-page-4 is requested by the stale seek below, not by the mount.
+  // Nothing here is asserted against threadpool work — this only lets the mount's own lookahead settle.
   await new Promise((resolve) => setImmediate(resolve));
   const stale = runtime.seekAsync(7);
   const staleRejection = assert.rejects(stale, errorCode("OPERATION_ABORTED"));