@rspack/test-tools 1.5.7 → 1.5.8

package/dist/case/common.js

@@ -135,49 +135,51 @@ async function checkSnapshot(env, context, name, snapshot, filter) {
     if (path_1.default.extname(snapshot) === ".snap") {
         throw new Error("Snapshot with `.snap` will be managed by jest, please use `.snap.txt` instead");
     }
-    const compiler = getCompiler(context, name);
-    const stats = compiler.getStats();
-    const c = compiler.getCompiler();
-    if (!stats || !c)
+    const compilerManager = getCompiler(context, name);
+    const stats = compilerManager.getStats();
+    const compiler = compilerManager.getCompiler();
+    if (!stats || !compiler)
         return;
-    if (stats.hasErrors()) {
-        const errors = [];
-        if (stats.stats) {
-            for (const s of stats.stats) {
-                if (s.hasErrors()) {
-                    errors.push(...s.compilation.errors);
-                }
-            }
+    const compilers = "compilers" in compiler
+        ? compiler.compilers
+        : [compiler];
+    const totalStats = "stats" in stats
+        ? stats.stats
+        : [stats];
+    const total = compilers.length;
+    for (let i = 0; i < compilers.length; i++) {
+        const c = compilers[i];
+        const stats = totalStats[i];
+        if (stats.hasErrors()) {
+            const errors = [];
+            errors.push(...stats.compilation.errors);
+            throw new Error(`Failed to compile in fixture ${name}, Errors: ${errors
+                ?.map(i => `${i.message}\n${i.stack}`)
+                .join("\n\n")}`);
         }
-        else {
-            const s = stats;
-            errors.push(...s.compilation.errors);
-        }
-        throw new Error(`Failed to compile in fixture ${name}, Errors: ${errors
-            ?.map(i => `${i.message}\n${i.stack}`)
-            .join("\n\n")}`);
-    }
-    const compilation = c._lastCompilation ||
-        c._lastCompilation;
-    const snapshotFileFilter = filter ||
-        ((file) => file.endsWith(".js") && !file.includes("runtime.js"));
-    const fileContents = Object.entries(compilation.assets)
-        .filter(([file]) => snapshotFileFilter(file))
-        .map(([file, source]) => {
-        const tag = path_1.default.extname(file).slice(1) || "txt";
-        let content = (0, placeholder_1.normalizePlaceholder)(source.source().toString());
-        const testConfig = context.getTestConfig();
-        if (testConfig.snapshotContent) {
-            content = testConfig.snapshotContent(content);
-        }
-        return `\`\`\`${tag} title=${file}\n${content}\n\`\`\``;
-    });
-    fileContents.sort();
-    const content = fileContents.join("\n\n");
-    const snapshotPath = path_1.default.isAbsolute(snapshot)
-        ? snapshot
-        : path_1.default.resolve(context.getSource(), `./__snapshots__/${snapshot}`);
-    env.expect(content).toMatchFileSnapshot(snapshotPath);
+        const compilation = c._lastCompilation ||
+            c._lastCompilation;
+        const snapshotFileFilter = filter ||
+            ((file) => (file.endsWith(".js") || file.endsWith(".mjs")) &&
+                !file.includes("runtime.js"));
+        const fileContents = Object.entries(compilation.assets)
+            .filter(([file]) => snapshotFileFilter(file))
+            .map(([file, source]) => {
+            const tag = path_1.default.extname(file).slice(1) || "txt";
+            let content = (0, placeholder_1.normalizePlaceholder)(source.source().toString());
+            const testConfig = context.getTestConfig();
+            if (testConfig.snapshotContent) {
+                content = testConfig.snapshotContent(content);
+            }
+            return `\`\`\`${tag} title=${file}\n${content}\n\`\`\``;
+        });
+        fileContents.sort();
+        const content = fileContents.join("\n\n");
+        const snapshotPath = path_1.default.isAbsolute(snapshot)
+            ? snapshot
+            : path_1.default.resolve(context.getSource(), `./__snapshots__/${snapshot}${total > 1 ? `-${i}` : ""}`);
+        env.expect(content).toMatchFileSnapshot(snapshotPath);
+    }
 }
 function findMultiCompilerBundle(context, name, multiFindBundle) {
     if (typeof multiFindBundle !== "function") {

package/dist/case/compiler.js

@@ -1,137 +1,155 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCompilerCase = createCompilerCase;
-const simple_1 = require("../test/simple");
+const creator_1 = require("../test/creator");
 const common_1 = require("./common");
-function createCompilerCase(name, src, dist, testConfig) {
-    let caseConfigList = require(testConfig);
-    if (!Array.isArray(caseConfigList)) {
-        caseConfigList = [caseConfigList];
-    }
-    const runner = (0, simple_1.getSimpleProcessorRunner)(src, dist);
-    for (const caseConfig of caseConfigList) {
-        const testFn = caseConfig.skip ? it.skip : it;
-        testFn(caseConfig.description, async () => {
-            const logs = {
-                mkdir: [],
-                writeFile: []
-            };
-            const files = {};
-            await runner(name, {
-                config: async (context) => {
-                    const compiler = (0, common_1.getCompiler)(context, name);
-                    const options = caseConfig.options?.(context) || {};
-                    options.mode ??= "production";
-                    options.context ??= context.getSource();
-                    options.entry ??= "./a.js";
-                    options.output ??= {};
-                    options.output.path ??= "/";
-                    options.output.pathinfo ??= true;
-                    options.optimization ??= {};
-                    options.optimization.minimize ??= false;
-                    compiler.setOptions(options);
-                },
-                compiler: async (context) => {
-                    const compiler = (0, common_1.getCompiler)(context, name);
-                    if (caseConfig.compilerCallback) {
-                        compiler.createCompilerWithCallback(caseConfig.compilerCallback);
+function createCompilerProcessor(name, caseConfig) {
+    const logs = {
+        mkdir: [],
+        writeFile: []
+    };
+    const files = {};
+    return {
+        config: async (context) => {
+            const compiler = (0, common_1.getCompiler)(context, name);
+            const options = caseConfig.options?.(context) || {};
+            options.mode ??= "production";
+            options.context ??= context.getSource();
+            options.entry ??= "./a.js";
+            options.output ??= {};
+            options.output.path ??= "/";
+            options.output.pathinfo ??= true;
+            options.optimization ??= {};
+            options.optimization.minimize ??= false;
+            compiler.setOptions(options);
+        },
+        compiler: async (context) => {
+            const compiler = (0, common_1.getCompiler)(context, name);
+            if (caseConfig.compilerCallback) {
+                compiler.createCompilerWithCallback(caseConfig.compilerCallback);
+            }
+            else {
+                compiler.createCompiler();
+            }
+            const c = compiler.getCompiler();
+            c.outputFileSystem = {
+                // CHANGE: Added support for the `options` parameter to enable recursive directory creation,
+                // accommodating Rspack's requirement that differs from webpack's usage
+                mkdir(path, callback) {
+                    const recursive = false;
+                    // if (typeof options === "function") {
+                    // 	callback = options;
+                    // } else if (options) {
+                    // 	if (options.recursive !== undefined) recursive = options.recursive;
+                    // }
+                    logs.mkdir.push(path);
+                    if (recursive) {
+                        callback();
                     }
                     else {
-                        compiler.createCompiler();
+                        const err = new Error();
+                        err.code = "EEXIST";
+                        callback(err);
                     }
-                    const c = compiler.getCompiler();
-                    c.outputFileSystem = {
-                        // CHANGE: Added support for the `options` parameter to enable recursive directory creation,
-                        // accommodating Rspack's requirement that differs from webpack's usage
-                        mkdir(path, callback) {
-                            const recursive = false;
-                            // if (typeof options === "function") {
-                            // 	callback = options;
-                            // } else if (options) {
-                            // 	if (options.recursive !== undefined) recursive = options.recursive;
-                            // }
-                            logs.mkdir.push(path);
-                            if (recursive) {
-                                callback();
-                            }
-                            else {
-                                const err = new Error();
-                                err.code = "EEXIST";
-                                callback(err);
-                            }
-                        },
-                        writeFile(name, content, callback) {
-                            logs.writeFile.push(name, content);
-                            files[name] = content.toString("utf-8");
-                            callback();
-                        },
-                        stat(path, callback) {
-                            callback(new Error("ENOENT"));
-                        }
-                    };
-                    c.hooks.compilation.tap("CompilerTest", compilation => (compilation.bail = true));
-                    await caseConfig.compiler?.(context, c);
                 },
-                build: async (context) => {
-                    const compiler = (0, common_1.getCompiler)(context, name);
-                    if (typeof caseConfig.build === "function") {
-                        await caseConfig.build?.(context, compiler.getCompiler());
-                    }
-                    else {
-                        await compiler.build();
-                    }
+                writeFile(name, content, callback) {
+                    logs.writeFile.push(name, content);
+                    files[name] = content.toString("utf-8");
+                    callback();
                 },
-                run: async (env, context) => { },
-                check: async (env, context) => {
-                    const compiler = (0, common_1.getCompiler)(context, name);
-                    const c = compiler.getCompiler();
-                    const stats = compiler.getStats();
-                    if (caseConfig.error) {
-                        const statsJson = stats?.toJson({
-                            modules: true,
-                            reasons: true
-                        });
-                        const compilation = stats?.compilation;
-                        await caseConfig.check?.({
-                            context,
-                            compiler: c,
-                            stats: statsJson,
-                            compilation,
-                            files
-                        });
-                    }
-                    else if (stats) {
-                        expect(typeof stats).toBe("object");
-                        const compilation = stats.compilation;
-                        const statsJson = stats.toJson({
-                            modules: true,
-                            reasons: true
-                        });
-                        expect(typeof statsJson).toBe("object");
-                        expect(statsJson).toHaveProperty("errors");
-                        expect(Array.isArray(statsJson.errors)).toBe(true);
-                        if (statsJson.errors.length > 0) {
-                            expect(statsJson.errors[0]).toBeInstanceOf(Object);
-                            throw statsJson.errors[0];
-                        }
-                        statsJson.logs = logs;
-                        await caseConfig.check?.({
-                            context,
-                            stats: statsJson,
-                            files,
-                            compiler: c,
-                            compilation
-                        });
-                    }
-                    else {
-                        await caseConfig.check?.({
-                            context,
-                            files,
-                            compiler: c
-                        });
-                    }
+                stat(path, callback) {
+                    callback(new Error("ENOENT"));
                 }
-            });
+            };
+            c.hooks.compilation.tap("CompilerTest", compilation => (compilation.bail = true));
+            await caseConfig.compiler?.(context, c);
+        },
+        build: async (context) => {
+            const compiler = (0, common_1.getCompiler)(context, name);
+            if (typeof caseConfig.build === "function") {
+                await caseConfig.build?.(context, compiler.getCompiler());
+            }
+            else {
+                await compiler.build();
+            }
+        },
+        run: async (env, context) => { },
+        check: async (env, context) => {
+            const compiler = (0, common_1.getCompiler)(context, name);
+            const c = compiler.getCompiler();
+            const stats = compiler.getStats();
+            if (caseConfig.error) {
+                const statsJson = stats?.toJson({
+                    modules: true,
+                    reasons: true
+                });
+                const compilation = stats?.compilation;
+                await caseConfig.check?.({
+                    context,
+                    compiler: c,
+                    stats: statsJson,
+                    compilation,
+                    files
+                });
+            }
+            else if (stats) {
+                expect(typeof stats).toBe("object");
+                const compilation = stats.compilation;
+                const statsJson = stats.toJson({
+                    modules: true,
+                    reasons: true
+                });
+                expect(typeof statsJson).toBe("object");
+                expect(statsJson).toHaveProperty("errors");
+                expect(Array.isArray(statsJson.errors)).toBe(true);
+                if (statsJson.errors.length > 0) {
+                    expect(statsJson.errors[0]).toBeInstanceOf(Object);
+                    throw statsJson.errors[0];
+                }
+                statsJson.logs = logs;
+                await caseConfig.check?.({
+                    context,
+                    stats: statsJson,
+                    files,
+                    compiler: c,
+                    compilation
+                });
+            }
+            else {
+                await caseConfig.check?.({
+                    context,
+                    files,
+                    compiler: c
+                });
+            }
+        },
+        after: async (context) => {
+            await context.closeCompiler(name);
+        }
+    };
+}
+const creator = new creator_1.BasicCaseCreator({
+    clean: true,
+    describe: false,
+    steps: ({ name, caseConfig }) => {
+        return [createCompilerProcessor(name, caseConfig)];
+    },
+    concurrent: false
+});
+function createCompilerCase(name, src, dist, testConfig) {
+    let caseConfigList = require(testConfig);
+    if (!Array.isArray(caseConfigList)) {
+        caseConfigList = [caseConfigList];
+    }
+    for (let i = 0; i < caseConfigList.length; i++) {
+        const caseConfig = caseConfigList[i];
+        if (caseConfig.skip) {
+            it.skip(`${name}[${i}]`, () => { });
+            continue;
+        }
+        creator.create(`${name}[${i}]`, src, dist, undefined, {
+            caseConfig,
+            description: () => caseConfig.description
         });
     }
 }

package/dist/case/error.js

@@ -6,42 +6,53 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createErrorCase = createErrorCase;
 const node_path_1 = __importDefault(require("node:path"));
 const webpack_merge_1 = __importDefault(require("webpack-merge"));
-const simple_1 = require("../test/simple");
+const creator_1 = require("../test/creator");
 const common_1 = require("./common");
 let addedSerializer = false;
+const creator = new creator_1.BasicCaseCreator({
+    clean: true,
+    describe: true,
+    steps: ({ name, caseConfig }) => {
+        const config = caseConfig;
+        return [
+            {
+                config: async (context) => {
+                    const compiler = (0, common_1.getCompiler)(context, name);
+                    compiler.setOptions(options(context, config.options));
+                },
+                compiler: async (context) => {
+                    const compilerManager = (0, common_1.getCompiler)(context, name);
+                    compilerManager.createCompiler();
+                    compiler(context, compilerManager.getCompiler(), config.compiler);
+                },
+                build: async (context) => {
+                    const compiler = (0, common_1.getCompiler)(context, name);
+                    if (typeof config.build === "function") {
+                        await config.build(context, compiler.getCompiler());
+                    }
+                    else {
+                        await compiler.build();
+                    }
+                },
+                run: async (env, context) => {
+                    // no need to run, just check the snapshot of diagnostics
+                },
+                check: async (env, context) => {
+                    await check(env, context, name, config.check);
+                }
+            }
+        ];
+    },
+    concurrent: true
+});
 function createErrorCase(name, src, dist, testConfig) {
     if (!addedSerializer) {
         addedSerializer = true;
     }
     const caseConfig = require(testConfig);
-    const runner = (0, simple_1.getSimpleProcessorRunner)(src, dist);
-    it(caseConfig.description, async () => {
-        await runner(name, {
-            config: async (context) => {
-                const compiler = (0, common_1.getCompiler)(context, name);
-                compiler.setOptions(options(context, caseConfig.options));
-            },
-            compiler: async (context) => {
-                const compilerManager = (0, common_1.getCompiler)(context, name);
-                compilerManager.createCompiler();
-                compiler(context, compilerManager.getCompiler(), caseConfig.compiler);
-            },
-            build: async (context) => {
-                const compiler = (0, common_1.getCompiler)(context, name);
-                if (typeof caseConfig.build === "function") {
-                    await caseConfig.build(context, compiler.getCompiler());
-                }
-                else {
-                    await compiler.build();
-                }
-            },
-            run: async (env, context) => {
-                // no need to run, just check the snapshot of diagnostics
-            },
-            check: async (env, context) => {
-                await check(env, context, name, caseConfig.check);
-            }
-        });
+    creator.create(name, src, dist, undefined, {
+        caseConfig,
+        description: () => caseConfig.description
     });
 }
 function options(context, custom) {

package/dist/case/esm-output.d.ts

@@ -0,0 +1 @@
+export declare function createEsmOutputCase(name: string, src: string, dist: string): void;

package/dist/case/esm-output.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEsmOutputCase = createEsmOutputCase;
+const core_1 = __importDefault(require("@rspack/core"));
+const creator_1 = require("../test/creator");
+const common_1 = require("./common");
+const runner_1 = require("./runner");
+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 }) => [
+        {
+            config: async (context) => {
+                (0, common_1.configMultiCompiler)(context, name, ["rspack.config.cjs", "rspack.config.js", "webpack.config.js"], defaultOptions, () => { });
+            },
+            compiler: async (context) => {
+                await (0, common_1.compiler)(context, name);
+            },
+            build: async (context) => {
+                await (0, common_1.build)(context, name);
+            },
+            run: async (env, context) => {
+                await (0, common_1.run)(env, context, name, (context) => (0, common_1.findMultiCompilerBundle)(context, name, (_index, _context, options) => {
+                    if (options.output?.filename === "[name].mjs") {
+                        return ["main.mjs"];
+                    }
+                    else {
+                        return [options.output.filename];
+                    }
+                }));
+            },
+            check: async (env, context) => {
+                await (0, common_1.check)(env, context, name);
+                await (0, common_1.checkSnapshot)(env, context, name, "esm.snap.txt");
+            }
+        }
+    ],
+    runner: {
+        key: runner_1.getMultiCompilerRunnerKey,
+        runner: runner_1.createMultiCompilerRunner
+    },
+    concurrent: false
+});
+const defaultOptions = (_index, context) => ({
+    context: context.getSource(),
+    mode: "production",
+    target: "async-node",
+    devtool: false,
+    entry: "./index.js",
+    cache: false,
+    output: {
+        path: context.getDist(),
+        filename: "[name].mjs",
+        chunkLoading: "import",
+        chunkFormat: false,
+        pathinfo: true,
+        module: true
+    },
+    bail: true,
+    optimization: {
+        minimize: false,
+        moduleIds: "named",
+        chunkIds: "named",
+        runtimeChunk: "single",
+        removeEmptyChunks: false,
+        concatenateModules: false,
+        splitChunks: false
+    },
+    plugins: [new core_1.default.experiments.EsmLibraryPlugin()],
+    experiments: {
+        css: true,
+        rspackFuture: {
+            bundlerInfo: {
+                force: false
+            }
+        },
+        outputModule: true
+    }
+});
+function createEsmOutputCase(name, src, dist) {
+    creator.create(name, src, dist);
+}

package/dist/case/hash.js

@@ -5,11 +5,11 @@ const creator_1 = require("../test/creator");
 const common_1 = require("./common");
 const REG_ERROR_CASE = /error$/;
 class HashCaseCreator extends creator_1.BasicCaseCreator {
-    describe(name, tester, testConfig) {
+    describe(name, tester, testConfig, options) {
         it(`should print correct hash for ${name}`, async () => {
             await tester.prepare();
             await tester.compile();
-            await tester.check(this.createEnv(testConfig));
+            await tester.check(this.createEnv(testConfig, options));
             await tester.resume();
         }, 30000);
     }

package/dist/case/hook.js

@@ -11,52 +11,59 @@ const jest_snapshot_1 = require("jest-snapshot");
 const path_serializer_1 = require("path-serializer");
 const pretty_format_1 = require("pretty-format");
 const webpack_merge_1 = __importDefault(require("webpack-merge"));
-const createLazyTestEnv_1 = __importDefault(require("../helper/legacy/createLazyTestEnv"));
 const context_1 = require("../test/context");
-const simple_1 = require("../test/simple");
+const creator_1 = require("../test/creator");
 const common_1 = require("./common");
 const srcDir = node_path_1.default.resolve(__dirname, "../../../../tests/rspack-test/fixtures");
 const distDir = node_path_1.default.resolve(__dirname, "../../../../tests/rspack-test/js/hook");
+const creator = new creator_1.BasicCaseCreator({
+    clean: true,
+    describe: true,
+    createContext: (config) => new HookCasesContext(config.src, config.name, config),
+    steps: ({ name, caseConfig: _caseConfig, src }) => {
+        const caseConfig = _caseConfig;
+        return [
+            {
+                config: async (context) => {
+                    const compiler = (0, common_1.getCompiler)(context, name);
+                    const options = await (0, common_1.config)(context, name, ["rspack.config.js", "webpack.config.js"], defaultOptions(context, caseConfig.options));
+                    if (!global.printLogger) {
+                        options.infrastructureLogging = {
+                            level: "error"
+                        };
+                    }
+                    compiler.setOptions(options);
+                },
+                compiler: async (context) => {
+                    const c = await (0, common_1.compiler)(context, name);
+                    if (caseConfig.compiler) {
+                        await caseConfig.compiler(context, c);
+                    }
+                },
+                build: async (context) => {
+                    await (0, common_1.build)(context, name);
+                },
+                run: async (env, context) => {
+                    // no need to run, just check snapshot
+                },
+                check: async (env, context) => {
+                    await (0, common_1.checkSnapshot)(env, context, name, node_path_1.default.join(src, "output.snap.txt"), caseConfig.snapshotFileFilter);
+                }
+            }
+        ];
+    }
+});
 function createHookCase(name, src, dist, source) {
     const caseConfig = require(node_path_1.default.join(src, "test.js"));
     const testName = node_path_1.default.basename(name.slice(0, name.indexOf(node_path_1.default.extname(name))));
-    const runner = (0, simple_1.getSimpleProcessorRunner)(source, dist, {
-        env: () => env,
-        context: () => new HookCasesContext(src, testName, {
+    creator.create(name, src, dist, undefined, {
+        caseConfig,
+        description: () => caseConfig.description,
+        createContext: (config) => new HookCasesContext(src, testName, {
             src: source,
             dist: dist
         })
     });
-    it(caseConfig.description, async () => {
-        await runner(name, {
-            config: async (context) => {
-                const compiler = (0, common_1.getCompiler)(context, name);
-                const options = await (0, common_1.config)(context, name, ["rspack.config.js", "webpack.config.js"], defaultOptions(context, caseConfig.options));
-                if (!global.printLogger) {
-                    options.infrastructureLogging = {
-                        level: "error"
-                    };
-                }
-                compiler.setOptions(options);
-            },
-            compiler: async (context) => {
-                const c = await (0, common_1.compiler)(context, name);
-                if (caseConfig.compiler) {
-                    await caseConfig.compiler(context, c);
-                }
-            },
-            build: async (context) => {
-                await (0, common_1.build)(context, name);
-            },
-            run: async (env, context) => {
-                // no need to run, just check snapshot
-            },
-            check: async (env, context) => {
-                await (0, common_1.checkSnapshot)(env, context, name, node_path_1.default.join(src, "output.snap.txt"), caseConfig.snapshotFileFilter);
-            }
-        });
-    });
-    const env = (0, createLazyTestEnv_1.default)(10000);
 }
 const sourceSerializer = {
     test(val) {

package/dist/case/index.d.ts

@@ -6,6 +6,7 @@ export { createDefaultsCase, getRspackDefaultConfig } from "./defaults";
 export { createDiagnosticCase } from "./diagnostic";
 export { createDiffCase } from "./diff";
 export { createErrorCase } from "./error";
+export { createEsmOutputCase } from "./esm-output";
 export { createHashCase } from "./hash";
 export { createHookCase } from "./hook";
 export { createHotCase } from "./hot";

package/dist/case/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createWatchCase = exports.createTreeShakingCase = exports.createStatsOutputCase = exports.createStatsAPICase = exports.createSerialCase = exports.createNormalCase = exports.createHotNormalCase = exports.createNativeWatcher = exports.createWatchIncrementalCase = exports.createHotIncrementalCase = exports.createHotStepCase = exports.createHotCase = exports.createHookCase = exports.createHashCase = exports.createErrorCase = exports.createDiffCase = exports.createDiagnosticCase = exports.getRspackDefaultConfig = exports.createDefaultsCase = exports.createConfigCase = exports.createCompilerCase = exports.createCacheCase = exports.createBuiltinCase = void 0;
+exports.createWatchCase = exports.createTreeShakingCase = exports.createStatsOutputCase = exports.createStatsAPICase = exports.createSerialCase = exports.createNormalCase = exports.createHotNormalCase = exports.createNativeWatcher = exports.createWatchIncrementalCase = exports.createHotIncrementalCase = exports.createHotStepCase = exports.createHotCase = exports.createHookCase = exports.createHashCase = exports.createEsmOutputCase = exports.createErrorCase = exports.createDiffCase = exports.createDiagnosticCase = exports.getRspackDefaultConfig = exports.createDefaultsCase = exports.createConfigCase = exports.createCompilerCase = exports.createCacheCase = exports.createBuiltinCase = void 0;
 var builtin_1 = require("./builtin");
 Object.defineProperty(exports, "createBuiltinCase", { enumerable: true, get: function () { return builtin_1.createBuiltinCase; } });
 var cache_1 = require("./cache");
@@ -18,6 +18,8 @@ var diff_1 = require("./diff");
 Object.defineProperty(exports, "createDiffCase", { enumerable: true, get: function () { return diff_1.createDiffCase; } });
 var error_1 = require("./error");
 Object.defineProperty(exports, "createErrorCase", { enumerable: true, get: function () { return error_1.createErrorCase; } });
+var esm_output_1 = require("./esm-output");
+Object.defineProperty(exports, "createEsmOutputCase", { enumerable: true, get: function () { return esm_output_1.createEsmOutputCase; } });
 var hash_1 = require("./hash");
 Object.defineProperty(exports, "createHashCase", { enumerable: true, get: function () { return hash_1.createHashCase; } });
 var hook_1 = require("./hook");

package/dist/case/stats-api.js

@@ -2,42 +2,53 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStatsAPICase = createStatsAPICase;
 const memfs_1 = require("memfs");
-const simple_1 = require("../test/simple");
+const creator_1 = require("../test/creator");
 const common_1 = require("./common");
 let addedSerializer = false;
+const creator = new creator_1.BasicCaseCreator({
+    clean: true,
+    describe: true,
+    steps: ({ name, caseConfig }) => {
+        const config = caseConfig;
+        return [
+            {
+                config: async (context) => {
+                    const compiler = (0, common_1.getCompiler)(context, name);
+                    compiler.setOptions(options(context, config.options));
+                },
+                compiler: async (context) => {
+                    const compilerManager = (0, common_1.getCompiler)(context, name);
+                    compilerManager.createCompiler();
+                    compiler(context, compilerManager.getCompiler(), config.compiler);
+                },
+                build: async (context) => {
+                    const compiler = (0, common_1.getCompiler)(context, name);
+                    if (typeof config.build === "function") {
+                        await config.build(context, compiler.getCompiler());
+                    }
+                    else {
+                        await compiler.build();
+                    }
+                },
+                run: async (env, context) => {
+                    // no need to run, just check the snapshot of diagnostics
+                },
+                check: async (env, context) => {
+                    await check(env, context, name, config.check);
+                }
+            }
+        ];
+    },
+    concurrent: true
+});
 function createStatsAPICase(name, src, dist, testConfig) {
     if (!addedSerializer) {
         addedSerializer = true;
     }
     const caseConfig = require(testConfig);
-    const runner = (0, simple_1.getSimpleProcessorRunner)(src, dist);
-    it(caseConfig.description, async () => {
-        await runner(name, {
-            config: async (context) => {
-                const compiler = (0, common_1.getCompiler)(context, name);
-                compiler.setOptions(options(context, caseConfig.options));
-            },
-            compiler: async (context) => {
-                const compilerManager = (0, common_1.getCompiler)(context, name);
-                compilerManager.createCompiler();
-                compiler(context, compilerManager.getCompiler(), caseConfig.compiler);
-            },
-            build: async (context) => {
-                const compiler = (0, common_1.getCompiler)(context, name);
-                if (typeof caseConfig.build === "function") {
-                    await caseConfig.build(context, compiler.getCompiler());
-                }
-                else {
-                    await compiler.build();
-                }
-            },
-            run: async (env, context) => {
-                // no need to run, just check the snapshot of diagnostics
-            },
-            check: async (env, context) => {
-                await check(env, context, name, caseConfig.check);
-            }
-        });
+    creator.create(name, src, dist, undefined, {
+        caseConfig,
+        description: () => caseConfig.description
     });
 }
 function options(context, custom) {

package/dist/case/stats-output.d.ts

@@ -1 +1,11 @@
+import type { ECompilerType, ITestContext, ITestEnv, TCompilerOptions } from "../type";
+export declare function createStatsProcessor(name: string, defaultOptions: (index: number, context: ITestContext) => TCompilerOptions<ECompilerType.Rspack>, overrideOptions: (index: number, context: ITestContext, options: TCompilerOptions<ECompilerType.Rspack>) => void): {
+    before: (context: ITestContext) => Promise<void>;
+    config: (context: ITestContext) => Promise<void>;
+    compiler: (context: ITestContext) => Promise<void>;
+    build: (context: ITestContext) => Promise<void>;
+    run: (env: ITestEnv, context: ITestContext) => Promise<void>;
+    check: (env: ITestEnv, context: ITestContext) => Promise<void>;
+    after: (context: ITestContext) => Promise<void>;
+};
 export declare function createStatsOutputCase(name: string, src: string, dist: string): void;

package/dist/case/stats-output.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStatsProcessor = createStatsProcessor;
 exports.createStatsOutputCase = createStatsOutputCase;
 const node_path_1 = __importDefault(require("node:path"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
@@ -11,7 +12,7 @@ const captureStdio_1 = __importDefault(require("../helper/legacy/captureStdio"))
 const creator_1 = require("../test/creator");
 const common_1 = require("./common");
 const REG_ERROR_CASE = /error$/;
-function createStatsProcessor(name) {
+function createStatsProcessor(name, defaultOptions, overrideOptions) {
     const writeStatsOuptut = false;
     const snapshotName = "stats.txt";
     let stderr = null;
@@ -43,7 +44,9 @@ function createStatsProcessor(name) {
 const creator = new creator_1.BasicCaseCreator({
     clean: true,
     describe: false,
-    steps: ({ name }) => [createStatsProcessor(name)],
+    steps: ({ name }) => [
+        createStatsProcessor(name, defaultOptions, overrideOptions)
+    ],
     description: () => "should print correct stats for"
 });
 function createStatsOutputCase(name, src, dist) {

package/dist/index.d.ts

@@ -6,6 +6,5 @@ export * from "./reporter";
 export * from "./runner";
 export * from "./test/context";
 export * from "./test/creator";
-export * from "./test/simple";
 export * from "./test/tester";
 export * from "./type";

package/dist/index.js

@@ -22,6 +22,5 @@ __exportStar(require("./reporter"), exports);
 __exportStar(require("./runner"), exports);
 __exportStar(require("./test/context"), exports);
 __exportStar(require("./test/creator"), exports);
-__exportStar(require("./test/simple"), exports);
 __exportStar(require("./test/tester"), exports);
 __exportStar(require("./type"), exports);

package/dist/runner/node/index.js

@@ -361,6 +361,8 @@ class NodeRunner {
                     context: esmContext,
                     initializeImportMeta: (meta, _) => {
                         meta.url = (0, node_url_1.pathToFileURL)(file.path).href;
+                        meta.dirname = node_path_1.default.dirname(file.path);
+                        meta.filename = file.path;
                     },
                     importModuleDynamically: async (specifier, module) => {
                         const result = await _require(node_path_1.default.dirname(file.path), specifier, {
@@ -374,13 +376,15 @@ class NodeRunner {
             if (context.esmMode === type_1.EEsmMode.Unlinked)
                 return esm;
             return (async () => {
-                await esm.link(async (specifier, referencingModule) => {
-                    return await (0, asModule_1.default)(await _require(node_path_1.default.dirname(referencingModule.identifier
-                        ? referencingModule.identifier.slice(esmIdentifier.length + 1)
-                        : (0, node_url_1.fileURLToPath)(referencingModule.url)), specifier, {
-                        esmMode: type_1.EEsmMode.Unlinked
-                    }), referencingModule.context, true);
-                });
+                if (esm.status === "unlinked") {
+                    await esm.link(async (specifier, referencingModule) => {
+                        return await (0, asModule_1.default)(await _require(node_path_1.default.dirname(referencingModule.identifier
+                            ? referencingModule.identifier.slice(esmIdentifier.length + 1)
+                            : (0, node_url_1.fileURLToPath)(referencingModule.url)), specifier, {
+                            esmMode: type_1.EEsmMode.Unlinked
+                        }), referencingModule.context, true);
+                    });
+                }
                 if (esm.instantiate)
                     esm.instantiate();
                 await esm.evaluate();

package/dist/test/creator.d.ts

@@ -1,4 +1,4 @@
-import type { ECompilerType, ITestEnv, ITester, ITestProcessor, TTestConfig, TTestRunnerCreator } from "../type";
+import type { ECompilerType, ITestContext, ITestEnv, ITester, ITesterConfig, ITestProcessor, TTestConfig, TTestRunnerCreator } from "../type";
 declare global {
     var testFilter: string | undefined;
 }
@@ -20,27 +20,28 @@ export interface IBasicCaseCreatorOptions<T extends ECompilerType> {
     testConfig?: (testConfig: TTestConfig<T>) => void;
     description?: (name: string, step: number) => string;
     runner?: TTestRunnerCreator;
-    [key: string]: unknown;
+    createContext?: (config: ITesterConfig) => ITestContext;
     concurrent?: boolean | number;
+    [key: string]: unknown;
 }
 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;
+    create(name: string, src: string, dist: string, temp?: string, caseOptions?: Partial<IBasicCaseCreatorOptions<T>>): 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 describeConcurrent(name: string, tester: ITester, testConfig: TTestConfig<T>, options: IBasicCaseCreatorOptions<T>): void;
+    protected describe(name: string, tester: ITester, testConfig: TTestConfig<T>, options: IBasicCaseCreatorOptions<T>): void;
     protected createConcurrentEnv(): ITestEnv & IConcurrentTestEnv;
-    protected createEnv(testConfig: TTestConfig<T>): ITestEnv;
+    protected createEnv(testConfig: TTestConfig<T>, options: IBasicCaseCreatorOptions<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 | undefined, testConfig: TTestConfig<T>): ITester;
-    protected tryRunTask(): void;
-    protected getMaxConcurrent(): number;
-    protected registerConcurrentTask(name: string, starter: () => void): () => void;
+    protected checkSkipped(src: string, testConfig: TTestConfig<T>, options: IBasicCaseCreatorOptions<T>): boolean | string;
+    protected createTester(name: string, src: string, dist: string, temp: string | undefined, testConfig: TTestConfig<T>, options: IBasicCaseCreatorOptions<T>): ITester;
+    protected tryRunTask(concurrent?: number): void;
+    protected getMaxConcurrent(concurrent?: number): number;
+    protected registerConcurrentTask(name: string, starter: () => void, concurrent?: number): () => void;
 }
 export {};

package/dist/test/creator.js

@@ -16,31 +16,35 @@ class BasicCaseCreator {
         this.currentConcurrent = 0;
         this.tasks = [];
     }
-    create(name, src, dist, temp) {
+    create(name, src, dist, temp, caseOptions) {
+        const options = {
+            ...this._options,
+            ...caseOptions
+        };
         const testConfig = this.readTestConfig(src);
-        if (typeof this._options.testConfig === "function") {
-            this._options.testConfig(testConfig);
+        if (typeof options.testConfig === "function") {
+            options.testConfig(testConfig);
         }
-        const skipped = this.checkSkipped(src, testConfig);
+        const skipped = this.checkSkipped(src, testConfig, options);
         if (skipped) {
             this.skip(name, skipped);
             return;
         }
-        if (this._options.clean) {
+        if (options.clean) {
             this.clean([dist, temp || ""].filter(Boolean));
         }
         const run = this.shouldRun(name);
-        const tester = this.createTester(name, src, dist, temp, testConfig);
+        const tester = this.createTester(name, src, dist, temp, testConfig, options);
         const concurrent = process.env.WASM
             ? false
-            : testConfig.concurrent || this._options.concurrent;
-        if (this._options.describe) {
+            : testConfig.concurrent || options.concurrent;
+        if (options.describe) {
             if (run) {
                 if (concurrent) {
-                    describe(name, () => this.describeConcurrent(name, tester, testConfig));
+                    describe(name, () => this.describeConcurrent(name, tester, testConfig, options));
                 }
                 else {
-                    describe(name, () => this.describe(name, tester, testConfig));
+                    describe(name, () => this.describe(name, tester, testConfig, options));
                 }
             }
             else {
@@ -52,10 +56,10 @@ class BasicCaseCreator {
         else {
             if (run) {
                 if (concurrent) {
-                    this.describeConcurrent(name, tester, testConfig);
+                    this.describeConcurrent(name, tester, testConfig, options);
                 }
                 else {
-                    this.describe(name, tester, testConfig);
+                    this.describe(name, tester, testConfig, options);
                 }
             }
             else {
@@ -71,7 +75,7 @@ class BasicCaseCreator {
         }
         return name.includes(global.testFilter);
     }
-    describeConcurrent(name, tester, testConfig) {
+    describeConcurrent(name, tester, testConfig, options) {
         beforeAll(async () => {
             await tester.prepare();
         });
@@ -79,7 +83,7 @@ class BasicCaseCreator {
         let chain = new Promise((resolve, reject) => {
             starter = resolve;
         });
-        const ender = this.registerConcurrentTask(name, starter);
+        const ender = this.registerConcurrentTask(name, starter, options.concurrent);
         const env = this.createConcurrentEnv();
         for (let index = 0; index < tester.total; index++) {
             let stepSignalResolve = null;
@@ -88,8 +92,8 @@ class BasicCaseCreator {
             }).catch(() => {
                 // prevent unhandled rejection
             });
-            const description = typeof this._options.description === "function"
-                ? this._options.description(name, index)
+            const description = typeof options.description === "function"
+                ? options.description(name, index)
                 : index
                     ? `step [${index}] should pass`
                     : "should pass";
@@ -97,7 +101,7 @@ class BasicCaseCreator {
                 stepSignal.then((e) => {
                     cb(e);
                 });
-            }, this._options.timeout || 180000);
+            }, options.timeout || 180000);
             chain = chain.then(async () => {
                 try {
                     env.clear();
@@ -136,22 +140,28 @@ class BasicCaseCreator {
             await tester.resume();
         });
     }
-    describe(name, tester, testConfig) {
+    describe(name, tester, testConfig, options) {
         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`;
+            const description = typeof options.description === "function"
+                ? options.description(name, index)
+                : `step [${index}] should pass`;
             it(description, async () => {
                 if (bailout) {
                     throw `Case "${name}" step ${index + 1} bailout because ${tester.step + 1} failed`;
                 }
-                await tester.compile();
-                await tester.check(env);
                 const context = tester.getContext();
+                try {
+                    await tester.compile();
+                }
+                catch (e) {
+                    bailout = true;
+                    context.emitError(name, e);
+                }
+                await tester.check(env);
                 if (!tester.next() && context.hasError()) {
                     bailout = true;
                     const errors = context
@@ -160,8 +170,8 @@ class BasicCaseCreator {
                         .join("\n\n");
                     throw new Error(`Case "${name}" failed at step ${tester.step + 1}:\n${errors}`);
                 }
-            }, this._options.timeout || 30000);
-            const env = this.createEnv(testConfig);
+            }, options.timeout || 30000);
+            const env = this.createEnv(testConfig, options);
         }
         afterAll(async () => {
             await tester.resume();
@@ -230,8 +240,8 @@ class BasicCaseCreator {
             jest
         };
     }
-    createEnv(testConfig) {
-        if (this._options.runner && !testConfig.noTests) {
+    createEnv(testConfig, options) {
+        if (options.runner && !testConfig.noTests) {
             return (0, createLazyTestEnv_1.default)(10000);
         }
         return {
@@ -257,30 +267,31 @@ class BasicCaseCreator {
         const testConfigFile = node_path_1.default.join(src, "test.config.js");
         return node_fs_1.default.existsSync(testConfigFile) ? require(testConfigFile) : {};
     }
-    checkSkipped(src, testConfig) {
+    checkSkipped(src, testConfig, options) {
         const filterPath = node_path_1.default.join(src, "test.filter.js");
         // no test.filter.js, should not skip
         if (!node_fs_1.default.existsSync(filterPath)) {
             return false;
         }
         // test.filter.js exists, skip if it returns false|string|array
-        const filtered = require(filterPath)(this._options, testConfig);
+        const filtered = require(filterPath)(options, testConfig);
         if (typeof filtered === "string" || Array.isArray(filtered)) {
             return true;
         }
         return !filtered;
     }
-    createTester(name, src, dist, temp, testConfig) {
+    createTester(name, src, dist, temp, testConfig, options) {
         return new tester_1.Tester({
             name,
             src,
             dist,
             temp,
             testConfig,
-            contextValue: this._options.contextValue,
-            runnerCreator: this._options.runner,
-            steps: this._options.steps({
-                ...this._options,
+            contextValue: options.contextValue,
+            runnerCreator: options.runner,
+            createContext: options.createContext,
+            steps: options.steps({
+                ...options,
                 name,
                 src,
                 dist,
@@ -288,25 +299,23 @@ class BasicCaseCreator {
             })
         });
     }
-    tryRunTask() {
+    tryRunTask(concurrent) {
         while (this.tasks.length !== 0 &&
-            this.currentConcurrent < this.getMaxConcurrent()) {
+            this.currentConcurrent < this.getMaxConcurrent(concurrent)) {
             const [_name, starter] = this.tasks.shift();
             this.currentConcurrent++;
             starter();
         }
     }
-    getMaxConcurrent() {
-        return typeof this._options.concurrent === "number"
-            ? this._options.concurrent
-            : DEFAULT_MAX_CONCURRENT;
+    getMaxConcurrent(concurrent) {
+        return typeof concurrent === "number" ? concurrent : DEFAULT_MAX_CONCURRENT;
     }
-    registerConcurrentTask(name, starter) {
+    registerConcurrentTask(name, starter, concurrent) {
         this.tasks.push([name, starter]);
-        this.tryRunTask();
+        this.tryRunTask(concurrent);
         return () => {
             this.currentConcurrent--;
-            this.tryRunTask();
+            this.tryRunTask(concurrent);
         };
     }
 }

package/dist/test/tester.js

@@ -12,7 +12,9 @@ class Tester {
         this.steps = [];
         this.step = 0;
         this.total = 0;
-        this.context = new context_1.TestContext(config);
+        this.context = config.createContext
+            ? config.createContext(config)
+            : new context_1.TestContext(config);
         this.steps = config.steps || [];
         this.step = 0;
         this.total = config.steps?.length || 0;
@@ -69,9 +71,9 @@ class Tester {
         for (const i of this.steps) {
             if (typeof i.afterAll === "function") {
                 await i.afterAll(this.context);
-                await this.context.closeCompiler(this.config.name);
             }
         }
+        await this.context.closeCompiler(this.config.name);
     }
     async runStepMethods(step, methods, force = false) {
         for (const i of methods) {

package/dist/type.d.ts

@@ -54,6 +54,7 @@ export interface ITesterConfig {
     compilerFactories?: TCompilerFactories<ECompilerType>;
     contextValue?: Record<string, unknown>;
     runnerCreator?: TTestRunnerCreator;
+    createContext?: (config: ITesterConfig) => ITestContext;
 }
 export interface ITester {
     step: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack/test-tools",
-  "version": "1.5.7",
+  "version": "1.5.8",
   "license": "MIT",
   "description": "Test tools for rspack",
   "main": "dist/index.js",
@@ -40,7 +40,7 @@
     "@babel/traverse": "7.28.4",
     "@babel/types": "7.28.4",
     "cross-env": "^10.0.0",
-    "csv-to-markdown-table": "^1.5.0",
+    "csv-to-markdown-table": "1.5.0",
     "deepmerge": "^4.3.1",
     "filenamify": "4.3.0",
     "fs-extra": "^11.3.2",
@@ -50,7 +50,7 @@
     "jest-diff": "^29.7.0",
     "jest-snapshot": "29.7.0",
     "jsdom": "^26.1.0",
-    "memfs": "4.38.2",
+    "memfs": "4.46.0",
     "loader-utils": "^2.0.4",
     "path-serializer": "0.5.1",
     "pretty-format": "29.7.0",
@@ -100,10 +100,10 @@
     "wast-loader": "^1.14.1",
     "worker-rspack-loader": "^3.1.2",
     "exports-loader": "^5.0.0",
-    "@rspack/cli": "1.5.7",
-    "@rspack/test-tools": "1.5.7",
+    "@rspack/cli": "1.5.8",
+    "@rspack/core": "1.5.8",
     "@rspack/binding-testing": "1.4.1",
-    "@rspack/core": "1.5.7"
+    "@rspack/test-tools": "1.5.8"
   },
   "peerDependencies": {
     "@rspack/core": ">=1.0.0"

package/dist/test/simple.d.ts

@@ -1,5 +0,0 @@
-import type { ITestContext, ITestEnv, ITestProcessor } from "../type";
-export declare function getSimpleProcessorRunner(src: string, dist: string, options?: {
-    env?: () => ITestEnv;
-    context?: (src: string, dist: string) => ITestContext;
-}): (name: string, processor: ITestProcessor) => Promise<void>;

package/dist/test/simple.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSimpleProcessorRunner = getSimpleProcessorRunner;
-const context_1 = require("./context");
-const CONTEXT_MAP = new Map();
-function getSimpleProcessorRunner(src, dist, options = {}) {
-    const createEnv = options.env || (() => ({ expect, it, beforeEach, afterEach, jest }));
-    const createContext = options.context ||
-        ((src, dist) => new context_1.TestContext({ src, dist }));
-    const key = `src: ${src}, dist: ${dist}`;
-    if (!CONTEXT_MAP.has(key)) {
-        const context = createContext(src, dist);
-        const runner = async function run(name, processor) {
-            try {
-                await processor.beforeAll?.(context);
-                await processor.before?.(context);
-                await processor.config?.(context);
-                await processor.compiler?.(context);
-                await processor.build?.(context);
-            }
-            catch (e) {
-                context.emitError(name, e);
-            }
-            finally {
-                if (!context.hasError()) {
-                    await processor.run?.(createEnv(), context);
-                }
-                await processor.check?.(createEnv(), context);
-                await processor.after?.(context);
-                await context.closeCompiler(name);
-                await processor.afterAll?.(context);
-            }
-            if (context.hasError()) {
-                const errors = context
-                    .getError()
-                    .map(i => `${i.stack}`.split("\n").join("\t\n"))
-                    .join("\n\n");
-                throw new Error(`Case "${name}" failed:\n${errors}`);
-            }
-        };
-        CONTEXT_MAP.set(key, runner);
-    }
-    return CONTEXT_MAP.get(key);
-}