@rstest/browser 0.9.9 → 0.10.0

package/src/hostController.ts

@@ -12,16 +12,19 @@ import {
   color,
   createCoverageProvider,
   type FormattedError,
+  getNoTestFilesMessage,
   getSetupFiles,
   getTestEntries,
   isDebug,
   type ListCommandResult,
   loadCoverageProvider,
   logger,
+  PhaseTracker,
   type ProjectContext,
   type Reporter,
   type Rstest,
   type RuntimeConfig,
+  resolveProjectBuildCache,
   rsbuild,
   serializableConfig,
   type Test,
@@ -94,6 +97,18 @@ type RsbuildInstance = rsbuild.RsbuildInstance;
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const OPTIONS_PLACEHOLDER = '__RSTEST_OPTIONS_PLACEHOLDER__';
 
+/**
+ * Monotonic counter for synthetic per-file Perfetto `pid` values in `--trace`
+ * mode. Browser host runs every test file inside the same Node process, so
+ * without an override every file would emit events under the same `pid` and
+ * share a single track labelled `worker <hostPid>`. Giving each file its own
+ * synthetic `pid` makes the track title surface the file path instead,
+ * matching node mode's default `isolate: true` behavior. The 1_000_000_000
+ * base keeps each synthetic `pid` well clear of real OS `pid` values in
+ * mixed-mode traces.
+ */
+let nextBrowserFilePid = 1_000_000_000;
+
 /**
  * Serialize JSON for inline <script> injection.
  * Escapes '<' to prevent accidental </script> break-out.
@@ -154,6 +169,10 @@ type TestFileStartPayload = {
 type LogPayload = {
   level: 'log' | 'warn' | 'error' | 'info' | 'debug';
   content: string;
+  taskId?: string;
+  taskName?: string;
+  taskParentNames?: string[];
+  taskType?: 'file' | 'suite' | 'case';
   testPath: string;
   type: 'stdout' | 'stderr';
   trace?: string;
@@ -186,6 +205,14 @@ type DeferredPromise<T> = {
   reject: (reason?: unknown) => void;
 };
 
+const getFileTaskId = (testPath: string): string => {
+  return `file:${testPath}`;
+};
+
+const getBufferedLogTaskId = (log: UserConsoleLog): string => {
+  return log.taskId ?? getFileTaskId(log.testPath);
+};
+
 const createDeferredPromise = <T>(): DeferredPromise<T> => {
   let resolve!: DeferredPromise<T>['resolve'];
   let reject!: DeferredPromise<T>['reject'];
@@ -506,8 +533,9 @@ const applyDefaultWatchOptions = (
     rspackConfig.watchOptions.ignored.push('**/.git', '**/node_modules');
   }
 
-  rspackConfig.output?.path &&
+  if (rspackConfig.output?.path) {
     rspackConfig.watchOptions.ignored.push(rspackConfig.output.path);
+  }
 };
 
 type LazyCompilationModule = {
@@ -796,10 +824,17 @@ const getRuntimeConfigFromProject = (
     logHeapUsage,
     chaiConfig,
     includeTaskLocation,
+    silent,
   } = project.normalizedConfig;
 
   return {
-    env,
+    // Propagate NODE_ENV from the host so `import.meta.env.NODE_ENV` resolves
+    // to `'test'` in browser tests (matches Node mode). User-supplied `env`
+    // wins so explicit overrides still take effect.
+    env: {
+      NODE_ENV: process.env.NODE_ENV,
+      ...env,
+    },
     testNamePattern,
     testTimeout,
     hookTimeout,
@@ -822,6 +857,7 @@ const getRuntimeConfigFromProject = (
     logHeapUsage,
     chaiConfig,
     includeTaskLocation,
+    silent,
   };
 };
 
@@ -915,6 +951,7 @@ const collectProjectEntries = async (
         rootPath: context.rootPath,
         projectRoot: project.rootPath,
         fileFilters: context.fileFilters || [],
+        fileFilterMode: context.fileFilterMode,
       });
 
       const setup = getSetupFiles(setupFiles, project.rootPath);
@@ -1279,6 +1316,10 @@ const createBrowserRuntime = async ({
             }
 
             const userRsbuildConfig = project.normalizedConfig;
+            const buildCache = resolveProjectBuildCache({
+              context,
+              project,
+            });
             const setupFiles = Object.values(
               getSetupFiles(
                 project.normalizedConfig.setupFiles,
@@ -1286,53 +1327,65 @@ const createBrowserRuntime = async ({
               ),
             );
             // Merge order: current config -> userConfig -> rstest required config (highest priority)
-            const merged = mergeEnvironmentConfig(config, userRsbuildConfig, {
-              resolve: {
-                alias: rstestInternalAliases,
+            const merged = mergeEnvironmentConfig(
+              config,
+              {
+                ...userRsbuildConfig,
+                performance: buildCache
+                  ? {
+                      ...userRsbuildConfig.performance,
+                      buildCache,
+                    }
+                  : userRsbuildConfig.performance,
               },
-              source: {
-                define: {
-                  'process.env': 'globalThis[Symbol.for("rstest.env")]',
-                  'import.meta.env': 'globalThis[Symbol.for("rstest.env")]',
+              {
+                resolve: {
+                  alias: rstestInternalAliases,
                 },
-              },
-              output: {
-                target: 'web',
-                // Enable source map for inline snapshot support
-                sourceMap: {
-                  js: 'source-map',
+                source: {
+                  define: {
+                    'process.env': 'globalThis[Symbol.for("rstest.env")]',
+                    'import.meta.env': 'globalThis[Symbol.for("rstest.env")]',
+                  },
                 },
-              },
-              tools: {
-                rspack: (rspackConfig) => {
-                  rspackConfig.mode = 'development';
-                  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
-                  const browserRuntimeDir = dirname(browserRuntimePath);
-                  rspackConfig.module = rspackConfig.module || {};
-                  rspackConfig.module.rules = rspackConfig.module.rules || [];
-                  rspackConfig.module.rules.unshift({
-                    test: /\.js$/,
-                    include: browserRuntimeDir,
-                    extractSourceMap: true,
-                  });
-
-                  if (isDebug()) {
-                    logger.log(
-                      `[rstest:browser] extractSourceMap rule added for: ${browserRuntimeDir}`,
-                    );
-                  }
+                output: {
+                  target: 'web',
+                  // Enable source map for inline snapshot support
+                  sourceMap: {
+                    js: 'source-map',
+                  },
+                },
+                tools: {
+                  rspack: (rspackConfig) => {
+                    rspackConfig.mode = 'development';
+                    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
+                    const browserRuntimeDir = dirname(browserRuntimePath);
+                    rspackConfig.module = rspackConfig.module || {};
+                    rspackConfig.module.rules = rspackConfig.module.rules || [];
+                    rspackConfig.module.rules.unshift({
+                      test: /\.js$/,
+                      include: browserRuntimeDir,
+                      extractSourceMap: true,
+                    });
+
+                    if (isDebug()) {
+                      logger.log(
+                        `[rstest:browser] extractSourceMap rule added for: ${browserRuntimeDir}`,
+                      );
+                    }
+                  },
                 },
               },
-            });
+            );
 
             // Completely overwrite entry to prevent Rsbuild default entry detection from taking effect.
             // In browser mode, entry is fully controlled by rstest (not user's src/index.ts).
@@ -1654,8 +1707,22 @@ export const runBrowserController = async (
   context: Rstest,
   options?: BrowserTestRunOptions,
 ): Promise<BrowserTestRunResult | void> => {
-  const { skipOnTestRunEnd = false } = options ?? {};
+  const {
+    skipOnTestRunEnd = false,
+    allowEmptyWatchRun = false,
+    onTraceEvents,
+  } = options ?? {};
   const buildStart = Date.now();
+  const isWatchMode = context.command === 'watch';
+
+  // Per-file PhaseTrackers, populated only when `--trace` is on (caller
+  // passes `onTraceEvents`). The browser host shares one Node process across
+  // every test file, so each tracker is assigned a synthetic per-file pid
+  // (`nextBrowserFilePid`) that lets Perfetto render each file as its own
+  // process track with the file path as the title.
+  const phaseTrackers = onTraceEvents
+    ? new Map<string, PhaseTracker>()
+    : undefined;
   const browserProjects = getBrowserProjects(context);
   const useHeadlessDirect = browserProjects.every(
     (project) => project.normalizedConfig.browser.headless,
@@ -1872,27 +1939,47 @@ export const runBrowserController = async (
     (total, item) => total + item.testFiles.length,
     0,
   );
+  const shouldKeepWatchingWithEmptySet = isWatchMode && allowEmptyWatchRun;
 
   if (totalTests === 0) {
     const code = context.normalizedConfig.passWithNoTests ? 0 : 1;
     if (!skipOnTestRunEnd) {
-      const message = `No test files found, exiting with code ${code}.`;
+      const message = shouldKeepWatchingWithEmptySet
+        ? 'No test files found.'
+        : getNoTestFilesMessage({
+            context,
+            code,
+            defaultMessage: `No test files found, exiting with code ${code}.`,
+          });
       if (code === 0) {
         logger.log(color.yellow(message));
       } else {
         logger.error(color.red(message));
       }
+
+      if (context.relatedFilters?.length) {
+        logger.log(
+          color.gray('related: '),
+          context.relatedFilters.join(color.gray(', ')),
+        );
+      } else if (context.fileFilters?.length) {
+        logger.log(
+          color.gray('filter: '),
+          context.fileFilters.join(color.gray(', ')),
+        );
+      }
     }
 
-    if (code !== 0) {
+    if (code !== 0 && !shouldKeepWatchingWithEmptySet) {
       ensureProcessExitCode(code);
     }
-    return;
+    if (!shouldKeepWatchingWithEmptySet) {
+      return;
+    }
   }
 
   await notifyTestRunStart();
 
-  const isWatchMode = context.command === 'watch';
   const enableCliShortcuts = isWatchMode && isBrowserWatchCliShortcutsEnabled();
   const browserTempOutputRoot = context.normalizedConfig.output.distPath.root;
   const tempDir =
@@ -2123,9 +2210,21 @@ export const runBrowserController = async (
   const handleTestFileStart = async (
     payload: TestFileStartPayload,
   ): Promise<void> => {
+    if (phaseTrackers) {
+      const tracker = new PhaseTracker({
+        trace: {
+          testPath: payload.testPath,
+          project: payload.projectName,
+        },
+        pid: nextBrowserFilePid++,
+      });
+      tracker.transition('prepare');
+      phaseTrackers.set(payload.testPath, tracker);
+    }
     await Promise.all(
       context.reporters.map((reporter) =>
         (reporter as Reporter).onTestFileStart?.({
+          testId: getFileTaskId(payload.testPath),
           testPath: payload.testPath,
           tests: [],
         }),
@@ -2136,6 +2235,7 @@ export const runBrowserController = async (
   const handleTestFileReady = async (
     payload: TestFileReadyPayload,
   ): Promise<void> => {
+    phaseTrackers?.get(payload.testPath)?.transition('tests');
     await Promise.all(
       context.reporters.map((reporter) =>
         (reporter as Reporter).onTestFileReady?.(payload),
@@ -2146,6 +2246,7 @@ export const runBrowserController = async (
   const handleTestSuiteStart = async (
     payload: TestSuiteStartPayload,
   ): Promise<void> => {
+    phaseTrackers?.get(payload.testPath)?.recordSuiteStart(payload);
     await Promise.all(
       context.reporters.map((reporter) =>
         (reporter as Reporter).onTestSuiteStart?.(payload),
@@ -2156,16 +2257,28 @@ export const runBrowserController = async (
   const handleTestSuiteResult = async (
     payload: TestSuiteResultPayload,
   ): Promise<void> => {
+    phaseTrackers?.get(payload.testPath)?.recordSuiteResult(payload);
     await Promise.all(
       context.reporters.map((reporter) =>
         (reporter as Reporter).onTestSuiteResult?.(payload),
       ),
     );
+
+    if (context.normalizedConfig.silent === 'passed-only') {
+      await flushBufferedLogsForTask({
+        taskId: payload.testId,
+        status: payload.status,
+        taskParentNames: payload.parentNames,
+        taskType: 'suite',
+        testPath: payload.testPath,
+      });
+    }
   };
 
   const handleTestCaseStart = async (
     payload: TestCaseStartPayload,
   ): Promise<void> => {
+    phaseTrackers?.get(payload.testPath)?.recordCaseStart(payload);
     await Promise.all(
       context.reporters.map((reporter) =>
         (reporter as Reporter).onTestCaseStart?.(payload),
@@ -2175,11 +2288,22 @@ export const runBrowserController = async (
 
   const handleTestCaseResult = async (payload: TestResult): Promise<void> => {
     caseResults.push(payload);
+    phaseTrackers?.get(payload.testPath)?.recordCaseResult(payload);
     await Promise.all(
       context.reporters.map((reporter) =>
         (reporter as Reporter).onTestCaseResult?.(payload),
       ),
     );
+
+    if (context.normalizedConfig.silent === 'passed-only') {
+      await flushBufferedLogsForTask({
+        taskId: payload.testId,
+        status: payload.status,
+        taskParentNames: payload.parentNames,
+        taskType: 'case',
+        testPath: payload.testPath,
+      });
+    }
   };
 
   const handleTestFileComplete = async (
@@ -2190,6 +2314,27 @@ export const runBrowserController = async (
     if (payload.snapshotResult) {
       context.snapshotManager.add(payload.snapshotResult);
     }
+
+    if (phaseTrackers) {
+      const tracker = phaseTrackers.get(payload.testPath);
+      if (tracker) {
+        tracker.end();
+        const events = tracker.getTraceEvents();
+        if (events) onTraceEvents?.(events);
+        phaseTrackers.delete(payload.testPath);
+      }
+    }
+
+    if (context.normalizedConfig.silent === 'passed-only') {
+      await flushBufferedLogsForTask({
+        taskId: payload.testId,
+        status: payload.status,
+        taskParentNames: payload.parentNames,
+        taskType: 'file',
+        testPath: payload.testPath,
+      });
+    }
+
     await Promise.all(
       context.reporters.map((reporter) =>
         (reporter as Reporter).onTestFileResult?.(payload),
@@ -2204,19 +2349,28 @@ export const runBrowserController = async (
     const log: UserConsoleLog = {
       content: payload.content,
       name: payload.level,
+      taskId: payload.taskId,
+      taskName: payload.taskName,
+      taskParentNames: payload.taskParentNames,
+      taskType: payload.taskType,
       testPath: payload.testPath,
       type: payload.type,
       trace: payload.trace,
     };
-    const shouldLog =
-      context.normalizedConfig.onConsoleLog?.(log.content) ?? true;
-    if (shouldLog) {
-      await Promise.all(
-        context.reporters.map((reporter) =>
-          (reporter as Reporter).onUserConsoleLog?.(log),
-        ),
-      );
+    if (context.normalizedConfig.silent === true) {
+      return;
+    }
+
+    if (context.normalizedConfig.silent === 'passed-only') {
+      bufferConsoleLog(log);
+      return;
     }
+
+    if (context.normalizedConfig.disableConsoleIntercept) {
+      return;
+    }
+
+    await emitUserConsoleLog(log);
   };
 
   const handleFatal = async (payload: FatalPayload): Promise<void> => {
@@ -2226,6 +2380,113 @@ export const runBrowserController = async (
     ensureProcessExitCode(1);
   };
 
+  const bufferedConsoleLogs = new Map<string, UserConsoleLog[]>();
+  const suiteIdsByChain = new Map<string, string>();
+
+  const getSuiteChainKey = (names: string[]): string => {
+    return names.join('\u0000');
+  };
+
+  const pushTaskId = (taskIds: string[], taskId: string): void => {
+    if (!taskIds.includes(taskId)) {
+      taskIds.push(taskId);
+    }
+  };
+
+  const shouldEmitUserConsoleLog = (log: UserConsoleLog): boolean => {
+    return context.normalizedConfig.onConsoleLog?.(log.content) !== false;
+  };
+
+  const emitUserConsoleLog = async (log: UserConsoleLog): Promise<void> => {
+    if (!shouldEmitUserConsoleLog(log)) {
+      return;
+    }
+
+    await Promise.all(
+      context.reporters.map((reporter) =>
+        (reporter as Reporter).onUserConsoleLog?.(log),
+      ),
+    );
+  };
+
+  const bufferConsoleLog = (log: UserConsoleLog): void => {
+    const taskId = getBufferedLogTaskId(log);
+    const logs = bufferedConsoleLogs.get(taskId) || [];
+    logs.push(log);
+    bufferedConsoleLogs.set(taskId, logs);
+
+    if (log.taskType === 'suite' && log.taskId) {
+      suiteIdsByChain.set(
+        getSuiteChainKey([...(log.taskParentNames || []), log.taskName || '']),
+        log.taskId,
+      );
+    }
+  };
+
+  const flushBufferedLogsForTask = async ({
+    taskId,
+    status,
+    taskParentNames,
+    taskType,
+    testPath,
+  }: {
+    taskId: string;
+    status: TestResult['status'];
+    taskParentNames?: string[];
+    taskType?: 'file' | 'suite' | 'case';
+    testPath: string;
+  }): Promise<void> => {
+    if (status !== 'fail') {
+      bufferedConsoleLogs.delete(taskId);
+      return;
+    }
+
+    const taskIdsToFlush: string[] = [];
+
+    if (taskType === 'case') {
+      pushTaskId(taskIdsToFlush, getFileTaskId(testPath));
+
+      const suiteNames = taskParentNames || [];
+      for (let i = 0; i < suiteNames.length; i++) {
+        const suiteId = suiteIdsByChain.get(
+          getSuiteChainKey(suiteNames.slice(0, i + 1)),
+        );
+
+        if (suiteId) {
+          pushTaskId(taskIdsToFlush, suiteId);
+        }
+      }
+
+      pushTaskId(taskIdsToFlush, taskId);
+    }
+
+    if (taskType === 'suite') {
+      pushTaskId(taskIdsToFlush, getFileTaskId(testPath));
+      pushTaskId(taskIdsToFlush, taskId);
+    }
+
+    if (taskType === 'file') {
+      pushTaskId(taskIdsToFlush, taskId);
+    }
+
+    for (const bufferedTaskId of taskIdsToFlush) {
+      const logs = bufferedConsoleLogs.get(bufferedTaskId);
+      if (!logs) {
+        continue;
+      }
+
+      bufferedConsoleLogs.delete(bufferedTaskId);
+
+      for (const log of logs) {
+        await Promise.all(
+          context.reporters.map((reporter) =>
+            (reporter as Reporter).onUserConsoleLog?.(log),
+          ),
+        );
+      }
+    }
+  };
+
   const runSnapshotRpc = async (
     request: SnapshotRpcRequest,
   ): Promise<unknown> => {
@@ -2612,6 +2873,69 @@ export const runBrowserController = async (
       },
     });
 
+    if (allTestFiles.length === 0) {
+      const duration = {
+        totalTime: buildTime,
+        buildTime,
+        testTime: 0,
+      };
+      const result = {
+        results: reporterResults,
+        testResults: caseResults,
+        duration,
+        hasFailure: false,
+        getSourcemap: getBrowserSourcemap,
+        resolveSourcemap: resolveBrowserSourcemap,
+        close: skipOnTestRunEnd
+          ? async () => {
+              sessionRegistry.clear();
+              await destroyBrowserRuntime(runtime);
+            }
+          : undefined,
+      };
+
+      if (!skipOnTestRunEnd) {
+        await notifyTestRunEnd({ duration });
+      }
+
+      if (isWatchMode) {
+        triggerRerun = async () => {
+          const newProjectEntries = await collectProjectEntries(context);
+          const rerunPlan = planWatchRerun({
+            projectEntries: newProjectEntries,
+            previousTestFiles: watchContext.lastTestFiles,
+            affectedTestFiles: watchContext.affectedTestFiles,
+          });
+          watchContext.affectedTestFiles = [];
+
+          if (rerunPlan.filesChanged) {
+            watchContext.lastTestFiles = rerunPlan.currentTestFiles;
+            if (rerunPlan.currentTestFiles.length === 0) {
+              logger.log(
+                color.cyan('No browser test files remain after update.\n'),
+              );
+              logBrowserWatchReadyMessage(enableCliShortcuts);
+              return;
+            }
+
+            logger.log(
+              color.cyan(
+                `Test file set changed, re-running ${rerunPlan.currentTestFiles.length} file(s)...\n`,
+              ),
+            );
+            void latestRerunScheduler.enqueueLatest(rerunPlan.currentTestFiles);
+            return;
+          }
+
+          logBrowserWatchReadyMessage(enableCliShortcuts);
+        };
+        watchContext.hooksEnabled = true;
+        logBrowserWatchReadyMessage(enableCliShortcuts);
+      }
+
+      return result;
+    }
+
     const testStart = Date.now();
     await runFilesWithPool(allTestFiles);
     const testTime = Date.now() - testStart;
@@ -3088,24 +3412,27 @@ export const runBrowserController = async (
     });
   };
 
-  const testStart = Date.now();
-  try {
-    await waitForRunnerFramesReady(
-      currentTestFiles.map((file) => file.testPath),
-    );
+  let testTime = 0;
+  if (currentTestFiles.length > 0) {
+    const testStart = Date.now();
+    try {
+      await waitForRunnerFramesReady(
+        currentTestFiles.map((file) => file.testPath),
+      );
 
-    for (const file of currentTestFiles) {
-      await enqueueHeadedReload(file);
-      if (fatalError) {
-        break;
+      for (const file of currentTestFiles) {
+        await enqueueHeadedReload(file);
+        if (fatalError) {
+          break;
+        }
       }
+    } catch (error) {
+      fatalError = fatalError ?? toError(error);
+      ensureProcessExitCode(1);
     }
-  } catch (error) {
-    fatalError = fatalError ?? toError(error);
-    ensureProcessExitCode(1);
-  }
 
-  const testTime = Date.now() - testStart;
+    testTime = Date.now() - testStart;
+  }
 
   // Define rerun logic for watch mode
   if (isWatchMode) {
@@ -3129,6 +3456,13 @@ export const runBrowserController = async (
         watchContext.lastTestFiles = rerunPlan.currentTestFiles;
         currentTestFiles = rerunPlan.currentTestFiles;
         await rpcManager.notifyTestFileUpdate(currentTestFiles);
+        if (currentTestFiles.length === 0) {
+          logger.log(
+            color.cyan('No browser test files remain after update.\n'),
+          );
+          logBrowserWatchReadyMessage(enableCliShortcuts);
+          return;
+        }
         await waitForRunnerFramesReady(
           currentTestFiles.map((file) => file.testPath),
         );