@ai-ecoverse/slicc-shared-web 1.5.0 → 1.5.1

package/README.md

@@ -62,9 +62,9 @@ test('boots', async (t) => {
 | `intercept` | Remote URL prefixes answered from a disk cache in `node_modules/.cache/` | none |
 | `extensions` | Unpacked extension directories to load. Their scripts are covered and profiled like the repo's own, and tests then run in the default browser context, closing their tabs when they end, because Chrome does not run extensions in the per-test contexts | none |
 | `args` | Extra Chromium flags, such as `--host-resolver-rules` or `--ignore-certificate-errors` | none |
-| `timeout` | How long `page.until` polls, in ms | `30000` |
+| `timeout` | How long `page.until` polls and `page.evaluate` waits, in ms | `30000` |
 
-`chrome.page(t)` opens a tab and returns the page API: `goto(path)`, `reload()`, `evaluate(fn, ...args)`, `until(fn, ...args)`, `press(key, ...modifiers)` (a key name like `Enter` or `F5`, or a single character typed with its US-layout key code), `type(text)`, `insert(text)`, `enter()`, `init(fn)` (runs in every new document), `expose(name, handler)` (a binding the page calls with a JSON string), `screenshot(file)`, `tab()` (another tab in the same context), `close()`, `errors`, `responses` and `dir` (the test's artifact directory). `goto` and `reload` wait until the new document is complete and no longer `about:blank`, and retry the navigation once if that never happens. `until` polls until the function returns a truthy value (not only strict `true`) and resolves with that value; the timeout error names the last result. `chrome.requests` lists the paths the server saw in this test, `chrome.overrides` is a `Map` of paths to bodies served instead of files, and `chrome.cdn` takes `status` (answer every intercepted request with it), `corrupt` (flip the last byte) and lists the intercepted `requests`. All of them reset with each test. `serve(options)` starts the same server on its own, for an `npm start`.
+`chrome.page(t)` opens a tab and returns the page API: `goto(path)`, `reload()`, `evaluate(fn, ...args)`, `until(fn, ...args)`, `press(key, ...modifiers)` (a key name like `Enter` or `F5`, or a single character typed with its US-layout key code), `type(text)`, `insert(text)`, `enter()`, `init(fn)` (runs in every new document), `expose(name, handler)` (a binding the page calls with a JSON string), `screenshot(file)`, `tab()` (another tab in the same context), `close()`, `errors`, `responses` and `dir` (the test's artifact directory). `goto` and `reload` wait until the new document is complete and no longer `about:blank`, and retry the navigation once if that never happens. `until` polls until the function returns a truthy value (not only strict `true`) and resolves with that value; the timeout error names the last result. `within(ms, fn, ...args)` is `until` with its own deadline, for a stage that should take a known time. Both stop at the deadline even if one evaluation never answers. Every CDP call has a deadline: `connect(url).send(method, params, sessionId, ms)` rejects with `<method>: no answer in <ms> ms` (60 s unless given), so a stuck page fails its test instead of hanging the run. Downloads of intercepted URLs time out after 60 s and are tried up to three times; a `4xx` is not retried. `chrome.requests` lists the paths the server saw in this test, `chrome.overrides` is a `Map` of paths to bodies served instead of files, and `chrome.cdn` takes `status` (answer every intercepted request with it), `corrupt` (flip the last byte) and lists the intercepted `requests`. All of them reset with each test. `serve(options)` starts the same server on its own, for an `npm start`.
 
 Why it works the way it does:
 

package/harness/cdn.mjs

@@ -7,15 +7,27 @@ import { cache, ignore } from './util.mjs';
 const cors = [{ name: 'access-control-allow-origin', value: '*' }];
 const store = new URL('cdn/', cache);
 
+export const DOWNLOAD_TIMEOUT = 60000;
+
+export async function fetched(url, { attempts = 3, ms = DOWNLOAD_TIMEOUT, fetcher = fetch } = {}) {
+  for (let attempt = 1; ; attempt++) {
+    try {
+      const response = await fetcher(url, { signal: AbortSignal.timeout(ms) });
+      if (!response.ok) throw new Error(`${response.status} ${url}`);
+      return Buffer.from(await response.arrayBuffer());
+    } catch (error) {
+      if (attempt >= attempts || /^4\d\d /.test(error.message)) throw error;
+    }
+  }
+}
+
 export async function download(url) {
   const { host, pathname, search } = new URL(url);
   const query = search ? encodeURIComponent(search) : '';
   const file = new URL(`./${host}${pathname}${query}`, store);
   const hit = await readFile(file).catch(ignore);
   if (hit) return hit;
-  const response = await fetch(url);
-  if (!response.ok) throw new Error(`${response.status} ${url}`);
-  const body = Buffer.from(await response.arrayBuffer());
+  const body = await fetched(url);
   await mkdir(dirname(fileURLToPath(file)), { recursive: true });
   const partial = new URL(`${file.href}.${process.pid}`);
   await writeFile(partial, body);

package/harness/cdp.mjs

@@ -1,3 +1,5 @@
+export const SEND_TIMEOUT = 60000;
+
 export async function connect(url) {
   const socket = new WebSocket(url);
   await new Promise((resolve, reject) => {
@@ -29,10 +31,19 @@ export async function connect(url) {
     for (const call of pending.values()) call.reject(new Error(`${call.method}: socket closed`));
   };
   return {
-    send: (method, params = {}, sessionId) =>
+    send: (method, params = {}, sessionId, ms = SEND_TIMEOUT) =>
       new Promise((resolve, reject) => {
-        pending.set(++id, { method, sessionId, resolve, reject });
-        socket.send(JSON.stringify({ id, method, params, sessionId }));
+        const key = ++id;
+        const timer = setTimeout(() => {
+          pending.delete(key);
+          reject(new Error(`${method}: no answer in ${ms} ms`));
+        }, ms);
+        const settle = (fn) => (value) => {
+          clearTimeout(timer);
+          fn(value);
+        };
+        pending.set(key, { method, sessionId, resolve: settle(resolve), reject: settle(reject) });
+        socket.send(JSON.stringify({ id: key, method, params, sessionId }));
       }),
     on: (listener) => {
       listeners.add(listener);

package/harness/page.mjs

@@ -85,7 +85,7 @@ export function decoded({ value, unserializableValue }) {
 }
 
 export function page(cdp, { sessionId, targetId }, server, timeout = 30000) {
-  const send = (method, params) => cdp.send(method, params, sessionId);
+  const send = (method, params, ms) => cdp.send(method, params, sessionId, ms);
   const errors = [];
   const responses = [];
   const bindings = new Map();
@@ -99,23 +99,27 @@ export function page(cdp, { sessionId, targetId }, server, timeout = 30000) {
     if (method === 'Network.responseReceived') responses.push(params.response);
   });
 
-  async function evaluate(fn, ...args) {
+  async function run(fn, args, ms) {
     const expression = `(${fn})(...${JSON.stringify(args)})`;
-    const { result, exceptionDetails } = await send('Runtime.evaluate', {
-      expression,
-      awaitPromise: true,
-      returnByValue: true,
-    });
+    const { result, exceptionDetails } = await send(
+      'Runtime.evaluate',
+      { expression, awaitPromise: true, returnByValue: true },
+      ms
+    );
     if (exceptionDetails) throw new Error(exceptionDetails.exception?.description);
     return decoded(result);
   }
 
-  async function until(fn, ...args) {
-    const deadline = Date.now() + timeout;
+  function evaluate(fn, ...args) {
+    return run(fn, args, timeout);
+  }
+
+  async function within(ms, fn, ...args) {
+    const deadline = Date.now() + ms;
     let last;
-    while (Date.now() < deadline) {
+    for (let left = ms; left > 0; left = deadline - Date.now()) {
       try {
-        last = await evaluate(fn, ...args);
+        last = await run(fn, args, left);
         if (last) return last;
       } catch (error) {
         last = error.message;
@@ -123,10 +127,14 @@ export function page(cdp, { sessionId, targetId }, server, timeout = 30000) {
       await sleep(25);
     }
     throw new Error(
-      `Timed out waiting for a truthy result from ${fn}\nlast result: ${JSON.stringify(last)}`
+      `Timed out after ${ms} ms waiting for a truthy result from ${fn}\nlast result: ${JSON.stringify(last)}`
     );
   }
 
+  function until(fn, ...args) {
+    return within(timeout, fn, ...args);
+  }
+
   async function press(key, ...modifiers) {
     const event = keystroke(key, modifiers);
     await send('Input.dispatchKeyEvent', { ...event, type: event.text ? 'keyDown' : 'rawKeyDown' });
@@ -152,6 +160,7 @@ export function page(cdp, { sessionId, targetId }, server, timeout = 30000) {
     dispose,
     evaluate,
     until,
+    within,
     press,
     goto: (path) => navigate(`location.assign(${JSON.stringify(new URL(path, server.url).href)})`),
     reload: () => navigate('location.reload()'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ecoverse/slicc-shared-web",
-  "version": "1.5.0",
+  "version": "1.5.1",
   "description": "Shared Renovate, Biome, TypeScript, lefthook and GitHub Actions configuration, plus the CDP integration-test harness, for SLICC's web repos",
   "type": "module",
   "license": "Apache-2.0",