@rstest/core 0.7.8 → 0.7.9

package/dist/browser.js

@@ -0,0 +1,14 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { __webpack_require__ } from "./rslib-runtime.js";
+const picocolors = __webpack_require__("../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js");
+var picocolors_default = /*#__PURE__*/ __webpack_require__.n(picocolors);
+var picocolors_default_0 = picocolors_default();
+export { TEMP_RSTEST_OUTPUT_DIR, getTestEntries, globalApis } from "./1157.js";
+export { afterAll, afterEach, assert, beforeAll, beforeEach, describe, expect, it, onTestFailed, onTestFinished, rs, rsbuild, rstest, test } from "./4484.js";
+export { createRstestRuntime } from "./6151.js";
+export { getSetupFiles } from "./6973.js";
+export { isDebug, logger } from "./3278.js";
+export { serializableConfig } from "./2672.js";
+export { setRealTimers } from "./1294.js";
+export { picocolors_default_0 as color };

package/dist/globalSetupWorker.js

@@ -1,8 +1,9 @@
 import 'module';
 /*#__PURE__*/ import.meta.url;
 import { __webpack_require__ } from "./rslib-runtime.js";
-import { formatTestError } from "./7913.js";
-import "./5693.js";
+import "./487.js";
+import "./2672.js";
+import { formatTestError } from "./1294.js";
 const source_map_support = __webpack_require__("../../node_modules/.pnpm/source-map-support@0.5.21/node_modules/source-map-support/source-map-support.js");
 const picocolors = __webpack_require__("../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js");
 var picocolors_default = /*#__PURE__*/ __webpack_require__.n(picocolors);

package/dist/index.d.ts

@@ -264,6 +264,45 @@ declare interface BranchMapping {
     line: number;
 }
 
+declare type BrowserModeConfig = {
+    /**
+     * Enable browser mode when running tests.
+     *
+     * @default false
+     */
+    enabled?: boolean;
+    /**
+     * Browser provider to use for running tests.
+     *
+     * Currently only 'playwright' is supported.
+     *
+     * @default 'playwright'
+     */
+    provider?: 'playwright';
+    /**
+     * Which browser to use for testing.
+     *
+     * - `chromium` - Google Chrome, Microsoft Edge
+     * - `firefox` - Mozilla Firefox
+     * - `webkit` - Safari
+     *
+     * @default 'chromium'
+     */
+    browser?: 'chromium' | 'firefox' | 'webkit';
+    /**
+     * Run browser in headless mode.
+     *
+     * @default Inferred from CI environment. `true` in CI, `false` otherwise.
+     */
+    headless?: boolean;
+    /**
+     * Port for the browser mode dev server.
+     *
+     * If not specified, a random available port will be used.
+     */
+    port?: number;
+};
+
 declare type BuiltInReporterNames = keyof typeof reportersMap;
 
 declare type BuiltinReporterOptions = {
@@ -310,6 +349,7 @@ declare type CommonOptions = {
     config?: string;
     configLoader?: LoadConfigOptions['loader'];
     globals?: boolean;
+    browser?: boolean;
     isolate?: boolean;
     include?: string[];
     exclude?: string[];
@@ -2039,10 +2079,19 @@ declare interface Node_2 {
     visit(visitor: Visitor, state: any): void;
 }
 
-declare type NormalizedConfig = Required<Omit<RstestConfig, OptionalKeys | 'pool' | 'projects' | 'coverage' | 'setupFiles' | 'globalSetup' | 'exclude' | 'testEnvironment'>> & Partial<Pick<RstestConfig, OptionalKeys>> & {
+declare type NormalizedBrowserModeConfig = {
+    enabled: boolean;
+    provider: 'playwright';
+    browser: 'chromium' | 'firefox' | 'webkit';
+    headless: boolean;
+    port?: number;
+};
+
+declare type NormalizedConfig = Required<Omit<RstestConfig, OptionalKeys | 'pool' | 'projects' | 'coverage' | 'setupFiles' | 'globalSetup' | 'exclude' | 'testEnvironment' | 'browser'>> & Partial<Pick<RstestConfig, OptionalKeys>> & {
     pool: RstestPoolOptions;
     testEnvironment: EnvironmentWithOptions;
     coverage: NormalizedCoverageOptions;
+    browser: NormalizedBrowserModeConfig;
     setupFiles: string[];
     globalSetup: string[];
     exclude: {
@@ -2246,6 +2295,10 @@ export declare interface Reporter {
      * Called before running the test case.
      */
     onTestCaseStart?: (test: TestCaseInfo) => void;
+    /**
+     * Called before all tests start
+     */
+    onTestRunStart?: () => MaybePromise<void>;
     /**
      * Called after all tests have finished running.
      */
@@ -2511,6 +2564,10 @@ export declare interface RstestConfig {
      * Custom environment variables available on `process.env` during tests.
      */
     env?: Partial<NodeJS.ProcessEnv>;
+    /**
+     * Browser mode configuration.
+     */
+    browser?: BrowserModeConfig;
     /**
      * Coverage options
      */

package/dist/index.js

@@ -1,3 +1,4 @@
 import 'module';
 /*#__PURE__*/ import.meta.url;
-export { afterAll, afterEach, assert, beforeAll, beforeEach, createRstest, defineConfig, defineProject, describe, expect, initCli, it, loadConfig, mergeProjectConfig, mergeRstestConfig, onTestFailed, onTestFinished, rs, rstest, runCLI, test } from "./9131.js";
+export { afterAll, afterEach, assert, beforeAll, beforeEach, describe, expect, it, onTestFailed, onTestFinished, rs, rstest, test } from "./4484.js";
+export { createRstest, defineConfig, defineProject, initCli, loadConfig, mergeProjectConfig, mergeRstestConfig, runCLI } from "./9131.js";

package/dist/rslib-runtime.js

@@ -29,6 +29,33 @@ __webpack_require__.m = __webpack_modules__;
         return getter;
     };
 })();
+(()=>{
+    var getProto = Object.getPrototypeOf ? (obj)=>Object.getPrototypeOf(obj) : (obj)=>obj.__proto__;
+    var leafPrototypes;
+    __webpack_require__.t = function(value, mode) {
+        if (1 & mode) value = this(value);
+        if (8 & mode) return value;
+        if ('object' == typeof value && value) {
+            if (4 & mode && value.__esModule) return value;
+            if (16 & mode && 'function' == typeof value.then) return value;
+        }
+        var ns = Object.create(null);
+        __webpack_require__.r(ns);
+        var def = {};
+        leafPrototypes = leafPrototypes || [
+            null,
+            getProto({}),
+            getProto([]),
+            getProto(getProto)
+        ];
+        for(var current = 2 & mode && value; ('object' == typeof current || 'function' == typeof current) && !~leafPrototypes.indexOf(current); current = getProto(current))Object.getOwnPropertyNames(current).forEach((key)=>{
+            def[key] = ()=>value[key];
+        });
+        def['default'] = ()=>value;
+        __webpack_require__.d(ns, def);
+        return ns;
+    };
+})();
 (()=>{
     __webpack_require__.d = (exports, definition)=>{
         for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {

package/dist/rstestSuppressWarnings.cjs

@@ -0,0 +1,9 @@
+const originalEmit = process.emit;
+process.emit = function(event, error, ...args) {
+    if ('warning' === event && 'ExperimentalWarning' === error.name) return false;
+    return Reflect.apply(originalEmit, this, [
+        event,
+        error,
+        ...args
+    ]);
+};

package/dist/worker.d.ts

@@ -251,6 +251,45 @@ declare interface BranchMapping {
     line: number;
 }
 
+declare type BrowserModeConfig = {
+    /**
+     * Enable browser mode when running tests.
+     *
+     * @default false
+     */
+    enabled?: boolean;
+    /**
+     * Browser provider to use for running tests.
+     *
+     * Currently only 'playwright' is supported.
+     *
+     * @default 'playwright'
+     */
+    provider?: 'playwright';
+    /**
+     * Which browser to use for testing.
+     *
+     * - `chromium` - Google Chrome, Microsoft Edge
+     * - `firefox` - Mozilla Firefox
+     * - `webkit` - Safari
+     *
+     * @default 'chromium'
+     */
+    browser?: 'chromium' | 'firefox' | 'webkit';
+    /**
+     * Run browser in headless mode.
+     *
+     * @default Inferred from CI environment. `true` in CI, `false` otherwise.
+     */
+    headless?: boolean;
+    /**
+     * Port for the browser mode dev server.
+     *
+     * If not specified, a random available port will be used.
+     */
+    port?: number;
+};
+
 declare type BuiltInReporterNames = keyof typeof reportersMap;
 
 declare type BuiltinReporterOptions = {
@@ -1682,10 +1721,19 @@ declare interface Node_2 {
     visit(visitor: Visitor, state: any): void;
 }
 
-declare type NormalizedConfig = Required<Omit<RstestConfig, OptionalKeys | 'pool' | 'projects' | 'coverage' | 'setupFiles' | 'globalSetup' | 'exclude' | 'testEnvironment'>> & Partial<Pick<RstestConfig, OptionalKeys>> & {
+declare type NormalizedBrowserModeConfig = {
+    enabled: boolean;
+    provider: 'playwright';
+    browser: 'chromium' | 'firefox' | 'webkit';
+    headless: boolean;
+    port?: number;
+};
+
+declare type NormalizedConfig = Required<Omit<RstestConfig, OptionalKeys | 'pool' | 'projects' | 'coverage' | 'setupFiles' | 'globalSetup' | 'exclude' | 'testEnvironment' | 'browser'>> & Partial<Pick<RstestConfig, OptionalKeys>> & {
     pool: RstestPoolOptions;
     testEnvironment: EnvironmentWithOptions;
     coverage: NormalizedCoverageOptions;
+    browser: NormalizedBrowserModeConfig;
     setupFiles: string[];
     globalSetup: string[];
     exclude: {
@@ -1872,6 +1920,10 @@ declare interface Reporter {
      * Called before running the test case.
      */
     onTestCaseStart?: (test: TestCaseInfo) => void;
+    /**
+     * Called before all tests start
+     */
+    onTestRunStart?: () => MaybePromise<void>;
     /**
      * Called after all tests have finished running.
      */
@@ -2124,6 +2176,10 @@ declare interface RstestConfig {
      * Custom environment variables available on `process.env` during tests.
      */
     env?: Partial<NodeJS.ProcessEnv>;
+    /**
+     * Browser mode configuration.
+     */
+    browser?: BrowserModeConfig;
     /**
      * Coverage options
      */

package/dist/worker.js

@@ -1,3 +1,417 @@
 import 'module';
 /*#__PURE__*/ import.meta.url;
-export { default } from "./554.js";
+import { __webpack_require__ } from "./rslib-runtime.js";
+import { basename, isAbsolute, undoSerializableConfig, dirname, resolve as pathe_M_eThtNZ_resolve, join } from "./2672.js";
+import "./487.js";
+import { node_v8, createBirpc } from "./3216.js";
+import { createCoverageProvider } from "./5734.js";
+import { formatTestError, setRealTimers, getRealTimers } from "./1294.js";
+import { globalApis } from "./1157.js";
+const processSend = process.send.bind(process);
+const processOn = process.on.bind(process);
+const processOff = process.off.bind(process);
+function createForksRpcOptions({ nodeV8 = node_v8, dispose = [] }) {
+    return {
+        serialize: nodeV8.serialize,
+        deserialize: (v)=>nodeV8.deserialize(Buffer.from(v)),
+        post (v) {
+            processSend(v);
+        },
+        on (fn) {
+            const handler = (message, ...extras)=>{
+                if (message?.__tinypool_worker_message__) return;
+                return fn(message, ...extras);
+            };
+            processOn('message', handler);
+            dispose.push(()=>processOff('message', handler));
+        }
+    };
+}
+function createRuntimeRpc(options, { originalConsole }) {
+    const rpc = createBirpc({}, {
+        ...options,
+        onTimeoutError: (functionName, error)=>{
+            switch(functionName){
+                case 'onTestCaseStart':
+                    {
+                        const caseTest = error[0];
+                        console.error(`[Rstest] timeout on calling "onTestCaseStart" rpc method (Case: "${caseTest.name}")`);
+                        return true;
+                    }
+                case 'onTestCaseResult':
+                    {
+                        const caseResult = error[0];
+                        console.error(`[Rstest] timeout on calling "onTestCaseResult" rpc method (Case: "${caseResult.name}", Result: "${caseResult.status}")`);
+                        return true;
+                    }
+                case 'onConsoleLog':
+                    originalConsole.error(`[Rstest] timeout on calling "onConsoleLog" rpc method (Original log: ${error[0].content})`);
+                    return true;
+                default:
+                    return false;
+            }
+        }
+    });
+    return {
+        rpc
+    };
+}
+const external_node_fs_ = __webpack_require__("fs");
+class NodeSnapshotEnvironment {
+    constructor(options = {}){
+        this.options = options;
+    }
+    getVersion() {
+        return "1";
+    }
+    getHeader() {
+        return `// Snapshot v${this.getVersion()}`;
+    }
+    async resolveRawPath(testPath, rawPath) {
+        return isAbsolute(rawPath) ? rawPath : pathe_M_eThtNZ_resolve(dirname(testPath), rawPath);
+    }
+    async resolvePath(filepath) {
+        return join(join(dirname(filepath), this.options.snapshotsDirName ?? "__snapshots__"), `${basename(filepath)}.snap`);
+    }
+    async prepareDirectory(dirPath) {
+        await external_node_fs_.promises.mkdir(dirPath, {
+            recursive: true
+        });
+    }
+    async saveSnapshotFile(filepath, snapshot) {
+        await external_node_fs_.promises.mkdir(dirname(filepath), {
+            recursive: true
+        });
+        await external_node_fs_.promises.writeFile(filepath, snapshot, "utf-8");
+    }
+    async readSnapshotFile(filepath) {
+        if (!(0, external_node_fs_.existsSync)(filepath)) return null;
+        return external_node_fs_.promises.readFile(filepath, "utf-8");
+    }
+    async removeSnapshotFile(filepath) {
+        if ((0, external_node_fs_.existsSync)(filepath)) await external_node_fs_.promises.unlink(filepath);
+    }
+}
+class RstestSnapshotEnvironment extends NodeSnapshotEnvironment {
+    resolveSnapshotPath;
+    constructor(options){
+        super();
+        this.resolveSnapshotPath = options.resolveSnapshotPath;
+    }
+    getHeader() {
+        return `// Rstest Snapshot v${this.getVersion()}`;
+    }
+    resolvePath(filepath) {
+        return this.resolveSnapshotPath(filepath);
+    }
+}
+const source_map_support = __webpack_require__("../../node_modules/.pnpm/source-map-support@0.5.21/node_modules/source-map-support/source-map-support.js");
+const picocolors = __webpack_require__("../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js");
+var picocolors_default = /*#__PURE__*/ __webpack_require__.n(picocolors);
+let sourceMaps = {};
+(0, source_map_support.install)({
+    environment: 'node',
+    handleUncaughtExceptions: false,
+    retrieveSourceMap: (source)=>{
+        if (sourceMaps[source]) return {
+            url: source,
+            map: JSON.parse(sourceMaps[source])
+        };
+        return null;
+    }
+});
+const registerGlobalApi = (api)=>globalApis.reduce((apis, key)=>{
+        globalThis[key] = api[key];
+        return apis;
+    }, {});
+const globalCleanups = [];
+let isTeardown = false;
+const setupEnv = (env)=>{
+    if (env) Object.assign(process.env, env);
+};
+const preparePool = async ({ entryInfo: { distPath, testPath }, updateSnapshot, context })=>{
+    globalCleanups.forEach((fn)=>{
+        fn();
+    });
+    globalCleanups.length = 0;
+    setRealTimers();
+    context.runtimeConfig = undoSerializableConfig(context.runtimeConfig);
+    process.env.RSTEST_WORKER_ID = String(process.__tinypool_state__.workerId || context.taskId);
+    const cleanupFns = [];
+    const originalConsole = global.console;
+    const disposeFns = [];
+    const { rpc } = createRuntimeRpc(createForksRpcOptions({
+        dispose: disposeFns
+    }), {
+        originalConsole
+    });
+    globalCleanups.push(()=>{
+        disposeFns.forEach((fn)=>{
+            fn();
+        });
+        rpc.$close();
+    });
+    const { runtimeConfig: { globals, printConsoleTrace, disableConsoleIntercept, testEnvironment, snapshotFormat, env } } = context;
+    setupEnv(env);
+    if (!disableConsoleIntercept) {
+        const { createCustomConsole } = await import("./0~130.js").then((mod)=>({
+                createCustomConsole: mod.createCustomConsole
+            }));
+        global.console = createCustomConsole({
+            rpc,
+            testPath,
+            printConsoleTrace
+        });
+    }
+    const interopDefault = true;
+    const workerState = {
+        ...context,
+        snapshotOptions: {
+            updateSnapshot,
+            snapshotEnvironment: new RstestSnapshotEnvironment({
+                resolveSnapshotPath: (filepath)=>rpc.resolveSnapshotPath(filepath)
+            }),
+            snapshotFormat
+        },
+        distPath,
+        testPath,
+        environment: 'node'
+    };
+    const { createRstestRuntime } = await import("./6151.js").then((mod)=>({
+            createRstestRuntime: mod.createRstestRuntime
+        }));
+    const unhandledErrors = [];
+    const handleError = (e, type)=>{
+        const error = 'string' == typeof e ? new Error(e) : e;
+        error.name = type;
+        if (isTeardown) {
+            error.stack = `${picocolors_default().yellow('Caught error after test environment was torn down:')}\n\n${error.stack}`;
+            console.error(error);
+        } else {
+            console.error(error);
+            unhandledErrors.push(error);
+        }
+    };
+    const uncaughtException = (e)=>handleError(e, 'uncaughtException');
+    const unhandledRejection = (e)=>handleError(e, 'unhandledRejection');
+    process.on('uncaughtException', uncaughtException);
+    process.on('unhandledRejection', unhandledRejection);
+    globalCleanups.push(()=>{
+        process.off('uncaughtException', uncaughtException);
+        process.off('unhandledRejection', unhandledRejection);
+    });
+    const { api, runner } = await createRstestRuntime(workerState);
+    switch(testEnvironment.name){
+        case 'node':
+            break;
+        case 'jsdom':
+            {
+                const { environment } = await import("./0~62.js").then((mod)=>({
+                        environment: mod.environment
+                    }));
+                const { teardown } = await environment.setup(global, testEnvironment.options || {});
+                cleanupFns.push(()=>teardown(global));
+                break;
+            }
+        case 'happy-dom':
+            {
+                const { environment } = await import("./0~4809.js").then((mod)=>({
+                        environment: mod.environment
+                    }));
+                const { teardown } = await environment.setup(global, testEnvironment.options || {});
+                cleanupFns.push(async ()=>teardown(global));
+                break;
+            }
+        default:
+            throw new Error(`Unknown test environment: ${testEnvironment.name}`);
+    }
+    if (globals) registerGlobalApi(api);
+    const rstestContext = {
+        global,
+        console: global.console,
+        Error
+    };
+    rstestContext.global['@rstest/core'] = api;
+    return {
+        interopDefault,
+        rstestContext,
+        runner,
+        rpc,
+        api,
+        unhandledErrors,
+        cleanup: async ()=>{
+            await Promise.all(cleanupFns.map((fn)=>fn()));
+        }
+    };
+};
+const loadFiles = async ({ setupEntries, assetFiles, rstestContext, distPath, testPath, interopDefault, isolate, outputModule })=>{
+    const { loadModule, updateLatestAssetFiles } = outputModule ? await import("./0~6923.js").then((mod)=>({
+            EsmMode: mod.loadEsModule_EsmMode,
+            asModule: mod.asModule,
+            loadModule: mod.loadModule,
+            updateLatestAssetFiles: mod.updateLatestAssetFiles
+        })) : await import("./0~5835.js").then((mod)=>({
+            cacheableLoadModule: mod.cacheableLoadModule,
+            loadModule: mod.loadModule,
+            updateLatestAssetFiles: mod.updateLatestAssetFiles
+        }));
+    if (!isolate) {
+        updateLatestAssetFiles(assetFiles);
+        await loadModule({
+            codeContent: `if (global && typeof global.__rstest_clean_core_cache__ === 'function') {
+  global.__rstest_clean_core_cache__();
+  }`,
+            distPath: '',
+            testPath,
+            rstestContext,
+            assetFiles,
+            interopDefault
+        });
+    }
+    for (const { distPath, testPath } of setupEntries){
+        const setupCodeContent = assetFiles[distPath];
+        await loadModule({
+            codeContent: setupCodeContent,
+            distPath,
+            testPath,
+            rstestContext,
+            assetFiles,
+            interopDefault
+        });
+    }
+    await loadModule({
+        codeContent: assetFiles[distPath],
+        distPath,
+        testPath,
+        rstestContext,
+        assetFiles,
+        interopDefault
+    });
+};
+const runInPool = async (options)=>{
+    isTeardown = false;
+    const { entryInfo: { distPath, testPath }, setupEntries, assets, type, context: { project, runtimeConfig: { isolate, bail } } } = options;
+    const cleanups = [];
+    const exit = process.exit.bind(process);
+    process.exit = (code = process.exitCode || 0)=>{
+        throw new Error(`process.exit unexpectedly called with "${code}"`);
+    };
+    const kill = process.kill.bind(process);
+    process.kill = (pid, signal)=>{
+        if (-1 === pid || Math.abs(pid) === process.pid) throw new Error(`process.kill unexpectedly called with "${pid}" and "${signal}"`);
+        return kill(pid, signal);
+    };
+    cleanups.push(()=>{
+        process.kill = kill;
+        process.exit = exit;
+    });
+    const teardown = async ()=>{
+        await new Promise((resolve)=>getRealTimers().setTimeout(resolve));
+        await Promise.all(cleanups.map((fn)=>fn()));
+        isTeardown = true;
+    };
+    if ('collect' === type) try {
+        const { rstestContext, runner, rpc, cleanup, unhandledErrors, interopDefault } = await preparePool(options);
+        const { assetFiles, sourceMaps: sourceMapsFromAssets } = assets || await rpc.getAssetsByEntry();
+        sourceMaps = sourceMapsFromAssets;
+        cleanups.push(cleanup);
+        await loadFiles({
+            rstestContext,
+            distPath,
+            testPath,
+            assetFiles,
+            setupEntries,
+            interopDefault,
+            isolate,
+            outputModule: options.context.outputModule
+        });
+        const tests = await runner.collectTests();
+        return {
+            project,
+            testPath,
+            tests,
+            errors: formatTestError(unhandledErrors)
+        };
+    } catch (err) {
+        return {
+            project,
+            testPath,
+            tests: [],
+            errors: formatTestError(err)
+        };
+    } finally{
+        await teardown();
+    }
+    try {
+        const { rstestContext, runner, rpc, api, cleanup, unhandledErrors, interopDefault } = await preparePool(options);
+        if (bail && await rpc.getCountOfFailedTests() >= bail) return {
+            testId: '0',
+            project,
+            testPath,
+            status: 'skip',
+            name: '',
+            results: []
+        };
+        const coverageProvider = await createCoverageProvider(options.context.runtimeConfig.coverage || {}, options.context.rootPath);
+        if (coverageProvider) coverageProvider.init();
+        const { assetFiles, sourceMaps: sourceMapsFromAssets } = assets || await rpc.getAssetsByEntry();
+        sourceMaps = sourceMapsFromAssets;
+        cleanups.push(cleanup);
+        rpc.onTestFileStart?.({
+            testPath,
+            tests: []
+        });
+        await loadFiles({
+            rstestContext,
+            distPath,
+            testPath,
+            assetFiles,
+            setupEntries,
+            interopDefault,
+            isolate,
+            outputModule: options.context.outputModule
+        });
+        const results = await runner.runTests(testPath, {
+            onTestFileReady: async (test)=>{
+                await rpc.onTestFileReady(test);
+            },
+            onTestSuiteStart: async (test)=>{
+                await rpc.onTestSuiteStart(test);
+            },
+            onTestSuiteResult: async (result)=>{
+                await rpc.onTestSuiteResult(result);
+            },
+            onTestCaseStart: async (test)=>{
+                await rpc.onTestCaseStart(test);
+            },
+            onTestCaseResult: async (result)=>{
+                await rpc.onTestCaseResult(result);
+            },
+            getCountOfFailedTests: async ()=>rpc.getCountOfFailedTests()
+        }, api);
+        if (unhandledErrors.length > 0) {
+            results.status = 'fail';
+            results.errors = (results.errors || []).concat(...formatTestError(unhandledErrors));
+        }
+        if (coverageProvider) {
+            const coverageMap = coverageProvider.collect();
+            if (coverageMap) results.coverage = coverageMap.toJSON();
+            coverageProvider.cleanup();
+        }
+        return results;
+    } catch (err) {
+        return {
+            testId: '0',
+            project,
+            testPath,
+            status: 'fail',
+            name: '',
+            results: [],
+            errors: formatTestError(err)
+        };
+    } finally{
+        await teardown();
+    }
+};
+const worker = runInPool;
+export default worker;