@ultimat3/testing 22.2.1 → 22.3.0

package/package.json

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

package/src/cdp-browser.ts

@@ -34,6 +34,8 @@ export interface E2eBrowser {
 export interface OpenE2eBrowserOptions {
   readonly env?: Readonly<Record<string, string | undefined>> | undefined;
   readonly timeoutMs?: number | undefined;
+  /** Pinned as `Accept-Language` on every request (`cdp-e2e-session.ts`). Absent: Chrome's own. */
+  readonly acceptLanguage?: string | undefined;
 }
 
 /**
@@ -63,7 +65,7 @@ export async function openE2eBrowser(options: OpenE2eBrowserOptions = {}): Promi
   const timeoutMs = budget(options);
   const executable = await findChrome(options.env ?? process.env);
   if (executable === undefined) throw new CdpBrowserMissingError({ tried: CHROME_CANDIDATES });
-  return openLaunched(executable, timeoutMs);
+  return openLaunched(executable, timeoutMs, options.acceptLanguage);
 }
 
 /** `undefined` when this machine has no browser. Every other failure still throws. */
@@ -73,7 +75,7 @@ export async function openE2eBrowserIfAvailable(
   const timeoutMs = budget(options);
   const executable = await findChrome(options.env ?? process.env);
   if (executable === undefined) return undefined;
-  return openLaunched(executable, timeoutMs);
+  return openLaunched(executable, timeoutMs, options.acceptLanguage);
 }
 
 /**
@@ -81,11 +83,19 @@ export async function openE2eBrowserIfAvailable(
  * launched and then refused the CDP handshake would otherwise be left running, holding its profile
  * directory, for the rest of the test process — one leaked browser per failing suite.
  */
-async function openLaunched(executable: string, timeoutMs: number): Promise<E2eBrowser> {
+async function openLaunched(
+  executable: string,
+  timeoutMs: number,
+  acceptLanguage: string | undefined,
+): Promise<E2eBrowser> {
   const launched = await launchChrome({ executable, timeoutMs });
   const { connection } = launched;
   try {
-    const session = await cdpE2eSession({ connection, loadTimeoutMs: timeoutMs });
+    const session = await cdpE2eSession({
+      connection,
+      loadTimeoutMs: timeoutMs,
+      ...(acceptLanguage === undefined ? {} : { acceptLanguage }),
+    });
     return compose(launched, session, await session.newTab());
   } catch (error) {
     launched.close();

package/src/cdp-e2e-session.ts

@@ -27,6 +27,12 @@ export interface CdpE2eSessionOptions {
   readonly connection: CdpConnection;
   /** The load budget every tab's `goto` waits on, and how long a new tab may take to attach. */
   readonly loadTimeoutMs: number;
+  /**
+   * Sent as `Accept-Language` by every page and worker. The e2e step pins the app's default
+   * locale here, so a `site/` page negotiates the same language on every box — never the one the
+   * CI runner's Chrome was installed with.
+   */
+  readonly acceptLanguage?: string | undefined;
 }
 
 const POLL_MS = 50;
@@ -90,6 +96,15 @@ export async function cdpE2eSession(options: CdpE2eSessionOptions): Promise<E2eS
       // Network domain is off — an `offline()` that does nothing while the assertion after it
       // reads as proof.
       const configured: Promise<unknown>[] = [send('Network.enable', {}, session)];
+      if (options.acceptLanguage !== undefined) {
+        configured.push(
+          send(
+            'Network.setExtraHTTPHeaders',
+            { headers: { 'accept-language': options.acceptLanguage } },
+            session,
+          ),
+        );
+      }
       if (cut) configured.push(condition(session));
       if (type === 'page') {
         configured.push(send('Page.enable', {}, session), send('Runtime.enable', {}, session));

package/src/e2e-locale.ts

@@ -0,0 +1,30 @@
+// The locale an e2e run's browser asks for: the app's own `defaultLocale`, read off `app.config.ts`
+// the way the CLI reads its other boot facts. `@ultimat3/testing` sits below `@ultimat3/cli`, so the
+// file name and the export name are restated here rather than imported from it.
+
+import { join } from 'node:path'; // why: Bun ships no path join.
+
+/** The app root's config module and the export holding the config — `x new` writes both. */
+const APP_CONFIG_FILE = 'app.config.ts';
+const APP_CONFIG_EXPORT = 'config';
+
+/**
+ * The app's `defaultLocale`, or `undefined` when it cannot be read — and then nothing is pinned.
+ * Never a guessed `en`: pinning the wrong language would make every run photograph and assert on a
+ * page no visitor at the unprefixed URL sees, which is worse than the runner's own Chrome locale.
+ * The import runs the config module, which may validate an environment this process lacks.
+ */
+export async function e2eDefaultLocale(root: string): Promise<string | undefined> {
+  const path = join(root, APP_CONFIG_FILE);
+  if (!(await Bun.file(path).exists())) return undefined;
+  let module: Record<string, unknown>;
+  try {
+    module = (await import(path)) as Record<string, unknown>;
+  } catch {
+    return undefined;
+  }
+  const config = Object.hasOwn(module, APP_CONFIG_EXPORT) ? module[APP_CONFIG_EXPORT] : undefined;
+  if (typeof config !== 'object' || config === null) return undefined;
+  const locale = (config as Record<string, unknown>)['defaultLocale'];
+  return typeof locale === 'string' && locale !== '' ? locale : undefined;
+}

package/src/e2e-preload.ts

@@ -7,14 +7,18 @@ import { openE2eBrowser } from './cdp-browser';
 import { startE2eApp } from './e2e-app';
 import { E2E_ROOT_ENV } from './e2e-browser-handle';
 import { installE2eDriver } from './e2e-driver';
+import { e2eDefaultLocale } from './e2e-locale';
 import { startE2eRun } from './e2e-run';
 
 const root = Bun.env[E2E_ROOT_ENV];
 if (root !== undefined && root !== '') {
+  // Read once, before the app boots: every browser this run opens — the first and every relaunch —
+  // asks for the app's default locale, so a page's language never depends on the runner's Chrome.
+  const acceptLanguage = await e2eDefaultLocale(root);
   await startE2eRun({
     app: await startE2eApp({ root }),
     // `openE2eBrowser`, never the `IfAvailable` door: the step only names a root after finding one.
-    openBrowser: openE2eBrowser,
+    openBrowser: () => openE2eBrowser(acceptLanguage === undefined ? {} : { acceptLanguage }),
     install: installE2eDriver,
     beforeEach,
     afterAll,