@rspack/test-tools 0.5.7 → 0.5.8

package/dist/case/defaults.d.ts

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

package/dist/case/defaults.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultsCase = void 0;
+const context_1 = require("../test/context");
+const path_1 = __importDefault(require("path"));
+const processor_1 = require("../processor");
+const srcDir = path_1.default.resolve(__dirname, "../../../rspack/tests/fixtures");
+const distDir = path_1.default.resolve(__dirname, "../../../rspack/tests/js/compiler");
+const context = new context_1.TestContext({
+    src: srcDir,
+    dist: distDir
+});
+async function run(name, processor) {
+    var _a, _b, _c, _d;
+    try {
+        await ((_a = processor.before) === null || _a === void 0 ? void 0 : _a.call(processor, context));
+        await ((_b = processor.config) === null || _b === void 0 ? void 0 : _b.call(processor, context));
+    }
+    catch (e) {
+        context.emitError(name, e);
+    }
+    finally {
+        await ((_c = processor.check) === null || _c === void 0 ? void 0 : _c.call(processor, null, context));
+        await ((_d = processor.after) === null || _d === void 0 ? void 0 : _d.call(processor, context));
+    }
+}
+function createDefaultsCase(src) {
+    const caseConfig = require(src);
+    it(`should generate the correct defaults from ${caseConfig.description}`, async () => {
+        await run(caseConfig.name, new processor_1.DefaultsConfigTaskProcessor(caseConfig));
+    });
+}
+exports.createDefaultsCase = createDefaultsCase;

package/dist/case/index.d.ts

@@ -6,3 +6,5 @@ export * from "./hot";
 export * from "./normal";
 export * from "./stats";
 export * from "./watch";
+export * from "./treeshaking";
+export * from "./defaults";

package/dist/case/index.js

@@ -22,3 +22,5 @@ __exportStar(require("./hot"), exports);
 __exportStar(require("./normal"), exports);
 __exportStar(require("./stats"), exports);
 __exportStar(require("./watch"), exports);
+__exportStar(require("./treeshaking"), exports);
+__exportStar(require("./defaults"), exports);

package/dist/case/treeshaking.d.ts

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

package/dist/case/treeshaking.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTreeShakingCase = void 0;
+const treeshaking_1 = require("../processor/treeshaking");
+const creator_1 = require("../test/creator");
+const creator = new creator_1.BasicCaseCreator({
+    clean: true,
+    describe: true,
+    description(name, step) {
+        if (step === 0) {
+            return `${name} with builtin.treeShaking should match snapshot`;
+        }
+        else {
+            return `${name} with newTreeshaking should match snapshot`;
+        }
+    },
+    steps: ({ name }) => [
+        new treeshaking_1.RspackTreeShakingProcessor({
+            name,
+            snapshot: "output.snap",
+            type: "builtin"
+        }),
+        new treeshaking_1.RspackTreeShakingProcessor({
+            name,
+            snapshot: "new_treeshaking.snap",
+            type: "new"
+        })
+    ]
+});
+function createTreeShakingCase(name, src, dist) {
+    creator.create(name, src, dist);
+}
+exports.createTreeShakingCase = createTreeShakingCase;

package/dist/case/watch.js

@@ -9,27 +9,14 @@ const path_1 = __importDefault(require("path"));
 const watch_1 = require("../processor/watch");
 const creator_1 = require("../test/creator");
 const runner_1 = require("../runner");
-class WatchCaseCreator extends creator_1.BasicCaseCreator {
-    describe(name, tester, testConfig) {
-        beforeAll(async () => {
-            await tester.prepare();
-        });
-        for (let index = 0; index < tester.total; index++) {
-            it(index === 0 ? `${name} should compile` : "should compile the next step", async () => {
-                await tester.compile();
-                await tester.check(env);
-                tester.next();
-            }, 5000);
-            const env = this.createEnv(testConfig);
-        }
-        afterAll(async () => {
-            await tester.resume();
-        });
-    }
-}
-const creator = new WatchCaseCreator({
+const creator = new creator_1.BasicCaseCreator({
     clean: true,
     runner: runner_1.WatchRunnerFactory,
+    description: (name, index) => {
+        return index === 0
+            ? `${name} should compile`
+            : "should compile the next step";
+    },
     describe: false,
     steps: ({ name, src, temp }) => {
         const runs = fs_1.default

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./type";
 export * from "./test/tester";
+export * from "./test/context";
 export * from "./processor";
 export * from "./reporter";
 export * from "./compare";

package/dist/index.js

@@ -16,6 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./type"), exports);
 __exportStar(require("./test/tester"), exports);
+__exportStar(require("./test/context"), exports);
 __exportStar(require("./processor"), exports);
 __exportStar(require("./reporter"), exports);
 __exportStar(require("./compare"), exports);

package/dist/processor/defaults.d.ts

@@ -0,0 +1,24 @@
+import { SimpleTaskProcessor } from "./simple";
+import { ECompilerType, ITestContext, ITestEnv, TCompilerOptions } from "../type";
+export interface IDefaultsConfigProcessorOptions {
+    options?: (context: ITestContext) => TCompilerOptions<ECompilerType.Rspack>;
+    cwd?: string;
+    name: string;
+    diff: (diff: any, defaults: any) => Promise<void>;
+}
+export declare class DefaultsConfigTaskProcessor extends SimpleTaskProcessor<ECompilerType.Rspack> {
+    protected _defaultsConfigOptions: IDefaultsConfigProcessorOptions;
+    private defaultConfig;
+    constructor(_defaultsConfigOptions: IDefaultsConfigProcessorOptions);
+    compiler(context: ITestContext): Promise<void>;
+    build(context: ITestContext): Promise<void>;
+    run(env: ITestEnv, context: ITestContext): Promise<void>;
+    check(env: ITestEnv, context: ITestContext): Promise<void>;
+    before(context: ITestContext): Promise<void>;
+    after(context: ITestContext): Promise<void>;
+    beforeAll(context: ITestContext): Promise<void>;
+    afterAll(context: ITestContext): Promise<void>;
+    protected getCompiler(context: ITestContext): import("../type").ITestCompilerManager<ECompilerType.Rspack>;
+    static getDefaultConfig(cwd: string, config: TCompilerOptions<ECompilerType.Rspack>): TCompilerOptions<ECompilerType.Rspack>;
+    static addSnapshotSerializer(): void;
+}

package/dist/processor/defaults.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultsConfigTaskProcessor = void 0;
+const simple_1 = require("./simple");
+const type_1 = require("../type");
+const jest_diff_1 = require("jest-diff");
+const strip_ansi_1 = __importDefault(require("strip-ansi"));
+const path_1 = __importDefault(require("path"));
+const CASE_CWD = path_1.default.resolve(__dirname, "../../../rspack");
+const CURRENT_CWD = process.cwd();
+const quoteMeta = (str) => str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
+const cwdRegExp = new RegExp(`${quoteMeta(CASE_CWD)}((?:\\\\)?(?:[a-zA-Z.\\-_]+\\\\)*)`, "g");
+const escapedCwd = JSON.stringify(CASE_CWD).slice(1, -1);
+const escapedCwdRegExp = new RegExp(`${quoteMeta(escapedCwd)}((?:\\\\\\\\)?(?:[a-zA-Z.\\-_]+\\\\\\\\)*)`, "g");
+const normalize = (str) => {
+    if (CASE_CWD.startsWith("/")) {
+        str = str.replace(new RegExp(quoteMeta(CASE_CWD), "g"), "<cwd>");
+    }
+    else {
+        str = str.replace(cwdRegExp, (m, g) => `<cwd>${g.replace(/\\/g, "/")}`);
+        str = str.replace(escapedCwdRegExp, (m, g) => `<cwd>${g.replace(/\\\\/g, "/")}`);
+    }
+    str = str.replace(/@@ -\d+,\d+ \+\d+,\d+ @@/g, "@@ ... @@");
+    return str;
+};
+class Diff {
+    constructor(value) {
+        this.value = value;
+    }
+}
+class DefaultsConfigTaskProcessor extends simple_1.SimpleTaskProcessor {
+    constructor(_defaultsConfigOptions) {
+        super({
+            options: context => {
+                let res;
+                if (typeof _defaultsConfigOptions.options === "function") {
+                    res = _defaultsConfigOptions.options(context);
+                }
+                else {
+                    res = {};
+                }
+                if (!("mode" in res)) {
+                    res.mode = "none";
+                }
+                return res;
+            },
+            compilerType: type_1.ECompilerType.Rspack,
+            name: _defaultsConfigOptions.name
+        });
+        this._defaultsConfigOptions = _defaultsConfigOptions;
+        this.defaultConfig = DefaultsConfigTaskProcessor.getDefaultConfig(CASE_CWD, {
+            mode: "none"
+        });
+    }
+    async compiler(context) {
+        throw new Error("Not support");
+    }
+    async build(context) {
+        throw new Error("Not support");
+    }
+    async run(env, context) {
+        throw new Error("Not support");
+    }
+    async check(env, context) {
+        const compiler = this.getCompiler(context);
+        const config = DefaultsConfigTaskProcessor.getDefaultConfig(this._defaultsConfigOptions.cwd || CASE_CWD, compiler.getOptions());
+        const diff = (0, strip_ansi_1.default)((0, jest_diff_1.diff)(this.defaultConfig, config, { expand: false, contextLines: 0 }));
+        await this._defaultsConfigOptions.diff(expect(new Diff(diff)), expect(this.defaultConfig));
+    }
+    async before(context) { }
+    async after(context) { }
+    async beforeAll(context) {
+        throw new Error("Not support");
+    }
+    async afterAll(context) {
+        throw new Error("Not support");
+    }
+    getCompiler(context) {
+        return context.getCompiler(this._options.name, this._options.compilerType);
+    }
+    static getDefaultConfig(cwd, config) {
+        process.chdir(cwd);
+        const { applyWebpackOptionsDefaults, getNormalizedWebpackOptions } = require("@rspack/core").config;
+        config = getNormalizedWebpackOptions(config);
+        applyWebpackOptionsDefaults(config);
+        // make snapshot stable
+        config.experiments.rspackFuture.bundlerInfo.version = "$version$";
+        process.chdir(CURRENT_CWD);
+        return config;
+    }
+    static addSnapshotSerializer() {
+        expect.addSnapshotSerializer({
+            test(value) {
+                return value instanceof Diff;
+            },
+            print(received) {
+                return normalize(received.value);
+            }
+        });
+        expect.addSnapshotSerializer({
+            test(value) {
+                return typeof value === "string";
+            },
+            print(received) {
+                return JSON.stringify(normalize(received));
+            }
+        });
+    }
+}
+exports.DefaultsConfigTaskProcessor = DefaultsConfigTaskProcessor;

package/dist/processor/index.d.ts

@@ -7,3 +7,6 @@ export * from "./hot";
 export * from "./hash";
 export * from "./stats";
 export * from "./watch";
+export * from "./simple";
+export * from "./defaults";
+export * from "./stats-api";

package/dist/processor/index.js

@@ -23,3 +23,6 @@ __exportStar(require("./hot"), exports);
 __exportStar(require("./hash"), exports);
 __exportStar(require("./stats"), exports);
 __exportStar(require("./watch"), exports);
+__exportStar(require("./simple"), exports);
+__exportStar(require("./defaults"), exports);
+__exportStar(require("./stats-api"), exports);

package/dist/processor/simple.d.ts

@@ -0,0 +1,23 @@
+import { ECompilerType, ITestContext, ITestEnv, ITestProcessor, TCompiler, TCompilerOptions, TCompilerStats } from "../type";
+export interface ISimpleProcessorOptions<T extends ECompilerType = ECompilerType.Rspack> {
+    options?: (context: ITestContext) => TCompilerOptions<T>;
+    compilerType: T;
+    name: string;
+    build?: (context: ITestContext, compiler: TCompiler<T>) => Promise<void>;
+    compiler?: (context: ITestContext, compiler: TCompiler<T>) => Promise<void>;
+    check?: (context: ITestContext, compiler: TCompiler<T>, stats: TCompilerStats<T>) => Promise<void>;
+}
+export declare class SimpleTaskProcessor<T extends ECompilerType = ECompilerType.Rspack> implements ITestProcessor {
+    protected _options: ISimpleProcessorOptions<T>;
+    constructor(_options: ISimpleProcessorOptions<T>);
+    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>;
+    before(context: ITestContext): Promise<void>;
+    after(context: ITestContext): Promise<void>;
+    beforeAll(context: ITestContext): Promise<void>;
+    afterAll(context: ITestContext): Promise<void>;
+    protected getCompiler(context: ITestContext): import("../type").ITestCompilerManager<T>;
+}

package/dist/processor/simple.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleTaskProcessor = void 0;
+class SimpleTaskProcessor {
+    constructor(_options) {
+        this._options = _options;
+    }
+    async config(context) {
+        const compiler = this.getCompiler(context);
+        if (typeof this._options.options === "function") {
+            compiler.setOptions(this._options.options(context));
+        }
+    }
+    async compiler(context) {
+        const compiler = this.getCompiler(context);
+        const instance = compiler.createCompiler();
+        if (typeof this._options.compiler === "function") {
+            await this._options.compiler(context, instance);
+        }
+    }
+    async build(context) {
+        const compiler = this.getCompiler(context);
+        if (typeof this._options.build === "function") {
+            await this._options.build(context, compiler.getCompiler());
+        }
+        else {
+            await compiler.build();
+        }
+    }
+    async run(env, context) { }
+    async check(env, context) {
+        const compiler = this.getCompiler(context);
+        const stats = compiler.getStats();
+        if (typeof this._options.check === "function") {
+            await this._options.check(context, compiler.getCompiler(), stats);
+        }
+    }
+    async before(context) { }
+    async after(context) {
+        const compiler = this.getCompiler(context);
+        await compiler.close();
+    }
+    async beforeAll(context) {
+        throw new Error("Not support");
+    }
+    async afterAll(context) {
+        throw new Error("Not support");
+    }
+    getCompiler(context) {
+        return context.getCompiler(this._options.name, this._options.compilerType);
+    }
+}
+exports.SimpleTaskProcessor = SimpleTaskProcessor;

package/dist/processor/stats-api.d.ts

@@ -0,0 +1,20 @@
+import { SimpleTaskProcessor } from "./simple";
+import { ECompilerType, ITestContext, ITestEnv, TCompiler, TCompilerOptions, TCompilerStats } from "../type";
+export interface IStatsAPITaskProcessorOptions<T extends ECompilerType> {
+    options?: (context: ITestContext) => TCompilerOptions<T>;
+    name: string;
+    cwd?: string;
+    compilerType: T;
+    build?: (context: ITestContext, compiler: TCompiler<T>) => Promise<void>;
+    check?: (stats: TCompilerStats<T>, compiler: TCompiler<T>) => Promise<void>;
+}
+export declare class StatsAPITaskProcessor<T extends ECompilerType> extends SimpleTaskProcessor<T> {
+    protected _statsAPIOptions: IStatsAPITaskProcessorOptions<T>;
+    constructor(_statsAPIOptions: IStatsAPITaskProcessorOptions<T>);
+    compiler(context: ITestContext): Promise<void>;
+    run(env: ITestEnv, context: ITestContext): Promise<void>;
+    check(env: ITestEnv, context: ITestContext): Promise<void>;
+    before(context: ITestContext): Promise<void>;
+    after(context: ITestContext): Promise<void>;
+    static addSnapshotSerializer(): void;
+}

package/dist/processor/stats-api.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatsAPITaskProcessor = void 0;
+const simple_1 = require("./simple");
+const memfs_1 = require("memfs");
+const path_1 = __importDefault(require("path"));
+const serializer = require("jest-serializer-path");
+const FAKE_CWD = path_1.default.resolve(__dirname, "../../../rspack");
+const CWD = process.cwd();
+class StatsAPITaskProcessor extends simple_1.SimpleTaskProcessor {
+    constructor(_statsAPIOptions) {
+        super({
+            options: _statsAPIOptions.options,
+            build: _statsAPIOptions.build,
+            compilerType: _statsAPIOptions.compilerType,
+            name: _statsAPIOptions.name
+        });
+        this._statsAPIOptions = _statsAPIOptions;
+    }
+    async compiler(context) {
+        await super.compiler(context);
+        const compiler = this.getCompiler(context).getCompiler();
+        if (compiler) {
+            compiler.outputFileSystem = (0, memfs_1.createFsFromVolume)(new memfs_1.Volume());
+        }
+    }
+    async run(env, context) {
+        throw new Error("Not support");
+    }
+    async check(env, context) {
+        var _a, _b;
+        const compiler = this.getCompiler(context);
+        const stats = compiler.getStats();
+        expect(typeof stats).toBe("object");
+        await ((_b = (_a = this._statsAPIOptions).check) === null || _b === void 0 ? void 0 : _b.call(_a, stats, compiler.getCompiler()));
+    }
+    async before(context) {
+        process.chdir(this._statsAPIOptions.cwd || FAKE_CWD);
+    }
+    async after(context) {
+        process.chdir(CWD);
+    }
+    static addSnapshotSerializer() {
+        expect.addSnapshotSerializer(serializer);
+    }
+}
+exports.StatsAPITaskProcessor = StatsAPITaskProcessor;

package/dist/processor/treeshaking.d.ts

@@ -0,0 +1,14 @@
+import { BasicTaskProcessor } from "./basic";
+import { ECompilerType, ITestContext, ITestEnv, TCompilerOptions } from "../type";
+export interface IRspackTreeShakingProcessorOptions {
+    name: string;
+    snapshot: string;
+    type: "new" | "builtin";
+}
+export declare class RspackTreeShakingProcessor extends BasicTaskProcessor<ECompilerType.Rspack> {
+    protected _treeShakingOptions: IRspackTreeShakingProcessorOptions;
+    constructor(_treeShakingOptions: IRspackTreeShakingProcessorOptions);
+    check(env: ITestEnv, context: ITestContext): Promise<void>;
+    static defaultOptions(context: ITestContext): TCompilerOptions<ECompilerType.Rspack>;
+    static overrideOptions(type: IRspackTreeShakingProcessorOptions["type"]): (context: ITestContext, options: TCompilerOptions<ECompilerType.Rspack>) => void;
+}

package/dist/processor/treeshaking.js

@@ -0,0 +1,186 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RspackTreeShakingProcessor = void 0;
+const basic_1 = require("./basic");
+const type_1 = require("../type");
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const webpack_merge_1 = require("webpack-merge");
+const core_1 = require("@rspack/core");
+class RspackTreeShakingProcessor extends basic_1.BasicTaskProcessor {
+    constructor(_treeShakingOptions) {
+        super({
+            compilerType: type_1.ECompilerType.Rspack,
+            defaultOptions: RspackTreeShakingProcessor.defaultOptions,
+            overrideOptions: RspackTreeShakingProcessor.overrideOptions(_treeShakingOptions.type),
+            name: _treeShakingOptions.name,
+            runable: false
+        });
+        this._treeShakingOptions = _treeShakingOptions;
+    }
+    async check(env, context) {
+        const compiler = this.getCompiler(context);
+        const stats = compiler.getStats();
+        const c = compiler.getCompiler();
+        if (!stats || !c)
+            return;
+        if (stats.hasErrors()) {
+            throw new Error(`Failed to compile in fixture ${this._options.name}, Errors: ${stats.toJson({ errors: true, all: false }).errors}`);
+        }
+        const fileContents = Object.entries(c.compilation.assets)
+            .filter(([file]) => file.endsWith(".js") && !file.includes("runtime.js"))
+            .map(([file, source]) => {
+            const tag = path_1.default.extname(file).slice(1) || "txt";
+            return `\`\`\`${tag} title=${file}\n${source.source().toString()}\n\`\`\``;
+        });
+        fileContents.sort();
+        const content = `---\nsource: crates/rspack_testing/src/run_fixture.rs\n---\n${fileContents.join("\n\n")}\n`;
+        const updateSnapshot = process.argv.includes("-u") || process.argv.includes("--updateSnapshot");
+        const snapshotPath = path_1.default.resolve(context.getSource(), `./snapshot/${this._treeShakingOptions.snapshot}`);
+        if (!fs_extra_1.default.existsSync(snapshotPath) || updateSnapshot) {
+            fs_extra_1.default.writeFileSync(snapshotPath, content, "utf-8");
+            return;
+        }
+        const snapshotContent = fs_extra_1.default.readFileSync(snapshotPath, "utf-8");
+        expect(content).toBe(snapshotContent);
+    }
+    static defaultOptions(context) {
+        var _a, _b, _c;
+        let defaultOptions = {
+            entry: {
+                main: {
+                    import: "./index",
+                    runtime: "runtime"
+                }
+            },
+            output: {
+                filename: "[name].js",
+                chunkFilename: "[name].js",
+                cssFilename: "[name].css",
+                cssChunkFilename: "[name].css",
+                sourceMapFilename: "[file].map",
+                chunkLoadingGlobal: "webpackChunkwebpack",
+                chunkLoading: "jsonp",
+                uniqueName: "__rspack_test__",
+                enabledLibraryTypes: ["system"],
+                strictModuleErrorHandling: false,
+                iife: true,
+                module: false,
+                asyncChunks: true,
+                scriptType: false,
+                globalObject: "self",
+                importFunctionName: "import"
+            },
+            module: {
+                rules: [
+                    {
+                        test: /\.json$/,
+                        type: "json"
+                    },
+                    {
+                        test: /\.mjs$/,
+                        type: "js/esm"
+                    },
+                    {
+                        test: /\.cjs$/,
+                        type: "js/dynamic"
+                    },
+                    {
+                        test: /\.js$/,
+                        type: "js/auto"
+                    },
+                    {
+                        test: /\.css$/,
+                        type: "css"
+                    },
+                    {
+                        test: /\.wasm$/,
+                        type: "webassembly/async"
+                    }
+                ]
+            },
+            node: {
+                __dirname: "mock",
+                __filename: "mock",
+                global: "warn"
+            },
+            optimization: {
+                minimize: false,
+                removeAvailableModules: true,
+                removeEmptyChunks: true,
+                moduleIds: "named",
+                chunkIds: "named",
+                sideEffects: false,
+                mangleExports: false,
+                usedExports: false,
+                concatenateModules: false,
+                nodeEnv: false
+            },
+            devtool: false,
+            context: context.getSource(),
+            plugins: []
+        };
+        const testConfigFile = context.getSource("test.config.js");
+        if (fs_extra_1.default.existsSync(testConfigFile)) {
+            defaultOptions = (0, webpack_merge_1.merge)(defaultOptions, require(testConfigFile));
+        }
+        else {
+            const testConfigJson = context.getSource("test.config.json");
+            if (fs_extra_1.default.existsSync(testConfigJson)) {
+                const content = fs_extra_1.default
+                    .readFileSync(testConfigJson, "utf-8")
+                    .split(`"true"`)
+                    .join("true")
+                    .split(`"false"`)
+                    .join("false");
+                const json = JSON.parse(content);
+                defaultOptions = (0, webpack_merge_1.merge)(defaultOptions, json);
+            }
+        }
+        // TODO: remove these after modify all test.config.json
+        const defineOptions = (_a = defaultOptions.builtins) === null || _a === void 0 ? void 0 : _a.define;
+        if (defineOptions) {
+            defaultOptions.plugins.push(new core_1.rspack.DefinePlugin(defineOptions));
+            (_b = defaultOptions.builtins) === null || _b === void 0 ? true : delete _b.define;
+        }
+        const rules = (_c = defaultOptions.module) === null || _c === void 0 ? void 0 : _c.rules;
+        if (rules) {
+            defaultOptions.module.rules = rules.map((rule) => {
+                var _a;
+                if (typeof ((_a = rule.test) === null || _a === void 0 ? void 0 : _a.type) === "string") {
+                    if (rule.test.type === "regexp") {
+                        rule.test = new RegExp(rule.test.matcher);
+                    }
+                }
+                if (typeof rule.sideEffect === "boolean") {
+                    rule.sideEffects = rule.sideEffect;
+                    delete rule.sideEffect;
+                }
+                return rule;
+            });
+        }
+        return defaultOptions;
+    }
+    static overrideOptions(type) {
+        return (context, options) => {
+            var _a, _b, _c, _d;
+            var _e;
+            options.target = options.target || ["web", "es2022"];
+            if (type === "new") {
+                (_a = options.optimization) !== null && _a !== void 0 ? _a : (options.optimization = {});
+                options.optimization.providedExports = true;
+                options.optimization.innerGraph = true;
+                options.optimization.usedExports = true;
+                (_b = options.experiments) !== null && _b !== void 0 ? _b : (options.experiments = {});
+                (_c = (_e = options.experiments).rspackFuture) !== null && _c !== void 0 ? _c : (_e.rspackFuture = {});
+                options.experiments.rspackFuture.newTreeshaking = true;
+                (_d = options.builtins) !== null && _d !== void 0 ? _d : (options.builtins = {});
+                options.builtins.treeShaking = false;
+            }
+        };
+    }
+}
+exports.RspackTreeShakingProcessor = RspackTreeShakingProcessor;

package/dist/test/context.d.ts

@@ -1,4 +1,5 @@
 import { ITestCompilerManager, ECompilerType, ITestContext, ITesterConfig, ITestRunner, TTestConfig, TRunnerFactory } from "../type";
+export type TTestContextOptions = Omit<ITesterConfig, "name" | "steps">;
 export declare class TestContext implements ITestContext {
     private config;
     protected errors: Map<string, Error[]>;
@@ -6,7 +7,7 @@ export declare class TestContext implements ITestContext {
     protected store: Map<string, Record<string, unknown>>;
     protected runners: Map<string, ITestRunner>;
     protected runnerFactory: TRunnerFactory<ECompilerType> | null;
-    constructor(config: ITesterConfig);
+    constructor(config: TTestContextOptions);
     getSource(sub?: string): string;
     getDist(sub?: string): string;
     getTemp(sub?: string): string | null;

package/dist/test/creator.d.ts

@@ -10,7 +10,7 @@ export interface IBasicCaseCreatorOptions<T extends ECompilerType> {
         dist: string;
         temp: string | void;
     }) => ITestProcessor[];
-    description?: (name: string) => string;
+    description?: (name: string, step: number) => string;
     runner?: new (name: string, context: ITestContext) => TRunnerFactory<ECompilerType>;
     [key: string]: unknown;
 }

package/dist/test/creator.js

@@ -35,17 +35,20 @@ class BasicCaseCreator {
         beforeAll(async () => {
             await tester.prepare();
         });
-        const description = typeof this._options.description === "function"
-            ? this._options.description(name)
-            : `${name} should compile`;
-        it(description, async () => {
-            await tester.compile();
-            await tester.check(env);
-        }, this._options.timeout || 30000);
+        for (let index = 0; index < tester.total; index++) {
+            const description = typeof this._options.description === "function"
+                ? this._options.description(name, index)
+                : `${name}${index ? `[${index}]` : ""} should compile`;
+            it(description, async () => {
+                await tester.compile();
+                await tester.check(env);
+                tester.next();
+            }, this._options.timeout || 30000);
+            const env = this.createEnv(testConfig);
+        }
         afterAll(async () => {
             await tester.resume();
         });
-        const env = this.createEnv(testConfig);
     }
     createEnv(testConfig) {
         if (typeof this._options.runner === "function" && !testConfig.noTest) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack/test-tools",
-  "version": "0.5.7",
+  "version": "0.5.8",
   "license": "MIT",
   "description": "Test tools for rspack",
   "main": "dist/index.js",
@@ -39,11 +39,12 @@
     "glob": "^10.3.10",
     "jest-diff": "^29.7.0",
     "jest-serializer-path": "^0.1.15",
+    "memfs": "4.7.7",
     "webpack": "^5.90.1",
     "webpack-merge": "5.9.0",
     "webpack-sources": "3.2.3",
     "which-module": "2.0.1",
-    "@rspack/core": "0.5.7"
+    "@rspack/core": "0.5.8"
   },
   "devDependencies": {
     "@arco-design/web-react": "^2.56.1",
@@ -62,7 +63,7 @@
     "react": "18.0.0",
     "react-dom": "18.0.0",
     "react-refresh": "0.14.0",
-    "@rspack/cli": "0.5.7"
+    "@rspack/cli": "0.5.8"
   },
   "scripts": {
     "build": "tsc -b ./tsconfig.build.json",