@rstest/browser 0.11.4 → 0.11.5

package/src/hostController.ts

@@ -1789,6 +1789,55 @@ const createBrowserRuntime = async ({
     }
   };
 
+  const serveContainerRoute = async (
+    req: IncomingMessage,
+    res: ServerResponse,
+    next: () => void,
+  ): Promise<void> => {
+    if (!req.url) {
+      next();
+      return;
+    }
+
+    const url = new URL(req.url, 'http://localhost');
+    if (url.pathname === '/') {
+      if (await respondWithDevServerHtml(url, res)) {
+        return;
+      }
+
+      const html =
+        injectedContainerHtml ||
+        containerHtmlTemplate?.replace(OPTIONS_PLACEHOLDER, 'null');
+
+      if (html) {
+        res.setHeader('Content-Type', 'text/html');
+        res.end(html);
+        return;
+      }
+
+      res.statusCode = 502;
+      res.end('Container UI is not available.');
+      return;
+    }
+
+    if (url.pathname.startsWith('/container-static/')) {
+      if (await proxyDevServerAsset(req, res)) {
+        return;
+      }
+
+      if (serveContainer) {
+        serveContainer(req, res, next);
+        return;
+      }
+
+      res.statusCode = 502;
+      res.end('Container assets are not available.');
+      return;
+    }
+
+    next();
+  };
+
   // ---- Build one isolated rsbuild instance + dev server per project ----
   const buildProjectServer = async (
     project: ProjectContext,
@@ -1846,6 +1895,13 @@ const createBrowserRuntime = async ({
             project.normalizedConfig.browser.port ??
             (isContainerServer ? 4000 : 0),
           strictPort: project.normalizedConfig.browser.strictPort,
+          // User plugins may emit index.html; register before Rsbuild's HTML
+          // completion middleware so `/` remains owned by the Browser UI.
+          setup: isContainerServer
+            ? ({ server }) => {
+                server.middlewares.use(serveContainerRoute);
+              }
+            : undefined,
         },
         dev: createBrowserRsbuildDevConfig(enableHmr),
         environments: {
@@ -2196,43 +2252,6 @@ const createBrowserRuntime = async ({
           }
           return;
         }
-        // Container UI HTML + static assets are served by the container origin
-        // only. Per-project runner servers expose just /runner.html + assets.
-        if (isContainerServer) {
-          if (url.pathname === '/') {
-            if (await respondWithDevServerHtml(url, res)) {
-              return;
-            }
-
-            const html =
-              injectedContainerHtml ||
-              containerHtmlTemplate?.replace(OPTIONS_PLACEHOLDER, 'null');
-
-            if (html) {
-              res.setHeader('Content-Type', 'text/html');
-              res.end(html);
-              return;
-            }
-
-            res.statusCode = 502;
-            res.end('Container UI is not available.');
-            return;
-          }
-          if (url.pathname.startsWith('/container-static/')) {
-            if (await proxyDevServerAsset(req, res)) {
-              return;
-            }
-
-            if (serveContainer) {
-              serveContainer(req, res, next);
-              return;
-            }
-
-            res.statusCode = 502;
-            res.end('Container assets are not available.');
-            return;
-          }
-        }
         if (url.pathname === '/runner.html') {
           res.setHeader('Content-Type', 'text/html');
           res.end(htmlTemplate);
@@ -2353,7 +2372,6 @@ export const runBrowserController = async (
   options?: BrowserTestRunOptions,
 ): Promise<BrowserTestRunResult | void> => {
   const {
-    allowEmptyWatchRun = false,
     allowEmptyRun = false,
     filesOnly = false,
     onTraceEvents,
@@ -2371,10 +2389,13 @@ export const runBrowserController = async (
   // 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.
+  // process track with the file path as the title. Keyed by project + path so
+  // concurrent projects running the same file keep separate trackers.
   const phaseTrackers = onTraceEvents
     ? new Map<string, PhaseTracker>()
     : undefined;
+  const trackerKey = (project: string, testPath: string) =>
+    `${project}\u0000${testPath}`;
   // Explicit projects input (plan output) replaces re-deriving `browser.enabled`
   // projects from `context`, whose `projects` array is mutated during planning.
   // Falls back to re-derivation only when the caller passes no list at all —
@@ -2520,47 +2541,27 @@ export const runBrowserController = async (
 
   const notifyTestRunEnd = async ({
     duration,
-    unhandledErrors,
-    filterRerunTestPaths,
+    coverage,
   }: {
     duration: {
       totalTime: number;
       buildTime: number;
       testTime: number;
     };
-    unhandledErrors?: Error[];
-    filterRerunTestPaths?: string[];
+    coverage?: CoverageMapData;
   }): Promise<void> => {
     if (!isWatchMode) {
       return;
     }
 
-    // Merge per-file coverage into a single CoverageMapData for reporters
-    let mergedCoverage: CoverageMapData | undefined;
-    if (coverageProvider) {
-      const coverageMap = coverageProvider.createCoverageMap();
-      let hasCoverage = false;
-      for (const result of context.reporterResults.results) {
-        if (result.coverage) {
-          coverageMap.merge(result.coverage);
-          hasCoverage = true;
-        }
-      }
-      if (hasCoverage) {
-        mergedCoverage = coverageMap.toJSON();
-      }
-    }
-
     for (const reporter of context.reporters) {
       await reporter.onTestRunEnd?.({
         results: context.reporterResults.results,
-        coverage: mergedCoverage,
+        coverage,
         testResults: context.reporterResults.testResults,
         duration,
         snapshotSummary: context.snapshotManager.summary,
         getSourcemap: getBrowserSourcemap,
-        unhandledErrors,
-        filterRerunTestPaths,
       });
     }
   };
@@ -2601,7 +2602,6 @@ export const runBrowserController = async (
     (total, item) => total + item.testFiles.length,
     0,
   );
-  const shouldKeepWatchingWithEmptySet = isWatchMode && allowEmptyWatchRun;
   const shouldInitializeEmptyBrowserHooks =
     totalTests === 0 && hasUserRstestConfigPlugins(browserProjects);
 
@@ -2621,16 +2621,14 @@ export const runBrowserController = async (
     };
   };
 
-  const reportEmptyTestSet = (): boolean => {
+  const reportEmptyTestSet = (): void => {
     const code = context.normalizedConfig.passWithNoTests ? 0 : 1;
     if (isWatchMode || !allowEmptyRun) {
-      const message = shouldKeepWatchingWithEmptySet
-        ? 'No test files found.'
-        : getNoTestFilesMessage({
-            context,
-            code,
-            defaultMessage: `No test files found, exiting with code ${code}.`,
-          });
+      const message = getNoTestFilesMessage({
+        context,
+        code,
+        defaultMessage: `No test files found, exiting with code ${code}.`,
+      });
       if (code === 0) {
         logger.log(color.yellow(message));
       } else {
@@ -2653,22 +2651,14 @@ export const runBrowserController = async (
     // In non-watch runs the host returns a void outcome and core's
     // `reportNoTestFiles` owns the exit code and the no-test reporter lifecycle;
     // the host must not set the code itself. Watch keeps its own exit code.
-    if (
-      isWatchMode &&
-      code !== 0 &&
-      !shouldKeepWatchingWithEmptySet &&
-      !allowEmptyRun
-    ) {
+    if (isWatchMode && code !== 0 && !allowEmptyRun) {
       ensureProcessExitCode(code);
     }
-
-    return !shouldKeepWatchingWithEmptySet;
   };
 
   if (totalTests === 0 && !shouldInitializeEmptyBrowserHooks) {
-    if (reportEmptyTestSet()) {
-      return allowEmptyRun ? createEmptyRunResult() : undefined;
-    }
+    reportEmptyTestSet();
+    return allowEmptyRun ? createEmptyRunResult() : undefined;
   }
 
   if (!filesOnly) {
@@ -2795,23 +2785,19 @@ export const runBrowserController = async (
     unhandledErrors?: Error[];
   }): Promise<void> => {
     const rerunPathSet = new Set(rerunTestPaths);
-    // Reporter coverage spans the whole session (unaffected files keep their
-    // last coverage), matching the previous self-finalize payload. The merge
-    // must not strip `result.coverage`, or later reruns would lose it.
-    let sessionCoverage: CoverageMapData | undefined;
-    const coverageMap = buildBrowserCoverageMap(
-      context.reporterResults.results,
-      coverageProvider,
-      { keepResultCoverage: true },
+    const rerunResults = context.reporterResults.results.filter((result) =>
+      rerunPathSet.has(result.testPath),
     );
+    // Watch coverage is per-cycle on both transports: only the files this
+    // rerun executed are reported.
+    let rerunCoverage: CoverageMapData | undefined;
+    const coverageMap = buildBrowserCoverageMap(rerunResults, coverageProvider);
     if (coverageMap && coverageMap.files().length > 0) {
-      sessionCoverage = coverageMap.toJSON();
+      rerunCoverage = coverageMap.toJSON();
     }
 
     const outcome: ExecutorCycleOutcome = {
-      results: context.reporterResults.results.filter((result) =>
-        rerunPathSet.has(result.testPath),
-      ),
+      results: rerunResults,
       testResults: context.reporterResults.testResults.filter((result) =>
         rerunPathSet.has(result.testPath),
       ),
@@ -2821,7 +2807,7 @@ export const runBrowserController = async (
         buildTime: drainPendingBuildTime(watchState),
         testTime,
       },
-      coverage: sessionCoverage ? { map: sessionCoverage } : undefined,
+      coverage: rerunCoverage ? { map: rerunCoverage } : undefined,
       resolveSourcemap: resolveBrowserSourcemap,
     };
 
@@ -2858,7 +2844,8 @@ export const runBrowserController = async (
     };
   }
 
-  if (totalTests === 0 && reportEmptyTestSet()) {
+  if (totalTests === 0) {
+    reportEmptyTestSet();
     await destroyBrowserRuntime(runtime);
     return allowEmptyRun ? createEmptyRunResult() : undefined;
   }
@@ -3022,22 +3009,18 @@ export const runBrowserController = async (
       createRunnerEventSink(context, project.normalizedConfig),
     ]),
   );
-  const firstBrowserSink = runnerSinks.get(browserProjects[0]!.name)!;
-
-  // testPath -> owning project name, stamped from the authoritative client
-  // file-start event (it carries the manifest-resolved projectName) before any
-  // other per-file event for that path fires — including on watch reruns, so the
-  // mapping stays correct when a rerun adds a file. Fully eliminating this map in
-  // favor of a project stamp on every wire event is deferred (it would add
-  // `project` to the shared `TestResult`/`TestFileResult` payloads).
-  const projectNameByTestPath = new Map<string, string>();
-
-  const sinkForProjectName = (projectName: string): RunnerEventSink =>
-    runnerSinks.get(projectName) ?? firstBrowserSink;
-
-  const sinkForTestPath = (testPath: string): RunnerEventSink => {
-    const projectName = projectNameByTestPath.get(testPath);
-    return projectName ? sinkForProjectName(projectName) : firstBrowserSink;
+  // Every per-file wire payload carries its owning project name, so routing
+  // never derives a project from a test path — concurrent projects can run the
+  // same file, and a path-keyed lookup would attribute events to the wrong one.
+  // The client resolves its project from the host's own manifest, so a miss is
+  // a protocol bug; fail loudly rather than route through another project's
+  // config.
+  const sinkForProjectName = (projectName: string): RunnerEventSink => {
+    const sink = runnerSinks.get(projectName);
+    if (!sink) {
+      throw new Error(`No runner event sink for project "${projectName}"`);
+    }
+    return sink;
   };
 
   // Silent-console buffering runs through the shared controller — the same
@@ -3054,7 +3037,7 @@ export const runBrowserController = async (
       disableConsoleIntercept: context.normalizedConfig.disableConsoleIntercept,
     },
     emitInterceptedLog: (log) =>
-      sinkForTestPath(log.testPath).onConsoleLog(log),
+      sinkForProjectName(log.project).onConsoleLog(log),
     writeOriginalLog: () => {},
   });
 
@@ -3089,7 +3072,6 @@ export const runBrowserController = async (
   const handleTestFileStart = async (
     payload: TestFileStartPayload,
   ): Promise<void> => {
-    projectNameByTestPath.set(payload.testPath, payload.projectName);
     if (phaseTrackers) {
       const tracker = new PhaseTracker({
         trace: {
@@ -3099,13 +3081,17 @@ export const runBrowserController = async (
         pid: nextBrowserFilePid++,
       });
       tracker.transition('prepare');
-      phaseTrackers.set(payload.testPath, tracker);
+      phaseTrackers.set(
+        trackerKey(payload.projectName, payload.testPath),
+        tracker,
+      );
     }
     // The client sends `{ testPath, projectName }`; the sink adapter builds the
     // `TestFileInfo` the reporters and stateManager expect.
     await sinkForProjectName(payload.projectName).onTestFileStart({
       testId: getFileTaskId(payload.testPath),
       testPath: payload.testPath,
+      project: payload.projectName,
       tests: [],
     });
   };
@@ -3113,22 +3099,28 @@ export const runBrowserController = async (
   const handleTestFileReady = async (
     payload: TestFileReadyPayload,
   ): Promise<void> => {
-    phaseTrackers?.get(payload.testPath)?.transition('tests');
-    await sinkForTestPath(payload.testPath).onTestFileReady(payload);
+    phaseTrackers
+      ?.get(trackerKey(payload.project, payload.testPath))
+      ?.transition('tests');
+    await sinkForProjectName(payload.project).onTestFileReady(payload);
   };
 
   const handleTestSuiteStart = async (
     payload: TestSuiteStartPayload,
   ): Promise<void> => {
-    phaseTrackers?.get(payload.testPath)?.recordSuiteStart(payload);
-    await sinkForTestPath(payload.testPath).onTestSuiteStart(payload);
+    phaseTrackers
+      ?.get(trackerKey(payload.project, payload.testPath))
+      ?.recordSuiteStart(payload);
+    await sinkForProjectName(payload.project).onTestSuiteStart(payload);
   };
 
   const handleTestSuiteResult = async (
     payload: TestSuiteResultPayload,
   ): Promise<void> => {
-    phaseTrackers?.get(payload.testPath)?.recordSuiteResult(payload);
-    await sinkForTestPath(payload.testPath).onTestSuiteResult(payload);
+    phaseTrackers
+      ?.get(trackerKey(payload.project, payload.testPath))
+      ?.recordSuiteResult(payload);
+    await sinkForProjectName(payload.project).onTestSuiteResult(payload);
 
     if (context.normalizedConfig.silent === 'passed-only') {
       silentConsoleController.flushBufferedLogsForTask({
@@ -3144,15 +3136,19 @@ export const runBrowserController = async (
   const handleTestCaseStart = async (
     payload: TestCaseStartPayload,
   ): Promise<void> => {
-    phaseTrackers?.get(payload.testPath)?.recordCaseStart(payload);
+    phaseTrackers
+      ?.get(trackerKey(payload.project, payload.testPath))
+      ?.recordCaseStart(payload);
     // Fire-and-forget on both transports (the sink does not await case-start).
-    sinkForTestPath(payload.testPath).onTestCaseStart(payload);
+    sinkForProjectName(payload.project).onTestCaseStart(payload);
   };
 
   const handleTestCaseResult = async (payload: TestResult): Promise<void> => {
     caseResults.push(payload);
-    phaseTrackers?.get(payload.testPath)?.recordCaseResult(payload);
-    await sinkForTestPath(payload.testPath).onTestCaseResult(payload);
+    phaseTrackers
+      ?.get(trackerKey(payload.project, payload.testPath))
+      ?.recordCaseResult(payload);
+    await sinkForProjectName(payload.project).onTestCaseResult(payload);
 
     if (context.normalizedConfig.silent === 'passed-only') {
       silentConsoleController.flushBufferedLogsForTask({
@@ -3172,12 +3168,13 @@ export const runBrowserController = async (
     context.updateReporterResultState([payload], payload.results);
 
     if (phaseTrackers) {
-      const tracker = phaseTrackers.get(payload.testPath);
+      const key = trackerKey(payload.project, payload.testPath);
+      const tracker = phaseTrackers.get(key);
       if (tracker) {
         tracker.end();
         const events = tracker.getTraceEvents();
         if (events) onTraceEvents?.(events);
-        phaseTrackers.delete(payload.testPath);
+        phaseTrackers.delete(key);
       }
     }
 
@@ -3193,7 +3190,7 @@ export const runBrowserController = async (
 
     // Feeds stateManager, fans out onTestFileResult to reporters, and ingests
     // payload.snapshotResult (the snapshotManager.add moved into the sink).
-    await sinkForTestPath(payload.testPath).onTestFileResult(payload);
+    await sinkForProjectName(payload.project).onTestFileResult(payload);
     // In non-watch runs core owns the exit code via `finalizeRunCycle` (the
     // failing file rides the returned outcome); watch reruns set it here.
     if (isWatchMode && payload.status === 'fail') {
@@ -3211,6 +3208,7 @@ export const runBrowserController = async (
       taskParentNames: payload.taskParentNames,
       taskType: payload.taskType,
       testPath: payload.testPath,
+      project: payload.projectName,
       type: payload.type,
       trace: payload.trace,
     };
@@ -3671,71 +3669,6 @@ export const runBrowserController = async (
 
     awaitHeadlessRerunIdle = () => latestRerunScheduler.whenIdle();
 
-    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: !isWatchMode
-          ? async () => {
-              sessionRegistry.clear();
-              await destroyBrowserRuntime(runtime);
-            }
-          : undefined,
-        watch: watchHandles,
-      };
-
-      if (isWatchMode) {
-        await notifyTestRunEnd({ duration });
-      }
-
-      if (isWatchMode) {
-        triggerRerun = async () => {
-          const newProjectEntries = await collectProjectEntries(context);
-          const rerunPlan = planWatchRerun({
-            projectEntries: newProjectEntries,
-            previousTestFiles: watchState.lastTestFiles,
-            affectedTestFiles: drainPendingAffectedTestFiles(watchState),
-          });
-
-          if (rerunPlan.filesChanged) {
-            watchState.lastTestFiles = rerunPlan.currentTestFiles;
-            if (rerunPlan.currentTestFiles.length === 0) {
-              logger.log(
-                color.cyan('No browser test files remain after update.\n'),
-              );
-              logWatchReadyMessage(context, enableCliShortcuts);
-              return;
-            }
-
-            logger.log(
-              color.cyan(
-                `Test file set changed, re-running ${rerunPlan.currentTestFiles.length} file(s)...\n`,
-              ),
-            );
-            await latestRerunScheduler.enqueueLatest(
-              rerunPlan.currentTestFiles,
-            );
-            return;
-          }
-
-          logWatchReadyMessage(context, enableCliShortcuts);
-        };
-        watchState.hooksEnabled = true;
-        logWatchReadyMessage(context, enableCliShortcuts);
-      }
-
-      return result;
-    }
-
     const testStart = Date.now();
     await runFilesWithPool(allTestFiles);
     const testTime = Date.now() - testStart;
@@ -3823,6 +3756,15 @@ export const runBrowserController = async (
       ensureProcessExitCode(1);
     }
 
+    // Fold and strip the initial cycle's coverage (the same per-cycle fold
+    // reruns get in `finalizeWatchRerun`); the map rides on the result so the
+    // browser-only watch path can report it without re-merging. Non-watch runs
+    // keep `result.coverage` intact for the executor's outcome fold.
+    const cycleCoverageMap =
+      isWatchMode && coverageProvider
+        ? buildBrowserCoverageMap(reporterResults, coverageProvider)
+        : undefined;
+
     const result = {
       results: reporterResults,
       testResults: caseResults,
@@ -3833,12 +3775,18 @@ export const runBrowserController = async (
       // `closeHeadlessRuntime` is already `undefined` in watch mode, so the
       // non-watch caller (core) receives the deferred close and watch does not.
       close: closeHeadlessRuntime,
+      coverage: cycleCoverageMap,
       watch: watchHandles,
     };
 
     if (isWatchMode) {
       try {
-        await notifyTestRunEnd({ duration });
+        await notifyTestRunEnd({
+          duration,
+          coverage: cycleCoverageMap?.files().length
+            ? cycleCoverageMap.toJSON()
+            : undefined,
+        });
       } finally {
         await closeHeadlessRuntime?.();
       }
@@ -4354,6 +4302,12 @@ export const runBrowserController = async (
     ensureProcessExitCode(1);
   }
 
+  // Same per-cycle fold-and-strip as the headless path above.
+  const cycleCoverageMap =
+    isWatchMode && coverageProvider
+      ? buildBrowserCoverageMap(reporterResults, coverageProvider)
+      : undefined;
+
   const result = {
     results: reporterResults,
     testResults: caseResults,
@@ -4364,12 +4318,18 @@ export const runBrowserController = async (
     // `closeContainerRuntime` is already `undefined` in watch mode, so the
     // non-watch caller (core) receives the deferred close and watch does not.
     close: closeContainerRuntime,
+    coverage: cycleCoverageMap,
     watch: watchHandles,
   };
 
   if (isWatchMode) {
     try {
-      await notifyTestRunEnd({ duration });
+      await notifyTestRunEnd({
+        duration,
+        coverage: cycleCoverageMap?.files().length
+          ? cycleCoverageMap.toJSON()
+          : undefined,
+      });
     } finally {
       await closeContainerRuntime?.();
     }

package/src/protocol.ts

@@ -69,6 +69,12 @@ export type BrowserExecutionMode = 'run' | 'collect';
 export type BrowserLogPayload = {
   level: 'log' | 'warn' | 'error' | 'info' | 'debug';
   content: string;
+  /**
+   * Owning project, resolved by the client from its manifest. The host must
+   * not re-derive it from `testPath` — concurrent projects can run the same
+   * file, so a path-keyed lookup can attribute the log to the wrong project.
+   */
+  projectName: string;
   taskId?: string;
   taskName?: string;
   taskParentNames?: string[];