@rstest/core 0.7.7 → 0.7.9

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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rstest/core",
-  "version": "0.7.7",
+  "version": "0.7.9",
   "description": "The Rsbuild-based test tool.",
   "bugs": {
     "url": "https://github.com/web-infra-dev/rstest/issues"
@@ -28,6 +28,14 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
+    "./browser": {
+      "types": "./dist/browser.d.ts",
+      "default": "./dist/browser.js"
+    },
+    "./browser-runtime": {
+      "types": "./dist/browser-runtime/index.d.ts",
+      "default": "./dist/browser-runtime/index.js"
+    },
     "./package.json": {
       "default": "./package.json"
     },
@@ -46,46 +54,53 @@
     "importMeta.d.ts"
   ],
   "dependencies": {
+    "@rsbuild/core": "1.7.1",
     "@types/chai": "^5.2.3",
-    "@rsbuild/core": "1.7.0-beta.1",
     "tinypool": "^1.1.1"
   },
   "devDependencies": {
-    "chai": "^5.3.3",
-    "pathe": "^2.0.3",
-    "birpc": "2.9.0",
-    "@vitest/expect": "^3.2.4",
-    "@vitest/snapshot": "^3.2.4",
     "@babel/code-frame": "^7.27.1",
     "@jridgewell/trace-mapping": "0.3.31",
     "@microsoft/api-extractor": "^7.55.2",
-    "@rslib/core": "^0.18.6",
+    "@rsbuild/plugin-node-polyfill": "^1.3.0",
+    "@rslib/core": "^0.19.0",
     "@sinonjs/fake-timers": "^15.1.0",
     "@types/babel__code-frame": "^7.0.6",
-    "@types/istanbul-reports": "^3.0.4",
     "@types/istanbul-lib-coverage": "^2.0.6",
     "@types/istanbul-lib-report": "^3.0.3",
+    "@types/istanbul-reports": "^3.0.4",
     "@types/jsdom": "^21.1.7",
+    "@types/picomatch": "^4.0.2",
     "@types/sinonjs__fake-timers": "^8.1.5",
+    "@clack/prompts": "^0.10.1",
+    "@vercel/detect-agent": "^1.0.0",
     "@types/source-map-support": "^0.5.10",
-    "@types/picomatch": "^4.0.2",
+    "@vitest/expect": "^3.2.4",
+    "@vitest/snapshot": "^3.2.4",
+    "birpc": "2.9.0",
     "cac": "^6.7.14",
+    "chai": "^5.3.3",
     "chokidar": "^4.0.3",
     "happy-dom": "^20.0.11",
     "jest-diff": "^30.2.0",
     "jsdom": "^26.1.0",
-    "webpack-license-plugin": "^4.5.1",
+    "memfs": "^4.51.1",
+    "package-manager-detector": "^1.6.0",
+    "pathe": "^2.0.3",
     "picocolors": "^1.1.1",
+    "picomatch": "^4.0.3",
     "pretty-format": "^30.2.0",
     "rslog": "^1.3.2",
     "source-map-support": "^0.5.21",
-    "std-env": "^3.10.0",
     "stacktrace-parser": "0.1.11",
+    "std-env": "^3.10.0",
     "strip-ansi": "^7.1.2",
     "tinyglobby": "^0.2.15",
     "tinyspy": "^4.0.4",
-    "picomatch": "^4.0.3",
-    "@rstest/tsconfig": "0.0.1"
+    "url-extras": "^0.1.0",
+    "webpack-license-plugin": "^4.5.1",
+    "@rstest/tsconfig": "0.0.1",
+    "@rstest/browser-ui": "0.7.9"
   },
   "peerDependencies": {
     "happy-dom": "*",

package/dist/0~8957.js

@@ -1,149 +0,0 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
-import { M, T } from "./0~6151.js";
-const isMockFunction = (fn)=>'function' == typeof fn && '_isMockFunction' in fn && fn._isMockFunction;
-const initSpy = ()=>{
-    let callOrder = 0;
-    const mocks = new Set();
-    const wrapSpy = (obj, methodName, mockFn)=>{
-        const spyImpl = M(obj, methodName, mockFn);
-        const spyFn = spyImpl;
-        let mockImplementationOnce = [];
-        let implementation = mockFn;
-        let mockName = mockFn?.name;
-        const initMockState = ()=>({
-                instances: [],
-                contexts: [],
-                invocationCallOrder: []
-            });
-        let mockState = initMockState();
-        const spyState = T(spyImpl);
-        spyFn.getMockName = ()=>mockName || methodName;
-        spyFn.mockName = (name)=>{
-            mockName = name;
-            return spyFn;
-        };
-        spyFn.getMockImplementation = ()=>mockImplementationOnce.length ? mockImplementationOnce[mockImplementationOnce.length - 1] : implementation;
-        function withImplementation(fn, cb) {
-            const originalImplementation = implementation;
-            const originalMockImplementationOnce = mockImplementationOnce;
-            implementation = fn;
-            mockImplementationOnce = [];
-            spyState.willCall(willCall);
-            const reset = ()=>{
-                implementation = originalImplementation;
-                mockImplementationOnce = originalMockImplementationOnce;
-            };
-            const result = cb();
-            if (result instanceof Promise) return result.then(()=>{
-                reset();
-            });
-            reset();
-        }
-        spyFn.withImplementation = withImplementation;
-        spyFn.mockImplementation = (fn)=>{
-            implementation = fn;
-            return spyFn;
-        };
-        spyFn.mockImplementationOnce = (fn)=>{
-            mockImplementationOnce.push(fn);
-            return spyFn;
-        };
-        spyFn.mockReturnValue = (value)=>spyFn.mockImplementation(()=>value);
-        spyFn.mockReturnValueOnce = (value)=>spyFn.mockImplementationOnce(()=>value);
-        spyFn.mockResolvedValue = (value)=>spyFn.mockImplementation(()=>Promise.resolve(value));
-        spyFn.mockResolvedValueOnce = (value)=>spyFn.mockImplementationOnce(()=>Promise.resolve(value));
-        spyFn.mockRejectedValue = (value)=>spyFn.mockImplementation(()=>Promise.reject(value));
-        spyFn.mockRejectedValueOnce = (value)=>spyFn.mockImplementationOnce(()=>Promise.reject(value));
-        spyFn.mockReturnThis = ()=>spyFn.mockImplementation(function() {
-                return this;
-            });
-        function willCall(...args) {
-            let impl = implementation || spyState.getOriginal();
-            mockState.instances.push(this);
-            mockState.contexts.push(this);
-            mockState.invocationCallOrder.push(++callOrder);
-            if (mockImplementationOnce.length) impl = mockImplementationOnce.shift();
-            return impl?.apply(this, args);
-        }
-        spyState.willCall(willCall);
-        Object.defineProperty(spyFn, 'mock', {
-            get: ()=>({
-                    get calls () {
-                        return spyState.calls;
-                    },
-                    get lastCall () {
-                        return spyState.calls[spyState.callCount - 1];
-                    },
-                    get instances () {
-                        return mockState.instances;
-                    },
-                    get contexts () {
-                        return mockState.contexts;
-                    },
-                    get invocationCallOrder () {
-                        return mockState.invocationCallOrder;
-                    },
-                    get results () {
-                        return spyState.results.map(([resultType, value])=>{
-                            const type = 'error' === resultType ? 'throw' : 'return';
-                            return {
-                                type: type,
-                                value
-                            };
-                        });
-                    },
-                    get settledResults () {
-                        return spyState.resolves.map(([resultType, value])=>{
-                            const type = 'error' === resultType ? 'rejected' : 'fulfilled';
-                            return {
-                                type,
-                                value
-                            };
-                        });
-                    }
-                })
-        });
-        spyFn.mockClear = ()=>{
-            mockState = initMockState();
-            spyState.reset();
-            return spyFn;
-        };
-        spyFn.mockReset = ()=>{
-            spyFn.mockClear();
-            implementation = mockFn;
-            mockImplementationOnce = [];
-            return spyFn;
-        };
-        spyFn.mockRestore = ()=>{
-            spyFn.mockReset();
-            spyState.restore();
-            mockName = mockFn?.name;
-        };
-        mocks.add(spyFn);
-        return spyFn;
-    };
-    const fn = (mockFn)=>{
-        const defaultName = 'rstest.fn()';
-        return wrapSpy({
-            [defaultName]: mockFn
-        }, defaultName, mockFn);
-    };
-    const spyOn = (obj, methodName, accessType)=>{
-        const accessTypeMap = {
-            get: 'getter',
-            set: 'setter'
-        };
-        const method = accessType ? {
-            [accessTypeMap[accessType]]: methodName
-        } : methodName;
-        return wrapSpy(obj, method);
-    };
-    return {
-        isMockFunction: isMockFunction,
-        spyOn,
-        fn,
-        mocks
-    };
-};
-export { initSpy };