@rstest/core 0.8.1 → 0.8.2

package/dist/0~1472.js

@@ -5,7 +5,7 @@ import { pathToFileURL } from "./6198.js";
 import "./1157.js";
 import { logger as logger_logger, color } from "./3160.js";
 async function loadBrowserModule(options = {}) {
-    const coreVersion = "0.8.1";
+    const coreVersion = "0.8.2";
     const { projectRoots = [] } = options;
     let browserModule;
     let browserVersion;

package/dist/0~2173.js

@@ -1,6 +1,6 @@
 import 'module';
 /*#__PURE__*/ import.meta.url;
-import { getTestEntries } from "./1157.js";
+import { resolveShardedEntries, getTestEntries } from "./1157.js";
 import { createCoverageProvider } from "./5734.js";
 import { prepareRsbuild, createPool, createRsbuildServer, runGlobalTeardown, runGlobalSetup } from "./0~89.js";
 import { loadBrowserModule } from "./0~1472.js";
@@ -156,26 +156,35 @@ async function runBrowserModeTests(context, browserProjects, options) {
 async function runTests(context) {
     const browserProjects = context.projects.filter((project)=>project.normalizedConfig.browser.enabled);
     const nodeProjects = context.projects.filter((project)=>!project.normalizedConfig.browser.enabled);
-    const hasBrowserTests = context.normalizedConfig.browser.enabled || browserProjects.length > 0;
-    const hasNodeTests = nodeProjects.length > 0;
+    const hasBrowserProjects = browserProjects.length > 0;
+    const hasNodeProjects = nodeProjects.length > 0;
     const isWatchMode = 'watch' === context.command;
-    const shouldUnifyReporter = !isWatchMode && hasBrowserTests && hasNodeTests;
-    if (hasBrowserTests && !hasNodeTests) return void await runBrowserModeTests(context, browserProjects, {
-        skipOnTestRunEnd: false
-    });
-    let browserResultPromise;
-    if (hasBrowserTests) browserResultPromise = runBrowserModeTests(context, browserProjects, {
-        skipOnTestRunEnd: shouldUnifyReporter
-    });
-    if (!hasNodeTests) {
-        if (browserResultPromise) await browserResultPromise;
+    const shouldUnifyReporter = !isWatchMode && hasBrowserProjects && hasNodeProjects;
+    if (hasBrowserProjects && !hasNodeProjects) {
+        const { coverage } = context.normalizedConfig;
+        if (coverage.enabled) logger_logger.log(` ${color.gray('Coverage enabled with')} %s\n`, color.yellow(coverage.provider));
+        const browserResult = await runBrowserModeTests(context, browserProjects, {
+            skipOnTestRunEnd: false
+        });
+        if (coverage.enabled && browserResult?.results) {
+            const coverageProvider = await createCoverageProvider(coverage, context.rootPath);
+            if (coverageProvider) {
+                const { generateCoverage } = await import("./0~4403.js").then((mod)=>({
+                        generateCoverage: mod.generateCoverage
+                    }));
+                await generateCoverage(context, browserResult.results, coverageProvider);
+            }
+        }
         return;
     }
-    const projects = nodeProjects;
-    const { rootPath, reporters, snapshotManager, command, normalizedConfig: { coverage } } = context;
-    const entriesCache = new Map();
+    let browserResultPromise;
+    const allProjects = context.projects;
+    const { rootPath, reporters, snapshotManager, command, normalizedConfig } = context;
+    const { coverage, shard } = normalizedConfig;
+    const entriesCache = await resolveShardedEntries(context) || new Map();
     const globTestSourceEntries = async (name)=>{
-        const { include, exclude, includeSource, root } = projects.find((p)=>p.environmentName === name).normalizedConfig;
+        if (!isWatchMode && shard && entriesCache.has(name)) return entriesCache.get(name).entries;
+        const { include, exclude, includeSource, root } = allProjects.find((p)=>p.environmentName === name).normalizedConfig;
         const entries = await getTestEntries({
             include,
             exclude: exclude.patterns,
@@ -190,6 +199,28 @@ async function runTests(context) {
         });
         return entries;
     };
+    let browserProjectsToRun = browserProjects;
+    let nodeProjectsToRun = nodeProjects;
+    if (shard) {
+        browserProjectsToRun = browserProjects.filter((p)=>Object.keys(entriesCache.get(p.environmentName)?.entries || {}).length > 0);
+        nodeProjectsToRun = nodeProjects.filter((p)=>Object.keys(entriesCache.get(p.environmentName)?.entries || {}).length > 0);
+    }
+    const hasBrowserTestsToRun = browserProjectsToRun.length > 0;
+    const hasNodeTestsToRun = nodeProjectsToRun.length > 0;
+    if (hasBrowserTestsToRun) {
+        const browserEntries = new Map();
+        if (shard) for (const p of browserProjectsToRun)browserEntries.set(p.environmentName, entriesCache.get(p.environmentName));
+        browserResultPromise = runBrowserModeTests(context, browserProjectsToRun, {
+            skipOnTestRunEnd: shouldUnifyReporter,
+            shardedEntries: shard ? browserEntries : void 0
+        });
+    }
+    if (!hasNodeTestsToRun) {
+        if (browserResultPromise) await browserResultPromise;
+        if (hasBrowserTestsToRun) return;
+        if (!hasNodeProjects) return;
+    }
+    const projects = nodeProjectsToRun;
     const { getSetupFiles } = await import("./6973.js").then((mod)=>({
             getSetupFiles: mod.getSetupFiles
         }));
@@ -214,17 +245,21 @@ async function runTests(context) {
             projects: projects.map((p)=>p.normalizedConfig)
         },
         isWatchMode,
-        globTestSourceEntries: isWatchMode ? globTestSourceEntries : async (name)=>{
-            if (entriesCache.has(name)) return entriesCache.get(name).entries;
-            return globTestSourceEntries(name);
-        },
+        globTestSourceEntries,
         setupFiles,
         globalSetupFiles,
         rsbuildInstance,
         rootPath
     });
     const entryFiles = Array.from(entriesCache.values()).reduce((acc, entry)=>acc.concat(Object.values(entry.entries) || []), []);
-    const recommendWorkerCount = 'watch' === command ? 1 / 0 : entryFiles.length;
+    const getRecommendWorkerCount = ()=>{
+        const nodeEntries = Array.from(entriesCache.entries()).filter(([key])=>{
+            const project = projects.find((p)=>p.environmentName === key);
+            return project?.normalizedConfig.browser.enabled !== true;
+        });
+        return nodeEntries.flatMap(([_key, entry])=>Object.values(entry.entries) || []).length;
+    };
+    const recommendWorkerCount = 'watch' === command ? 1 / 0 : getRecommendWorkerCount();
     const pool = await createPool({
         context,
         recommendWorkerCount
@@ -302,6 +337,8 @@ async function runTests(context) {
         const results = returns.flatMap((r)=>r.results);
         const testResults = returns.flatMap((r)=>r.testResults);
         const errors = returns.flatMap((r)=>r.errors || []);
+        if (shouldUnifyReporter && browserResult?.results) results.push(...browserResult.results);
+        if (shouldUnifyReporter && browserResult?.testResults) testResults.push(...browserResult.testResults);
         context.updateReporterResultState(results, testResults, currentDeletedEntries);
         const nodeHasFailure = results.some((r)=>'fail' === r.status) || errors.length;
         const browserHasFailure = shouldUnifyReporter && browserResult?.hasFailure;
@@ -310,13 +347,15 @@ async function runTests(context) {
             else logger_logger.log(color.yellow('No test files found.'));
             else {
                 const code = context.normalizedConfig.passWithNoTests ? 0 : 1;
-                logger_logger.log(color[code ? 'red' : 'yellow'](`No test files found, exiting with code ${code}.`));
+                const message = `No test files found, exiting with code ${code}.`;
+                if (0 === code) logger_logger.log(color.yellow(message));
+                else logger_logger.error(color.red(message));
                 process.exitCode = code;
             }
             if ('all' === mode) {
                 if (context.fileFilters?.length) logger_logger.log(color.gray('filter: '), context.fileFilters.join(color.gray(', ')));
-                projects.forEach((p)=>{
-                    if (projects.length > 1) {
+                allProjects.forEach((p)=>{
+                    if (allProjects.length > 1) {
                         logger_logger.log('');
                         logger_logger.log(color.gray('project:'), p.name);
                     }

package/dist/0~2255.js

@@ -2,7 +2,7 @@ import 'module';
 /*#__PURE__*/ import.meta.url;
 import { __webpack_require__ } from "./rslib-runtime.js";
 import "./3160.js";
-const external_node_fs_ = __webpack_require__("node:fs");
+const external_node_fs_ = __webpack_require__("fs");
 const pluginCoverageCore = (coverageOptions)=>({
         name: 'rstest:coverage-core',
         setup: (api)=>{

package/dist/0~4403.js

@@ -53,12 +53,13 @@ async function generateCoverage(context, results, coverageProvider) {
             });
             if (!thresholdResult.success) {
                 logger_logger.log('');
-                logger_logger.log(thresholdResult.message);
+                logger_logger.stderr(thresholdResult.message);
                 process.exitCode = 1;
             }
         }
     } catch (error) {
-        logger_logger.error('Failed to generate coverage reports:', error);
+        logger_logger.stderr('Failed to generate coverage reports:', error);
+        process.exitCode = 1;
     }
 }
 async function generateCoverageForUntestedFiles(environmentName, uncoveredFiles, coverageMap, coverageProvider) {

package/dist/0~5835.js

@@ -6,7 +6,7 @@ import { createRequire as external_node_module_createRequire } from "./4881.js";
 import { pathToFileURL } from "./6198.js";
 import { node_vm, asModule, shouldInterop, interopModule } from "./0~3346.js";
 import { posix } from "./7011.js";
-const external_node_path_ = __webpack_require__("node:path");
+const external_node_path_ = __webpack_require__("path");
 let latestAssetFiles = {};
 const updateLatestAssetFiles = (assetFiles)=>{
     latestAssetFiles = assetFiles;

package/dist/0~6588.js

@@ -28,7 +28,7 @@ async function createChokidar(pathOrGlobs, root, options) {
     }
     return chokidar.watch(Array.from(watchFiles), options);
 }
-const external_node_path_ = __webpack_require__("node:path");
+const external_node_path_ = __webpack_require__("path");
 let cleaners = [];
 const onBeforeRestart = (cleaner)=>{
     cleaners.push(cleaner);

package/dist/0~6923.js

@@ -5,7 +5,7 @@ import { logger as logger_logger } from "./3160.js";
 import { pathToFileURL } from "./6198.js";
 import { node_vm, interopModule, shouldInterop } from "./0~3346.js";
 import { posix } from "./7011.js";
-const external_node_path_ = __webpack_require__("node:path");
+const external_node_path_ = __webpack_require__("path");
 var loadEsModule_EsmMode = /*#__PURE__*/ function(EsmMode) {
     EsmMode[EsmMode["Unknown"] = 0] = "Unknown";
     EsmMode[EsmMode["Evaluated"] = 1] = "Evaluated";

package/dist/0~7583.js

@@ -7,7 +7,7 @@ import "./3160.js";
 import { readdir as promises_readdir, lstat as promises_lstat, promises_stat as promises_promises_stat, realpath as external_node_fs_promises_realpath } from "./1157.js";
 import { Readable } from "./0~1981.js";
 import { EventEmitter } from "./9131.js";
-const external_node_path_ = __webpack_require__("node:path");
+const external_node_path_ = __webpack_require__("path");
 const EntryTypes = {
     FILE_TYPE: 'files',
     DIR_TYPE: 'directories',
@@ -221,7 +221,7 @@ function readdirp(root, options = {}) {
     options.root = root;
     return new ReaddirpStream(options);
 }
-const external_node_fs_ = __webpack_require__("node:fs");
+const external_node_fs_ = __webpack_require__("fs");
 const external_node_os_ = __webpack_require__("node:os");
 const STR_DATA = 'data';
 const STR_END = 'end';