@rstest/browser 0.8.5 → 0.9.0

package/src/client/dispatchTransport.ts

@@ -0,0 +1,178 @@
+import type {
+  BrowserDispatchRequest,
+  BrowserDispatchResponse,
+} from '../protocol';
+import {
+  DISPATCH_MESSAGE_TYPE,
+  DISPATCH_RESPONSE_TYPE,
+  DISPATCH_RPC_REQUEST_TYPE,
+} from '../protocol';
+
+export const DEFAULT_RPC_TIMEOUT_MS = 30_000;
+
+export const getRpcTimeout = (): number => {
+  return (
+    window.__RSTEST_BROWSER_OPTIONS__?.rpcTimeout ?? DEFAULT_RPC_TIMEOUT_MS
+  );
+};
+
+const pendingRequests = new Map<
+  string,
+  {
+    resolve: (value: unknown) => void;
+    reject: (error: Error) => void;
+    staleMessage: string;
+  }
+>();
+
+let requestIdCounter = 0;
+let messageListenerInitialized = false;
+
+export const createRequestId = (prefix: string): string => {
+  if (typeof globalThis.crypto?.randomUUID === 'function') {
+    return globalThis.crypto.randomUUID();
+  }
+
+  requestIdCounter += 1;
+  return `${prefix}-${Date.now().toString(36)}-${requestIdCounter.toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+};
+
+const isDispatchResponse = (
+  value: unknown,
+): value is BrowserDispatchResponse => {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'requestId' in value &&
+    typeof (value as { requestId: unknown }).requestId === 'string'
+  );
+};
+
+const settlePendingRequest = (response: BrowserDispatchResponse): void => {
+  const pending = pendingRequests.get(response.requestId);
+  if (!pending) {
+    return;
+  }
+
+  pendingRequests.delete(response.requestId);
+  if (response.stale) {
+    pending.reject(new Error(pending.staleMessage));
+    return;
+  }
+  if (response.error) {
+    pending.reject(new Error(response.error));
+    return;
+  }
+  pending.resolve(response.result);
+};
+
+const initMessageListener = (): void => {
+  if (messageListenerInitialized) {
+    return;
+  }
+  messageListenerInitialized = true;
+
+  window.addEventListener('message', (event: MessageEvent) => {
+    if (event.data?.type === DISPATCH_RESPONSE_TYPE) {
+      settlePendingRequest(event.data.payload as BrowserDispatchResponse);
+    }
+  });
+};
+
+const unwrapDispatchBridgeResult = <T>(
+  requestId: string,
+  result: unknown,
+  staleMessage: string,
+): T => {
+  if (!isDispatchResponse(result)) {
+    throw new Error('Invalid dispatch bridge response payload.');
+  }
+
+  if (result.requestId !== requestId) {
+    throw new Error(
+      `Mismatched dispatch response id: expected ${requestId}, got ${result.requestId}`,
+    );
+  }
+  if (result.stale) {
+    throw new Error(staleMessage);
+  }
+  if (result.error) {
+    throw new Error(result.error);
+  }
+  return result.result as T;
+};
+
+export const dispatchRpc = <T>({
+  requestId,
+  request,
+  timeoutMs,
+  timeoutMessage,
+  staleMessage,
+}: {
+  requestId: string;
+  request: BrowserDispatchRequest;
+  timeoutMs: number;
+  timeoutMessage: string;
+  staleMessage: string;
+}): Promise<T> => {
+  if (window.parent === window) {
+    const dispatchBridge = window.__rstest_dispatch_rpc__;
+    if (!dispatchBridge) {
+      throw new Error(
+        'Dispatch RPC bridge is not available in top-level runner.',
+      );
+    }
+
+    return new Promise<T>((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        reject(new Error(timeoutMessage));
+      }, timeoutMs);
+
+      const call = Promise.resolve(dispatchBridge(request)).then((result) =>
+        unwrapDispatchBridgeResult<T>(requestId, result, staleMessage),
+      );
+
+      call
+        .then((result) => {
+          clearTimeout(timeoutId);
+          resolve(result);
+        })
+        .catch((error) => {
+          clearTimeout(timeoutId);
+          reject(error instanceof Error ? error : new Error(String(error)));
+        });
+    });
+  }
+
+  initMessageListener();
+
+  return new Promise<T>((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      pendingRequests.delete(requestId);
+      reject(new Error(timeoutMessage));
+    }, timeoutMs);
+
+    pendingRequests.set(requestId, {
+      staleMessage,
+      resolve: (value) => {
+        clearTimeout(timeoutId);
+        resolve(value as T);
+      },
+      reject: (error) => {
+        clearTimeout(timeoutId);
+        reject(error);
+      },
+    });
+
+    window.parent.postMessage(
+      {
+        type: DISPATCH_MESSAGE_TYPE,
+        payload: {
+          type: DISPATCH_RPC_REQUEST_TYPE,
+          payload: request,
+        },
+      },
+      '*',
+    );
+  });
+};

package/src/client/entry.ts

@@ -20,9 +20,15 @@ import {
 import { normalize } from 'pathe';
 import type {
   BrowserClientMessage,
-  BrowserHostConfig,
+  BrowserDispatchRequest,
   BrowserProjectRuntime,
 } from '../protocol';
+import {
+  DISPATCH_MESSAGE_TYPE,
+  DISPATCH_NAMESPACE_RUNNER,
+  DISPATCH_RPC_REQUEST_TYPE,
+  RSTEST_CONFIG_MESSAGE_TYPE,
+} from '../protocol';
 import { BrowserSnapshotEnvironment } from './snapshot';
 import {
   findNewScriptUrl,
@@ -32,14 +38,18 @@ import {
 } from './sourceMapSupport';
 
 declare global {
-  interface Window {
-    __RSTEST_BROWSER_OPTIONS__?: BrowserHostConfig;
-    __rstest_dispatch__?: (message: BrowserClientMessage) => void;
-  }
   // eslint-disable-next-line no-var
   var __coverage__: Record<string, unknown> | undefined;
 }
 
+type RunnerLifecycleMethod =
+  | 'file-ready'
+  | 'suite-start'
+  | 'suite-result'
+  | 'case-start';
+
+let runnerDispatchRequestId = 0;
+
 /**
  * Debug logger for browser client.
  * Only logs when debug mode is enabled (DEBUG=rstest on server side).
@@ -50,10 +60,13 @@ const debugLog = (...args: unknown[]): void => {
   }
 };
 
-type GlobalWithProcess = typeof globalThis & {
-  global?: typeof globalThis;
-  process?: NodeJS.Process;
-};
+type RuntimeEnvStore = Record<string, string | undefined>;
+const RSTEST_ENV_SYMBOL = Symbol.for('rstest.env');
+
+type GlobalWithRuntimeEnv = typeof globalThis &
+  Record<symbol, unknown> & {
+    global?: typeof globalThis;
+  };
 
 const REGEXP_FLAG_PREFIX = 'RSTEST_REGEXP:';
 
@@ -82,36 +95,34 @@ const restoreRuntimeConfig = (
   };
 };
 
-const ensureProcessEnv = (env: RuntimeConfig['env'] | undefined): void => {
-  const globalRef = globalThis as GlobalWithProcess;
+const ensureRuntimeEnv = (env: RuntimeConfig['env'] | undefined): void => {
+  const globalRef = globalThis as GlobalWithRuntimeEnv;
   if (!globalRef.global) {
     globalRef.global = globalRef;
   }
 
-  if (!globalRef.process) {
-    const processShim: Partial<NodeJS.Process> & {
-      env: Record<string, string | undefined>;
-    } = {
-      env: {},
-      argv: [],
-      version: 'browser',
-      cwd: () => '/',
-      platform: 'linux',
-      nextTick: (cb: (...args: unknown[]) => void, ...args: unknown[]) =>
-        queueMicrotask(() => cb(...args)),
-    };
-
-    globalRef.process = processShim as unknown as NodeJS.Process;
+  const existingEnv = globalRef[RSTEST_ENV_SYMBOL];
+  let runtimeEnv: RuntimeEnvStore;
+  if (existingEnv && typeof existingEnv === 'object') {
+    runtimeEnv = existingEnv as RuntimeEnvStore;
+  } else {
+    runtimeEnv = {};
+    globalRef[RSTEST_ENV_SYMBOL] = runtimeEnv;
   }
 
-  globalRef.process.env ??= {};
-
   if (env) {
     for (const [key, value] of Object.entries(env)) {
-      if (value === undefined) {
-        delete globalRef.process.env[key];
+      const normalizedValue =
+        typeof value === 'string'
+          ? value
+          : value == null
+            ? undefined
+            : String(value);
+
+      if (normalizedValue === undefined) {
+        delete runtimeEnv[key];
       } else {
-        globalRef.process.env[key] = value;
+        runtimeEnv[key] = normalizedValue;
       }
     }
   }
@@ -206,7 +217,7 @@ const send = (message: BrowserClientMessage): void => {
   // If in iframe, send to parent window (container) which will forward to host via RPC
   if (window.parent !== window) {
     window.parent.postMessage(
-      { type: '__rstest_dispatch__', payload: message },
+      { type: DISPATCH_MESSAGE_TYPE, payload: message },
       '*',
     );
     return;
@@ -216,6 +227,38 @@ const send = (message: BrowserClientMessage): void => {
   window.__rstest_dispatch__?.(message);
 };
 
+const dispatchRunnerLifecycle = (
+  method: RunnerLifecycleMethod,
+  payload: unknown,
+): void => {
+  const request: BrowserDispatchRequest = {
+    requestId: `runner-lifecycle-${++runnerDispatchRequestId}`,
+    namespace: DISPATCH_NAMESPACE_RUNNER,
+    method,
+    args: payload,
+  };
+
+  if (window.parent === window) {
+    const dispatchBridge = window.__rstest_dispatch_rpc__;
+    if (!dispatchBridge) {
+      debugLog(
+        '[Runner] Missing dispatch bridge for lifecycle method:',
+        method,
+      );
+      return;
+    }
+    void Promise.resolve(dispatchBridge(request)).catch((error: unknown) => {
+      debugLog('[Runner] Failed to dispatch lifecycle method:', method, error);
+    });
+    return;
+  }
+
+  send({
+    type: DISPATCH_RPC_REQUEST_TYPE,
+    payload: request,
+  });
+};
+
 /** Timeout for waiting for browser config from container (30 seconds) */
 const CONFIG_WAIT_TIMEOUT_MS = 30_000;
 
@@ -231,7 +274,7 @@ const waitForConfig = (): Promise<void> => {
 
   return new Promise((resolve, reject) => {
     const handleMessage = (event: MessageEvent) => {
-      if (event.data?.type === 'RSTEST_CONFIG') {
+      if (event.data?.type === RSTEST_CONFIG_MESSAGE_TYPE) {
         window.__RSTEST_BROWSER_OPTIONS__ = event.data.payload;
         debugLog(
           '[Runner] Received config from container:',
@@ -324,6 +367,7 @@ const run = async () => {
   // Support reading testFile and testNamePattern from URL parameters
   const urlParams = new URLSearchParams(window.location.search);
   const urlTestFile = urlParams.get('testFile');
+  const urlRunId = urlParams.get('runId');
   const urlTestNamePattern = urlParams.get('testNamePattern');
 
   if (urlTestFile && options) {
@@ -334,6 +378,13 @@ const run = async () => {
     };
   }
 
+  if (urlRunId && options) {
+    options = {
+      ...options,
+      runId: urlRunId,
+    };
+  }
+
   // Override testNamePattern from URL parameter if provided
   if (urlTestNamePattern && options) {
     options = {
@@ -404,7 +455,7 @@ const run = async () => {
   }
 
   const runtimeConfig = restoreRuntimeConfig(projectRuntime.runtimeConfig);
-  ensureProcessEnv(runtimeConfig.env);
+  ensureRuntimeEnv(runtimeConfig.env);
 
   // Get this project's setup loaders and test context
   const currentSetupLoaders =
@@ -556,6 +607,18 @@ const run = async () => {
     let failedTestsCount = 0;
 
     const runnerHooks: RunnerHooks = {
+      onTestFileReady: async (test) => {
+        dispatchRunnerLifecycle('file-ready', test);
+      },
+      onTestSuiteStart: async (test) => {
+        dispatchRunnerLifecycle('suite-start', test);
+      },
+      onTestSuiteResult: async (result) => {
+        dispatchRunnerLifecycle('suite-result', result);
+      },
+      onTestCaseStart: async (test) => {
+        dispatchRunnerLifecycle('case-start', test);
+      },
       onTestCaseResult: async (result) => {
         if (result.status === 'fail') {
           failedTestsCount++;