@rstest/core 0.6.0 → 0.6.2

package/dist/0~470.js

@@ -0,0 +1,382 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { __webpack_require__ } from "./runtime.js";
+import { getTestEntries, getSetupFiles, isTTY, clearScreen, src_logger } from "./857.js";
+import { createCoverageProvider } from "./603.js";
+import { prepareRsbuild, createPool, createRsbuildServer } from "./0~814.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);
+const isCliShortcutsEnabled = ()=>isTTY('stdin');
+async function setupCliShortcuts({ closeServer, runAll, updateSnapshot, runFailedTests, runWithTestNamePattern, runWithFileFilters }) {
+    const { createInterface, emitKeypressEvents } = await import("./0~610.js").then(__webpack_require__.bind(__webpack_require__, "node:readline"));
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+    let isPrompting = false;
+    const clearCurrentInputLine = ()=>{
+        try {
+            process.stdout.write('\r\x1b[2K');
+        } catch  {}
+    };
+    const promptInput = async (promptText, onComplete)=>{
+        if (isPrompting) return;
+        isPrompting = true;
+        let buffer = '';
+        const render = ()=>{
+            process.stdout.write(`\r\x1b[2K${promptText}${buffer}`);
+        };
+        render();
+        const onPromptKey = async (str, key)=>{
+            if (!isPrompting) return;
+            if (key.ctrl && 'c' === key.name) process.exit(0);
+            if ('return' === key.name || 'enter' === key.name) {
+                process.stdin.off('keypress', onPromptKey);
+                process.stdout.write('\n');
+                const value = '' === buffer.trim() ? void 0 : buffer.trim();
+                isPrompting = false;
+                await onComplete(value);
+                return;
+            }
+            if ('escape' === key.name) {
+                clearCurrentInputLine();
+                process.stdin.off('keypress', onPromptKey);
+                isPrompting = false;
+                return;
+            }
+            if ('backspace' === key.name) {
+                buffer = buffer.slice(0, -1);
+                render();
+                return;
+            }
+            if ('string' == typeof str && 1 === str.length) {
+                buffer += str;
+                render();
+            }
+        };
+        process.stdin.on('keypress', onPromptKey);
+    };
+    const shortcuts = [
+        {
+            key: 'f',
+            description: `${picocolors_default().bold('f')}  ${picocolors_default().dim('rerun failed tests')}`,
+            action: async ()=>{
+                await runFailedTests();
+            }
+        },
+        {
+            key: 'a',
+            description: `${picocolors_default().bold('a')}  ${picocolors_default().dim('rerun all tests')}`,
+            action: async ()=>{
+                await runAll();
+            }
+        },
+        {
+            key: 'u',
+            description: `${picocolors_default().bold('u')}  ${picocolors_default().dim('update snapshot')}`,
+            action: async ()=>{
+                await updateSnapshot();
+            }
+        },
+        {
+            key: 't',
+            description: `${picocolors_default().bold('t')}  ${picocolors_default().dim('filter by a test name regex pattern')}`,
+            action: async ()=>{
+                clearCurrentInputLine();
+                await promptInput('Enter test name pattern (empty to clear): ', async (pattern)=>{
+                    await runWithTestNamePattern(pattern);
+                });
+            }
+        },
+        {
+            key: 'p',
+            description: `${picocolors_default().bold('p')}  ${picocolors_default().dim('filter by a filename regex pattern')}`,
+            action: async ()=>{
+                clearCurrentInputLine();
+                await promptInput('Enter file name pattern (empty to clear): ', async (input)=>{
+                    const filters = input ? input.split(/\s+/).filter(Boolean) : void 0;
+                    await runWithFileFilters(filters);
+                });
+            }
+        },
+        {
+            key: 'c',
+            description: `${picocolors_default().bold('c')}  ${picocolors_default().dim('clear screen')}`,
+            action: ()=>{
+                clearScreen(true);
+            }
+        },
+        {
+            key: 'q',
+            description: `${picocolors_default().bold('q')}  ${picocolors_default().dim('quit process')}`,
+            action: async ()=>{
+                try {
+                    await closeServer();
+                } finally{
+                    process.exit(0);
+                }
+            }
+        }
+    ];
+    const handleKeypress = (str, key)=>{
+        if (isPrompting) return;
+        if (key.ctrl && 'c' === key.name) process.exit(0);
+        for (const shortcut of shortcuts)if (str === shortcut.key) {
+            clearCurrentInputLine();
+            shortcut.action();
+            return;
+        }
+        if ('h' === str) {
+            clearCurrentInputLine();
+            let message = `  ${picocolors_default().bold(picocolors_default().blue('Shortcuts:'))}\n`;
+            for (const shortcut of shortcuts)message += `  ${shortcut.description}\n`;
+            src_logger.log(message);
+        }
+    };
+    process.stdin.on('keypress', handleKeypress);
+    return ()=>{
+        try {
+            process.stdin.setRawMode(false);
+            process.stdin.pause();
+        } catch  {}
+        process.stdin.off('keypress', handleKeypress);
+        rl.close();
+    };
+}
+async function runTests(context) {
+    const { rootPath, reporters, projects, snapshotManager, command, normalizedConfig: { coverage } } = context;
+    const entriesCache = new Map();
+    const globTestSourceEntries = async (name)=>{
+        const { include, exclude, includeSource, root } = projects.find((p)=>p.environmentName === name).normalizedConfig;
+        const entries = await getTestEntries({
+            include,
+            exclude: exclude.patterns,
+            includeSource,
+            rootPath,
+            projectRoot: root,
+            fileFilters: context.fileFilters || []
+        });
+        entriesCache.set(name, {
+            entries,
+            fileFilters: context.fileFilters
+        });
+        return entries;
+    };
+    const setupFiles = Object.fromEntries(context.projects.map((project)=>{
+        const { environmentName, rootPath, normalizedConfig: { setupFiles } } = project;
+        return [
+            environmentName,
+            getSetupFiles(setupFiles, rootPath)
+        ];
+    }));
+    const rsbuildInstance = await prepareRsbuild(context, globTestSourceEntries, setupFiles);
+    const { getRsbuildStats, closeServer } = await createRsbuildServer({
+        inspectedConfig: {
+            ...context.normalizedConfig,
+            projects: context.projects.map((p)=>p.normalizedConfig)
+        },
+        globTestSourceEntries: 'watch' === command ? globTestSourceEntries : async (name)=>{
+            if (entriesCache.has(name)) return entriesCache.get(name).entries;
+            return globTestSourceEntries(name);
+        },
+        setupFiles,
+        rsbuildInstance,
+        rootPath
+    });
+    const recommendWorkerCount = 'watch' === command ? 1 / 0 : Array.from(entriesCache.values()).reduce((acc, entry)=>acc + Object.keys(entry.entries).length, 0);
+    const pool = await createPool({
+        context,
+        recommendWorkerCount
+    });
+    const coverageProvider = coverage.enabled ? await createCoverageProvider(coverage, context.rootPath) : null;
+    if (coverageProvider) src_logger.log(` ${picocolors_default().gray('Coverage enabled with')} %s\n`, picocolors_default().yellow(coverage.provider));
+    const run = async ({ fileFilters, mode = 'all', buildStart = Date.now() } = {})=>{
+        let testStart;
+        const currentEntries = [];
+        const currentDeletedEntries = [];
+        const returns = await Promise.all(context.projects.map(async (p)=>{
+            const { assetNames, entries, setupEntries, getAssetFiles, getSourceMaps, 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) src_logger.debug(picocolors_default().yellow(`No test files need re-run in project(${p.environmentName}).`));
+                else src_logger.debug(picocolors_default().yellow(`Test files to re-run in project(${p.environmentName}):\n`) + affectedEntries.map((e)=>e.testPath).join('\n') + '\n');
+                finalEntries = affectedEntries;
+            } else src_logger.debug(picocolors_default().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,
+                getSourceMaps,
+                setupEntries,
+                getAssetFiles,
+                project: p,
+                updateSnapshot: context.snapshotManager.options.updateSnapshot
+            });
+            return {
+                results,
+                testResults,
+                assetNames,
+                getSourceMaps
+            };
+        }));
+        const buildTime = testStart - buildStart;
+        const testTime = Date.now() - testStart;
+        const duration = {
+            totalTime: testTime + buildTime,
+            buildTime,
+            testTime
+        };
+        const results = returns.flatMap((r)=>r.results);
+        const testResults = returns.flatMap((r)=>r.testResults);
+        context.updateReporterResultState(results, testResults, currentDeletedEntries);
+        if (0 === results.length) {
+            if ('watch' === command) if ('on-demand' === mode) src_logger.log(picocolors_default().yellow('No test files need re-run.'));
+            else src_logger.log(picocolors_default().yellow('No test files found.'));
+            else {
+                const code = context.normalizedConfig.passWithNoTests ? 0 : 1;
+                src_logger.log(picocolors_default()[code ? 'red' : 'yellow'](`No test files found, exiting with code ${code}.`));
+                process.exitCode = code;
+            }
+            if ('all' === mode) {
+                if (context.fileFilters?.length) src_logger.log(picocolors_default().gray('filter: '), context.fileFilters.join(picocolors_default().gray(', ')));
+                context.projects.forEach((p)=>{
+                    if (context.projects.length > 1) {
+                        src_logger.log('');
+                        src_logger.log(picocolors_default().gray('project:'), p.name);
+                    }
+                    src_logger.log(picocolors_default().gray('include:'), p.normalizedConfig.include.join(picocolors_default().gray(', ')));
+                    src_logger.log(picocolors_default().gray('exclude:'), p.normalizedConfig.exclude.patterns.join(picocolors_default().gray(', ')));
+                });
+            }
+        }
+        const isFailure = results.some((r)=>'fail' === r.status);
+        if (isFailure) process.exitCode = 1;
+        for (const reporter of reporters)await reporter.onTestRunEnd?.({
+            results: context.reporterResults.results,
+            testResults: context.reporterResults.testResults,
+            snapshotSummary: snapshotManager.summary,
+            duration,
+            getSourcemap: async (name)=>{
+                const resource = returns.find((r)=>r.assetNames.includes(name));
+                const sourceMap = (await resource?.getSourceMaps([
+                    name
+                ]))?.[name];
+                return sourceMap ? JSON.parse(sourceMap) : null;
+            },
+            filterRerunTestPaths: currentEntries.length ? currentEntries.map((e)=>e.testPath) : void 0
+        });
+        if (coverageProvider && (!isFailure || coverage.reportOnFailure)) {
+            const { generateCoverage } = await import("./0~204.js").then((mod)=>({
+                    generateCoverage: mod.generateCoverage
+                }));
+            await generateCoverage(context, results, coverageProvider);
+        }
+    };
+    if ('watch' === command) {
+        const enableCliShortcuts = isCliShortcutsEnabled();
+        const afterTestsWatchRun = ()=>{
+            src_logger.log(picocolors_default().green('  Waiting for file changes...'));
+            if (enableCliShortcuts) if (snapshotManager.summary.unmatched) src_logger.log(`  ${picocolors_default().dim('press')} ${picocolors_default().yellow(picocolors_default().bold('u'))} ${picocolors_default().dim('to update snapshot')}${picocolors_default().dim(', press')} ${picocolors_default().bold('h')} ${picocolors_default().dim('to show help')}\n`);
+            else src_logger.log(`  ${picocolors_default().dim('press')} ${picocolors_default().bold('h')} ${picocolors_default().dim('to show help')}${picocolors_default().dim(', press')} ${picocolors_default().bold('q')} ${picocolors_default().dim('to quit')}\n`);
+        };
+        const { onBeforeRestart } = await import("./0~365.js").then((mod)=>({
+                onBeforeRestart: mod.onBeforeRestart
+            }));
+        onBeforeRestart(async ()=>{
+            await pool.close();
+            await closeServer();
+        });
+        let buildStart;
+        rsbuildInstance.onBeforeDevCompile(({ isFirstCompile })=>{
+            buildStart = Date.now();
+            if (!isFirstCompile) clearScreen();
+        });
+        rsbuildInstance.onAfterDevCompile(async ({ isFirstCompile })=>{
+            snapshotManager.clear();
+            await run({
+                buildStart,
+                mode: isFirstCompile ? 'all' : 'on-demand'
+            });
+            buildStart = void 0;
+            if (isFirstCompile && enableCliShortcuts) {
+                const closeCliShortcuts = await setupCliShortcuts({
+                    closeServer: async ()=>{
+                        await pool.close();
+                        await closeServer();
+                    },
+                    runAll: async ()=>{
+                        clearScreen();
+                        snapshotManager.clear();
+                        context.normalizedConfig.testNamePattern = void 0;
+                        context.fileFilters = void 0;
+                        await run({
+                            mode: 'all'
+                        });
+                        afterTestsWatchRun();
+                    },
+                    runWithTestNamePattern: async (pattern)=>{
+                        clearScreen();
+                        context.normalizedConfig.testNamePattern = pattern;
+                        if (pattern) src_logger.log(`\n${picocolors_default().dim('Applied testNamePattern:')} ${picocolors_default().bold(pattern)}\n`);
+                        else src_logger.log(`\n${picocolors_default().dim('Cleared testNamePattern filter')}\n`);
+                        snapshotManager.clear();
+                        await run();
+                        afterTestsWatchRun();
+                    },
+                    runWithFileFilters: async (filters)=>{
+                        clearScreen();
+                        if (filters && filters.length > 0) src_logger.log(`\n${picocolors_default().dim('Applied file filters:')} ${picocolors_default().bold(filters.join(', '))}\n`);
+                        else src_logger.log(`\n${picocolors_default().dim('Cleared file filters')}\n`);
+                        snapshotManager.clear();
+                        context.fileFilters = filters;
+                        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 src_logger.log(filters ? picocolors_default().yellow(`\nNo matching test files to run with current file filters: ${filters.join(',')}\n`) : picocolors_default().yellow('\nNo matching test files to run.\n'));
+                        await run({
+                            fileFilters: entries
+                        });
+                        afterTestsWatchRun();
+                    },
+                    runFailedTests: async ()=>{
+                        const failedTests = context.reporterResults.results.filter((result)=>'fail' === result.status).map((r)=>r.testPath);
+                        if (!failedTests.length) return void src_logger.log(picocolors_default().yellow('\nNo failed tests were found that needed to be rerun.'));
+                        clearScreen();
+                        snapshotManager.clear();
+                        await run({
+                            fileFilters: failedTests,
+                            mode: 'all'
+                        });
+                        afterTestsWatchRun();
+                    },
+                    updateSnapshot: async ()=>{
+                        if (!snapshotManager.summary.unmatched) return void src_logger.log(picocolors_default().yellow('\nNo snapshots were found that needed to be updated.'));
+                        const failedTests = context.reporterResults.results.filter((result)=>result.snapshotResult?.unmatched).map((r)=>r.testPath);
+                        clearScreen();
+                        const originalUpdateSnapshot = snapshotManager.options.updateSnapshot;
+                        snapshotManager.clear();
+                        snapshotManager.options.updateSnapshot = 'all';
+                        await run({
+                            fileFilters: failedTests
+                        });
+                        afterTestsWatchRun();
+                        snapshotManager.options.updateSnapshot = originalUpdateSnapshot;
+                    }
+                });
+                onBeforeRestart(closeCliShortcuts);
+            }
+            afterTestsWatchRun();
+        });
+    } else {
+        await run();
+        await pool.close();
+        await closeServer();
+    }
+}
+export { runTests };

package/dist/0~535.js

@@ -0,0 +1,10 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { __webpack_require__ } from "./runtime.js";
+__webpack_require__.add({
+    "node:vm?8d7d": function(module) {
+        module.exports = import("node:vm").then(function(module) {
+            return module;
+        });
+    }
+});

package/dist/0~607.js

@@ -0,0 +1,119 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { __webpack_require__ } from "./runtime.js";
+import { AssertionError, strict } from "node:assert";
+import { Console } from "node:console";
+import { prettyTime } from "./857.js";
+const external_node_util_ = __webpack_require__("node:util");
+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 RealDate = Date;
+function createCustomConsole({ rpc, testPath, printConsoleTrace }) {
+    const getConsoleTrace = ()=>{
+        const limit = Error.stackTraceLimit;
+        Error.stackTraceLimit = 4;
+        const stack = new Error('STACK_TRACE').stack;
+        const trace = stack?.split('\n').slice(4).join('\n');
+        Error.stackTraceLimit = limit;
+        return trace;
+    };
+    class CustomConsole extends Console {
+        _counters = {};
+        _timers = {};
+        _groupDepth = 0;
+        Console = Console;
+        getPrettyName(type) {
+            switch(type){
+                case 'error':
+                    return picocolors_default().red(type);
+                case 'warn':
+                    return picocolors_default().yellow(type);
+                case 'info':
+                    return picocolors_default().cyan(type);
+                default:
+                    return picocolors_default().gray(type);
+            }
+        }
+        _log(name, message, type = 'stdout') {
+            rpc.onConsoleLog({
+                content: '  '.repeat(this._groupDepth) + message,
+                name: this.getPrettyName(name),
+                testPath,
+                type,
+                trace: printConsoleTrace ? getConsoleTrace() : void 0
+            });
+        }
+        assert(value, message) {
+            try {
+                strict(value, message);
+            } catch (error) {
+                if (!(error instanceof AssertionError)) throw error;
+                this._log('assert', error.toString().replaceAll(/:\n\n.*\n/gs, ''), 'stderr');
+            }
+        }
+        count(label = 'default') {
+            if (!this._counters[label]) this._counters[label] = 0;
+            this._log('count', (0, external_node_util_.format)(`${label}: ${++this._counters[label]}`));
+        }
+        countReset(label = 'default') {
+            this._counters[label] = 0;
+        }
+        debug(firstArg, ...args) {
+            this._log('debug', (0, external_node_util_.format)(firstArg, ...args));
+        }
+        dir(firstArg, options = {}) {
+            const representation = (0, external_node_util_.inspect)(firstArg, options);
+            this._log('dir', (0, external_node_util_.formatWithOptions)(options, representation));
+        }
+        dirxml(firstArg, ...args) {
+            this._log('dirxml', (0, external_node_util_.format)(firstArg, ...args));
+        }
+        error(firstArg, ...args) {
+            this._log('error', (0, external_node_util_.format)(firstArg, ...args), 'stderr');
+        }
+        group(title, ...args) {
+            this._groupDepth++;
+            if (null != title || args.length > 0) this._log('group', picocolors_default().bold((0, external_node_util_.format)(title, ...args)));
+        }
+        groupCollapsed(title, ...args) {
+            this._groupDepth++;
+            if (null != title || args.length > 0) this._log('groupCollapsed', picocolors_default().bold((0, external_node_util_.format)(title, ...args)));
+        }
+        groupEnd() {
+            if (this._groupDepth > 0) this._groupDepth--;
+        }
+        info(firstArg, ...args) {
+            this._log('info', (0, external_node_util_.format)(firstArg, ...args));
+        }
+        log(firstArg, ...args) {
+            this._log('log', (0, external_node_util_.format)(firstArg, ...args));
+        }
+        time(label = 'default') {
+            if (null != this._timers[label]) return;
+            this._timers[label] = new RealDate();
+        }
+        timeEnd(label = 'default') {
+            const startTime = this._timers[label];
+            if (null != startTime) {
+                const endTime = RealDate.now();
+                const time = endTime - startTime.getTime();
+                this._log('time', (0, external_node_util_.format)(`${label}: ${prettyTime(time)}`));
+                delete this._timers[label];
+            }
+        }
+        timeLog(label = 'default', ...data) {
+            const startTime = this._timers[label];
+            if (null != startTime) {
+                const endTime = new RealDate();
+                const time = endTime.getTime() - startTime.getTime();
+                this._log('time', (0, external_node_util_.format)(`${label}: ${prettyTime(time)}`, ...data));
+            }
+        }
+        warn(firstArg, ...args) {
+            this._log('warn', (0, external_node_util_.format)(firstArg, ...args), 'stderr');
+        }
+        getBuffer() {}
+    }
+    return new CustomConsole(process.stdout, process.stderr);
+}
+export { createCustomConsole };

package/dist/0~610.js

@@ -0,0 +1,10 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { __webpack_require__ } from "./runtime.js";
+__webpack_require__.add({
+    "node:readline": function(module) {
+        module.exports = import("node:readline").then(function(module) {
+            return module;
+        });
+    }
+});

package/dist/0~673.js

@@ -0,0 +1,10 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { __webpack_require__ } from "./runtime.js";
+__webpack_require__.add({
+    jsdom: function(module) {
+        module.exports = import("jsdom").then(function(module) {
+            return module;
+        });
+    }
+});