@rstest/core 0.7.3 → 0.7.5

package/dist/{0~122.js → 0~89.js}

@@ -4,8 +4,12 @@ import { __webpack_require__ } from "./rslib-runtime.js";
 import node_events from "node:events";
 import { Tinypool } from "tinypool";
 import node_inspector from "node:inspector";
-import { basename, TEMP_RSTEST_OUTPUT_DIR, dirname, posix, resolve as pathe_M_eThtNZ_resolve, serializableConfig, node_process, isBuiltin, castArray, TEMP_RSTEST_OUTPUT_DIR_GLOB, isDebug, ADDITIONAL_NODE_BUILTINS, join, needFlagExperimentalDetectModule } from "./946.js";
-import { node_v8, fileURLToPath, createBirpc } from "./404.js";
+import "./693.js";
+import { node_process, basename, isDebug, dirname, posix, resolve as pathe_M_eThtNZ_resolve, join } from "./278.js";
+import { fileURLToPath } from "./198.js";
+import { node_v8, createBirpc } from "./216.js";
+import { serializableConfig, bgColor, TEMP_RSTEST_OUTPUT_DIR, TEMP_RSTEST_OUTPUT_DIR_GLOB, castArray, ADDITIONAL_NODE_BUILTINS, needFlagExperimentalDetectModule } from "./157.js";
+import { isBuiltin } from "./881.js";
 import { core_logger, createRsbuild } from "./131.js";
 const DefaultMaxHeapSize = 1073741824;
 function memory_isMemorySufficient(options) {
@@ -63,6 +67,8 @@ const createForksPool = (poolOptions)=>{
         isolateWorkers: isolate
     };
     const pool = new Tinypool(options);
+    const destroy = pool.destroy.bind(pool);
+    process.on('SIGTERM', destroy);
     return {
         name: 'forks',
         runTest: async ({ options, rpcMethods })=>{
@@ -85,7 +91,10 @@ const createForksPool = (poolOptions)=>{
                 cleanup();
             }
         },
-        close: ()=>pool.destroy()
+        close: ()=>{
+            process.off('SIGTERM', destroy);
+            return destroy();
+        }
     };
 };
 const external_node_os_ = __webpack_require__("node:os");
@@ -104,7 +113,10 @@ const parseWorkers = (maxWorkers)=>{
 const getRuntimeConfig = (context)=>{
     const { testNamePattern, testTimeout, passWithNoTests, retry, globals, clearMocks, resetMocks, restoreMocks, unstubEnvs, unstubGlobals, maxConcurrency, printConsoleTrace, disableConsoleIntercept, testEnvironment, hookTimeout, isolate, coverage, snapshotFormat, env, logHeapUsage, bail, chaiConfig, includeTaskLocation } = context.normalizedConfig;
     return {
-        env,
+        env: {
+            ...process.env,
+            ...env
+        },
         testNamePattern,
         testTimeout,
         hookTimeout,
@@ -121,7 +133,10 @@ const getRuntimeConfig = (context)=>{
         disableConsoleIntercept,
         testEnvironment,
         isolate,
-        coverage,
+        coverage: {
+            ...coverage,
+            reporters: []
+        },
         snapshotFormat,
         logHeapUsage,
         bail,
@@ -165,8 +180,7 @@ const createPool = async ({ context, recommendWorkerCount = 1 / 0 })=>{
         ].filter(Boolean),
         env: {
             NODE_ENV: 'test',
-            FORCE_COLOR: '1' === process.env.NO_COLOR ? '0' : '1',
-            ...process.env
+            FORCE_COLOR: '1' === process.env.NO_COLOR ? '0' : '1'
         }
     });
     const rpcMethods = {
@@ -313,6 +327,78 @@ const createPool = async ({ context, recommendWorkerCount = 1 / 0 })=>{
         close: ()=>pool.close()
     };
 };
+let globalTeardownCallbacks = [];
+function applyEnvChanges(changes) {
+    for(const key in changes)if (void 0 === changes[key]) delete process.env[key];
+    else process.env[key] = changes[key];
+}
+const globalSetup_filename = fileURLToPath(import.meta.url);
+const globalSetup_dirname = dirname(globalSetup_filename);
+async function createSetupPool() {
+    const options = {
+        runtime: 'child_process',
+        filename: pathe_M_eThtNZ_resolve(globalSetup_dirname, './globalSetupWorker.js'),
+        execArgv: [
+            ...process.execArgv,
+            '--experimental-vm-modules',
+            '--experimental-import-meta-resolve',
+            '--no-warnings'
+        ],
+        maxThreads: 1,
+        minThreads: 1,
+        concurrentTasksPerWorker: 1,
+        isolateWorkers: false,
+        env: {
+            NODE_ENV: 'test',
+            FORCE_COLOR: '1' === process.env.NO_COLOR ? '0' : '1',
+            ...process.env
+        }
+    };
+    const pool = new Tinypool(options);
+    const destroy = pool.destroy.bind(pool);
+    process.on('SIGTERM', destroy);
+    return pool;
+}
+async function runGlobalSetup({ globalSetupEntries, assetFiles, sourceMaps, interopDefault, outputModule }) {
+    const pool = await createSetupPool();
+    const result = await pool.run({
+        type: 'setup',
+        entries: globalSetupEntries,
+        assetFiles,
+        interopDefault,
+        outputModule,
+        sourceMaps
+    });
+    if (result.success) {
+        if (result.envChanges) applyEnvChanges(result.envChanges);
+        if (result.hasTeardown) globalTeardownCallbacks.push(()=>runWorkerTeardown(pool));
+    }
+    return {
+        success: result.success,
+        errors: result.errors
+    };
+}
+async function runWorkerTeardown(pool) {
+    const result = await pool.run({
+        type: 'teardown'
+    });
+    if (!result.success) process.exitCode = 1;
+    await pool.destroy();
+}
+async function runGlobalTeardown() {
+    const teardownCallbacks = [
+        ...globalTeardownCallbacks
+    ];
+    globalTeardownCallbacks = [];
+    for (const teardown of teardownCallbacks.reverse())try {
+        await teardown();
+    } catch (error) {
+        console.error(bgColor('bgRed', 'Error during global teardown'));
+        if (error instanceof Error) error.stack ? console.error(picocolors_default().red(error.stack)) : console.error(picocolors_default().red(error.message));
+        else console.error(picocolors_default().red(String(error)));
+        process.exitCode = 1;
+    }
+}
 const RUNTIME_CHUNK_NAME = 'runtime';
 const requireShim = `// Rstest ESM shims
 import __rstest_shim_module__ from 'node:module';
@@ -417,7 +503,7 @@ const pluginBasic = (context)=>({
             });
         }
     });
-const external_node_path_ = __webpack_require__("path");
+const external_node_path_ = __webpack_require__("node:path");
 const PLUGIN_CSS_FILTER = 'rstest:css-filter';
 const css_filter_dirname = external_node_path_["default"].dirname(fileURLToPath(import.meta.url));
 const pluginCSSFilter = ()=>({
@@ -461,7 +547,7 @@ class TestFileWatchPlugin {
         });
     }
 }
-const pluginEntryWatch = ({ isWatch, globTestSourceEntries, setupFiles, context })=>({
+const pluginEntryWatch = ({ isWatch, globTestSourceEntries, setupFiles, globalSetupFiles, context })=>({
         name: 'rstest:entry-watch',
         setup: (api)=>{
             api.modifyRspackConfig(async (config, { environment })=>{
@@ -471,13 +557,14 @@ const pluginEntryWatch = ({ isWatch, globTestSourceEntries, setupFiles, context
                         const sourceEntries = await globTestSourceEntries(environment.name);
                         return {
                             ...sourceEntries,
-                            ...setupFiles[environment.name]
+                            ...setupFiles[environment.name],
+                            ...globalSetupFiles?.[environment.name] || {}
                         };
                     };
                     config.watchOptions ??= {};
                     config.watchOptions.ignored = castArray(config.watchOptions.ignored || []);
                     if (0 === config.watchOptions.ignored.length) config.watchOptions.ignored.push('**/.git', '**/node_modules');
-                    config.watchOptions.ignored.push(TEMP_RSTEST_OUTPUT_DIR_GLOB, context.normalizedConfig.coverage.reportsDirectory, '**/*.snap');
+                    config.watchOptions.ignored.push(TEMP_RSTEST_OUTPUT_DIR_GLOB, context.normalizedConfig.coverage.reportsDirectory, ...Object.values(globalSetupFiles?.[environment.name] || {}), '**/*.snap');
                     const configFilePath = context.projects.find((project)=>project.environmentName === environment.name)?.configFilePath;
                     if (configFilePath) config.watchOptions.ignored.push(configFilePath);
                 } else {
@@ -487,6 +574,7 @@ const pluginEntryWatch = ({ isWatch, globTestSourceEntries, setupFiles, context
                     const sourceEntries = await globTestSourceEntries(environment.name);
                     config.entry = {
                         ...setupFiles[environment.name],
+                        ...globalSetupFiles?.[environment.name] || {},
                         ...sourceEntries
                     };
                 }
@@ -694,7 +782,7 @@ function parseInlineSourceMapStr(code) {
     }
 }
 const isMultiCompiler = (compiler)=>'compilers' in compiler && Array.isArray(compiler.compilers);
-const prepareRsbuild = async (context, globTestSourceEntries, setupFiles)=>{
+const prepareRsbuild = async (context, globTestSourceEntries, setupFiles, globalSetupFiles)=>{
     const { command, normalizedConfig: { isolate, dev = {}, coverage } } = context;
     const debugMode = isDebug();
     core_logger.level = debugMode ? 'verbose' : 'error';
@@ -733,11 +821,15 @@ const prepareRsbuild = async (context, globTestSourceEntries, setupFiles)=>{
                 pluginEntryWatch({
                     globTestSourceEntries,
                     setupFiles,
+                    globalSetupFiles,
                     context,
                     isWatch: 'watch' === command
                 }),
                 pluginExternal(context),
-                !isolate ? pluginCacheControl(Object.values(setupFiles).flatMap((files)=>Object.values(files))) : null,
+                !isolate ? pluginCacheControl(Object.values({
+                    ...setupFiles,
+                    ...globalSetupFiles
+                }).flatMap((files)=>Object.values(files))) : null,
                 pluginInspect()
             ].filter(Boolean)
         }
@@ -750,7 +842,7 @@ const prepareRsbuild = async (context, globTestSourceEntries, setupFiles)=>{
                 pluginCoverageCore: mod.pluginCoverageCore
             }));
         const { pluginCoverage } = await loadCoverageProvider(coverage, context.rootPath);
-        coverage.exclude.push(...Object.values(setupFiles).flatMap((files)=>Object.values(files)));
+        coverage.exclude.push(...Object.values(setupFiles).flatMap((files)=>Object.values(files)), ...Object.values(globalSetupFiles || {}).flatMap((files)=>Object.values(files)));
         rsbuildInstance.addPlugins([
             pluginCoverage(coverage),
             pluginCoverageCore(coverage)
@@ -758,50 +850,79 @@ const prepareRsbuild = async (context, globTestSourceEntries, setupFiles)=>{
     }
     return rsbuildInstance;
 };
-const calcEntriesToRerun = (entries, chunks, buildData, runtimeChunkName)=>{
-    const entryToChunkHashesMap = new Map();
-    const buildChunkHashes = (entry)=>{
+const calcEntriesToRerun = (entries, chunks, buildData, runtimeChunkName, setupEntries)=>{
+    const buildChunkHashes = (entry, map)=>{
         const validChunks = (entry.chunks || []).filter((chunk)=>chunk !== runtimeChunkName);
         validChunks.forEach((chunkName)=>{
             const chunkInfo = chunks?.find((c)=>c.names?.includes(chunkName));
             if (chunkInfo) {
-                const existing = entryToChunkHashesMap.get(entry.testPath) || {};
+                const existing = map.get(entry.testPath) || {};
                 existing[chunkName] = chunkInfo.hash ?? '';
-                entryToChunkHashesMap.set(entry.testPath, existing);
+                map.set(entry.testPath, existing);
             }
         });
     };
-    (entries || []).forEach(buildChunkHashes);
+    const processEntryChanges = (_entries, prevHashes, currentHashesMap)=>{
+        const affectedPaths = new Set();
+        const deletedPaths = [];
+        if (prevHashes) {
+            const prevMap = new Map(prevHashes.map((e)=>[
+                    e.name,
+                    e.chunks
+                ]));
+            const currentNames = new Set(currentHashesMap.keys());
+            deletedPaths.push(...Array.from(prevMap.keys()).filter((name)=>!currentNames.has(name)));
+            const findAffectedEntry = (testPath)=>{
+                const currentChunks = currentHashesMap.get(testPath);
+                const prevChunks = prevMap.get(testPath);
+                if (!currentChunks) return;
+                if (!prevChunks) return void affectedPaths.add(testPath);
+                const hasChanges = Object.entries(currentChunks).some(([chunkName, hash])=>prevChunks[chunkName] !== hash);
+                if (hasChanges) affectedPaths.add(testPath);
+            };
+            currentHashesMap.forEach((_, testPath)=>{
+                findAffectedEntry(testPath);
+            });
+        }
+        return {
+            affectedPaths,
+            deletedPaths
+        };
+    };
+    const previousSetupHashes = buildData.setupEntryToChunkHashes;
+    const previousEntryHashes = buildData.entryToChunkHashes;
+    const setupEntryToChunkHashesMap = new Map();
+    setupEntries.forEach((entry)=>{
+        buildChunkHashes(entry, setupEntryToChunkHashesMap);
+    });
+    const setupEntryToChunkHashes = Array.from(setupEntryToChunkHashesMap.entries()).map(([name, chunks])=>({
+            name,
+            chunks
+        }));
+    buildData.setupEntryToChunkHashes = setupEntryToChunkHashes;
+    const entryToChunkHashesMap = new Map();
+    (entries || []).forEach((entry)=>{
+        buildChunkHashes(entry, entryToChunkHashesMap);
+    });
     const entryToChunkHashes = Array.from(entryToChunkHashesMap.entries()).map(([name, chunks])=>({
             name,
             chunks
         }));
-    const affectedTestPaths = new Set();
-    const deletedEntries = [];
-    if (buildData.entryToChunkHashes) {
-        const prevMap = new Map(buildData.entryToChunkHashes.map((e)=>[
-                e.name,
-                e.chunks
-            ]));
-        const currentNames = new Set(entryToChunkHashesMap.keys());
-        deletedEntries.push(...Array.from(prevMap.keys()).filter((name)=>!currentNames.has(name)));
-        const findAffectedEntry = (testPath)=>{
-            const currentChunks = entryToChunkHashesMap.get(testPath);
-            const prevChunks = prevMap.get(testPath);
-            if (!currentChunks) return;
-            if (!prevChunks) return void affectedTestPaths.add(testPath);
-            const hasChanges = Object.entries(currentChunks).some(([chunkName, hash])=>prevChunks[chunkName] !== hash);
-            if (hasChanges) affectedTestPaths.add(testPath);
-        };
-        entryToChunkHashesMap.forEach((_, testPath)=>{
-            findAffectedEntry(testPath);
-        });
-    }
     buildData.entryToChunkHashes = entryToChunkHashes;
+    const isSetupChanged = ()=>{
+        const { affectedPaths: affectedSetupPaths, deletedPaths: deletedSetups } = processEntryChanges(setupEntries, previousSetupHashes, setupEntryToChunkHashesMap);
+        const affectedSetups = Array.from(affectedSetupPaths).map((testPath)=>setupEntries.find((e)=>e.testPath === testPath)).filter((entry)=>void 0 !== entry);
+        return affectedSetups.length > 0 || deletedSetups.length > 0;
+    };
+    if (isSetupChanged()) return {
+        affectedEntries: entries,
+        deletedEntries: []
+    };
+    const { affectedPaths: affectedTestPaths, deletedPaths } = processEntryChanges(entries, previousEntryHashes, entryToChunkHashesMap);
     const affectedEntries = Array.from(affectedTestPaths).map((testPath)=>entries.find((e)=>e.testPath === testPath)).filter((entry)=>void 0 !== entry);
     return {
         affectedEntries,
-        deletedEntries
+        deletedEntries: deletedPaths
     };
 };
 class AssetsMemorySafeMap extends Map {
@@ -811,7 +932,7 @@ class AssetsMemorySafeMap extends Map {
         return super.set(key, value);
     }
 }
-const createRsbuildServer = async ({ globTestSourceEntries, setupFiles, rsbuildInstance, inspectedConfig })=>{
+const createRsbuildServer = async ({ globTestSourceEntries, setupFiles, globalSetupFiles, rsbuildInstance, inspectedConfig, isWatchMode })=>{
     let rspackCompiler;
     const rstestCompilerPlugin = {
         name: 'rstest:compiler',
@@ -876,12 +997,13 @@ const createRsbuildServer = async ({ globTestSourceEntries, setupFiles, rsbuildI
         const entryFiles = await getEntryFiles(manifest, outputPath);
         const entries = [];
         const setupEntries = [];
+        const globalSetupEntries = [];
         const sourceEntries = await globTestSourceEntries(environmentName);
         for (const entry of Object.keys(entrypoints)){
             const e = entrypoints[entry];
             const filteredAssets = e.assets.filter((asset)=>!asset.name.endsWith('.wasm'));
             const distPath = posix.join(outputPath, filteredAssets[filteredAssets.length - 1].name);
-            if (setupFiles[environmentName][entry]) setupEntries.push({
+            if (setupFiles[environmentName]?.[entry]) setupEntries.push({
                 distPath,
                 testPath: setupFiles[environmentName][entry],
                 files: entryFiles[entry],
@@ -895,7 +1017,12 @@ const createRsbuildServer = async ({ globTestSourceEntries, setupFiles, rsbuildI
                     files: entryFiles[entry],
                     chunks: e.chunks || []
                 });
-            }
+            } else if (globalSetupFiles?.[environmentName]?.[entry]) globalSetupEntries.push({
+                distPath,
+                testPath: globalSetupFiles[environmentName][entry],
+                files: entryFiles[entry],
+                chunks: e.chunks || []
+            });
         }
         const inlineSourceMap = 'inline-source-map' === stats.compilation.options.devtool;
         const sourceMapPaths = Object.fromEntries(assets.map((asset)=>{
@@ -918,7 +1045,10 @@ const createRsbuildServer = async ({ globTestSourceEntries, setupFiles, rsbuildI
             ];
         }));
         buildData[environmentName] ??= {};
-        const { affectedEntries, deletedEntries } = calcEntriesToRerun(entries, chunks, buildData[environmentName], `${environmentName}-${RUNTIME_CHUNK_NAME}`);
+        const { affectedEntries, deletedEntries } = isWatchMode ? calcEntriesToRerun(entries, chunks, buildData[environmentName], `${environmentName}-${RUNTIME_CHUNK_NAME}`, setupEntries) : {
+            affectedEntries: [],
+            deletedEntries: []
+        };
         const cachedAssetFiles = new AssetsMemorySafeMap();
         const cachedSourceMaps = new AssetsMemorySafeMap();
         const readFileWithCache = async (name)=>{
@@ -949,6 +1079,7 @@ const createRsbuildServer = async ({ globTestSourceEntries, setupFiles, rsbuildI
             hash,
             entries,
             setupEntries,
+            globalSetupEntries,
             assetNames,
             getAssetFiles: async (names)=>Object.fromEntries(await Promise.all(names.map(async (name)=>{
                     const content = await readFileWithCache(name);
@@ -971,4 +1102,4 @@ const createRsbuildServer = async ({ globTestSourceEntries, setupFiles, rsbuildI
         getRsbuildStats
     };
 };
-export { createPool, createRsbuildServer, prepareRsbuild };
+export { createPool, createRsbuildServer, prepareRsbuild, runGlobalSetup, runGlobalTeardown };

package/dist/0~919.js

@@ -1,7 +1,7 @@
 import 'module';
 /*#__PURE__*/ import.meta.url;
 import { __webpack_require__ } from "./rslib-runtime.js";
-import "./946.js";
+import "./693.js";
 __webpack_require__.add({
     "../../node_modules/.pnpm/js-tokens@4.0.0/node_modules/js-tokens/index.js" (__unused_rspack_module, exports) {
         Object.defineProperty(exports, "__esModule", {

package/dist/0~923.js

@@ -1,10 +1,11 @@
 import 'module';
 /*#__PURE__*/ import.meta.url;
 import { __webpack_require__ } from "./rslib-runtime.js";
-import { posix, logger_logger } from "./946.js";
-import { pathToFileURL } from "./404.js";
+import "./693.js";
+import { pathToFileURL } from "./198.js";
 import { node_vm, interopModule, shouldInterop } from "./0~346.js";
-const external_node_path_ = __webpack_require__("path");
+import { posix, logger_logger } from "./278.js";
+const external_node_path_ = __webpack_require__("node:path");
 var loadEsModule_EsmMode = /*#__PURE__*/ function(EsmMode) {
     EsmMode[EsmMode["Unknown"] = 0] = "Unknown";
     EsmMode[EsmMode["Evaluated"] = 1] = "Evaluated";

package/dist/0~973.js

@@ -0,0 +1,50 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { __webpack_require__ } from "./rslib-runtime.js";
+import "./693.js";
+import { fileURLToPath } from "./198.js";
+import { rspack } from "./131.js";
+import { getAbsolutePath, formatTestEntryName } from "./157.js";
+import { posix } from "./278.js";
+const external_node_fs_ = __webpack_require__("node:fs");
+const picocolors = __webpack_require__("../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js");
+var picocolors_default = /*#__PURE__*/ __webpack_require__.n(picocolors);
+const tryResolve = (request, rootPath)=>{
+    const { resolver } = rspack.experiments;
+    const esmFirstResolver = new resolver.ResolverFactory({
+        conditionNames: [
+            'node',
+            'import',
+            'require'
+        ]
+    });
+    const { path: resolvedPath } = esmFirstResolver.sync(rootPath, request);
+    return resolvedPath;
+};
+const getSetupFiles = (setups, rootPath)=>{
+    if (!setups.length) return {};
+    return Object.fromEntries(setups.map((filePath)=>{
+        const setupFile = filePath.startsWith('file://') ? fileURLToPath(filePath) : filePath;
+        const setupFilePath = getAbsolutePath(rootPath, setupFile);
+        try {
+            if (!(0, external_node_fs_.existsSync)(setupFilePath)) {
+                let errorMessage = `Setup file ${picocolors_default().red(setupFile)} not found`;
+                if (setupFilePath !== setupFile) errorMessage += picocolors_default().gray(` (resolved path: ${setupFilePath})`);
+                throw errorMessage;
+            }
+            const relativePath = posix.relative(rootPath, setupFilePath);
+            return [
+                formatTestEntryName(relativePath),
+                setupFilePath
+            ];
+        } catch (err) {
+            const resolvedPath = tryResolve(setupFile, rootPath);
+            if (resolvedPath) return [
+                formatTestEntryName(setupFile),
+                resolvedPath
+            ];
+            throw err;
+        }
+    }));
+};
+export { getSetupFiles };