@rstest/browser 0.11.8 → 0.11.10

package/dist/client/runner.js

@@ -1,5 +1,5 @@
 import { projectSetupLoaders, projectTestContexts, projects } from "__rstest_virtual_browser_manifest__";
-import { RSTEST_API_GLOBAL_KEY, RSTEST_ENV_SYMBOL_KEY, RSTEST_IMPORT_META_GLOBAL_KEY, SNAPSHOT_HEADER, createBrowserTaskContext, createRstestRuntime, formatConsoleArgs, globalApis, setRealTimers, unwrapRegex } from "@rstest/core/internal/browser-runtime";
+import { FIXTURE_CLEANUP_TIMEOUT_MS, RSTEST_API_GLOBAL_KEY, RSTEST_ENV_SYMBOL_KEY, RSTEST_IMPORT_META_GLOBAL_KEY, SNAPSHOT_HEADER, cleanupWorkerFixtures as browser_runtime_cleanupWorkerFixtures, createBrowserTaskContext, createRstestRuntime, formatConsoleArgs, getRealTimers, globalApis, setRealTimers, unwrapRegex } from "@rstest/core/internal/browser-runtime";
 import { normalize } from "pathe";
 import { AnyMap, TraceMap, encodedMap, originalPositionFor } from "@jridgewell/trace-mapping";
 import convert_source_map from "convert-source-map";
@@ -186,6 +186,42 @@ class BrowserSnapshotEnvironment {
 const debugLog = (...args)=>{
     if (window.__RSTEST_BROWSER_OPTIONS__?.debug) console.log(...args);
 };
+const cloneCoverage = (coverage)=>JSON.parse(JSON.stringify(coverage));
+const subtractCounters = (current, previous)=>Object.fromEntries(Object.entries(current).map(([key, value])=>[
+            key,
+            value - (previous?.[key] ?? 0)
+        ]));
+const getCoverageDelta = (current, previous)=>Object.fromEntries(Object.entries(current).map(([path, file])=>{
+        const previousFile = previous?.[path];
+        return [
+            path,
+            {
+                ...file,
+                s: subtractCounters(file.s, previousFile?.s),
+                f: subtractCounters(file.f, previousFile?.f),
+                b: Object.fromEntries(Object.entries(file.b).map(([key, values])=>[
+                        key,
+                        values.map((value, index)=>value - (previousFile?.b[key]?.[index] ?? 0))
+                    ]))
+            }
+        ];
+    }));
+const cleanupWorkerFixturesWithTimeout = async ()=>{
+    const realTimers = getRealTimers();
+    let timer;
+    try {
+        await Promise.race([
+            browser_runtime_cleanupWorkerFixtures(),
+            new Promise((_, reject)=>{
+                timer = realTimers.setTimeout?.(()=>{
+                    reject(new Error(`Worker fixture cleanup did not finish within ${FIXTURE_CLEANUP_TIMEOUT_MS}ms`));
+                }, FIXTURE_CLEANUP_TIMEOUT_MS);
+            })
+        ]);
+    } finally{
+        if (timer) realTimers.clearTimeout?.(timer);
+    }
+};
 const RSTEST_ENV_SYMBOL = Symbol.for(RSTEST_ENV_SYMBOL_KEY);
 const installRuntimeGlobals = (runtime, runtimeConfig)=>{
     Object.assign(globalThis, {
@@ -289,8 +325,9 @@ const waitForConfig = ()=>{
     if (window.parent === window || window.__RSTEST_BROWSER_OPTIONS__) return Promise.resolve();
     return new Promise((resolve, reject)=>{
         const handleMessage = (event)=>{
-            if (event.data?.type === RSTEST_CONFIG_MESSAGE_TYPE && 'string' == typeof event.data.payload?.runId) {
-                window.__RSTEST_BROWSER_OPTIONS__ = event.data.payload;
+            const payload = event.data?.payload;
+            if (event.data?.type === RSTEST_CONFIG_MESSAGE_TYPE && 'string' == typeof payload?.runId) {
+                window.__RSTEST_BROWSER_OPTIONS__ = payload;
                 debugLog('[Runner] Received config from container:', event.data.payload);
                 window.removeEventListener('message', handleMessage);
                 resolve();
@@ -364,6 +401,9 @@ const run = async ()=>{
     setRealTimers();
     await preloadRunnerSourceMap();
     const targetTestFile = options.testFile;
+    const targetTestFiles = options.testFiles?.length ? options.testFiles : targetTestFile ? [
+        targetTestFile
+    ] : void 0;
     const currentProject = targetTestFile ? findProjectForTestFile(targetTestFile, projects) : projects["0"];
     if (!currentProject) {
         send({
@@ -404,12 +444,7 @@ const run = async ()=>{
         for (const loadSetup of currentSetupLoaders)await loadSetup();
     };
     let testKeysToRun;
-    if (targetTestFile) {
-        const key = toContextKey(targetTestFile, currentProject.projectRoot);
-        testKeysToRun = [
-            key
-        ];
-    } else testKeysToRun = currentTestContext.getTestKeys();
+    testKeysToRun = targetTestFiles ? targetTestFiles.map((testFile)=>toContextKey(testFile, currentProject.projectRoot)) : currentTestContext.getTestKeys();
     const executionMode = options.mode || 'run';
     if ('collect' === executionMode) {
         for (const key of testKeysToRun){
@@ -478,183 +513,269 @@ const run = async ()=>{
     };
     window.addEventListener('error', onWindowError);
     window.addEventListener('unhandledrejection', onUnhandledRejection);
-    for (const key of testKeysToRun){
-        const testPath = toAbsolutePath(key, currentProject.projectRoot);
-        const taskStack = [
-            {
-                taskId: getFileTaskId(testPath),
-                taskType: 'file',
-                testPath
-            }
-        ];
-        const taskContext = createBrowserTaskContext();
-        const shouldInterceptConsole = !runtimeConfig.disableConsoleIntercept || true === runtimeConfig.silent || 'passed-only' === runtimeConfig.silent;
-        const restoreConsole = shouldInterceptConsole ? interceptConsole(projectRuntime.name, ()=>taskContext.getCurrent() ?? taskStack[taskStack.length - 1], runtimeConfig.disableConsoleIntercept ? false : runtimeConfig.printConsoleTrace ?? false) : ()=>{};
-        const workerState = {
-            project: projectRuntime.name,
-            projectRoot: projectRuntime.projectRoot,
-            rootPath: options.rootPath,
-            runtimeConfig,
-            taskId: 0,
-            buildId: 0,
-            outputModule: false,
-            environment: 'browser',
-            currentTask: taskStack[0],
-            testPath,
-            distPath: testPath,
-            snapshotOptions: {
-                updateSnapshot: options.snapshot.updateSnapshot,
-                snapshotEnvironment: new BrowserSnapshotEnvironment(),
-                snapshotFormat: runtimeConfig.snapshotFormat
-            }
-        };
-        const syncCurrentTask = ()=>{
-            workerState.currentTask = taskStack[taskStack.length - 1];
-        };
-        const removeTaskFromStack = (taskId)=>{
-            const taskIndex = taskStack.findLastIndex((task)=>task.taskId === taskId);
-            if (taskIndex < 0) return;
-            taskStack.splice(taskIndex, 1);
-            syncCurrentTask();
-        };
-        const runtime = await createRstestRuntime(workerState, {
-            taskContext
-        });
-        installRuntimeGlobals(runtime, runtimeConfig);
-        let failedTestsCount = 0;
-        const dispatchFileCleanup = async (method, result, waitForAcknowledgement = true)=>{
-            const requestId = createRequestId(`file-cleanup-${method}`);
-            const request = {
-                requestId,
-                namespace: DISPATCH_NAMESPACE_FILE_CLEANUP,
-                method,
-                args: {
-                    projectName: projectRuntime.name,
-                    result,
-                    runId: getRunIdentity(),
+    const keepWorkerFixtures = false === runtimeConfig.isolate && true !== projectRuntime.hasSetupFiles;
+    let restoreWorkerConsole;
+    let workerCleanupFailed = false;
+    let workerCleanupAttempted = false;
+    let setupListeners;
+    let previousIstanbulCoverage;
+    try {
+        for(let fileIndex = 0; fileIndex < testKeysToRun.length; fileIndex++){
+            const key = testKeysToRun[fileIndex];
+            const testPath = toAbsolutePath(key, currentProject.projectRoot);
+            options = {
+                ...options,
+                testFile: testPath
+            };
+            window.__RSTEST_BROWSER_OPTIONS__ = options;
+            const taskStack = [
+                {
+                    taskId: getFileTaskId(testPath),
+                    taskType: 'file',
                     testPath
                 }
+            ];
+            const taskContext = createBrowserTaskContext();
+            const shouldInterceptConsole = !runtimeConfig.disableConsoleIntercept || true === runtimeConfig.silent || 'passed-only' === runtimeConfig.silent;
+            const restoreConsole = shouldInterceptConsole ? interceptConsole(projectRuntime.name, ()=>taskContext.getCurrent() ?? taskStack[taskStack.length - 1], runtimeConfig.disableConsoleIntercept ? false : runtimeConfig.printConsoleTrace ?? false) : ()=>{};
+            if (keepWorkerFixtures) restoreWorkerConsole = restoreConsole;
+            const workerState = {
+                project: projectRuntime.name,
+                projectRoot: projectRuntime.projectRoot,
+                rootPath: options.rootPath,
+                runtimeConfig,
+                taskId: 0,
+                buildId: 0,
+                outputModule: false,
+                environment: 'browser',
+                currentTask: taskStack[0],
+                testPath,
+                distPath: testPath,
+                snapshotOptions: {
+                    updateSnapshot: options.snapshot.updateSnapshot,
+                    snapshotEnvironment: new BrowserSnapshotEnvironment(),
+                    snapshotFormat: runtimeConfig.snapshotFormat
+                }
+            };
+            const syncCurrentTask = ()=>{
+                workerState.currentTask = taskStack[taskStack.length - 1];
+            };
+            const removeTaskFromStack = (taskId)=>{
+                const taskIndex = taskStack.findLastIndex((task)=>task.taskId === taskId);
+                if (taskIndex < 0) return;
+                taskStack.splice(taskIndex, 1);
+                syncCurrentTask();
+            };
+            let runtime;
+            try {
+                runtime = await createRstestRuntime(workerState, {
+                    taskContext
+                });
+                installRuntimeGlobals(runtime, runtimeConfig);
+            } catch (error) {
+                restoreConsole();
+                throw error;
+            }
+            let failedTestsCount = 0;
+            const dispatchFileCleanup = async (method, result, waitForAcknowledgement = true)=>{
+                const requestId = createRequestId(`file-cleanup-${method}`);
+                const request = {
+                    requestId,
+                    namespace: DISPATCH_NAMESPACE_FILE_CLEANUP,
+                    method,
+                    args: {
+                        projectName: projectRuntime.name,
+                        result,
+                        runId: getRunIdentity(),
+                        testPath
+                    }
+                };
+                if (!waitForAcknowledgement) return void sendDispatchRequest(request);
+                await dispatchRpc({
+                    requestId,
+                    request,
+                    timeoutMs: getRpcTimeout('framework'),
+                    timeoutMessage: `File cleanup ${method} acknowledgement timed out for ${testPath}.`,
+                    staleMessage: `File cleanup ${method} became stale for ${testPath}.`
+                });
             };
-            if (!waitForAcknowledgement) return void sendDispatchRequest(request);
-            await dispatchRpc({
-                requestId,
-                request,
-                timeoutMs: getRpcTimeout('framework'),
-                timeoutMessage: `File cleanup ${method} acknowledgement timed out for ${testPath}.`,
-                staleMessage: `File cleanup ${method} became stale for ${testPath}.`
+            const cleanupWorkerFixtures = async (result)=>{
+                await dispatchFileCleanup('worker-start', result);
+                try {
+                    await cleanupWorkerFixturesWithTimeout();
+                } finally{
+                    await dispatchFileCleanup('worker-end');
+                }
+            };
+            const updateIstanbulCoverage = (result)=>{
+                if (!globalThis.__coverage__) return;
+                const currentCoverage = globalThis.__coverage__;
+                result.coverage = getCoverageDelta(currentCoverage, previousIstanbulCoverage);
+                previousIstanbulCoverage = cloneCoverage(currentCoverage);
+            };
+            const runnerHooks = {
+                onFileCleanupStart: async (result)=>{
+                    if (result && globalThis.__coverage__) result.coverage = globalThis.__coverage__;
+                    await dispatchFileCleanup('start', result, window.parent !== window);
+                },
+                onFileCleanupEnd: ()=>dispatchFileCleanup('end', void 0, window.parent !== window),
+                onSnapshotSetupStart: async ()=>{
+                    setRpcPhase('framework');
+                },
+                onSnapshotSetupEnd: async ()=>{
+                    setRpcPhase('test');
+                },
+                onSnapshotFinishStart: async ()=>{
+                    setRpcPhase('framework');
+                },
+                onSnapshotFinishEnd: async ()=>{
+                    setRpcPhase('test');
+                },
+                onTestFileReady: async (test)=>{
+                    dispatchRunnerLifecycle('file-ready', test);
+                },
+                onTestSuiteStart: async (test)=>{
+                    taskStack.push({
+                        taskId: test.testId,
+                        taskName: test.name,
+                        taskParentNames: test.parentNames,
+                        taskType: 'suite',
+                        testPath: test.testPath
+                    });
+                    syncCurrentTask();
+                    dispatchRunnerLifecycle('suite-start', test);
+                },
+                onTestSuiteResult: async (result)=>{
+                    removeTaskFromStack(result.testId);
+                    dispatchRunnerLifecycle('suite-result', result);
+                },
+                onTestCaseStart: async (test)=>{
+                    taskStack.push({
+                        taskId: test.testId,
+                        taskName: test.name,
+                        taskParentNames: test.parentNames,
+                        taskType: 'case',
+                        testPath: test.testPath
+                    });
+                    syncCurrentTask();
+                    dispatchRunnerLifecycle('case-start', test);
+                },
+                onTestCaseResult: async (result)=>{
+                    removeTaskFromStack(result.testId);
+                    if ('fail' === result.status) failedTestsCount++;
+                    send({
+                        type: 'case-result',
+                        payload: result
+                    });
+                },
+                getCountOfFailedTests: async ()=>failedTestsCount
+            };
+            send({
+                type: 'file-start',
+                payload: {
+                    testPath,
+                    projectName: projectRuntime.name
+                }
             });
-        };
-        const runnerHooks = {
-            onFileCleanupStart: async (result)=>{
-                if (result && globalThis.__coverage__) result.coverage = globalThis.__coverage__;
-                await dispatchFileCleanup('start', result, window.parent !== window);
-            },
-            onFileCleanupEnd: ()=>dispatchFileCleanup('end', void 0, window.parent !== window),
-            onSnapshotSetupStart: async ()=>{
-                setRpcPhase('framework');
-            },
-            onSnapshotSetupEnd: async ()=>{
-                setRpcPhase('test');
-            },
-            onSnapshotFinishStart: async ()=>{
+            const unhandledErrors = [];
+            activeUnhandledErrors = unhandledErrors;
+            try {
                 setRpcPhase('framework');
-            },
-            onSnapshotFinishEnd: async ()=>{
-                setRpcPhase('test');
-            },
-            onTestFileReady: async (test)=>{
-                dispatchRunnerLifecycle('file-ready', test);
-            },
-            onTestSuiteStart: async (test)=>{
-                taskStack.push({
-                    taskId: test.testId,
-                    taskName: test.name,
-                    taskParentNames: test.parentNames,
-                    taskType: 'suite',
-                    testPath: test.testPath
-                });
-                syncCurrentTask();
-                dispatchRunnerLifecycle('suite-start', test);
-            },
-            onTestSuiteResult: async (result)=>{
-                removeTaskFromStack(result.testId);
-                dispatchRunnerLifecycle('suite-result', result);
-            },
-            onTestCaseStart: async (test)=>{
-                taskStack.push({
-                    taskId: test.testId,
-                    taskName: test.name,
-                    taskParentNames: test.parentNames,
-                    taskType: 'case',
-                    testPath: test.testPath
+                if (setupListeners) runtime.runner.setRootSuiteListeners(setupListeners);
+                await loadSetupFiles();
+                setupListeners ??= runtime.runner.getRootSuiteListeners();
+                const beforeScripts = getScriptUrls();
+                await currentTestContext.loadTest(key);
+                const afterScripts = getScriptUrls();
+                const chunkUrl = findNewScriptUrl(beforeScripts, afterScripts);
+                if (chunkUrl) await preloadTestFileSourceMap(chunkUrl);
+                const result = await runtime.runner.runTests(testPath, runnerHooks, runtime.api);
+                const cleanupBeforeFileComplete = !keepWorkerFixtures || fileIndex === testKeysToRun.length - 1;
+                if (cleanupBeforeFileComplete) {
+                    workerCleanupAttempted = true;
+                    try {
+                        await cleanupWorkerFixtures(result);
+                    } catch (cleanupError) {
+                        const formattedCleanupError = cleanupError instanceof Error ? cleanupError : new Error(String(cleanupError));
+                        result.status = 'fail';
+                        result.errors = [
+                            ...result.errors ?? [],
+                            {
+                                fullStack: true,
+                                message: `Worker fixture cleanup failed: ${formattedCleanupError.message}`,
+                                name: formattedCleanupError.name,
+                                stack: formattedCleanupError.stack
+                            }
+                        ];
+                    }
+                }
+                updateIstanbulCoverage(result);
+                for(let i = 0; i < 2; i++)await new Promise((resolve)=>{
+                    setTimeout(resolve, 0);
                 });
-                syncCurrentTask();
-                dispatchRunnerLifecycle('case-start', test);
-            },
-            onTestCaseResult: async (result)=>{
-                removeTaskFromStack(result.testId);
-                if ('fail' === result.status) failedTestsCount++;
+                if (unhandledErrors.length > 0) {
+                    result.status = 'fail';
+                    result.errors = [
+                        ...result.errors ?? [],
+                        ...unhandledErrors.map((error)=>({
+                                name: error.name,
+                                message: error.message,
+                                stack: error.stack
+                            }))
+                    ];
+                }
                 send({
-                    type: 'case-result',
+                    type: 'file-complete',
                     payload: result
                 });
-            },
-            getCountOfFailedTests: async ()=>failedTestsCount
-        };
-        send({
-            type: 'file-start',
-            payload: {
-                testPath,
-                projectName: projectRuntime.name
-            }
-        });
-        const unhandledErrors = [];
-        activeUnhandledErrors = unhandledErrors;
-        try {
-            setRpcPhase('framework');
-            await loadSetupFiles();
-            const beforeScripts = getScriptUrls();
-            await currentTestContext.loadTest(key);
-            const afterScripts = getScriptUrls();
-            const chunkUrl = findNewScriptUrl(beforeScripts, afterScripts);
-            if (chunkUrl) await preloadTestFileSourceMap(chunkUrl);
-            const result = await runtime.runner.runTests(testPath, runnerHooks, runtime.api);
-            for(let i = 0; i < 2; i++)await new Promise((resolve)=>{
-                setTimeout(resolve, 0);
-            });
-            if (unhandledErrors.length > 0) {
-                result.status = 'fail';
-                result.errors = [
-                    ...result.errors ?? [],
-                    ...unhandledErrors.map((error)=>({
-                            name: error.name,
-                            message: error.message,
-                            stack: error.stack
-                        }))
-                ];
+            } catch (_error) {
+                let error = _error instanceof Error ? _error : new Error(String(_error));
+                if (!workerCleanupAttempted) try {
+                    workerCleanupAttempted = true;
+                    await cleanupWorkerFixtures();
+                } catch (cleanupError) {
+                    const formattedCleanupError = cleanupError instanceof Error ? cleanupError : new Error(String(cleanupError));
+                    error = new Error(`${error.message}\nWorker fixture cleanup failed: ${formattedCleanupError.message}`, {
+                        cause: error
+                    });
+                }
+                send({
+                    type: 'fatal',
+                    payload: {
+                        message: error.message,
+                        stack: error.stack
+                    }
+                });
+                window.__RSTEST_DONE__ = true;
+                return;
+            } finally{
+                if (keepWorkerFixtures && fileIndex === testKeysToRun.length - 1) restoreWorkerConsole = restoreConsole;
+                else restoreConsole();
+                activeUnhandledErrors = void 0;
             }
-            send({
-                type: 'file-complete',
-                payload: result
-            });
-        } catch (_error) {
-            const error = _error instanceof Error ? _error : new Error(String(_error));
+        }
+    } finally{
+        if (keepWorkerFixtures && !workerCleanupAttempted) try {
+            await cleanupWorkerFixturesWithTimeout();
+        } catch (error) {
+            workerCleanupFailed = true;
+            const cleanupError = error instanceof Error ? error : new Error(String(error));
             send({
                 type: 'fatal',
                 payload: {
-                    message: error.message,
-                    stack: error.stack
+                    message: cleanupError.message,
+                    stack: cleanupError.stack
                 }
             });
-            window.__RSTEST_DONE__ = true;
-            return;
-        } finally{
-            restoreConsole();
-            activeUnhandledErrors = void 0;
         }
+        restoreWorkerConsole?.();
     }
     window.removeEventListener('error', onWindowError);
     window.removeEventListener('unhandledrejection', onUnhandledRejection);
+    if (workerCleanupFailed) {
+        window.__RSTEST_DONE__ = true;
+        return;
+    }
     send({
         type: 'complete'
     });