@rstest/core 0.1.3 → 0.2.1

package/dist/668.js.LICENSE.txt

@@ -0,0 +1 @@
+/*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */

package/dist/813.js

@@ -134,7 +134,7 @@ export const __webpack_modules__ = {
         var constants = __webpack_require__("./src/utils/constants.ts");
         var helper = __webpack_require__("./src/utils/helper.ts");
         __webpack_require__("./src/utils/logger.ts");
-        __webpack_require__("fs");
+        __webpack_require__("node:fs");
         __webpack_require__("node:fs/promises");
         __webpack_require__("node:module");
         __webpack_require__("pathe");

package/dist/854.js

@@ -141,7 +141,7 @@ export const __webpack_modules__ = {
                 });
             }
         }
-        const pluginEntryWatch = ({ isWatch, globTestSourceEntries, setupFiles })=>({
+        const pluginEntryWatch = ({ isWatch, globTestSourceEntries, setupFiles, configFilePath })=>({
                 name: 'rstest:entry-watch',
                 setup: (api)=>{
                     api.modifyRspackConfig(async (config)=>{
@@ -157,7 +157,8 @@ export const __webpack_modules__ = {
                             config.watchOptions ??= {};
                             config.watchOptions.ignored = (0, utils.XQ)(config.watchOptions.ignored || []);
                             if (0 === config.watchOptions.ignored.length) config.watchOptions.ignored.push('**/.git', '**/node_modules');
-                            config.watchOptions.ignored.push(utils.f1);
+                            config.watchOptions.ignored.push(utils.f1, '**/*.snap');
+                            if (configFilePath) config.watchOptions.ignored.push(configFilePath);
                         } else {
                             config.watch = false;
                             config.watchOptions ??= {};
@@ -475,6 +476,7 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                         pluginEntryWatch({
                             globTestSourceEntries,
                             setupFiles,
+                            configFilePath: context.configFilePath,
                             isWatch: 'watch' === command
                         }),
                         pluginExternal(testEnvironment),
@@ -754,7 +756,6 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                     ...process.env
                 }
             });
-            const runtimeConfig = getRuntimeConfig(context);
             const rpcMethods = {
                 onTestCaseResult: async (result)=>{
                     await Promise.all(reporters.map((reporter)=>reporter.onTestCaseResult?.(result)));
@@ -773,6 +774,7 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                 runTests: async ({ entries, assetFiles, setupEntries, sourceMaps, updateSnapshot })=>{
                     const setupAssets = setupEntries.flatMap((entry)=>entry.files || []);
                     const entryLength = Object.keys(entries).length;
+                    const runtimeConfig = getRuntimeConfig(context);
                     const results = await Promise.all(entries.map((entryInfo)=>{
                         const { assetFiles: neededFiles, sourceMaps: neededSourceMaps } = filterAssetsByEntry(entryInfo, assetFiles, setupAssets, sourceMaps, entryLength);
                         return pool.runTest({
@@ -812,6 +814,7 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                 collectTests: async ({ entries, assetFiles, setupEntries, sourceMaps, updateSnapshot })=>{
                     const setupAssets = setupEntries.flatMap((entry)=>entry.files || []);
                     const entryLength = Object.keys(entries).length;
+                    const runtimeConfig = getRuntimeConfig(context);
                     return Promise.all(entries.map((entryInfo)=>{
                         const { assetFiles: neededFiles, sourceMaps: neededSourceMaps } = filterAssetsByEntry(entryInfo, assetFiles, setupAssets, sourceMaps, entryLength);
                         return pool.collectTests({

package/dist/867.js

@@ -1757,7 +1757,7 @@ export const __webpack_modules__ = {
         var constants = __webpack_require__("./src/utils/constants.ts");
         var helper = __webpack_require__("./src/utils/helper.ts");
         __webpack_require__("./src/utils/logger.ts");
-        __webpack_require__("fs");
+        __webpack_require__("node:fs");
         __webpack_require__("node:fs/promises");
         __webpack_require__("node:module");
         __webpack_require__("pathe");

package/dist/920.js

@@ -11,15 +11,60 @@ export const __webpack_modules__ = {
         var src_pool = __webpack_require__("./src/pool/index.ts");
         var utils = __webpack_require__("./src/utils/index.ts");
         const isCliShortcutsEnabled = ()=>(0, utils._l)('stdin');
-        async function setupCliShortcuts({ closeServer, runAll, updateSnapshot, runFailedTests }) {
-            const shortcuts = [
-                {
-                    key: 'c',
-                    description: `${utils.$_.bold('c')}  ${utils.$_.dim('clear console')}`,
-                    action: ()=>{
-                        console.clear();
+        async function setupCliShortcuts({ closeServer, runAll, updateSnapshot, runFailedTests, runWithTestNamePattern, runWithFileFilters }) {
+            const { createInterface, emitKeypressEvents } = await import("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: `${utils.$_.bold('f')}  ${utils.$_.dim('rerun failed tests')}`,
@@ -41,6 +86,34 @@ export const __webpack_modules__ = {
                         await updateSnapshot();
                     }
                 },
+                {
+                    key: 't',
+                    description: `${utils.$_.bold('t')}  ${utils.$_.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: `${utils.$_.bold('p')}  ${utils.$_.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: `${utils.$_.bold('c')}  ${utils.$_.dim('clear console')}`,
+                    action: ()=>{
+                        console.clear();
+                    }
+                },
                 {
                     key: 'q',
                     description: `${utils.$_.bold('q')}  ${utils.$_.dim('quit process')}`,
@@ -53,18 +126,16 @@ export const __webpack_modules__ = {
                     }
                 }
             ];
-            const { createInterface } = await import("node:readline");
-            const rl = createInterface({
-                input: process.stdin,
-                output: process.stdout
-            });
-            process.stdin.setRawMode(true);
-            process.stdin.resume();
-            process.stdin.setEncoding('utf8');
             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) return void shortcut.action();
+                for (const shortcut of shortcuts)if (str === shortcut.key) {
+                    clearCurrentInputLine();
+                    shortcut.action();
+                    return;
+                }
                 if ('h' === str) {
+                    clearCurrentInputLine();
                     let message = `\n  ${utils.$_.bold(utils.$_.blue('Shortcuts:'))}\n`;
                     for (const shortcut of shortcuts)message += `  ${shortcut.description}\n`;
                     utils.kg.log(message);
@@ -72,13 +143,16 @@ export const __webpack_modules__ = {
             };
             process.stdin.on('keypress', handleKeypress);
             return ()=>{
-                process.stdin.setRawMode(false);
-                process.stdin.pause();
+                try {
+                    process.stdin.setRawMode(false);
+                    process.stdin.pause();
+                } catch  {}
+                process.stdin.off('keypress', handleKeypress);
                 rl.close();
             };
         }
         var rsbuild = __webpack_require__("./src/core/rsbuild.ts");
-        async function runTests(context, fileFilters) {
+        async function runTests(context) {
             const { normalizedConfig: { include, exclude, root, name, setupFiles: setups, includeSource }, rootPath, reporters, snapshotManager, command } = context;
             const entriesCache = new Map();
             const globTestSourceEntries = async ()=>{
@@ -87,13 +161,16 @@ export const __webpack_modules__ = {
                     exclude,
                     includeSource,
                     root,
-                    fileFilters
+                    fileFilters: context.fileFilters || []
+                });
+                entriesCache.set(name, {
+                    entries,
+                    fileFilters: context.fileFilters
                 });
-                entriesCache.set(name, entries);
                 if (!Object.keys(entries).length) {
                     utils.kg.log(utils.$_.red('No test files found.'));
                     utils.kg.log('');
-                    if (fileFilters.length) utils.kg.log(utils.$_.gray('filter: '), fileFilters.join(utils.$_.gray(', ')));
+                    if (context.fileFilters?.length) utils.kg.log(utils.$_.gray('filter: '), context.fileFilters.join(utils.$_.gray(', ')));
                     utils.kg.log(utils.$_.gray('include:'), include.join(utils.$_.gray(', ')));
                     utils.kg.log(utils.$_.gray('exclude:'), exclude.join(utils.$_.gray(', ')));
                     utils.kg.log('');
@@ -106,14 +183,14 @@ export const __webpack_modules__ = {
                 name,
                 normalizedConfig: context.normalizedConfig,
                 globTestSourceEntries: 'watch' === command ? globTestSourceEntries : async ()=>{
-                    if (entriesCache.has(name)) return entriesCache.get(name);
+                    if (entriesCache.has(name)) return entriesCache.get(name).entries;
                     return globTestSourceEntries();
                 },
                 setupFiles,
                 rsbuildInstance,
                 rootPath
             });
-            const recommendWorkerCount = 'watch' === command ? 1 / 0 : Array.from(entriesCache.values()).reduce((acc, entries)=>acc + Object.keys(entries).length, 0);
+            const recommendWorkerCount = 'watch' === command ? 1 / 0 : Array.from(entriesCache.values()).reduce((acc, entry)=>acc + Object.keys(entry.entries).length, 0);
             const pool = await (0, src_pool.K)({
                 context,
                 recommendWorkerCount
@@ -126,6 +203,7 @@ export const __webpack_modules__ = {
                 });
                 const testStart = Date.now();
                 const { results, testResults } = await pool.runTests({
+                    context,
                     entries,
                     sourceMaps,
                     setupEntries,
@@ -160,42 +238,77 @@ export const __webpack_modules__ = {
                 const clearLogs = ()=>{
                     console.clear();
                 };
+                const { onBeforeRestart } = await __webpack_require__.e("25").then(__webpack_require__.bind(__webpack_require__, "./src/core/restart.ts"));
+                onBeforeRestart(async ()=>{
+                    await pool.close();
+                    await closeServer();
+                });
                 rsbuildInstance.onDevCompileDone(async ({ isFirstCompile })=>{
                     if (!isFirstCompile) clearLogs();
                     snapshotManager.clear();
                     await run();
-                    if (isFirstCompile && enableCliShortcuts) await setupCliShortcuts({
-                        closeServer: async ()=>{
-                            await pool.close();
-                            await closeServer();
-                        },
-                        runAll: async ()=>{
-                            clearLogs();
-                            snapshotManager.clear();
-                            await run();
-                            afterTestsWatchRun();
-                        },
-                        runFailedTests: async ()=>{
-                            const failedTests = testFileResult.filter((result)=>'fail' === result.status).map((r)=>r.testPath);
-                            if (!failedTests.length) return void utils.kg.log(utils.$_.yellow('\nNo failed tests were found that needed to be rerun.'));
-                            clearLogs();
-                            snapshotManager.clear();
-                            await run({
-                                fileFilters: failedTests
-                            });
-                            afterTestsWatchRun();
-                        },
-                        updateSnapshot: async ()=>{
-                            if (!snapshotManager.summary.unmatched) return void utils.kg.log(utils.$_.yellow('\nNo snapshots were found that needed to be updated.'));
-                            clearLogs();
-                            const originalUpdateSnapshot = snapshotManager.options.updateSnapshot;
-                            snapshotManager.clear();
-                            snapshotManager.options.updateSnapshot = 'all';
-                            await run();
-                            afterTestsWatchRun();
-                            snapshotManager.options.updateSnapshot = originalUpdateSnapshot;
-                        }
-                    });
+                    if (isFirstCompile && enableCliShortcuts) {
+                        const closeCliShortcuts = await setupCliShortcuts({
+                            closeServer: async ()=>{
+                                await pool.close();
+                                await closeServer();
+                            },
+                            runAll: async ()=>{
+                                clearLogs();
+                                snapshotManager.clear();
+                                context.normalizedConfig.testNamePattern = void 0;
+                                context.fileFilters = void 0;
+                                await run();
+                                afterTestsWatchRun();
+                            },
+                            runWithTestNamePattern: async (pattern)=>{
+                                clearLogs();
+                                context.normalizedConfig.testNamePattern = pattern;
+                                if (pattern) utils.kg.log(`\n${utils.$_.dim('Applied testNamePattern:')} ${utils.$_.bold(pattern)}\n`);
+                                else utils.kg.log(`\n${utils.$_.dim('Cleared testNamePattern filter')}\n`);
+                                snapshotManager.clear();
+                                await run();
+                                afterTestsWatchRun();
+                            },
+                            runWithFileFilters: async (filters)=>{
+                                clearLogs();
+                                if (filters && filters.length > 0) utils.kg.log(`\n${utils.$_.dim('Applied file filters:')} ${utils.$_.bold(filters.join(', '))}\n`);
+                                else utils.kg.log(`\n${utils.$_.dim('Cleared file filters')}\n`);
+                                snapshotManager.clear();
+                                context.fileFilters = filters;
+                                const entries = await globTestSourceEntries();
+                                if (!Object.keys(entries).length) return;
+                                await run({
+                                    fileFilters: Object.values(entries)
+                                });
+                                afterTestsWatchRun();
+                            },
+                            runFailedTests: async ()=>{
+                                const failedTests = testFileResult.filter((result)=>'fail' === result.status).map((r)=>r.testPath);
+                                if (!failedTests.length) return void utils.kg.log(utils.$_.yellow('\nNo failed tests were found that needed to be rerun.'));
+                                clearLogs();
+                                snapshotManager.clear();
+                                await run({
+                                    fileFilters: failedTests
+                                });
+                                afterTestsWatchRun();
+                            },
+                            updateSnapshot: async ()=>{
+                                if (!snapshotManager.summary.unmatched) return void utils.kg.log(utils.$_.yellow('\nNo snapshots were found that needed to be updated.'));
+                                const failedTests = testFileResult.filter((result)=>result.snapshotResult?.unmatched).map((r)=>r.testPath);
+                                clearLogs();
+                                const originalUpdateSnapshot = snapshotManager.options.updateSnapshot;
+                                snapshotManager.clear();
+                                snapshotManager.options.updateSnapshot = 'all';
+                                await run({
+                                    fileFilters: failedTests
+                                });
+                                afterTestsWatchRun();
+                                snapshotManager.options.updateSnapshot = originalUpdateSnapshot;
+                            }
+                        });
+                        onBeforeRestart(closeCliShortcuts);
+                    }
                     afterTestsWatchRun();
                 });
             } else {