@rspack/test-tools 1.2.7-alpha.0 → 1.2.8

package/dist/case/builtin.js

@@ -31,7 +31,8 @@ const creator = new creator_1.BasicCaseCreator({
                 compilerType: type_1.ECompilerType.Rspack
             })
         ];
-    }
+    },
+    concurrent: true
 });
 function createBuiltinCase(name, src, dist) {
     creator.create(name, src, dist);

package/dist/case/cache.js

@@ -20,7 +20,8 @@ function getCreator(target) {
                     configFiles: ["rspack.config.js", "webpack.config.js"]
                 })
             ],
-            runner: runner_1.CacheRunnerFactory
+            runner: runner_1.CacheRunnerFactory,
+            concurrent: true
         }));
     }
     return creators.get(target);

package/dist/case/config.js

@@ -27,7 +27,8 @@ const creator = new creator_1.BasicCaseCreator({
             configFiles: ["rspack.config.js", "webpack.config.js"]
         })
     ],
-    runner: runner_1.MultipleRunnerFactory
+    runner: runner_1.MultipleRunnerFactory,
+    concurrent: 3
 });
 function createConfigCase(name, src, dist) {
     creator.create(name, src, dist);

package/dist/case/diagnostic.js

@@ -19,7 +19,8 @@ const creator = new creator_1.BasicCaseCreator({
                 return output.replace(/(│.* at ).*/g, "$1xxx");
             }
         })
-    ]
+    ],
+    concurrent: true
 });
 function createDiagnosticCase(name, src, dist) {
     creator.create(name, src, dist);

package/dist/case/diff.js

@@ -33,11 +33,10 @@ function createDiffCase(name, src, dist) {
         steps: [processor]
     });
     (0, rimraf_1.rimrafSync)(dist);
-    const buildTask = tester.compile();
     const prefix = node_path_1.default.basename(name);
     describe(`${prefix}:check`, () => {
         beforeAll(async () => {
-            await buildTask;
+            await tester.compile();
             compareMap.clear();
             await tester.check(env);
         });

package/dist/case/hot-step.js

@@ -20,7 +20,8 @@ function getCreator(target) {
                     configFiles: ["rspack.config.js", "webpack.config.js"]
                 })
             ],
-            runner: runner_1.HotStepRunnerFactory
+            runner: runner_1.HotStepRunnerFactory,
+            concurrent: true
         }));
     }
     return creators.get(target);

package/dist/case/hot.js

@@ -20,7 +20,8 @@ function getCreator(target) {
                     configFiles: ["rspack.config.js", "webpack.config.js"]
                 })
             ],
-            runner: runner_1.HotRunnerFactory
+            runner: runner_1.HotRunnerFactory,
+            concurrent: true
         }));
     }
     return creators.get(target);

package/dist/case/index.d.ts

@@ -17,3 +17,4 @@ export * from "./watch";
 export * from "./new-incremental";
 export * from "./cache";
 export * from "./new-code-splitting";
+export * from "./serial";

package/dist/case/index.js

@@ -33,3 +33,4 @@ __exportStar(require("./watch"), exports);
 __exportStar(require("./new-incremental"), exports);
 __exportStar(require("./cache"), exports);
 __exportStar(require("./new-code-splitting"), exports);
+__exportStar(require("./serial"), exports);

package/dist/case/new-code-splitting.js

@@ -33,7 +33,8 @@ const configCreator = new creator_1.BasicCaseCreator({
             configFiles: ["rspack.config.js", "webpack.config.js"]
         });
         return [processor];
-    }
+    },
+    concurrent: 3
 });
 class NewCodeSplittingProcessor extends processor_1.ConfigProcessor {
     constructor(_configOptions) {

package/dist/case/new-incremental.js

@@ -29,7 +29,8 @@ function getHotCreator(target, documentType) {
                     documentType
                 })
             ],
-            runner: runner_1.HotRunnerFactory
+            runner: runner_1.HotRunnerFactory,
+            concurrent: true
         }));
     }
     return hotCreators.get(key);
@@ -76,7 +77,8 @@ const watchCreator = new creator_1.BasicCaseCreator({
                 compilerType: type_1.ECompilerType.Rspack,
                 configFiles: ["rspack.config.js", "webpack.config.js"]
             }, watchState));
-    }
+    },
+    concurrent: true
 });
 function createWatchNewIncrementalCase(name, src, dist, temp) {
     watchCreator.create(name, src, dist, temp);

package/dist/case/normal.js

@@ -21,7 +21,8 @@ const creator = new creator_1.BasicCaseCreator({
             compilerType: type_1.ECompilerType.Rspack
         })
     ],
-    runner: runner_1.NormalRunnerFactory
+    runner: runner_1.NormalRunnerFactory,
+    concurrent: true
 });
 function createNormalCase(name, src, dist) {
     creator.create(name, src, dist);

package/dist/case/serial.d.ts

@@ -0,0 +1,3 @@
+import { ECompilerType, type TTestConfig } from "../type";
+export type TSerialCaseConfig = Omit<TTestConfig<ECompilerType.Rspack>, "validate">;
+export declare function createSerialCase(name: string, src: string, dist: string): void;

package/dist/case/serial.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSerialCase = createSerialCase;
+const config_1 = require("../processor/config");
+const runner_1 = require("../runner");
+const creator_1 = require("../test/creator");
+const type_1 = require("../type");
+const creator = new creator_1.BasicCaseCreator({
+    clean: true,
+    describe: false,
+    testConfig: testConfig => {
+        const oldModuleScope = testConfig.moduleScope;
+        testConfig.moduleScope = (ms, stats) => {
+            let res = ms;
+            // TODO: modify runner module scope based on stats here
+            if (typeof oldModuleScope === "function") {
+                res = oldModuleScope(ms, stats);
+            }
+            return res;
+        };
+    },
+    steps: ({ name }) => [
+        new config_1.ConfigProcessor({
+            name,
+            runable: true,
+            compilerType: type_1.ECompilerType.Rspack,
+            configFiles: ["rspack.config.js", "webpack.config.js"]
+        })
+    ],
+    runner: runner_1.MultipleRunnerFactory
+});
+function createSerialCase(name, src, dist) {
+    creator.create(name, src, dist);
+}

package/dist/case/watch.js

@@ -45,7 +45,8 @@ const creator = new creator_1.BasicCaseCreator({
                 compilerType: type_1.ECompilerType.Rspack,
                 configFiles: ["rspack.config.js", "webpack.config.js"]
             }, watchState));
-    }
+    },
+    concurrent: true
 });
 function createWatchCase(name, src, dist, temp) {
     creator.create(name, src, dist, temp);

package/dist/compiler.js

@@ -65,6 +65,10 @@ class TestCompilerManager {
         if (!this.compilerInstance)
             throw new Error("Compiler should be created before watch");
         this.compilerInstance.watch({
+            // IMPORTANT:
+            // This is a workaround for the issue that watchpack cannot detect the file change in time
+            // so we set the poll to 300ms to make it more sensitive to the file change
+            poll: 300,
             aggregateTimeout: timeout
         }, (error, newStats) => {
             this.emitter.emit(ECompilerEvent.Build, error, newStats);

package/dist/helper/expect/to-match-file-snapshot.d.ts

@@ -17,7 +17,7 @@ export declare function toMatchFileSnapshot(this: {
         unmatched: number;
         _updateSnapshot: "none" | "new" | "all";
     };
-}, content: string | Buffer, filepath: string, options?: FileMatcherOptions): {
+}, rawContent: string | Buffer, filepath: string, options?: FileMatcherOptions): {
     pass: boolean;
     message: () => string;
 };

package/dist/helper/expect/to-match-file-snapshot.js

@@ -11,6 +11,7 @@ const node_path_1 = __importDefault(require("node:path"));
 const chalk_1 = __importDefault(require("chalk"));
 const filenamify_1 = __importDefault(require("filenamify"));
 const jest_diff_1 = require("jest-diff");
+const { serialize } = require(node_path_1.default.join(node_path_1.default.dirname(require.resolve("jest-snapshot")), "./utils.js"));
 /**
  * Check if 2 strings or buffer are equal
  */
@@ -25,7 +26,10 @@ const isEqual = (a, b) => {
  * @param filepath Path to the file to match against
  * @param options Additional options for matching
  */
-function toMatchFileSnapshot(content, filepath, options = {}) {
+function toMatchFileSnapshot(rawContent, filepath, options = {}) {
+    const content = Buffer.isBuffer(rawContent) || typeof rawContent === "string"
+        ? rawContent
+        : serialize(rawContent);
     const { isNot, snapshotState } = this;
     const filename = filepath === undefined
         ? // If file name is not specified, generate one from the test title

package/dist/helper/util/currentWatchStep.d.ts

@@ -1 +1 @@
-export { undefined as step };
+export const step: {};

package/dist/helper/util/currentWatchStep.js

@@ -1,2 +1,2 @@
 "use strict";
-exports.step = undefined;
+exports.step = {};

package/dist/processor/config.js

@@ -71,6 +71,11 @@ class ConfigProcessor extends multi_1.MultiTaskProcessor {
             options.output ??= {};
             options.output.filename = `bundle${index}${outputModule ? ".mjs" : ".js"}`;
         }
+        if (!global.printLogger) {
+            options.infrastructureLogging = {
+                level: "error"
+            };
+        }
     }
 }
 exports.ConfigProcessor = ConfigProcessor;

package/dist/processor/hot.js

@@ -121,6 +121,11 @@ class HotProcessor extends basic_1.BasicProcessor {
             options.plugins ??= [];
             options.plugins.push(new core_1.rspack.LoaderOptionsPlugin(this.updateOptions));
         }
+        if (!global.printLogger) {
+            options.infrastructureLogging = {
+                level: "error"
+            };
+        }
     }
 }
 exports.HotProcessor = HotProcessor;

package/dist/processor/watch.js

@@ -36,7 +36,8 @@ class WatchProcessor extends multi_1.MultiTaskProcessor {
     async build(context) {
         const compiler = this.getCompiler(context);
         const currentWatchStepModule = require(currentWatchStepModulePath);
-        currentWatchStepModule.step = this._watchOptions.stepName;
+        currentWatchStepModule.step[this._options.name] =
+            this._watchOptions.stepName;
         node_fs_1.default.mkdirSync(this._watchOptions.tempDir, { recursive: true });
         (0, copyDiff_1.default)(node_path_1.default.join(context.getSource(), this._watchOptions.stepName), this._watchOptions.tempDir, true);
         const task = new Promise((resolve, reject) => {
@@ -173,7 +174,7 @@ class WatchProcessor extends multi_1.MultiTaskProcessor {
             if (!options.output.path)
                 options.output.path = context.getDist();
             if (typeof options.output.pathinfo === "undefined")
-                options.output.pathinfo = true;
+                options.output.pathinfo = false;
             if (!options.output.filename)
                 options.output.filename = "bundle.js";
             if (options.cache && options.cache.type === "filesystem") {
@@ -203,6 +204,11 @@ class WatchProcessor extends multi_1.MultiTaskProcessor {
             options.experiments.rspackFuture ??= {};
             options.experiments.rspackFuture.bundlerInfo ??= {};
             options.experiments.rspackFuture.bundlerInfo.force ??= false;
+            if (!global.printLogger) {
+                options.infrastructureLogging = {
+                    level: "error"
+                };
+            }
         };
     }
     static findBundle(index, context, options) {
@@ -226,7 +232,8 @@ class WatchStepProcessor extends WatchProcessor {
     async build(context) {
         const compiler = this.getCompiler(context);
         const currentWatchStepModule = require(currentWatchStepModulePath);
-        currentWatchStepModule.step = this._watchOptions.stepName;
+        currentWatchStepModule.step[this._options.name] =
+            this._watchOptions.stepName;
         const task = new Promise((resolve, reject) => {
             compiler.getEmitter().once(compiler_1.ECompilerEvent.Build, (e, stats) => {
                 if (e)

package/dist/runner/runner/cjs.d.ts

@@ -1,6 +1,9 @@
 import type { ECompilerType } from "../../type";
 import type { IBasicGlobalContext, IBasicModuleScope, TBasicRunnerFile, TModuleObject, TRunnerRequirer } from "../type";
 import { BasicRunner } from "./basic";
+declare global {
+    var printLogger: boolean;
+}
 export declare class CommonJsRunner<T extends ECompilerType = ECompilerType.Rspack> extends BasicRunner<T> {
     protected createGlobalContext(): IBasicGlobalContext;
     protected createBaseModuleScope(): IBasicModuleScope;

package/dist/runner/runner/cjs.js

@@ -14,7 +14,42 @@ const define = (...args) => {
 class CommonJsRunner extends basic_1.BasicRunner {
     createGlobalContext() {
         return {
-            console: console,
+            console: {
+                log: (...args) => {
+                    if (printLogger) {
+                        console.log(...args);
+                    }
+                },
+                warn: (...args) => {
+                    if (printLogger) {
+                        console.warn(...args);
+                    }
+                },
+                error: (...args) => {
+                    console.error(...args);
+                },
+                info: (...args) => {
+                    if (printLogger) {
+                        console.info(...args);
+                    }
+                },
+                debug: (...args) => {
+                    if (printLogger) {
+                        console.info(...args);
+                    }
+                },
+                trace: (...args) => {
+                    if (printLogger) {
+                        console.info(...args);
+                    }
+                },
+                assert: (...args) => {
+                    console.assert(...args);
+                },
+                clear: () => {
+                    console.clear();
+                }
+            },
             setTimeout: ((cb, ms, ...args) => {
                 const timeout = setTimeout(cb, ms, ...args);
                 timeout.unref();
@@ -34,6 +69,7 @@ class CommonJsRunner extends basic_1.BasicRunner {
                 });
                 return m;
             },
+            __SNAPSHOT__: node_path_1.default.join(this._options.source, "__snapshot__"),
             ...this._options.env
         };
         return baseModuleScope;

package/dist/runner/runner/web/jsdom.d.ts

@@ -1,10 +1,11 @@
 import type { ECompilerType } from "../../../type";
-import type { TRunnerRequirer } from "../../type";
+import type { TBasicRunnerFile, TRunnerRequirer } from "../../type";
 import type { IBasicRunnerOptions } from "../basic";
 import { CommonJsRunner } from "../cjs";
 export declare class JSDOMWebRunner<T extends ECompilerType = ECompilerType.Rspack> extends CommonJsRunner<T> {
     protected _webOptions: IBasicRunnerOptions<T>;
     private dom;
+    private requireCache;
     constructor(_webOptions: IBasicRunnerOptions<T>);
     run(file: string): Promise<unknown>;
     getGlobal(name: string): unknown;
@@ -14,6 +15,12 @@ export declare class JSDOMWebRunner<T extends ECompilerType = ECompilerType.Rspa
         }): any;
     };
     protected createBaseModuleScope(): import("../../type").IBasicModuleScope;
+    protected getModuleContent(file: TBasicRunnerFile): [
+        {
+            exports: Record<string, unknown>;
+        },
+        string
+    ];
     protected createJSDOMRequirer(): TRunnerRequirer;
     protected createRunner(): void;
 }

package/dist/runner/runner/web/jsdom.js

@@ -12,10 +12,13 @@ const EventSourceForNode_1 = __importDefault(require("../../../helper/legacy/Eve
 const createFakeWorker_1 = __importDefault(require("../../../helper/legacy/createFakeWorker"));
 const urlToRelativePath_1 = __importDefault(require("../../../helper/legacy/urlToRelativePath"));
 const cjs_1 = require("../cjs");
+// Compatibility code to suppress iconv-lite warnings
+require("iconv-lite").skipDecodeWarning = true;
 class JSDOMWebRunner extends cjs_1.CommonJsRunner {
     constructor(_webOptions) {
         super(_webOptions);
         this._webOptions = _webOptions;
+        this.requireCache = Object.create(null);
         const virtualConsole = new jsdom_1.VirtualConsole();
         virtualConsole.sendTo(console);
         this.dom = new jsdom_1.JSDOM(`
@@ -74,10 +77,25 @@ class JSDOMWebRunner extends cjs_1.CommonJsRunner {
                 .resolve(this._webOptions.dist, `./${url.startsWith("https://test.cases/path/") ? url.slice(24) : url}`)
                 .split("?")[0];
         };
+        const that = this;
         class CustomResourceLoader extends jsdom_1.ResourceLoader {
             fetch(url, _) {
+                const filePath = urlToPath(url);
+                let finalCode;
+                if (node_path_1.default.extname(filePath) === ".js") {
+                    const currentDirectory = node_path_1.default.dirname(filePath);
+                    const file = that.getFile(filePath, currentDirectory);
+                    if (!file) {
+                        throw new Error(`File not found: ${filePath}`);
+                    }
+                    const [_m, code] = that.getModuleContent(file);
+                    finalCode = code;
+                }
+                else {
+                    finalCode = node_fs_1.default.readFileSync(filePath);
+                }
                 try {
-                    return Promise.resolve(node_fs_1.default.readFileSync(urlToPath(url)));
+                    return Promise.resolve(finalCode);
                 }
                 catch (err) {
                     console.error(err);
@@ -135,56 +153,61 @@ class JSDOMWebRunner extends cjs_1.CommonJsRunner {
         };
         return moduleScope;
     }
+    getModuleContent(file) {
+        const m = {
+            exports: {}
+        };
+        const currentModuleScope = this.createModuleScope(this.getRequire(), m, file);
+        if (this._options.testConfig.moduleScope) {
+            this._options.testConfig.moduleScope(currentModuleScope);
+        }
+        const scopeKey = (0, helper_1.escapeSep)(file.path);
+        const args = Object.keys(currentModuleScope).filter(arg => !["window", "self", "globalThis", "console"].includes(arg));
+        const argValues = args
+            .map(arg => `window["${scopeKey}"]["${arg}"]`)
+            .join(", ");
+        this.dom.window[scopeKey] = currentModuleScope;
+        return [
+            m,
+            `
+			// hijack document.currentScript for auto public path
+			var $$g$$ = new Proxy(window, {
+				get(target, prop, receiver) {
+					if (prop === "document") {
+						return new Proxy(window.document, {
+							get(target, prop, receiver) {
+								if (prop === "currentScript") {
+									var script = target.createElement("script");
+									script.src = "https://test.cases/path/${(0, helper_1.escapeSep)(file.subPath)}index.js";
+									return script;
+								}
+								return Reflect.get(target, prop, receiver);
+							}
+						});
+					}
+					return Reflect.get(target, prop, receiver);
+				}
+			});
+			(function(window, self, globalThis, console, ${args.join(", ")}) {
+				${file.content}
+			})($$g$$, $$g$$, $$g$$, window["console"], ${argValues});
+		`
+        ];
+    }
     createJSDOMRequirer() {
-        const requireCache = Object.create(null);
         return (currentDirectory, modulePath, context = {}) => {
             const file = context.file || this.getFile(modulePath, currentDirectory);
             if (!file) {
                 return this.requirers.get("miss")(currentDirectory, modulePath);
             }
-            if (file.path in requireCache) {
-                return requireCache[file.path].exports;
+            if (file.path in this.requireCache) {
+                return this.requireCache[file.path].exports;
             }
-            const m = {
-                exports: {}
-            };
-            requireCache[file.path] = m;
-            const currentModuleScope = this.createModuleScope(this.getRequire(), m, file);
-            if (this._options.testConfig.moduleScope) {
-                this._options.testConfig.moduleScope(currentModuleScope);
-            }
-            const scopeKey = (0, helper_1.escapeSep)(file.path);
-            const args = Object.keys(currentModuleScope).filter(arg => !["window", "self", "globalThis", "console"].includes(arg));
-            const argValues = args
-                .map(arg => `window["${scopeKey}"]["${arg}"]`)
-                .join(", ");
-            const code = `
-        // hijack document.currentScript for auto public path
-        var $$g$$ = new Proxy(window, {
-          get(target, prop, receiver) {
-            if (prop === "document") {
-              return new Proxy(window.document, {
-                get(target, prop, receiver) {
-                  if (prop === "currentScript") {
-                    var script = target.createElement("script");
-                    script.src = "https://test.cases/path/${(0, helper_1.escapeSep)(file.subPath)}index.js";
-                    return script;
-                  }
-                  return Reflect.get(target, prop, receiver);
-                }
-              });
-            }
-            return Reflect.get(target, prop, receiver);
-          }
-        });
-        (function(window, self, globalThis, console, ${args.join(", ")}) {
-          ${file.content}
-        })($$g$$, $$g$$, $$g$$, window["console"], ${argValues});
-      `;
+            const [m, code] = this.getModuleContent(file);
             this.preExecute(code, file);
-            this.dom.window[scopeKey] = currentModuleScope;
             this.dom.window.eval(code);
             this.postExecute(m, file);
+            this.requireCache[file.path] = m;
             return m.exports;
         };
     }

package/dist/runner/type.d.ts

@@ -14,12 +14,12 @@ export declare enum EEsmMode {
     Unlinked = 2
 }
 export interface IBasicModuleScope extends ITestEnv {
-    console: Console;
+    console: Record<string, (...args: any[]) => void>;
     expect: jest.Expect;
     [key: string]: any;
 }
 export interface IBasicGlobalContext {
-    console: Console;
+    console: Record<string, (...args: any[]) => void>;
     setTimeout: typeof setTimeout;
     clearTimeout: typeof clearTimeout;
     [key: string]: any;

package/dist/test/creator.d.ts

@@ -1,4 +1,11 @@
 import type { ECompilerType, ITestContext, ITestEnv, ITestProcessor, ITester, TRunnerFactory, TTestConfig } from "../type";
+declare global {
+    var testFilter: string | undefined;
+}
+interface IConcurrentTestEnv {
+    clear: () => void;
+    run: () => Promise<void>;
+}
 export interface IBasicCaseCreatorOptions<T extends ECompilerType> {
     clean?: boolean;
     describe?: boolean;
@@ -14,16 +21,26 @@ export interface IBasicCaseCreatorOptions<T extends ECompilerType> {
     description?: (name: string, step: number) => string;
     runner?: new (name: string, context: ITestContext) => TRunnerFactory<ECompilerType>;
     [key: string]: unknown;
+    concurrent?: boolean | number;
 }
 export declare class BasicCaseCreator<T extends ECompilerType> {
     protected _options: IBasicCaseCreatorOptions<T>;
+    protected currentConcurrent: number;
+    protected tasks: [string, () => void][];
     constructor(_options: IBasicCaseCreatorOptions<T>);
     create(name: string, src: string, dist: string, temp?: string): ITester | undefined;
+    protected shouldRun(name: string): boolean;
+    protected describeConcurrent(name: string, tester: ITester, testConfig: TTestConfig<T>): void;
     protected describe(name: string, tester: ITester, testConfig: TTestConfig<T>): void;
+    protected createConcurrentEnv(): ITestEnv & IConcurrentTestEnv;
     protected createEnv(testConfig: TTestConfig<T>): ITestEnv;
     protected clean(folders: string[]): void;
     protected skip(name: string, reason: string | boolean): void;
     protected readTestConfig(src: string): TTestConfig<T>;
     protected checkSkipped(src: string, testConfig: TTestConfig<T>): boolean | string;
     protected createTester(name: string, src: string, dist: string, temp: string | void, testConfig: TTestConfig<T>): ITester;
+    protected tryRunTask(): void;
+    protected getMaxConcurrent(): number;
+    protected registerConcurrentTask(name: string, starter: () => void): () => void;
 }
+export {};

package/dist/test/creator.js

@@ -9,9 +9,12 @@ const node_path_1 = __importDefault(require("node:path"));
 const rimraf_1 = require("rimraf");
 const createLazyTestEnv_1 = __importDefault(require("../helper/legacy/createLazyTestEnv"));
 const tester_1 = require("./tester");
+const DEFAULT_MAX_CONCURRENT = 5;
 class BasicCaseCreator {
     constructor(_options) {
         this._options = _options;
+        this.currentConcurrent = 0;
+        this.tasks = [];
     }
     create(name, src, dist, temp) {
         const testConfig = this.readTestConfig(src);
@@ -26,24 +29,113 @@ class BasicCaseCreator {
         if (this._options.clean) {
             this.clean([dist, temp || ""].filter(Boolean));
         }
+        const run = this.shouldRun(name);
         const tester = this.createTester(name, src, dist, temp, testConfig);
+        const concurrent = testConfig.concurrent ?? this._options.concurrent ?? false;
         if (this._options.describe) {
-            describe(name, () => this.describe(name, tester, testConfig));
+            if (run) {
+                if (concurrent) {
+                    describe(name, () => this.describeConcurrent(name, tester, testConfig));
+                }
+                else {
+                    describe(name, () => this.describe(name, tester, testConfig));
+                }
+            }
+            else {
+                describe.skip(name, () => {
+                    it.skip("skipped", () => { });
+                });
+            }
         }
         else {
-            this.describe(name, tester, testConfig);
+            if (run) {
+                if (concurrent) {
+                    this.describeConcurrent(name, tester, testConfig);
+                }
+                else {
+                    this.describe(name, tester, testConfig);
+                }
+            }
+            else {
+                it.skip("skipped", () => { });
+            }
         }
         return tester;
     }
+    shouldRun(name) {
+        // TODO: more flexible filter
+        if (typeof global.testFilter !== "string" || !global.testFilter) {
+            return true;
+        }
+        return name.includes(global.testFilter);
+    }
+    describeConcurrent(name, tester, testConfig) {
+        beforeAll(async () => {
+            await tester.prepare();
+        });
+        let starter = null;
+        let chain = new Promise((resolve, reject) => {
+            starter = resolve;
+        });
+        const ender = this.registerConcurrentTask(name, starter);
+        const env = this.createConcurrentEnv();
+        let bailout = false;
+        for (let index = 0; index < tester.total; index++) {
+            let stepSignalResolve = null;
+            let stepSignalReject = null;
+            const stepSignal = new Promise((resolve, reject) => {
+                stepSignalResolve = resolve;
+                stepSignalReject = reject;
+            });
+            const description = typeof this._options.description === "function"
+                ? this._options.description(name, index)
+                : index
+                    ? `step [${index}] should pass`
+                    : "should pass";
+            it(description, async () => {
+                await stepSignal;
+            }, this._options.timeout || 180000);
+            chain = chain.then(async () => {
+                try {
+                    if (bailout) {
+                        throw `Case "${name}" step ${index + 1} bailout because ${tester.step + 1} failed`;
+                    }
+                    env.clear();
+                    await tester.compile();
+                    await tester.check(env);
+                    await env.run();
+                    const context = tester.getContext();
+                    if (!tester.next() && context.hasError()) {
+                        bailout = true;
+                        const errors = context
+                            .getError()
+                            .map(i => `${i.stack}`.split("\n").join("\t\n"))
+                            .join("\n\n");
+                        throw new Error(`Case "${name}" failed at step ${tester.step + 1}:\n${errors}`);
+                    }
+                    stepSignalResolve();
+                }
+                catch (e) {
+                    stepSignalReject(e);
+                }
+            });
+        }
+        chain.finally(() => {
+            ender();
+        });
+        afterAll(async () => {
+            await tester.resume();
+        });
+    }
     describe(name, tester, testConfig) {
         beforeAll(async () => {
             await tester.prepare();
         });
+        let bailout = false;
         for (let index = 0; index < tester.total; index++) {
             const description = typeof this._options.description === "function"
                 ? this._options.description(name, index)
                 : `step ${index ? `[${index}]` : ""} should pass`;
-            let bailout = false;
             it(description, async () => {
                 if (bailout) {
                     throw `Case "${name}" step ${index + 1} bailout because ${tester.step + 1} failed`;
@@ -66,6 +158,69 @@ class BasicCaseCreator {
             await tester.resume();
         });
     }
+    createConcurrentEnv() {
+        const tasks = [];
+        const beforeTasks = [];
+        const afterTasks = [];
+        return {
+            clear: () => {
+                tasks.length = 0;
+                beforeTasks.length = 0;
+                afterTasks.length = 0;
+            },
+            run: async () => {
+                const runFn = async (fn) => {
+                    if (fn.length) {
+                        await new Promise((resolve, reject) => {
+                            fn(e => {
+                                if (e) {
+                                    reject(e);
+                                }
+                                else {
+                                    resolve();
+                                }
+                            });
+                        });
+                    }
+                    else {
+                        const res = fn();
+                        if (typeof res?.then === "function") {
+                            await res;
+                        }
+                    }
+                };
+                for (const [description, fn] of tasks) {
+                    for (const before of beforeTasks) {
+                        await runFn(before);
+                    }
+                    try {
+                        await runFn(fn);
+                    }
+                    catch (e) {
+                        throw new Error(`Error: ${description} failed\n${e.stack}`);
+                    }
+                    for (const after of afterTasks) {
+                        await runFn(after);
+                    }
+                }
+            },
+            expect,
+            it: (description, fn) => {
+                expect(typeof description === "string");
+                expect(typeof fn === "function");
+                tasks.push([description, fn]);
+            },
+            beforeEach: (fn) => {
+                expect(typeof fn === "function");
+                beforeTasks.push(fn);
+            },
+            afterEach: (fn) => {
+                expect(typeof fn === "function");
+                afterTasks.push(fn);
+            },
+            jest
+        };
+    }
     createEnv(testConfig) {
         if (typeof this._options.runner === "function" && !testConfig.noTest) {
             return (0, createLazyTestEnv_1.default)(10000);
@@ -115,5 +270,26 @@ class BasicCaseCreator {
             })
         });
     }
+    tryRunTask() {
+        while (this.tasks.length !== 0 &&
+            this.currentConcurrent < this.getMaxConcurrent()) {
+            const [_name, starter] = this.tasks.shift();
+            this.currentConcurrent++;
+            starter();
+        }
+    }
+    getMaxConcurrent() {
+        return typeof this._options.concurrent === "number"
+            ? this._options.concurrent
+            : DEFAULT_MAX_CONCURRENT;
+    }
+    registerConcurrentTask(name, starter) {
+        this.tasks.push([name, starter]);
+        this.tryRunTask();
+        return () => {
+            this.currentConcurrent--;
+            this.tryRunTask();
+        };
+    }
 }
 exports.BasicCaseCreator = BasicCaseCreator;

package/dist/type.d.ts

@@ -141,12 +141,13 @@ export type TTestConfig<T extends ECompilerType> = {
     beforeExecute?: () => void;
     afterExecute?: () => void;
     moduleScope?: (ms: IBasicModuleScope, stats?: TCompilerStatsCompilation<T>) => IBasicModuleScope;
-    checkStats?: (stepName: string, jsonStats: TCompilerStatsCompilation<T>, stringStats: String) => boolean;
+    checkStats?: (stepName: string, jsonStats: TCompilerStatsCompilation<T> | undefined, stringStats: String) => boolean;
     findBundle?: (index: number, options: TCompilerOptions<T>, stepName?: string) => string | string[];
     bundlePath?: string[];
     nonEsmThis?: (p: string | string[]) => Object;
     modules?: Record<string, Object>;
     timeout?: number;
+    concurrent?: boolean;
 };
 export type TTestFilter<T extends ECompilerType> = (creatorConfig: Record<string, unknown>, testConfig: TTestConfig<T>) => boolean | string;
 export interface ITestRunner {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack/test-tools",
-  "version": "1.2.7-alpha.0",
+  "version": "1.2.8",
   "license": "MIT",
   "description": "Test tools for rspack",
   "main": "dist/index.js",
@@ -34,7 +34,7 @@
     "@babel/generator": "7.26.9",
     "@babel/helpers": "7.26.9",
     "@babel/parser": "7.26.9",
-    "@babel/template": "7.25.9",
+    "@babel/template": "7.26.9",
     "@babel/traverse": "7.26.9",
     "@babel/types": "7.26.9",
     "cross-env": "^7.0.3",
@@ -53,7 +53,7 @@
     "pretty-format": "29.7.0",
     "rimraf": "^5.0.10",
     "source-map": "^0.7.4",
-    "terser-webpack-plugin": "^5.3.11",
+    "terser-webpack-plugin": "^5.3.13",
     "webpack": "5.98.0",
     "webpack-merge": "5.9.0",
     "webpack-sources": "3.2.3"
@@ -74,17 +74,17 @@
     "@types/webpack": "5.28.5",
     "@types/webpack-sources": "3.2.3",
     "@webdiscus/pug-loader": "^2.11.1",
-    "acorn": "^8.14.0",
-    "babel-loader": "^9.2.1",
+    "acorn": "^8.14.1",
+    "babel-loader": "^10.0.0",
     "babel-plugin-import": "^1.13.8",
     "chalk": "^4.1.2",
     "coffee-loader": "^5.0.0",
     "coffeescript": "^2.7.0",
-    "core-js": "3.40.0",
+    "core-js": "3.41.0",
     "css-loader": "^7.1.2",
     "file-loader": "^6.2.0",
     "graceful-fs": "^4.2.11",
-    "html-loader": "^5.0.0",
+    "html-loader": "^5.1.0",
     "html-webpack-plugin": "^5.6.3",
     "less-loader": "^12.2.0",
     "lodash": "^4.17.21",
@@ -106,9 +106,9 @@
     "typescript": "^5.7.3",
     "wast-loader": "^1.14.1",
     "worker-rspack-loader": "^3.1.2",
-    "@rspack/cli": "1.2.7-alpha.0",
-    "@rspack/core": "1.2.7-alpha.0",
-    "@rspack/test-tools": "1.2.7-alpha.0"
+    "@rspack/cli": "1.2.8",
+    "@rspack/core": "1.2.8",
+    "@rspack/test-tools": "1.2.8"
   },
   "peerDependencies": {
     "@rspack/core": ">=1.0.0"
@@ -120,9 +120,9 @@
     "dev": "tsc -b -w",
     "test": "pnpm run --stream /^test:.*/",
     "testu": "pnpm run --stream /^test:.*/ -u",
-    "test:base": "cross-env NO_COLOR=1 node --expose-gc --max-old-space-size=8192 --experimental-vm-modules ../../node_modules/jest-cli/bin/jest --logHeapUsage --colors --config ./jest.config.js --passWithNoTests",
-    "test:hot": "cross-env RSPACK_HOT_TEST=true NO_COLOR=1 node --expose-gc --max-old-space-size=8192 --experimental-vm-modules ../../node_modules/jest-cli/bin/jest --logHeapUsage --colors --config ./jest.config.hot.js --passWithNoTests",
-    "test:diff": "cross-env RSPACK_DIFF=true NO_COLOR=1 node --expose-gc --max-old-space-size=8192 --experimental-vm-modules ../../node_modules/jest-cli/bin/jest --logHeapUsage --colors --config ./jest.config.diff.js --passWithNoTests",
+    "test:base": "cross-env node --no-warnings --expose-gc --max-old-space-size=8192 --experimental-vm-modules ../../node_modules/jest-cli/bin/jest --logHeapUsage --colors --config ./jest.config.js --passWithNoTests",
+    "test:hot": "cross-env RSPACK_HOT_TEST=true node --no-warnings --expose-gc --max-old-space-size=8192 --experimental-vm-modules ../../node_modules/jest-cli/bin/jest --logHeapUsage --colors --config ./jest.config.hot.js --passWithNoTests",
+    "test:diff": "cross-env RSPACK_DIFF=true node --no-warnings --expose-gc --max-old-space-size=8192 --experimental-vm-modules ../../node_modules/jest-cli/bin/jest --logHeapUsage --colors --config ./jest.config.diff.js --passWithNoTests",
     "api-extractor": "api-extractor run --verbose",
     "api-extractor:ci": "api-extractor run --verbose || diff temp/test-tools.api.md etc/test-tools.api.md"
   }