@ultimat3/testing 22.8.0 → 22.8.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ultimat3/testing",
-  "version": "22.8.0",
+  "version": "22.8.2",
   "description": "Test harness: cloned template DBs per worker, frozen clock, sealed network, 6 test types",
   "license": "MIT",
   "type": "module",
@@ -35,18 +35,18 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@ultimat3/action": "22.8.0",
-    "@ultimat3/cache": "22.8.0",
-    "@ultimat3/core": "22.8.0",
-    "@ultimat3/db": "22.8.0",
-    "@ultimat3/entity": "22.8.0",
-    "@ultimat3/i18n": "22.8.0",
-    "@ultimat3/jobs": "22.8.0",
-    "@ultimat3/mail": "22.8.0",
-    "@ultimat3/policy": "22.8.0",
-    "@ultimat3/query": "22.8.0",
-    "@ultimat3/realtime": "22.8.0",
-    "@ultimat3/render": "22.8.0",
-    "@ultimat3/time": "22.8.0"
+    "@ultimat3/action": "22.8.2",
+    "@ultimat3/cache": "22.8.2",
+    "@ultimat3/core": "22.8.2",
+    "@ultimat3/db": "22.8.2",
+    "@ultimat3/entity": "22.8.2",
+    "@ultimat3/i18n": "22.8.2",
+    "@ultimat3/jobs": "22.8.2",
+    "@ultimat3/mail": "22.8.2",
+    "@ultimat3/policy": "22.8.2",
+    "@ultimat3/query": "22.8.2",
+    "@ultimat3/realtime": "22.8.2",
+    "@ultimat3/render": "22.8.2",
+    "@ultimat3/time": "22.8.2"
   }
 }

package/src/cdp-browser.ts

@@ -29,6 +29,11 @@ export interface E2eBrowser {
   readonly session: E2eSession;
   /** Idempotent, and it closes both halves: the CDP socket, then the process and its profile. */
   close(): void;
+  /**
+   * `close()`, resolving once the process has exited (bounded — `CLOSE_GRACE_MS`, then SIGKILL).
+   * Optional so a test double need not model a process; the launched browser always has it.
+   */
+  closed?(): Promise<void>;
 }
 
 export interface OpenE2eBrowserOptions {
@@ -55,6 +60,10 @@ const compose = (launched: LaunchedBrowser, session: E2eSession, page: E2eTab):
   // the process out from under an open connection makes every in-flight call report "the browser
   // closed the CDP connection", which is true and useless.
   close: () => launched.close(),
+  closed: async () => {
+    if (launched.closed === undefined) launched.close();
+    else await launched.closed();
+  },
 });
 
 /**

package/src/cdp-e2e-page.ts

@@ -44,6 +44,13 @@ export interface E2eTab extends E2eBrowserPage {
    * with `evaluate('location.href = …')` and poll with `waitFor`.
    */
   scripting(enabled: boolean): Promise<void>;
+  /**
+   * A REAL click: the pointer moved to the element's centre, pressed and released through
+   * `Input.dispatchMouseEvent`, so the browser hit-tests it as it would a person's — and anything
+   * painted over the element (a view transition's overlay, a modal) receives it instead. `click()`
+   * dispatches straight at the element and can never see that.
+   */
+  pointerClick(selector: string): Promise<void>;
   /** Reload and wait for the load, at the url the tab already had. */
   reload(): Promise<void>;
   /** Poll `expression` in the page until it is truthy, or refuse naming `what`. */
@@ -166,6 +173,26 @@ export function cdpE2eTab(options: CdpE2eTabOptions): E2eTab {
         });
       }
     },
+    async pointerClick(selector: string): Promise<void> {
+      const at = await evaluate(
+        `(() => { const el = document.querySelector(${JSON.stringify(selector)}); if (!el) return null; const r = el.getBoundingClientRect(); return [r.left + r.width / 2, r.top + r.height / 2]; })()`,
+      );
+      if (!Array.isArray(at) || typeof at[0] !== 'number' || typeof at[1] !== 'number') {
+        throw new CdpCallFailedError({
+          method: `pointerClick(${selector})`,
+          detail: 'no element in the page matches that selector',
+        });
+      }
+      const [x, y] = at;
+      for (const type of ['mouseMoved', 'mousePressed', 'mouseReleased'] as const) {
+        const pressed = type !== 'mouseMoved';
+        await send(
+          'Input.dispatchMouseEvent',
+          { type, x, y, button: pressed ? 'left' : 'none', clickCount: pressed ? 1 : 0 },
+          sessionId,
+        );
+      }
+    },
     offline: (enabled: boolean) => options.offline(enabled),
     async scripting(enabled: boolean): Promise<void> {
       await send('Emulation.setScriptExecutionDisabled', { value: !enabled }, sessionId);

package/src/cdp-launch.ts

@@ -86,6 +86,14 @@ export interface LaunchedBrowser {
   readonly connection: CdpConnection;
   /** Idempotent: closes the connection, kills the process, deletes the profile. */
   close(): void;
+  /**
+   * `close()`, then resolves once the process has EXITED — SIGTERM, then SIGKILL after
+   * `CLOSE_GRACE_MS`, never waiting longer than twice that. What a suite's `afterAll` awaits: a
+   * Chrome told to die but still shutting down competes with the next suite's launch on a 4-CPU
+   * runner, and one still running keeps the test process from exiting at all. Optional so a test
+   * double of a launch need not model a process; `launchChrome` always provides it.
+   */
+  closed?(): Promise<void>;
 }
 
 export interface LaunchOptions {
@@ -125,6 +133,9 @@ function stderrTail(stream: ReadableStream<Uint8Array>): {
  */
 const FAILURE_DRAIN_MS = 1_000;
 
+/** How long a closed Chrome gets to exit on SIGTERM before it is killed outright. */
+export const CLOSE_GRACE_MS = 5_000;
+
 const within = (ms: number, work: Promise<unknown>): Promise<unknown> =>
   Promise.race([work, Bun.sleep(ms)]);
 
@@ -163,9 +174,24 @@ export async function launchChrome(options: LaunchOptions): Promise<LaunchedBrow
     child.kill();
     rmSync(profileDir, { recursive: true, force: true });
   };
+  let exiting: Promise<void> | undefined;
+  const closeAndWait = (): Promise<void> => {
+    close();
+    exiting ??= (async () => {
+      const exited =
+        (await within(
+          CLOSE_GRACE_MS,
+          child.exited.then(() => true),
+        )) === true;
+      if (exited) return;
+      child.kill('SIGKILL');
+      await within(CLOSE_GRACE_MS, child.exited);
+    })();
+    return exiting;
+  };
   try {
     await connection.send('Browser.getVersion');
-    return { connection, close };
+    return { connection, close, closed: closeAndWait };
   } catch {
     await within(FAILURE_DRAIN_MS, child.exited);
     close();