@rstest/browser 0.9.0 → 0.9.1

package/dist/index.js

@@ -1760,6 +1760,17 @@ const createHostDispatchRouter = ({ routerOptions, runnerCallbacks, runSnapshotR
     }
     return router;
 };
+const createHeadedSerialTaskQueue = ()=>{
+    let queue = Promise.resolve();
+    const enqueue = (task)=>{
+        const next = queue.then(task);
+        queue = next.catch(()=>{});
+        return next;
+    };
+    return {
+        enqueue
+    };
+};
 const createHeadlessLatestRerunScheduler = (options)=>{
     let pendingFiles = null;
     let draining = null;
@@ -2490,6 +2501,45 @@ const resolveBrowserViewportPreset = (presetId)=>{
     const size = BROWSER_VIEWPORT_PRESET_DIMENSIONS[presetId];
     return size ?? null;
 };
+const isTTY = ()=>Boolean(process.stdin.isTTY && !process.env.CI);
+const isBrowserWatchCliShortcutsEnabled = ()=>isTTY();
+const getBrowserWatchCliShortcutsHintMessage = ()=>`  ${color.dim('press')} ${color.bold('q')} ${color.dim('to quit')}\n`;
+const logBrowserWatchReadyMessage = (enableCliShortcuts)=>{
+    logger.log(color.green('  Waiting for file changes...'));
+    if (enableCliShortcuts) logger.log(getBrowserWatchCliShortcutsHintMessage());
+};
+async function setupBrowserWatchCliShortcuts({ close }) {
+    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, key)=>{
+        if (key.ctrl && 'c' === key.name) return void process.kill(process.pid, 'SIGINT');
+        if (key.ctrl && 'z' === key.name) {
+            if ('win32' !== process.platform) process.kill(process.pid, 'SIGTSTP');
+            return;
+        }
+        if ('q' !== str || isClosing) return;
+        isClosing = true;
+        (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);
+    };
+}
 const serializeTestFiles = (files)=>JSON.stringify(files.map((f)=>`${f.projectName}:${f.testPath}`).sort());
 const normalizeTestFiles = (files)=>files.map((file)=>({
             ...file,
@@ -2588,6 +2638,8 @@ const watchContext = {
     lastTestFiles: [],
     hooksEnabled: false,
     cleanupRegistered: false,
+    cleanupPromise: null,
+    closeCliShortcuts: null,
     chunkHashes: new Map(),
     affectedTestFiles: []
 };
@@ -2611,6 +2663,43 @@ const mapViewportByProject = (projects)=>{
 const ensureProcessExitCode = (code)=>{
     if (void 0 === process.exitCode || 0 === process.exitCode) process.exitCode = code;
 };
+const castArray = (arr)=>{
+    if (void 0 === arr) return [];
+    return Array.isArray(arr) ? arr : [
+        arr
+    ];
+};
+const applyDefaultWatchOptions = (rspackConfig, isWatchMode)=>{
+    rspackConfig.watchOptions ??= {};
+    if (!isWatchMode) {
+        rspackConfig.watchOptions.ignored = '**/**';
+        return;
+    }
+    rspackConfig.watchOptions.ignored = castArray(rspackConfig.watchOptions.ignored || []);
+    if (0 === rspackConfig.watchOptions.ignored.length) rspackConfig.watchOptions.ignored.push('**/.git', '**/node_modules');
+    rspackConfig.output?.path && rspackConfig.watchOptions.ignored.push(rspackConfig.output.path);
+};
+const createBrowserLazyCompilationConfig = (setupFiles)=>{
+    const eagerSetupFiles = new Set(setupFiles.map((filePath)=>normalize(filePath)));
+    if (0 === eagerSetupFiles.size) return {
+        imports: true,
+        entries: false
+    };
+    return {
+        imports: true,
+        entries: false,
+        test (module) {
+            const filePath = module.nameForCondition?.();
+            return !filePath || !eagerSetupFiles.has(normalize(filePath));
+        }
+    };
+};
+const createBrowserRsbuildDevConfig = (isWatchMode)=>({
+        hmr: isWatchMode,
+        client: {
+            logLevel: 'error'
+        }
+    });
 const globToRegexp = (glob)=>{
     const regex = picomatch.makeRe(glob, {
         fastpaths: false,
@@ -2873,21 +2962,28 @@ const destroyBrowserRuntime = async (runtime)=>{
         force: true
     }).catch(()=>{});
 };
-const registerWatchCleanup = ()=>{
-    if (watchContext.cleanupRegistered) return;
-    const cleanup = async ()=>{
+const cleanupWatchRuntime = ()=>{
+    if (watchContext.cleanupPromise) return watchContext.cleanupPromise;
+    watchContext.cleanupPromise = (async ()=>{
+        watchContext.closeCliShortcuts?.();
+        watchContext.closeCliShortcuts = null;
         if (!watchContext.runtime) return;
         await destroyBrowserRuntime(watchContext.runtime);
         watchContext.runtime = null;
-    };
+    })();
+    return watchContext.cleanupPromise;
+};
+const registerWatchCleanup = ()=>{
+    if (watchContext.cleanupRegistered) return;
     for (const signal of [
         'SIGINT',
-        'SIGTERM'
+        'SIGTERM',
+        'SIGTSTP'
     ])process.once(signal, ()=>{
-        cleanup();
+        cleanupWatchRuntime();
     });
     process.once('exit', ()=>{
-        cleanup();
+        cleanupWatchRuntime();
     });
     watchContext.cleanupRegistered = true;
 };
@@ -2929,11 +3025,7 @@ const createBrowserRuntime = async ({ context, manifestPath, manifestSource, tem
                 port: browserLaunchOptions.port ?? 4000,
                 strictPort: browserLaunchOptions.strictPort
             },
-            dev: {
-                client: {
-                    logLevel: 'error'
-                }
-            },
+            dev: createBrowserRsbuildDevConfig(isWatchMode),
             environments: {
                 ...Object.fromEntries(browserProjects.map((project)=>[
                         project.environmentName,
@@ -2956,6 +3048,7 @@ const createBrowserRuntime = async ({ context, manifestPath, manifestSource, tem
                         const project = projectByEnvironmentName.get(name);
                         if (!project) return config;
                         const userRsbuildConfig = project.normalizedConfig;
+                        const setupFiles = Object.values(getSetupFiles(project.normalizedConfig.setupFiles, project.rootPath));
                         const merged = mergeEnvironmentConfig(config, userRsbuildConfig, {
                             resolve: {
                                 alias: rstestInternalAliases
@@ -2975,12 +3068,10 @@ const createBrowserRuntime = async ({ context, manifestPath, manifestSource, tem
                             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);
                                     const browserRuntimeDir = dirname(browserRuntimePath);
                                     rspackConfig.module = rspackConfig.module || {};
                                     rspackConfig.module.rules = rspackConfig.module.rules || [];
@@ -3314,6 +3405,7 @@ const runBrowserController = async (context, options)=>{
     }
     await notifyTestRunStart();
     const isWatchMode = 'watch' === context.command;
+    const enableCliShortcuts = isWatchMode && isBrowserWatchCliShortcutsEnabled();
     const tempDir = isWatchMode && watchContext.runtime ? watchContext.runtime.tempDir : isWatchMode ? join(context.rootPath, TEMP_RSTEST_OUTPUT_DIR, 'browser', 'watch') : join(context.rootPath, TEMP_RSTEST_OUTPUT_DIR, 'browser', Date.now().toString());
     const manifestPath = join(tempDir, VIRTUAL_MANIFEST_FILENAME);
     const manifestSource = generateManifestModule({
@@ -3348,6 +3440,9 @@ const runBrowserController = async (context, options)=>{
         if (isWatchMode) {
             watchContext.runtime = runtime;
             registerWatchCleanup();
+            if (enableCliShortcuts && !watchContext.closeCliShortcuts) watchContext.closeCliShortcuts = await setupBrowserWatchCliShortcuts({
+                close: cleanupWatchRuntime
+            });
         }
     }
     const { browser, port, wsPort, wss } = runtime;
@@ -3734,6 +3829,7 @@ const runBrowserController = async (context, options)=>{
                             rerunFatalError
                         ] : void 0
                     });
+                    logBrowserWatchReadyMessage(enableCliShortcuts);
                 }
             },
             onError: async (error)=>{
@@ -3765,13 +3861,18 @@ const runBrowserController = async (context, options)=>{
                 if (0 === rerunPlan.currentTestFiles.length) {
                     await latestRerunScheduler.enqueueLatest([]);
                     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`));
                 latestRerunScheduler.enqueueLatest(rerunPlan.currentTestFiles);
                 return;
             }
-            if (0 === rerunPlan.affectedTestFiles.length) return void logger.log(color.cyan('No affected browser test files detected, skipping re-run.\n'));
+            if (0 === rerunPlan.affectedTestFiles.length) {
+                logger.log(color.cyan('No affected browser test files detected, skipping re-run.\n'));
+                logBrowserWatchReadyMessage(enableCliShortcuts);
+                return;
+            }
             logger.log(color.cyan(`Re-running ${rerunPlan.affectedTestFiles.length} affected test file(s)...\n`));
             latestRerunScheduler.enqueueLatest(rerunPlan.affectedTestFiles);
         };
@@ -3806,15 +3907,59 @@ const runBrowserController = async (context, options)=>{
         }
         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 resolveAllTests;
-    const allTestsPromise = new Promise((resolve)=>{
-        resolveAllTests = resolve;
-    });
+    let currentTestFiles = allTestFiles;
+    const RUNNER_FRAMES_READY_TIMEOUT_MS = 30000;
+    let currentRunnerFramesSignature = null;
+    const runnerFramesWaiters = new Map();
+    const createTestFilesSignature = (testFiles)=>JSON.stringify(testFiles.map((testFile)=>normalize(testFile)));
+    const markRunnerFramesReady = (testFiles)=>{
+        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)=>{
+        const signature = createTestFilesSignature(testFiles);
+        if (currentRunnerFramesSignature === signature) return;
+        await new Promise((resolve, reject)=>{
+            const waiters = runnerFramesWaiters.get(signature) ?? new Set();
+            let timeoutId;
+            const cleanup = ()=>{
+                const currentWaiters = runnerFramesWaiters.get(signature);
+                if (!currentWaiters) return;
+                currentWaiters.delete(onReady);
+                if (0 === currentWaiters.size) 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)=>{
+        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)=>{
+        const projectRuntime = projectRuntimeConfigs.find((project)=>project.name === file.projectName);
+        return (projectRuntime?.runtimeConfig.testTimeout ?? maxTestTimeoutForRpc) + 30000;
+    };
     let containerContext;
     let containerPage;
     let isNewPage = false;
@@ -3845,16 +3990,39 @@ const runBrowserController = async (context, options)=>{
     }
     activeContainerPage = containerPage;
     const dispatchRouter = createDispatchRouter();
+    const headedReloadQueue = createHeadedSerialTaskQueue();
+    let enqueueHeadedReload = async (_file, _testNamePattern)=>{
+        throw new Error('Headed reload queue is not initialized');
+    };
+    const reloadTestFileWithTimeout = async (file, testNamePattern)=>{
+        const timeoutMs = getHeadedPerFileTimeoutMs(file);
+        let timeoutId;
+        try {
+            await Promise.race([
+                rpcManager.reloadTestFile(file.testPath, testNamePattern),
+                new Promise((_, reject)=>{
+                    timeoutId = setTimeout(()=>{
+                        reject(new Error(`Headed test execution timeout after ${timeoutMs / 1000}s for ${file.testPath}.`));
+                    }, timeoutMs);
+                })
+            ]);
+        } finally{
+            if (timeoutId) clearTimeout(timeoutId);
+        }
+    };
     const createRpcMethods = ()=>({
             async rerunTest (testFile, testNamePattern) {
                 const projectName = context.normalizedConfig.name || 'project';
                 const relativePath = relative(context.rootPath, testFile);
                 const displayPath = `<${projectName}>/${relativePath}`;
                 logger.log(color.cyan(`\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) {
+                markRunnerFramesReady(testFiles);
             },
             async onTestFileStart (payload) {
                 await handleTestFileStart(payload);
@@ -3864,15 +4032,12 @@ const runBrowserController = async (context, options)=>{
             },
             async onTestFileComplete (payload) {
                 await handleTestFileComplete(payload);
-                completedTests++;
-                if (completedTests >= allTestFiles.length && resolveAllTests) resolveAllTests();
             },
             async onLog (payload) {
                 await handleLog(payload);
             },
             async onFatal (payload) {
                 await handleFatal(payload);
-                if (resolveAllTests) resolveAllTests();
             },
             async dispatch (request) {
                 return dispatchRouter.dispatch(request);
@@ -3895,21 +4060,21 @@ const runBrowserController = async (context, options)=>{
         });
         logger.log(color.cyan(`\nBrowser mode opened at http://localhost:${port}${pagePath}\n`));
     }
-    const maxTestTimeout = Math.max(...browserProjects.map((p)=>p.normalizedConfig.testTimeout ?? 5000));
-    const totalTimeoutMs = maxTestTimeout * allTestFiles.length + 30000;
-    let timeoutId;
-    const testTimeout = new Promise((resolve)=>{
-        timeoutId = setTimeout(()=>{
-            logger.log(color.yellow(`\nTest execution timeout after ${totalTimeoutMs / 1000}s. Completed: ${completedTests}/${allTestFiles.length}\n`));
-            resolve();
-        }, totalTimeoutMs);
-    });
+    enqueueHeadedReload = async (file, testNamePattern)=>headedReloadQueue.enqueue(async ()=>{
+            if (fatalError) return;
+            await reloadTestFileWithTimeout(file, testNamePattern);
+        });
     const testStart = Date.now();
-    await Promise.race([
-        allTestsPromise,
-        testTimeout
-    ]);
-    if (timeoutId) clearTimeout(timeoutId);
+    try {
+        await waitForRunnerFramesReady(currentTestFiles.map((file)=>file.testPath));
+        for (const file of currentTestFiles){
+            await enqueueHeadedReload(file);
+            if (fatalError) break;
+        }
+    } catch (error) {
+        fatalError = fatalError ?? toError(error);
+        ensureProcessExitCode(1);
+    }
     const testTime = Date.now() - testStart;
     if (isWatchMode) triggerRerun = async ()=>{
         const newProjectEntries = await collectProjectEntries(context);
@@ -3923,7 +4088,9 @@ const runBrowserController = async (context, options)=>{
             const deletedTestPaths = collectDeletedTestPaths(watchContext.lastTestFiles, rerunPlan.currentTestFiles);
             if (deletedTestPaths.length > 0) 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) {
             logger.log(color.cyan(`Re-running ${rerunPlan.normalizedAffectedTestFiles.length} affected test file(s)...\n`));
@@ -3932,7 +4099,7 @@ const runBrowserController = async (context, options)=>{
             const fatalErrorBeforeRun = fatalError;
             let rerunError;
             try {
-                for (const testFile of rerunPlan.normalizedAffectedTestFiles)await rpcManager.reloadTestFile(testFile);
+                for (const testFile of rerunPlan.normalizedAffectedTestFiles)await enqueueHeadedReload(getTestFileInfo(testFile));
             } catch (error) {
                 rerunError = toError(error);
                 throw error;
@@ -3952,8 +4119,13 @@ const runBrowserController = async (context, options)=>{
                         rerunFatalError
                     ] : void 0
                 });
+                logBrowserWatchReadyMessage(enableCliShortcuts);
             }
-        } else if (!rerunPlan.filesChanged) logger.log(color.cyan('Tests will be re-executed automatically\n'));
+        } else if (rerunPlan.filesChanged) logBrowserWatchReadyMessage(enableCliShortcuts);
+        else {
+            logger.log(color.cyan('Tests will be re-executed automatically\n'));
+            logBrowserWatchReadyMessage(enableCliShortcuts);
+        }
     };
     const closeContainerRuntime = isWatchMode ? void 0 : async ()=>{
         try {
@@ -3991,7 +4163,7 @@ const runBrowserController = async (context, options)=>{
     }
     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/dist/watchCliShortcuts.d.ts

@@ -0,0 +1,6 @@
+export declare const isBrowserWatchCliShortcutsEnabled: () => boolean;
+export declare const getBrowserWatchCliShortcutsHintMessage: () => string;
+export declare const logBrowserWatchReadyMessage: (enableCliShortcuts: boolean) => void;
+export declare function setupBrowserWatchCliShortcuts({ close, }: {
+    close: () => Promise<void>;
+}): Promise<() => void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rstest/browser",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "Browser mode support for Rstest testing framework.",
   "bugs": {
     "url": "https://github.com/web-infra-dev/rstest/issues"
@@ -42,9 +42,9 @@
   "dependencies": {
     "@jridgewell/trace-mapping": "0.3.31",
     "convert-source-map": "^2.0.0",
-    "open-editor": "^4.1.1",
+    "open-editor": "^6.0.0",
     "pathe": "^2.0.3",
-    "sirv": "^2.0.4",
+    "sirv": "^3.0.2",
     "ws": "^8.19.0"
   },
   "devDependencies": {
@@ -57,13 +57,13 @@
     "picocolors": "^1.1.1",
     "picomatch": "^4.0.3",
     "playwright": "^1.58.2",
-    "@rstest/browser-ui": "0.0.0",
+    "@rstest/core": "0.9.1",
     "@rstest/tsconfig": "0.0.1",
-    "@rstest/core": "0.9.0"
+    "@rstest/browser-ui": "0.0.0"
   },
   "peerDependencies": {
     "playwright": "^1.49.1",
-    "@rstest/core": "^0.9.0"
+    "@rstest/core": "^0.9.1"
   },
   "peerDependenciesMeta": {
     "playwright": {

package/src/headedSerialTaskQueue.ts

@@ -0,0 +1,19 @@
+export type HeadedSerialTask = () => Promise<void>;
+
+/**
+ * Serializes headed browser file execution so only one task runs at a time.
+ * The queue keeps draining even if an earlier task rejects.
+ */
+export const createHeadedSerialTaskQueue = () => {
+  let queue: Promise<void> = Promise.resolve();
+
+  const enqueue = (task: HeadedSerialTask): Promise<void> => {
+    const next = queue.then(task);
+    queue = next.catch(() => {});
+    return next;
+  };
+
+  return {
+    enqueue,
+  };
+};