@rstest/core 0.2.2 → 0.3.1

package/dist/85.js

@@ -617,7 +617,7 @@ export const __webpack_modules__ = {
             workerState;
             async runTests({ tests, testPath, state, hooks, api }) {
                 this.workerState = state;
-                const { runtimeConfig: { passWithNoTests, retry, maxConcurrency }, snapshotOptions } = state;
+                const { runtimeConfig: { passWithNoTests, retry, maxConcurrency }, project, snapshotOptions } = state;
                 const results = [];
                 const errors = [];
                 let defaultStatus = 'pass';
@@ -633,7 +633,8 @@ export const __webpack_modules__ = {
                             status: 'skip',
                             parentNames: test.parentNames,
                             name: test.name,
-                            testPath
+                            testPath,
+                            project
                         };
                         return result;
                     }
@@ -642,7 +643,8 @@ export const __webpack_modules__ = {
                             status: 'todo',
                             parentNames: test.parentNames,
                             name: test.name,
-                            testPath
+                            testPath,
+                            project
                         };
                         return result;
                     }
@@ -660,7 +662,8 @@ export const __webpack_modules__ = {
                             parentNames: test.parentNames,
                             name: test.name,
                             errors: (0, runtime_util.o9)(error, test),
-                            testPath
+                            testPath,
+                            project
                         };
                     }
                     if (result?.status !== 'fail') if (test.fails) try {
@@ -673,6 +676,7 @@ export const __webpack_modules__ = {
                             parentNames: test.parentNames,
                             name: test.name,
                             testPath,
+                            project,
                             errors: [
                                 {
                                     message: 'Expect test to fail'
@@ -681,6 +685,7 @@ export const __webpack_modules__ = {
                         };
                     } catch (_err) {
                         result = {
+                            project,
                             status: 'pass',
                             parentNames: test.parentNames,
                             name: test.name,
@@ -693,6 +698,7 @@ export const __webpack_modules__ = {
                         await test.fn?.(test.context);
                         this.afterRunTest(test);
                         result = {
+                            project,
                             parentNames: test.parentNames,
                             name: test.name,
                             status: 'pass',
@@ -700,6 +706,7 @@ export const __webpack_modules__ = {
                         };
                     } catch (error) {
                         result = {
+                            project,
                             status: 'fail',
                             parentNames: test.parentNames,
                             name: test.name,
@@ -709,14 +716,30 @@ export const __webpack_modules__ = {
                     }
                     const afterEachFns = [
                         ...parentHooks.afterEachListeners || []
-                    ].reverse().concat(cleanups);
+                    ].reverse().concat(cleanups).concat(test.onFinished);
                     try {
-                        for (const fn of afterEachFns)await fn();
+                        for (const fn of afterEachFns)await fn({
+                            task: {
+                                result
+                            }
+                        });
                     } catch (error) {
                         result.status = 'fail';
                         result.errors ??= [];
                         result.errors.push(...(0, runtime_util.o9)(error));
                     }
+                    if ('fail' === result.status) for (const fn of [
+                        ...test.onFailed
+                    ].reverse())try {
+                        await fn({
+                            task: {
+                                result
+                            }
+                        });
+                    } catch (error) {
+                        result.errors ??= [];
+                        result.errors.push(...(0, runtime_util.o9)(error));
+                    }
                     this.resetCurrentTest();
                     return result;
                 };
@@ -764,7 +787,8 @@ export const __webpack_modules__ = {
                                 testPath,
                                 errors: [
                                     noTestError
-                                ]
+                                ],
+                                project
                             };
                             hooks.onTestCaseResult?.(result);
                         }
@@ -823,12 +847,14 @@ export const __webpack_modules__ = {
                 const start = RealDate.now();
                 if (0 === tests.length) {
                     if (passWithNoTests) return {
+                        project,
                         testPath,
                         name: '',
                         status: 'pass',
                         results
                     };
                     return {
+                        project,
                         testPath,
                         name: '',
                         status: 'fail',
@@ -847,6 +873,7 @@ export const __webpack_modules__ = {
                 });
                 const snapshotResult = await snapshotClient.finish(testPath);
                 return {
+                    project,
                     testPath,
                     name: '',
                     status: errors.length ? 'fail' : getTestStatus(results, defaultStatus),
@@ -894,8 +921,36 @@ export const __webpack_modules__ = {
                         return null != _expect;
                     }
                 });
+                Object.defineProperty(context, 'onTestFinished', {
+                    get: ()=>(fn, timeout)=>{
+                            this.onTestFinished(current, fn, timeout);
+                        }
+                });
+                Object.defineProperty(context, 'onTestFailed', {
+                    get: ()=>(fn, timeout)=>{
+                            this.onTestFailed(current, fn, timeout);
+                        }
+                });
                 return context;
             }
+            onTestFinished(test, fn, timeout) {
+                if (!test) throw new Error('onTestFinished() can only be called inside a test');
+                test.onFinished.push(wrapTimeout({
+                    name: 'onTestFinished hook',
+                    fn,
+                    timeout: timeout || this.workerState.runtimeConfig.hookTimeout,
+                    stackTraceError: new Error('STACK_TRACE_ERROR')
+                }));
+            }
+            onTestFailed(test, fn, timeout) {
+                if (!test) throw new Error('onTestFailed() can only be called inside a test');
+                test.onFailed.push(wrapTimeout({
+                    name: 'onTestFailed hook',
+                    fn,
+                    timeout: timeout || this.workerState.runtimeConfig.hookTimeout,
+                    stackTraceError: new Error('STACK_TRACE_ERROR')
+                }));
+            }
             async beforeRunTest(test, snapshotState) {
                 (0, dist.wb)({
                     assertionCalls: 0,
@@ -931,7 +986,9 @@ export const __webpack_modules__ = {
             collectStatus = 'lazy';
             currentCollectList = [];
             runtimeConfig;
-            constructor({ testPath, runtimeConfig }){
+            project;
+            constructor({ testPath, runtimeConfig, project }){
+                this.project = project;
                 this.testPath = testPath;
                 this.runtimeConfig = runtimeConfig;
             }
@@ -982,6 +1039,7 @@ export const __webpack_modules__ = {
             }
             getDefaultRootSuite() {
                 return {
+                    project: this.project,
                     runMode: 'run',
                     testPath: this.testPath,
                     name: src_utils.q_,
@@ -992,6 +1050,7 @@ export const __webpack_modules__ = {
             describe({ name, fn, runMode = 'run', each = false, concurrent, sequential }) {
                 this.checkStatus(name, 'suite');
                 const currentSuite = {
+                    project: this.project,
                     name,
                     runMode,
                     tests: [],
@@ -1067,6 +1126,7 @@ export const __webpack_modules__ = {
             it({ name, fn, originalFn = fn, fixtures, timeout = this.runtimeConfig.testTimeout, runMode = 'run', fails = false, each = false, concurrent, sequential }) {
                 this.checkStatus(name, 'case');
                 this.addTestCase({
+                    project: this.project,
                     name,
                     originalFn,
                     fn: fn ? wrapTimeout({
@@ -1082,7 +1142,9 @@ export const __webpack_modules__ = {
                     concurrent,
                     sequential,
                     each,
-                    fails
+                    fails,
+                    onFinished: [],
+                    onFailed: []
                 });
             }
             describeEach({ cases, ...options }) {
@@ -1152,8 +1214,9 @@ export const __webpack_modules__ = {
                 throw new Error('Expect to find a suite, but got undefined');
             }
         }
-        const createRuntimeAPI = ({ testPath, runtimeConfig })=>{
+        const createRuntimeAPI = ({ testPath, runtimeConfig, project })=>{
             const runtimeInstance = new RunnerRuntime({
+                project,
                 testPath,
                 runtimeConfig
             });
@@ -1303,14 +1366,23 @@ export const __webpack_modules__ = {
             };
         };
         function createRunner({ workerState }) {
-            const { testPath, runtimeConfig: { testNamePattern } } = workerState;
+            const { testPath, project, runtimeConfig: { testNamePattern } } = workerState;
             const runtime = createRuntimeAPI({
+                project,
                 testPath,
                 runtimeConfig: workerState.runtimeConfig
             });
             const testRunner = new TestRunner();
             return {
-                api: runtime.api,
+                api: {
+                    ...runtime.api,
+                    onTestFinished: (fn, timeout)=>{
+                        testRunner.onTestFinished(testRunner.getCurrentTest(), fn, timeout);
+                    },
+                    onTestFailed: (fn, timeout)=>{
+                        testRunner.onTestFailed(testRunner.getCurrentTest(), fn, timeout);
+                    }
+                },
                 runner: {
                     runTests: async (testPath, hooks, api)=>{
                         const tests = await runtime.instance.getTests();

package/dist/967.js

@@ -40,21 +40,22 @@ export const __webpack_modules__ = {
         const clearConsole = ()=>{
             if ((0, utils.Un)() && !process.env.DEBUG) process.stdout.write('\x1B[H\x1B[2J');
         };
-        const beforeRestart = async ({ filePath, clear = true })=>{
+        const beforeRestart = async ({ filePath, root, clear = true })=>{
             if (clear) clearConsole();
             if (filePath) {
-                const filename = external_node_path_["default"].basename(filePath);
+                const filename = external_node_path_["default"].relative(root, filePath);
                 utils.vF.info(`restarting Rstest as ${utils.yW.yellow(filename)} changed\n`);
             } else utils.vF.info('restarting Rstest...\n');
             for (const cleaner of cleaners)await cleaner();
             cleaners = [];
         };
-        const restart = async ({ filePath, clear = true, options, filters })=>{
+        const restart = async ({ filePath, clear = true, options, filters, root })=>{
             await beforeRestart({
                 filePath,
+                root,
                 clear
             });
-            await (0, commands.a8)({
+            await (0, commands.a)({
                 options,
                 filters,
                 command: 'watch'
@@ -62,11 +63,13 @@ export const __webpack_modules__ = {
             return true;
         };
         async function watchFilesForRestart({ rstest, watchOptions, options, filters }) {
-            if (!rstest.context.configFilePath) return;
+            const configFilePaths = [
+                rstest.context.configFilePath,
+                ...rstest.context.projects.map((project)=>project.configFilePath)
+            ].filter(Boolean);
+            if (0 === configFilePaths.length) return;
             const root = rstest.context.rootPath;
-            const watcher = await createChokidar([
-                rstest.context.configFilePath
-            ], root, {
+            const watcher = await createChokidar(configFilePaths, root, {
                 ignoreInitial: true,
                 ignorePermissionErrors: true,
                 ...watchOptions
@@ -77,6 +80,7 @@ export const __webpack_modules__ = {
                 restarting = true;
                 const restarted = await restart({
                     options,
+                    root,
                     filters,
                     filePath
                 });

package/dist/971.js

@@ -15,50 +15,79 @@ export const __webpack_modules__ = {
         var _utils__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("./src/utils/index.ts");
         var _rsbuild__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__("./src/core/rsbuild.ts");
         async function listTests(context, { filesOnly, json }) {
-            const { normalizedConfig: { include, exclude, root, name, setupFiles: setups, includeSource }, rootPath } = context;
-            const testEntries = await (0, _utils__WEBPACK_IMPORTED_MODULE_3__.tG)({
-                include,
-                exclude,
-                root,
-                fileFilters: context.fileFilters || [],
-                includeSource
-            });
-            const globTestSourceEntries = async ()=>testEntries;
-            const setupFiles = (0, _utils__WEBPACK_IMPORTED_MODULE_3__.pr)(setups, rootPath);
-            const rsbuildInstance = await (0, _rsbuild__WEBPACK_IMPORTED_MODULE_4__.z)(context, globTestSourceEntries, setupFiles);
-            const { getRsbuildStats, closeServer } = await (0, _rsbuild__WEBPACK_IMPORTED_MODULE_4__.X)({
-                name,
+            const { rootPath } = context;
+            const testEntries = {};
+            const globTestSourceEntries = async (name)=>{
+                if (testEntries[name]) return testEntries[name];
+                const { include, exclude, includeSource, root } = context.projects.find((p)=>p.environmentName === name).normalizedConfig;
+                const entries = await (0, _utils__WEBPACK_IMPORTED_MODULE_3__.tG)({
+                    include,
+                    exclude,
+                    rootPath,
+                    projectRoot: root,
+                    fileFilters: context.fileFilters || [],
+                    includeSource
+                });
+                testEntries[name] = entries;
+                return entries;
+            };
+            const setupFiles = Object.fromEntries(context.projects.map((project)=>{
+                const { environmentName, rootPath, normalizedConfig: { setupFiles } } = project;
+                return [
+                    environmentName,
+                    (0, _utils__WEBPACK_IMPORTED_MODULE_3__.pr)(setupFiles, rootPath)
+                ];
+            }));
+            const rsbuildInstance = await (0, _rsbuild__WEBPACK_IMPORTED_MODULE_4__.zh)(context, globTestSourceEntries, setupFiles);
+            const { getRsbuildStats, closeServer } = await (0, _rsbuild__WEBPACK_IMPORTED_MODULE_4__.XD)({
                 globTestSourceEntries,
                 normalizedConfig: context.normalizedConfig,
                 setupFiles,
                 rsbuildInstance,
                 rootPath
             });
-            const { entries, setupEntries, assetFiles, sourceMaps, getSourcemap } = await getRsbuildStats();
             const pool = await (0, _pool__WEBPACK_IMPORTED_MODULE_2__.b)({
                 context
             });
-            const list = await pool.collectTests({
-                context,
-                entries,
-                sourceMaps,
-                setupEntries,
-                assetFiles,
-                updateSnapshot: context.snapshotManager.options.updateSnapshot
-            });
+            const updateSnapshot = context.snapshotManager.options.updateSnapshot;
+            const returns = await Promise.all(context.projects.map(async (project)=>{
+                const { entries, setupEntries, assetFiles, sourceMaps } = await getRsbuildStats({
+                    environmentName: project.environmentName
+                });
+                const list = await pool.collectTests({
+                    entries,
+                    sourceMaps,
+                    setupEntries,
+                    assetFiles,
+                    project,
+                    updateSnapshot
+                });
+                return {
+                    list,
+                    sourceMaps
+                };
+            }));
+            const list = returns.flatMap((r)=>r.list);
+            const sourceMaps = Object.assign({}, ...returns.map((r)=>r.sourceMaps));
             const tests = [];
             const traverseTests = (test)=>{
                 if ([
                     'skip',
                     'todo'
                 ].includes(test.runMode)) return;
-                if ('case' === test.type) tests.push({
+                if ('case' === test.type) if (showProject) tests.push({
+                    file: test.testPath,
+                    name: (0, _utils__WEBPACK_IMPORTED_MODULE_3__.fN)(test),
+                    project: test.project
+                });
+                else tests.push({
                     file: test.testPath,
                     name: (0, _utils__WEBPACK_IMPORTED_MODULE_3__.fN)(test)
                 });
                 else for (const child of test.tests)traverseTests(child);
             };
             const hasError = list.some((file)=>file.errors?.length);
+            const showProject = context.projects.length > 1;
             if (hasError) {
                 const { printError } = await Promise.all([
                     __webpack_require__.e("829"),
@@ -69,7 +98,7 @@ export const __webpack_modules__ = {
                     const relativePath = (0, node_path__WEBPACK_IMPORTED_MODULE_1__.relative)(rootPath, file.testPath);
                     if (file.errors?.length) {
                         _utils__WEBPACK_IMPORTED_MODULE_3__.vF.log(`${_utils__WEBPACK_IMPORTED_MODULE_3__.yW.bgRed(' FAIL ')} ${relativePath}`);
-                        for (const error of file.errors)await printError(error, getSourcemap, rootPath);
+                        for (const error of file.errors)await printError(error, (name)=>sourceMaps[name] || null, rootPath);
                     }
                 }
                 await closeServer();
@@ -78,7 +107,11 @@ export const __webpack_modules__ = {
             }
             for (const file of list){
                 if (filesOnly) {
-                    tests.push({
+                    if (showProject) tests.push({
+                        file: file.testPath,
+                        project: file.project
+                    });
+                    else tests.push({
                         file: file.testPath
                     });
                     continue;