@rstest/browser 0.9.0 → 0.9.2

package/src/hostController.ts

@@ -3,6 +3,7 @@ import fs from 'node:fs/promises';
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { AddressInfo } from 'node:net';
 import { fileURLToPath } from 'node:url';
+import type { Rspack } from '@rstest/core';
 import {
   type BrowserTestRunOptions,
   type BrowserTestRunResult,
@@ -37,6 +38,7 @@ import {
   createHostDispatchRouter,
   type HostDispatchRouterOptions,
 } from './dispatchCapabilities';
+import { createHeadedSerialTaskQueue } from './headedSerialTaskQueue';
 import { createHeadlessLatestRerunScheduler } from './headlessLatestRerunScheduler';
 import { attachHeadlessRunnerTransport } from './headlessTransport';
 import type {
@@ -76,6 +78,11 @@ import {
   type SourceMapPayload,
 } from './sourceMap/sourceMapLoader';
 import { resolveBrowserViewportPreset } from './viewportPresets';
+import {
+  isBrowserWatchCliShortcutsEnabled,
+  logBrowserWatchReadyMessage,
+  setupBrowserWatchCliShortcuts,
+} from './watchCliShortcuts';
 import { collectWatchTestFiles, planWatchRerun } from './watchRerunPlanner';
 
 const { createRsbuild, rspack } = rsbuild;
@@ -155,6 +162,7 @@ type TestCaseStartPayload = ReporterHookArg<'onTestCaseStart'>;
 type HostRpcMethods = {
   rerunTest: (testFile: string, testNamePattern?: string) => Promise<void>;
   getTestFiles: () => Promise<TestFileInfo[]>;
+  onRunnerFramesReady: (testFiles: string[]) => Promise<void>;
   // Test result callbacks from container
   onTestFileStart: (payload: TestFileStartPayload) => Promise<void>;
   onTestCaseResult: (payload: TestResult) => Promise<void>;
@@ -314,6 +322,8 @@ type WatchContext = {
   lastTestFiles: TestFileInfo[];
   hooksEnabled: boolean;
   cleanupRegistered: boolean;
+  cleanupPromise: Promise<void> | null;
+  closeCliShortcuts: (() => void) | null;
   chunkHashes: Map<string, string>;
   affectedTestFiles: string[];
 };
@@ -323,6 +333,8 @@ const watchContext: WatchContext = {
   lastTestFiles: [],
   hooksEnabled: false,
   cleanupRegistered: false,
+  cleanupPromise: null,
+  closeCliShortcuts: null,
   chunkHashes: new Map(),
   affectedTestFiles: [],
 };
@@ -378,6 +390,81 @@ const ensureProcessExitCode = (code: number): void => {
   }
 };
 
+const castArray = <T>(arr?: T | T[]): T[] => {
+  if (arr === undefined) {
+    return [];
+  }
+  return Array.isArray(arr) ? arr : [arr];
+};
+
+const applyDefaultWatchOptions = (
+  rspackConfig: Rspack.Configuration,
+  isWatchMode: boolean,
+) => {
+  rspackConfig.watchOptions ??= {};
+
+  if (!isWatchMode) {
+    rspackConfig.watchOptions.ignored = '**/**';
+    return;
+  }
+
+  rspackConfig.watchOptions.ignored = castArray(
+    rspackConfig.watchOptions.ignored || [],
+  ) as string[];
+
+  if (rspackConfig.watchOptions.ignored.length === 0) {
+    rspackConfig.watchOptions.ignored.push('**/.git', '**/node_modules');
+  }
+
+  rspackConfig.output?.path &&
+    rspackConfig.watchOptions.ignored.push(rspackConfig.output.path);
+};
+
+type LazyCompilationModule = {
+  nameForCondition?: () => string | null | undefined;
+};
+
+type BrowserLazyCompilationConfig = {
+  imports: true;
+  entries: false;
+  test?: (module: LazyCompilationModule) => boolean;
+};
+
+export const createBrowserLazyCompilationConfig = (
+  setupFiles: string[],
+): BrowserLazyCompilationConfig => {
+  const eagerSetupFiles = new Set(
+    setupFiles.map((filePath) => normalize(filePath)),
+  );
+
+  if (eagerSetupFiles.size === 0) {
+    return {
+      imports: true,
+      entries: false,
+    };
+  }
+
+  return {
+    imports: true,
+    entries: false,
+    test(module: LazyCompilationModule) {
+      const filePath = module.nameForCondition?.();
+      return !filePath || !eagerSetupFiles.has(normalize(filePath));
+    },
+  };
+};
+
+export const createBrowserRsbuildDevConfig = (isWatchMode: boolean) => {
+  return {
+    // Disable HMR in non-watch mode (tests run once and exit).
+    // Aligns with node mode behavior (packages/core/src/core/rsbuild.ts).
+    hmr: isWatchMode,
+    client: {
+      logLevel: 'error' as const,
+    },
+  };
+};
+
 /**
  * Convert a single glob pattern to RegExp using picomatch
  * Based on Storybook's implementation
@@ -920,27 +1007,39 @@ const destroyBrowserRuntime = async (
     .catch(() => {});
 };
 
-const registerWatchCleanup = (): void => {
-  if (watchContext.cleanupRegistered) {
-    return;
+const cleanupWatchRuntime = (): Promise<void> => {
+  if (watchContext.cleanupPromise) {
+    return watchContext.cleanupPromise;
   }
 
-  const cleanup = async () => {
+  watchContext.cleanupPromise = (async () => {
+    watchContext.closeCliShortcuts?.();
+    watchContext.closeCliShortcuts = null;
+
     if (!watchContext.runtime) {
       return;
     }
+
     await destroyBrowserRuntime(watchContext.runtime);
     watchContext.runtime = null;
-  };
+  })();
+
+  return watchContext.cleanupPromise;
+};
+
+const registerWatchCleanup = (): void => {
+  if (watchContext.cleanupRegistered) {
+    return;
+  }
 
-  for (const signal of ['SIGINT', 'SIGTERM'] as const) {
+  for (const signal of ['SIGINT', 'SIGTERM', 'SIGTSTP'] as const) {
     process.once(signal, () => {
-      void cleanup();
+      void cleanupWatchRuntime();
     });
   }
 
   process.once('exit', () => {
-    void cleanup();
+    void cleanupWatchRuntime();
   });
 
   watchContext.cleanupRegistered = true;
@@ -1029,11 +1128,7 @@ const createBrowserRuntime = async ({
         port: browserLaunchOptions.port ?? 4000,
         strictPort: browserLaunchOptions.strictPort,
       },
-      dev: {
-        client: {
-          logLevel: 'error',
-        },
-      },
+      dev: createBrowserRsbuildDevConfig(isWatchMode),
       environments: {
         ...Object.fromEntries(
           browserProjects.map((project) => [project.environmentName, {}]),
@@ -1069,6 +1164,12 @@ const createBrowserRuntime = async ({
             }
 
             const userRsbuildConfig = project.normalizedConfig;
+            const setupFiles = Object.values(
+              getSetupFiles(
+                project.normalizedConfig.setupFiles,
+                project.rootPath,
+              ),
+            );
             // Merge order: current config -> userConfig -> rstest required config (highest priority)
             const merged = mergeEnvironmentConfig(config, userRsbuildConfig, {
               resolve: {
@@ -1090,13 +1191,13 @@ const createBrowserRuntime = async ({
               tools: {
                 rspack: (rspackConfig) => {
                   rspackConfig.mode = 'development';
-                  rspackConfig.lazyCompilation = {
-                    imports: true,
-                    entries: false,
-                  };
+                  rspackConfig.lazyCompilation =
+                    createBrowserLazyCompilationConfig(setupFiles);
                   rspackConfig.plugins = rspackConfig.plugins || [];
                   rspackConfig.plugins.push(virtualManifestPlugin);
 
+                  applyDefaultWatchOptions(rspackConfig, isWatchMode);
+
                   // Extract and merge sourcemaps from pre-built @rstest/core files
                   // This preserves the sourcemap chain for inline snapshot support
                   // See: https://rspack.dev/config/module-rules#rulesextractsourcemap
@@ -1638,6 +1739,7 @@ export const runBrowserController = async (
   await notifyTestRunStart();
 
   const isWatchMode = context.command === 'watch';
+  const enableCliShortcuts = isWatchMode && isBrowserWatchCliShortcutsEnabled();
   const tempDir =
     isWatchMode && watchContext.runtime
       ? watchContext.runtime.tempDir
@@ -1691,6 +1793,12 @@ export const runBrowserController = async (
     if (isWatchMode) {
       watchContext.runtime = runtime;
       registerWatchCleanup();
+
+      if (enableCliShortcuts && !watchContext.closeCliShortcuts) {
+        watchContext.closeCliShortcuts = await setupBrowserWatchCliShortcuts({
+          close: cleanupWatchRuntime,
+        });
+      }
     }
   }
 
@@ -2331,6 +2439,7 @@ export const runBrowserController = async (
                 ? [rerunFatalError]
                 : undefined,
           });
+          logBrowserWatchReadyMessage(enableCliShortcuts);
         }
       },
       onError: async (error) => {
@@ -2375,6 +2484,7 @@ export const runBrowserController = async (
             logger.log(
               color.cyan('No browser test files remain after update.\n'),
             );
+            logBrowserWatchReadyMessage(enableCliShortcuts);
             return;
           }
 
@@ -2393,6 +2503,7 @@ export const runBrowserController = async (
               'No affected browser test files detected, skipping re-run.\n',
             ),
           );
+          logBrowserWatchReadyMessage(enableCliShortcuts);
           return;
         }
 
@@ -2451,23 +2562,104 @@ export const runBrowserController = async (
 
     if (isWatchMode && triggerRerun) {
       watchContext.hooksEnabled = true;
-      logger.log(
-        color.cyan(
-          '\nWatch mode enabled - will re-run tests on file changes\n',
-        ),
-      );
+      logBrowserWatchReadyMessage(enableCliShortcuts);
     }
 
     return result;
   }
 
-  let completedTests = 0;
+  let currentTestFiles = allTestFiles;
+  const RUNNER_FRAMES_READY_TIMEOUT_MS = 30_000;
+  let currentRunnerFramesSignature: string | null = null;
+  const runnerFramesWaiters = new Map<string, Set<() => void>>();
 
-  // Promise that resolves when all tests complete
-  let resolveAllTests: (() => void) | undefined;
-  const allTestsPromise = new Promise<void>((resolve) => {
-    resolveAllTests = resolve;
-  });
+  const createTestFilesSignature = (testFiles: readonly string[]): string => {
+    return JSON.stringify(testFiles.map((testFile) => normalize(testFile)));
+  };
+
+  const markRunnerFramesReady = (testFiles: string[]): void => {
+    const signature = createTestFilesSignature(testFiles);
+    currentRunnerFramesSignature = signature;
+    const waiters = runnerFramesWaiters.get(signature);
+    if (!waiters) {
+      return;
+    }
+    runnerFramesWaiters.delete(signature);
+    for (const waiter of waiters) {
+      waiter();
+    }
+  };
+
+  const waitForRunnerFramesReady = async (
+    testFiles: readonly string[],
+  ): Promise<void> => {
+    const signature = createTestFilesSignature(testFiles);
+    if (currentRunnerFramesSignature === signature) {
+      return;
+    }
+
+    await new Promise<void>((resolve, reject) => {
+      const waiters =
+        runnerFramesWaiters.get(signature) ?? new Set<() => void>();
+      let timeoutId: ReturnType<typeof setTimeout> | undefined;
+
+      const cleanup = () => {
+        const currentWaiters = runnerFramesWaiters.get(signature);
+        if (!currentWaiters) {
+          return;
+        }
+        currentWaiters.delete(onReady);
+        if (currentWaiters.size === 0) {
+          runnerFramesWaiters.delete(signature);
+        }
+      };
+
+      const onReady = () => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        cleanup();
+        resolve();
+      };
+
+      timeoutId = setTimeout(() => {
+        cleanup();
+        reject(
+          new Error(
+            `Timed out waiting for headed runner frames to be ready for ${testFiles.length} file(s).`,
+          ),
+        );
+      }, RUNNER_FRAMES_READY_TIMEOUT_MS);
+
+      waiters.add(onReady);
+      runnerFramesWaiters.set(signature, waiters);
+
+      if (currentRunnerFramesSignature === signature) {
+        onReady();
+      }
+    });
+  };
+
+  const getTestFileInfo = (testFile: string): TestFileInfo => {
+    const normalizedTestFile = normalize(testFile);
+    const fileInfo = currentTestFiles.find(
+      (file) => file.testPath === normalizedTestFile,
+    );
+    if (!fileInfo) {
+      throw new Error(`Unknown browser test file: ${JSON.stringify(testFile)}`);
+    }
+    return fileInfo;
+  };
+
+  const getHeadedPerFileTimeoutMs = (file: TestFileInfo): number => {
+    const projectRuntime = projectRuntimeConfigs.find(
+      (project) => project.name === file.projectName,
+    );
+    return (
+      (projectRuntime?.runtimeConfig.testTimeout ?? maxTestTimeoutForRpc) +
+      30_000
+    );
+  };
 
   // Open a container page for user to view (reuse in watch mode)
   let containerContext: BrowserProviderContext;
@@ -2513,6 +2705,40 @@ export const runBrowserController = async (
   activeContainerPage = containerPage;
 
   const dispatchRouter = createDispatchRouter();
+  const headedReloadQueue = createHeadedSerialTaskQueue();
+  let enqueueHeadedReload = async (
+    _file: TestFileInfo,
+    _testNamePattern?: string,
+  ): Promise<void> => {
+    throw new Error('Headed reload queue is not initialized');
+  };
+
+  const reloadTestFileWithTimeout = async (
+    file: TestFileInfo,
+    testNamePattern?: string,
+  ): Promise<void> => {
+    const timeoutMs = getHeadedPerFileTimeoutMs(file);
+    let timeoutId: ReturnType<typeof setTimeout> | undefined;
+
+    try {
+      await Promise.race([
+        rpcManager.reloadTestFile(file.testPath, testNamePattern),
+        new Promise<never>((_, reject) => {
+          timeoutId = setTimeout(() => {
+            reject(
+              new Error(
+                `Headed test execution timeout after ${timeoutMs / 1000}s for ${file.testPath}.`,
+              ),
+            );
+          }, timeoutMs);
+        }),
+      ]);
+    } finally {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    }
+  };
 
   // Create RPC methods that can access test state variables
   const createRpcMethods = (): HostRpcMethods => ({
@@ -2525,10 +2751,13 @@ export const runBrowserController = async (
           `\nRe-running test: ${displayPath}${testNamePattern ? ` (pattern: ${testNamePattern})` : ''}\n`,
         ),
       );
-      await rpcManager.reloadTestFile(testFile, testNamePattern);
+      await enqueueHeadedReload(getTestFileInfo(testFile), testNamePattern);
     },
     async getTestFiles() {
-      return allTestFiles;
+      return currentTestFiles;
+    },
+    async onRunnerFramesReady(testFiles: string[]) {
+      markRunnerFramesReady(testFiles);
     },
     async onTestFileStart(payload: TestFileStartPayload) {
       await handleTestFileStart(payload);
@@ -2538,20 +2767,12 @@ export const runBrowserController = async (
     },
     async onTestFileComplete(payload: TestFileResult) {
       await handleTestFileComplete(payload);
-
-      completedTests++;
-      if (completedTests >= allTestFiles.length && resolveAllTests) {
-        resolveAllTests();
-      }
     },
     async onLog(payload: LogPayload) {
       await handleLog(payload);
     },
     async onFatal(payload: FatalPayload) {
       await handleFatal(payload);
-      if (resolveAllTests) {
-        resolveAllTests();
-      }
     },
     async dispatch(request: BrowserDispatchRequest) {
       // Headed/container path now shares the same dispatch contract as headless.
@@ -2593,31 +2814,33 @@ export const runBrowserController = async (
     );
   }
 
-  // Wait for all tests to complete
-  // Calculate total timeout based on config: max testTimeout * file count + buffer
-  const maxTestTimeout = Math.max(
-    ...browserProjects.map((p) => p.normalizedConfig.testTimeout ?? 5000),
-  );
-  const totalTimeoutMs = maxTestTimeout * allTestFiles.length + 30_000;
-
-  let timeoutId: ReturnType<typeof setTimeout> | undefined;
-  const testTimeout = new Promise<void>((resolve) => {
-    timeoutId = setTimeout(() => {
-      logger.log(
-        color.yellow(
-          `\nTest execution timeout after ${totalTimeoutMs / 1000}s. ` +
-            `Completed: ${completedTests}/${allTestFiles.length}\n`,
-        ),
-      );
-      resolve();
-    }, totalTimeoutMs);
-  });
+  enqueueHeadedReload = async (
+    file: TestFileInfo,
+    testNamePattern?: string,
+  ): Promise<void> => {
+    return headedReloadQueue.enqueue(async () => {
+      if (fatalError) {
+        return;
+      }
+      await reloadTestFileWithTimeout(file, testNamePattern);
+    });
+  };
 
   const testStart = Date.now();
-  await Promise.race([allTestsPromise, testTimeout]);
+  try {
+    await waitForRunnerFramesReady(
+      currentTestFiles.map((file) => file.testPath),
+    );
 
-  if (timeoutId) {
-    clearTimeout(timeoutId);
+    for (const file of currentTestFiles) {
+      await enqueueHeadedReload(file);
+      if (fatalError) {
+        break;
+      }
+    }
+  } catch (error) {
+    fatalError = fatalError ?? toError(error);
+    ensureProcessExitCode(1);
   }
 
   const testTime = Date.now() - testStart;
@@ -2642,7 +2865,11 @@ export const runBrowserController = async (
           context.updateReporterResultState([], [], deletedTestPaths);
         }
         watchContext.lastTestFiles = rerunPlan.currentTestFiles;
-        await rpcManager.notifyTestFileUpdate(rerunPlan.currentTestFiles);
+        currentTestFiles = rerunPlan.currentTestFiles;
+        await rpcManager.notifyTestFileUpdate(currentTestFiles);
+        await waitForRunnerFramesReady(
+          currentTestFiles.map((file) => file.testPath),
+        );
       }
 
       if (rerunPlan.normalizedAffectedTestFiles.length > 0) {
@@ -2659,7 +2886,7 @@ export const runBrowserController = async (
 
         try {
           for (const testFile of rerunPlan.normalizedAffectedTestFiles) {
-            await rpcManager.reloadTestFile(testFile);
+            await enqueueHeadedReload(getTestFileInfo(testFile));
           }
         } catch (error) {
           rerunError = toError(error);
@@ -2683,9 +2910,13 @@ export const runBrowserController = async (
                 ? [rerunFatalError]
                 : undefined,
           });
+          logBrowserWatchReadyMessage(enableCliShortcuts);
         }
       } else if (!rerunPlan.filesChanged) {
         logger.log(color.cyan('Tests will be re-executed automatically\n'));
+        logBrowserWatchReadyMessage(enableCliShortcuts);
+      } else {
+        logBrowserWatchReadyMessage(enableCliShortcuts);
       }
     };
   }
@@ -2746,9 +2977,7 @@ export const runBrowserController = async (
   // Enable watch hooks AFTER initial test run to avoid duplicate runs
   if (isWatchMode && triggerRerun) {
     watchContext.hooksEnabled = true;
-    logger.log(
-      color.cyan('\nWatch mode enabled - will re-run tests on file changes\n'),
-    );
+    logBrowserWatchReadyMessage(enableCliShortcuts);
   }
 
   return result;

package/src/watchCliShortcuts.ts

@@ -0,0 +1,77 @@
+import { color, logger } from '@rstest/core/browser';
+
+const isTTY = (): boolean => Boolean(process.stdin.isTTY && !process.env.CI);
+
+export const isBrowserWatchCliShortcutsEnabled = (): boolean => isTTY();
+
+export const getBrowserWatchCliShortcutsHintMessage = (): string => {
+  return `  ${color.dim('press')} ${color.bold('q')} ${color.dim('to quit')}\n`;
+};
+
+export const logBrowserWatchReadyMessage = (
+  enableCliShortcuts: boolean,
+): void => {
+  logger.log(color.green('  Waiting for file changes...'));
+
+  if (enableCliShortcuts) {
+    logger.log(getBrowserWatchCliShortcutsHintMessage());
+  }
+};
+
+export async function setupBrowserWatchCliShortcuts({
+  close,
+}: {
+  close: () => Promise<void>;
+}): Promise<() => void> {
+  const { emitKeypressEvents } = await import('node:readline');
+
+  emitKeypressEvents(process.stdin);
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdin.setEncoding('utf8');
+
+  let isClosing = false;
+
+  const handleKeypress = (
+    str: string,
+    key: { name: string; ctrl: boolean },
+  ) => {
+    if (key.ctrl && key.name === 'c') {
+      process.kill(process.pid, 'SIGINT');
+      return;
+    }
+
+    if (key.ctrl && key.name === 'z') {
+      if (process.platform !== 'win32') {
+        process.kill(process.pid, 'SIGTSTP');
+      }
+      return;
+    }
+
+    if (str !== 'q' || isClosing) {
+      return;
+    }
+
+    // TODO: Support more browser watch shortcuts only after this path is
+    // refactored to share the same shortcut model as node mode.
+    isClosing = true;
+    void (async () => {
+      try {
+        await close();
+      } finally {
+        process.exit(0);
+      }
+    })();
+  };
+
+  process.stdin.on('keypress', handleKeypress);
+
+  return () => {
+    try {
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+    } catch {}
+
+    process.stdin.off('keypress', handleKeypress);
+  };
+}

package/dist/browser-container/container-static/js/101.36a8ccdf84.js.LICENSE.txt

@@ -1 +0,0 @@
-/*! LICENSE: 101.36a8ccdf84.js.LICENSE.txt */

package/dist/browser-container/container-static/js/lib-react.dcf2a5e57a.js.LICENSE.txt

@@ -1 +0,0 @@
-/*! LICENSE: lib-react.dcf2a5e57a.js.LICENSE.txt */