@rstest/core 0.2.2 → 0.3.1

package/dist/{698.js → 12.js}

@@ -1,8 +1,8 @@
 import 'module';
 /*#__PURE__*/ import.meta.url;
-export const __webpack_id__ = "698";
+export const __webpack_id__ = "12";
 export const __webpack_ids__ = [
-    "698"
+    "12"
 ];
 export const __webpack_modules__ = {
     "../../node_modules/.pnpm/stacktrace-parser@0.1.11/node_modules/stacktrace-parser/dist/stack-trace-parser.esm.js": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
@@ -367,10 +367,10 @@ export const __webpack_modules__ = {
             utils.vF.log(`${utils.yW.gray('Duration'.padStart(11))} ${(0, utils.kV)(duration.totalTime)} ${utils.yW.gray(`(build ${(0, utils.kV)(duration.buildTime)}, tests ${(0, utils.kV)(duration.testTime)})`)}`);
             utils.vF.log('');
         };
-        const printSummaryErrorLogs = async ({ testResults, results, rootPath, getSourcemap })=>{
+        const printSummaryErrorLogs = async ({ testResults, results, rootPath, getSourcemap, filterRerunTestPaths })=>{
             const failedTests = [
-                ...results.filter((i)=>'fail' === i.status && i.errors?.length),
-                ...testResults.filter((i)=>'fail' === i.status)
+                ...results.filter((i)=>'fail' === i.status && i.errors?.length && (filterRerunTestPaths ? filterRerunTestPaths.includes(i.testPath) : true)),
+                ...testResults.filter((i)=>'fail' === i.status && (filterRerunTestPaths ? filterRerunTestPaths.includes(i.testPath) : true))
             ];
             if (0 === failedTests.length) return;
             utils.vF.log('');
@@ -468,14 +468,15 @@ export const __webpack_modules__ = {
             async onExit() {
                 this.statusRenderer?.clear();
             }
-            async onTestRunEnd({ results, testResults, duration, getSourcemap, snapshotSummary }) {
+            async onTestRunEnd({ results, testResults, duration, getSourcemap, snapshotSummary, filterRerunTestPaths }) {
                 this.statusRenderer?.clear();
                 if (false === this.options.summary) return;
                 await printSummaryErrorLogs({
                     testResults,
                     results,
                     rootPath: this.rootPath,
-                    getSourcemap
+                    getSourcemap,
+                    filterRerunTestPaths
                 });
                 printSummaryLog({
                     results,
@@ -551,6 +552,82 @@ export const __webpack_modules__ = {
             }
         }
         var helper = __webpack_require__("./src/utils/helper.ts");
+        function formatEnvironmentName(name) {
+            return name.replace(/[^a-zA-Z0-9\-_$]/g, '_');
+        }
+        class Rstest {
+            cwd;
+            command;
+            fileFilters;
+            configFilePath;
+            reporters;
+            snapshotManager;
+            version;
+            rootPath;
+            originalConfig;
+            normalizedConfig;
+            idMap = new Map();
+            reporterResults = {
+                results: [],
+                testResults: []
+            };
+            projects = [];
+            constructor({ cwd = process.cwd(), command, fileFilters, configFilePath, projects }, userConfig){
+                this.cwd = cwd;
+                this.command = command;
+                this.fileFilters = fileFilters;
+                this.configFilePath = configFilePath;
+                const rootPath = userConfig.root ? (0, helper.FI)(cwd, userConfig.root) : cwd;
+                const rstestConfig = (0, src_config.wX)(userConfig);
+                const reporters = 'list' !== command ? createReporters(rstestConfig.reporters, {
+                    rootPath,
+                    config: rstestConfig
+                }) : [];
+                const snapshotManager = new SnapshotManager({
+                    updateSnapshot: rstestConfig.update ? 'all' : external_std_env_.isCI ? 'none' : 'new'
+                });
+                this.reporters = reporters;
+                this.snapshotManager = snapshotManager;
+                this.version = "0.3.1";
+                this.rootPath = rootPath;
+                this.originalConfig = userConfig;
+                this.normalizedConfig = rstestConfig;
+                this.projects = projects.length ? projects.map((project)=>{
+                    const config = (0, src_config.wX)(project.config);
+                    config.isolate = rstestConfig.isolate;
+                    return {
+                        configFilePath: project.configFilePath,
+                        rootPath: config.root,
+                        name: config.name,
+                        environmentName: formatEnvironmentName(config.name),
+                        normalizedConfig: config
+                    };
+                }) : [
+                    {
+                        configFilePath,
+                        rootPath,
+                        name: rstestConfig.name,
+                        environmentName: formatEnvironmentName(rstestConfig.name),
+                        normalizedConfig: rstestConfig
+                    }
+                ];
+            }
+            updateReporterResultState(results, testResults, deletedEntries = []) {
+                results.forEach((item)=>{
+                    const existingIndex = this.reporterResults.results.findIndex((r)=>r.testPath === item.testPath);
+                    if (-1 !== existingIndex) this.reporterResults.results[existingIndex] = item;
+                    else this.reporterResults.results.push(item);
+                });
+                const testPathsToUpdate = new Set(testResults.map((r)=>r.testPath));
+                this.reporterResults.testResults = this.reporterResults.testResults.filter((r)=>!testPathsToUpdate.has(r.testPath));
+                this.reporterResults.testResults.push(...testResults);
+                if (deletedEntries.length > 0) {
+                    const deletedPathsSet = new Set(deletedEntries);
+                    this.reporterResults.results = this.reporterResults.results.filter((r)=>!deletedPathsSet.has(r.testPath));
+                    this.reporterResults.testResults = this.reporterResults.testResults.filter((r)=>!deletedPathsSet.has(r.testPath));
+                }
+            }
+        }
         const reportersMap = {
             default: DefaultReporter,
             verbose: VerboseReporter,
@@ -576,35 +653,13 @@ export const __webpack_modules__ = {
             });
             return result;
         }
-        function createContext(options, userConfig) {
-            const { cwd, command, fileFilters, configFilePath } = options;
-            const rootPath = userConfig.root ? (0, helper.FI)(cwd, userConfig.root) : cwd;
-            const rstestConfig = (0, src_config.wX)(userConfig);
-            const reporters = 'list' !== command ? createReporters(rstestConfig.reporters, {
-                rootPath,
-                config: rstestConfig
-            }) : [];
-            const snapshotManager = new SnapshotManager({
-                updateSnapshot: rstestConfig.update ? 'all' : external_std_env_.isCI ? 'none' : 'new'
-            });
-            return {
-                configFilePath,
-                command,
-                version: "0.2.2",
-                rootPath,
-                reporters,
-                fileFilters,
-                snapshotManager,
-                originalConfig: userConfig,
-                normalizedConfig: rstestConfig
-            };
-        }
-        function createRstest({ config, configFilePath }, command, fileFilters) {
-            const context = createContext({
+        function createRstest({ config, projects, configFilePath }, command, fileFilters) {
+            const context = new Rstest({
                 cwd: process.cwd(),
                 command,
                 fileFilters,
-                configFilePath
+                configFilePath,
+                projects
             }, config);
             const runTests = async ()=>{
                 const { runTests } = await Promise.all([

package/dist/223.js

@@ -0,0 +1,155 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+export const __webpack_id__ = "223";
+export const __webpack_ids__ = [
+    "223"
+];
+export const __webpack_modules__ = {
+    "./src/cli/init.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            initCli: ()=>initCli
+        });
+        var node_fs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("node:fs");
+        var pathe__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("pathe");
+        var tinyglobby__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__("../../node_modules/.pnpm/tinyglobby@0.2.14/node_modules/tinyglobby/dist/index.mjs");
+        var _config__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./src/config.ts");
+        var _utils__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("./src/utils/index.ts");
+        async function resolveConfig(options) {
+            const { content: config, filePath: configFilePath } = await (0, _config__WEBPACK_IMPORTED_MODULE_2__.Z9)({
+                cwd: options.root,
+                path: options.config,
+                configLoader: options.configLoader
+            });
+            const keys = [
+                'root',
+                'globals',
+                'isolate',
+                'passWithNoTests',
+                'update',
+                'testNamePattern',
+                'testTimeout',
+                'hookTimeout',
+                'clearMocks',
+                'resetMocks',
+                'restoreMocks',
+                'unstubEnvs',
+                'unstubGlobals',
+                'retry',
+                'slowTestThreshold',
+                'maxConcurrency',
+                'printConsoleTrace',
+                'disableConsoleIntercept',
+                'testEnvironment'
+            ];
+            for (const key of keys)if (void 0 !== options[key]) config[key] = options[key];
+            if (options.reporter) config.reporters = (0, _utils__WEBPACK_IMPORTED_MODULE_3__.bg)(options.reporter);
+            if (options.exclude) config.exclude = (0, _utils__WEBPACK_IMPORTED_MODULE_3__.bg)(options.exclude);
+            if (options.include) config.include = (0, _utils__WEBPACK_IMPORTED_MODULE_3__.bg)(options.include);
+            return {
+                config,
+                configFilePath: configFilePath ?? void 0
+            };
+        }
+        async function resolveProjects({ config, root, options }) {
+            if (!config.projects) return [];
+            const getDefaultProjectName = (dir)=>{
+                const pkgJsonPath = (0, pathe__WEBPACK_IMPORTED_MODULE_1__.resolve)(dir, 'package.json');
+                const name = (0, node_fs__WEBPACK_IMPORTED_MODULE_0__.existsSync)(pkgJsonPath) ? JSON.parse((0, node_fs__WEBPACK_IMPORTED_MODULE_0__.readFileSync)(pkgJsonPath, 'utf-8')).name : '';
+                if ('string' != typeof name || !name) return (0, pathe__WEBPACK_IMPORTED_MODULE_1__.basename)(dir);
+                return name;
+            };
+            const globProjects = async (patterns)=>{
+                const globOptions = {
+                    absolute: true,
+                    dot: true,
+                    onlyFiles: false,
+                    cwd: root,
+                    expandDirectories: false,
+                    ignore: [
+                        '**/node_modules/**',
+                        '**/.DS_Store'
+                    ]
+                };
+                return (0, tinyglobby__WEBPACK_IMPORTED_MODULE_4__.glob)(patterns, globOptions);
+            };
+            const formatRootStr = (rootStr)=>rootStr.replace('<rootDir>', root);
+            const { projectPaths, projectPatterns, projectConfigs } = (config.projects || []).reduce((total, p)=>{
+                if ('object' == typeof p) {
+                    const projectRoot = p.root ? formatRootStr(p.root) : root;
+                    total.projectConfigs.push({
+                        config: {
+                            root: projectRoot,
+                            name: p.name ? p.name : getDefaultProjectName(projectRoot),
+                            ...p
+                        },
+                        configFilePath: void 0
+                    });
+                    return total;
+                }
+                const projectStr = formatRootStr(p);
+                if ((0, tinyglobby__WEBPACK_IMPORTED_MODULE_4__.ey)(projectStr)) total.projectPatterns.push(projectStr);
+                else {
+                    const absolutePath = (0, _utils__WEBPACK_IMPORTED_MODULE_3__.FI)(root, projectStr);
+                    if (!(0, node_fs__WEBPACK_IMPORTED_MODULE_0__.existsSync)(absolutePath)) throw `Can't resolve project "${p}", please make sure "${p}" is a existing file or a directory.`;
+                    total.projectPaths.push(absolutePath);
+                }
+                return total;
+            }, {
+                projectPaths: [],
+                projectPatterns: [],
+                projectConfigs: []
+            });
+            projectPaths.push(...await globProjects(projectPatterns));
+            const projects = await Promise.all(projectPaths.map(async (project)=>{
+                const isDirectory = (0, node_fs__WEBPACK_IMPORTED_MODULE_0__.statSync)(project).isDirectory();
+                const { config, configFilePath } = await resolveConfig({
+                    ...options,
+                    config: isDirectory ? void 0 : project,
+                    root: isDirectory ? project : (0, pathe__WEBPACK_IMPORTED_MODULE_1__.dirname)(project)
+                });
+                config.name ??= getDefaultProjectName(project);
+                if (config.projects?.length && config.root !== root) _utils__WEBPACK_IMPORTED_MODULE_3__.vF.warn(`Projects cannot have nested projects, the "projects" field in project "${config.name}" will be ignored.`);
+                return {
+                    config,
+                    configFilePath
+                };
+            })).then((projects)=>(0, _utils__WEBPACK_IMPORTED_MODULE_3__.zz)(projects.concat(projectConfigs), options));
+            if (!projects.length) {
+                let errorMsg = `No projects found, please make sure you have at least one valid project.
+${_utils__WEBPACK_IMPORTED_MODULE_3__.yW.gray('projects:')} ${JSON.stringify(config.projects, null, 2)}`;
+                if (options.project) errorMsg += `\n${_utils__WEBPACK_IMPORTED_MODULE_3__.yW.gray('projectName filter:')} ${JSON.stringify(options.project, null, 2)}`;
+                throw errorMsg;
+            }
+            const names = new Set();
+            projects.forEach((project)=>{
+                if (names.has(project.config.name)) {
+                    const conflictProjects = projects.filter((p)=>p.config.name === project.config.name);
+                    throw `Project name "${project.config.name}" is already used. Please ensure all projects have unique names.
+Conflicting projects:
+${conflictProjects.map((p)=>`- ${p.configFilePath || p.config.root}`).join('\n')}
+        `;
+                }
+                names.add(project.config.name);
+            });
+            return projects;
+        }
+        async function initCli(options) {
+            const cwd = process.cwd();
+            const root = options.root ? (0, _utils__WEBPACK_IMPORTED_MODULE_3__.FI)(cwd, options.root) : cwd;
+            const { config, configFilePath } = await resolveConfig({
+                ...options,
+                root
+            });
+            const projects = await resolveProjects({
+                config,
+                root,
+                options
+            });
+            return {
+                config,
+                configFilePath,
+                projects
+            };
+        }
+    }
+};

package/dist/33.js

@@ -110,9 +110,9 @@ export const __webpack_modules__ = {
                 },
                 {
                     key: 'c',
-                    description: `${utils.yW.bold('c')}  ${utils.yW.dim('clear console')}`,
+                    description: `${utils.yW.bold('c')}  ${utils.yW.dim('clear screen')}`,
                     action: ()=>{
-                        console.clear();
+                        (0, utils.mT)(true);
                     }
                 },
                 {
@@ -154,38 +154,37 @@ export const __webpack_modules__ = {
         }
         var rsbuild = __webpack_require__("./src/core/rsbuild.ts");
         async function runTests(context) {
-            const { normalizedConfig: { include, exclude, root, name, setupFiles: setups, includeSource }, rootPath, reporters, snapshotManager, command } = context;
+            const { rootPath, reporters, projects, snapshotManager, command } = context;
             const entriesCache = new Map();
-            const globTestSourceEntries = async ()=>{
+            const globTestSourceEntries = async (name)=>{
+                const { include, exclude, includeSource, root } = projects.find((p)=>p.environmentName === name).normalizedConfig;
                 const entries = await (0, utils.tG)({
                     include,
                     exclude,
                     includeSource,
-                    root,
+                    rootPath,
+                    projectRoot: root,
                     fileFilters: context.fileFilters || []
                 });
                 entriesCache.set(name, {
                     entries,
                     fileFilters: context.fileFilters
                 });
-                if (!Object.keys(entries).length) {
-                    utils.vF.log(utils.yW.red('No test files found.'));
-                    utils.vF.log('');
-                    if (context.fileFilters?.length) utils.vF.log(utils.yW.gray('filter: '), context.fileFilters.join(utils.yW.gray(', ')));
-                    utils.vF.log(utils.yW.gray('include:'), include.join(utils.yW.gray(', ')));
-                    utils.vF.log(utils.yW.gray('exclude:'), exclude.join(utils.yW.gray(', ')));
-                    utils.vF.log('');
-                }
                 return entries;
             };
-            const setupFiles = (0, utils.pr)(setups, rootPath);
-            const rsbuildInstance = await (0, rsbuild.z)(context, globTestSourceEntries, setupFiles);
-            const { getRsbuildStats, closeServer } = await (0, rsbuild.X)({
-                name,
+            const setupFiles = Object.fromEntries(context.projects.map((project)=>{
+                const { environmentName, rootPath, normalizedConfig: { setupFiles } } = project;
+                return [
+                    environmentName,
+                    (0, utils.pr)(setupFiles, rootPath)
+                ];
+            }));
+            const rsbuildInstance = await (0, rsbuild.zh)(context, globTestSourceEntries, setupFiles);
+            const { getRsbuildStats, closeServer } = await (0, rsbuild.XD)({
                 normalizedConfig: context.normalizedConfig,
-                globTestSourceEntries: 'watch' === command ? globTestSourceEntries : async ()=>{
+                globTestSourceEntries: 'watch' === command ? globTestSourceEntries : async (name)=>{
                     if (entriesCache.has(name)) return entriesCache.get(name).entries;
-                    return globTestSourceEntries();
+                    return globTestSourceEntries(name);
                 },
                 setupFiles,
                 rsbuildInstance,
@@ -196,37 +195,78 @@ export const __webpack_modules__ = {
                 context,
                 recommendWorkerCount
             });
-            let testFileResult = [];
-            let buildHash;
-            const run = async ({ fileFilters } = {})=>{
-                const { entries, setupEntries, assetFiles, sourceMaps, getSourcemap, buildTime, hash } = await getRsbuildStats({
-                    fileFilters
-                });
-                const testStart = Date.now();
-                const { results, testResults } = await pool.runTests({
-                    context,
-                    entries,
-                    sourceMaps,
-                    setupEntries,
-                    assetFiles,
-                    updateSnapshot: snapshotManager.options.updateSnapshot
-                });
-                const actualBuildTime = buildHash === hash ? 0 : buildTime;
+            const run = async ({ fileFilters, mode = 'all' } = {})=>{
+                let testStart;
+                const buildStart = Date.now();
+                const currentEntries = [];
+                const currentDeletedEntries = [];
+                const returns = await Promise.all(context.projects.map(async (p)=>{
+                    const { entries, setupEntries, assetFiles, sourceMaps, affectedEntries, deletedEntries } = await getRsbuildStats({
+                        environmentName: p.environmentName,
+                        fileFilters
+                    });
+                    testStart ??= Date.now();
+                    currentDeletedEntries.push(...deletedEntries);
+                    let finalEntries = entries;
+                    if ('on-demand' === mode) {
+                        if (0 === affectedEntries.length) utils.vF.debug(utils.yW.yellow(`No test files need re-run in project(${p.environmentName}).`));
+                        else utils.vF.debug(utils.yW.yellow(`Test files to re-run in project(${p.environmentName}):\n`) + affectedEntries.map((e)=>e.testPath).join('\n') + '\n');
+                        finalEntries = affectedEntries;
+                    } else utils.vF.debug(utils.yW.yellow(fileFilters?.length ? `Run filtered tests in project(${p.environmentName}).\n` : `Run all tests in project(${p.environmentName}).\n`));
+                    currentEntries.push(...finalEntries);
+                    const { results, testResults } = await pool.runTests({
+                        entries: finalEntries,
+                        sourceMaps,
+                        setupEntries,
+                        assetFiles,
+                        project: p,
+                        updateSnapshot: context.snapshotManager.options.updateSnapshot
+                    });
+                    return {
+                        results,
+                        testResults,
+                        sourceMaps
+                    };
+                }));
+                const buildTime = testStart - buildStart;
                 const testTime = Date.now() - testStart;
                 const duration = {
-                    totalTime: testTime + actualBuildTime,
-                    buildTime: actualBuildTime,
+                    totalTime: testTime + buildTime,
+                    buildTime,
                     testTime
                 };
-                buildHash = hash;
-                testFileResult = results;
+                const results = returns.flatMap((r)=>r.results);
+                const testResults = returns.flatMap((r)=>r.testResults);
+                const sourceMaps = Object.assign({}, ...returns.map((r)=>r.sourceMaps));
+                context.updateReporterResultState(results, testResults, currentDeletedEntries);
+                if (0 === results.length) {
+                    if ('watch' === command) if ('on-demand' === mode) utils.vF.log(utils.yW.yellow('No test files need re-run.'));
+                    else utils.vF.log(utils.yW.yellow('No test files found.'));
+                    else {
+                        const code = context.normalizedConfig.passWithNoTests ? 0 : 1;
+                        utils.vF.log(utils.yW[code ? 'red' : 'yellow'](`No test files found, exiting with code ${code}.`));
+                        process.exitCode = code;
+                    }
+                    if ('all' === mode) {
+                        if (context.fileFilters?.length) utils.vF.log(utils.yW.gray('filter: '), context.fileFilters.join(utils.yW.gray(', ')));
+                        context.projects.forEach((p)=>{
+                            if (context.projects.length > 1) {
+                                utils.vF.log('');
+                                utils.vF.log(utils.yW.gray('project:'), p.name);
+                            }
+                            utils.vF.log(utils.yW.gray('include:'), p.normalizedConfig.include.join(utils.yW.gray(', ')));
+                            utils.vF.log(utils.yW.gray('exclude:'), p.normalizedConfig.exclude.join(utils.yW.gray(', ')));
+                        });
+                    }
+                }
                 if (results.some((r)=>'fail' === r.status)) process.exitCode = 1;
                 for (const reporter of reporters)await reporter.onTestRunEnd?.({
-                    results,
-                    testResults,
+                    results: context.reporterResults.results,
+                    testResults: context.reporterResults.testResults,
                     snapshotSummary: snapshotManager.summary,
                     duration,
-                    getSourcemap
+                    getSourcemap: (name)=>sourceMaps[name] || null,
+                    filterRerunTestPaths: currentEntries.length ? currentEntries.map((e)=>e.testPath) : void 0
                 });
             };
             if ('watch' === command) {
@@ -236,20 +276,19 @@ export const __webpack_modules__ = {
                     if (enableCliShortcuts) if (snapshotManager.summary.unmatched) utils.vF.log(`  ${utils.yW.dim('press')} ${utils.yW.yellow(utils.yW.bold('u'))} ${utils.yW.dim('to update snapshot')}${utils.yW.dim(', press')} ${utils.yW.bold('h')} ${utils.yW.dim('to show help')}\n`);
                     else utils.vF.log(`  ${utils.yW.dim('press')} ${utils.yW.bold('h')} ${utils.yW.dim('to show help')}${utils.yW.dim(', press')} ${utils.yW.bold('q')} ${utils.yW.dim('to quit')}\n`);
                 };
-                const clearLogs = ()=>{
-                    console.clear();
-                };
                 const { onBeforeRestart } = await __webpack_require__.e("967").then(__webpack_require__.bind(__webpack_require__, "./src/core/restart.ts"));
                 onBeforeRestart(async ()=>{
                     await pool.close();
                     await closeServer();
                 });
                 rsbuildInstance.onBeforeDevCompile(({ isFirstCompile })=>{
-                    if (!isFirstCompile) clearLogs();
+                    if (!isFirstCompile) (0, utils.mT)();
                 });
                 rsbuildInstance.onAfterDevCompile(async ({ isFirstCompile })=>{
                     snapshotManager.clear();
-                    await run();
+                    await run({
+                        mode: isFirstCompile ? 'all' : 'on-demand'
+                    });
                     if (isFirstCompile && enableCliShortcuts) {
                         const closeCliShortcuts = await setupCliShortcuts({
                             closeServer: async ()=>{
@@ -257,15 +296,17 @@ export const __webpack_modules__ = {
                                 await closeServer();
                             },
                             runAll: async ()=>{
-                                clearLogs();
+                                (0, utils.mT)();
                                 snapshotManager.clear();
                                 context.normalizedConfig.testNamePattern = void 0;
                                 context.fileFilters = void 0;
-                                await run();
+                                await run({
+                                    mode: 'all'
+                                });
                                 afterTestsWatchRun();
                             },
                             runWithTestNamePattern: async (pattern)=>{
-                                clearLogs();
+                                (0, utils.mT)();
                                 context.normalizedConfig.testNamePattern = pattern;
                                 if (pattern) utils.vF.log(`\n${utils.yW.dim('Applied testNamePattern:')} ${utils.yW.bold(pattern)}\n`);
                                 else utils.vF.log(`\n${utils.yW.dim('Cleared testNamePattern filter')}\n`);
@@ -274,32 +315,33 @@ export const __webpack_modules__ = {
                                 afterTestsWatchRun();
                             },
                             runWithFileFilters: async (filters)=>{
-                                clearLogs();
+                                (0, utils.mT)();
                                 if (filters && filters.length > 0) utils.vF.log(`\n${utils.yW.dim('Applied file filters:')} ${utils.yW.bold(filters.join(', '))}\n`);
                                 else utils.vF.log(`\n${utils.yW.dim('Cleared file filters')}\n`);
                                 snapshotManager.clear();
                                 context.fileFilters = filters;
-                                const entries = await globTestSourceEntries();
-                                if (!Object.keys(entries).length) return;
+                                const entries = await Promise.all(projects.map(async (p)=>globTestSourceEntries(p.environmentName))).then((entries)=>entries.reduce((acc, entry)=>acc.concat(...Object.values(entry)), []));
+                                if (!entries.length) return void utils.vF.log(filters ? utils.yW.yellow(`\nNo matching test files to run with current file filters: ${filters.join(',')}\n`) : utils.yW.yellow('\nNo matching test files to run.\n'));
                                 await run({
-                                    fileFilters: Object.values(entries)
+                                    fileFilters: entries
                                 });
                                 afterTestsWatchRun();
                             },
                             runFailedTests: async ()=>{
-                                const failedTests = testFileResult.filter((result)=>'fail' === result.status).map((r)=>r.testPath);
+                                const failedTests = context.reporterResults.results.filter((result)=>'fail' === result.status).map((r)=>r.testPath);
                                 if (!failedTests.length) return void utils.vF.log(utils.yW.yellow('\nNo failed tests were found that needed to be rerun.'));
-                                clearLogs();
+                                (0, utils.mT)();
                                 snapshotManager.clear();
                                 await run({
-                                    fileFilters: failedTests
+                                    fileFilters: failedTests,
+                                    mode: 'all'
                                 });
                                 afterTestsWatchRun();
                             },
                             updateSnapshot: async ()=>{
                                 if (!snapshotManager.summary.unmatched) return void utils.vF.log(utils.yW.yellow('\nNo snapshots were found that needed to be updated.'));
-                                const failedTests = testFileResult.filter((result)=>result.snapshotResult?.unmatched).map((r)=>r.testPath);
-                                clearLogs();
+                                const failedTests = context.reporterResults.results.filter((result)=>result.snapshotResult?.unmatched).map((r)=>r.testPath);
+                                (0, utils.mT)();
                                 const originalUpdateSnapshot = snapshotManager.options.updateSnapshot;
                                 snapshotManager.clear();
                                 snapshotManager.options.updateSnapshot = 'all';