@rspack-canary/test-tools 1.5.7-canary-a3406c0a-20250922173625 → 1.5.8-canary-e350b761-20250924173613

package/dist/case/serial.js

@@ -1,11 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSerialCase = createSerialCase;
-const processor_1 = require("../processor");
-const runner_1 = require("../runner");
 const creator_1 = require("../test/creator");
-const type_1 = require("../type");
 const config_1 = require("./config");
+const runner_1 = require("./runner");
 const creator = new creator_1.BasicCaseCreator({
     clean: true,
     describe: false,
@@ -20,18 +18,12 @@ const creator = new creator_1.BasicCaseCreator({
             return res;
         };
     },
-    steps: ({ name }) => [
-        new processor_1.MultiTaskProcessor({
-            name,
-            runable: true,
-            compilerType: type_1.ECompilerType.Rspack,
-            configFiles: ["rspack.config.js", "webpack.config.js"],
-            defaultOptions: config_1.defaultOptions,
-            overrideOptions: config_1.overrideOptions,
-            findBundle: config_1.findBundle
-        })
-    ],
-    runner: runner_1.MultipleRunnerFactory
+    steps: ({ name }) => [(0, config_1.createConfigProcessor)(name)],
+    runner: {
+        key: runner_1.getMultiCompilerRunnerKey,
+        runner: runner_1.createMultiCompilerRunner
+    },
+    concurrent: false
 });
 function createSerialCase(name, src, dist) {
     creator.create(name, src, dist);

package/dist/case/stats-api.js

@@ -2,10 +2,55 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStatsAPICase = createStatsAPICase;
 const memfs_1 = require("memfs");
-const processor_1 = require("../processor");
-const simple_1 = require("../test/simple");
-const type_1 = require("../type");
+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);
+    creator.create(name, src, dist, undefined, {
+        caseConfig,
+        description: () => caseConfig.description
+    });
+}
 function options(context, custom) {
     const res = (custom?.(context) ||
         {});
@@ -29,24 +74,9 @@ async function compiler(context, compiler, custom) {
         compiler.outputFileSystem = (0, memfs_1.createFsFromVolume)(new memfs_1.Volume());
     }
 }
-async function check(env, context, compiler, stats, custom) {
+async function check(env, context, name, custom) {
+    const manager = (0, common_1.getCompiler)(context, name);
+    const stats = manager.getStats();
     env.expect(typeof stats).toBe("object");
-    await custom?.(stats, compiler);
-}
-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, new processor_1.SimpleTaskProcessor({
-            name: name,
-            compilerType: type_1.ECompilerType.Rspack,
-            options: context => options(context, caseConfig.options),
-            compiler: (context, c) => compiler(context, c, caseConfig.compiler),
-            build: caseConfig.build,
-            check: (env, context, compiler, stats) => check(env, context, compiler, stats, caseConfig.check)
-        }));
-    });
+    await custom?.(stats, manager.getCompiler());
 }

package/dist/case/stats-output.js

@@ -8,10 +8,47 @@ const node_path_1 = __importDefault(require("node:path"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const placeholder_1 = require("../helper/expect/placeholder");
 const captureStdio_1 = __importDefault(require("../helper/legacy/captureStdio"));
-const processor_1 = require("../processor");
 const creator_1 = require("../test/creator");
-const type_1 = require("../type");
+const common_1 = require("./common");
 const REG_ERROR_CASE = /error$/;
+function createStatsProcessor(name) {
+    const writeStatsOuptut = false;
+    const snapshotName = "stats.txt";
+    let stderr = null;
+    return {
+        before: async (context) => {
+            stderr = (0, captureStdio_1.default)(process.stderr, true);
+        },
+        config: async (context) => {
+            (0, common_1.configMultiCompiler)(context, name, ["rspack.config.js", "webpack.config.js"], defaultOptions, overrideOptions);
+        },
+        compiler: async (context) => {
+            const c = await (0, common_1.compiler)(context, name);
+            await statsCompiler(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 check(env, context, name, writeStatsOuptut, snapshotName, stderr);
+        },
+        after: async (context) => {
+            stderr.restore();
+        }
+    };
+}
+const creator = new creator_1.BasicCaseCreator({
+    clean: true,
+    describe: false,
+    steps: ({ name }) => [createStatsProcessor(name)],
+    description: () => "should print correct stats for"
+});
+function createStatsOutputCase(name, src, dist) {
+    creator.create(name, src, dist);
+}
 function defaultOptions(index, context) {
     if (fs_extra_1.default.existsSync(node_path_1.default.join(context.getSource(), "rspack.config.js"))) {
         return {
@@ -73,141 +110,100 @@ class RspackStats {
         this.value = value;
     }
 }
-function createStatsProcessor(name) {
-    const writeStatsOuptut = false;
-    const snapshotName = "stats.txt";
-    const processor = new processor_1.MultiTaskProcessor({
-        name,
-        compilerType: type_1.ECompilerType.Rspack,
-        configFiles: ["rspack.config.js", "webpack.config.js"],
-        runable: false,
-        defaultOptions: (index, context) => defaultOptions(index, context),
-        overrideOptions: (index, context, options) => overrideOptions(index, context, options),
-        async check(env, context, compiler, stats) {
-            if (!stats || !compiler)
-                return;
-            for (const compilation of []
-                .concat(stats.stats || stats)
-                .map((s) => s.compilation)) {
-                compilation.logging.delete("webpack.Compilation.ModuleProfile");
-            }
-            if (REG_ERROR_CASE.test(name)) {
-                env.expect(stats.hasErrors()).toBe(true);
-            }
-            else if (stats.hasErrors()) {
-                throw new Error(stats.toString({
-                    all: false,
-                    errors: true
-                    // errorStack: true,
-                    // errorDetails: true
-                }));
-            }
-            else if (writeStatsOuptut) {
-                fs_extra_1.default.writeFileSync(node_path_1.default.join(context.getDist(), "stats.txt"), stats.toString({
-                    preset: "verbose",
-                    // context: context.getSource(),
-                    colors: false
-                }), "utf-8");
-            }
-            let toStringOptions = {
-                context: context.getSource(),
-                colors: false
-            };
-            let hasColorSetting = false;
-            if (typeof compiler.options.stats !== "undefined") {
-                toStringOptions = compiler.options.stats;
-                if (toStringOptions === null || typeof toStringOptions !== "object")
-                    toStringOptions = { preset: toStringOptions };
-                if (!toStringOptions.context)
-                    toStringOptions.context = context.getSource();
-                hasColorSetting = typeof toStringOptions.colors !== "undefined";
-            }
-            if (Array.isArray(compiler.options) && !toStringOptions.children) {
-                toStringOptions.children = compiler.options.map(o => o.stats);
-            }
-            // mock timestamps
-            for (const { compilation: s } of [].concat(stats.stats || stats)) {
-                env.expect(s.startTime).toBeGreaterThan(0);
-                env.expect(s.endTime).toBeGreaterThan(0);
-                s.endTime = new Date("04/20/1970, 12:42:42 PM").getTime();
-                s.startTime = s.endTime - 1234;
-            }
-            let actual = stats.toString(toStringOptions);
-            env.expect(typeof actual).toBe("string");
-            actual = stderr.toString() + actual;
-            if (!hasColorSetting) {
-                actual = actual
-                    .replace(/\u001b\[[0-9;]*m/g, "")
-                    // CHANGE: The time unit display in Rspack is second
-                    .replace(/[.0-9]+(\s?s)/g, "X$1")
-                    // CHANGE: Replace bundle size, since bundle sizes may differ between platforms
-                    .replace(/[0-9]+\.?[0-9]+ KiB/g, "xx KiB");
-            }
-            const snapshotPath = node_path_1.default.isAbsolute(snapshotName)
-                ? snapshotName
-                : node_path_1.default.resolve(context.getSource(), `./__snapshots__/${snapshotName}`);
-            env.expect(new RspackStats(actual)).toMatchFileSnapshot(snapshotPath);
-            const testConfig = context.getTestConfig();
-            if (typeof testConfig?.validate === "function") {
-                testConfig.validate(stats, stderr.toString());
-            }
-        },
-        async compiler(context, compiler) {
-            const compilers = compiler.compilers
-                ? compiler.compilers
-                : [compiler];
-            for (const compiler of compilers) {
-                if (!compiler.inputFileSystem) {
-                    continue;
-                }
-                const ifs = compiler.inputFileSystem;
-                const inputFileSystem = Object.create(ifs);
-                compiler.inputFileSystem = inputFileSystem;
-                inputFileSystem.readFile = (...args) => {
-                    const callback = args.pop();
-                    ifs.readFile.apply(ifs, args.concat([
-                        (err, result) => {
-                            if (err)
-                                return callback(err);
-                            if (!/\.(js|json|txt)$/.test(args[0]))
-                                return callback(null, result);
-                            callback(null, (0, placeholder_1.normalizePlaceholder)(result.toString("utf-8")));
-                        }
-                    ]));
-                };
-                // CHANGE: The checkConstraints() function is currently not implemented in rspack
-                // compiler.hooks.compilation.tap("StatsTestCasesTest", compilation => {
-                // 	[
-                // 		"optimize",
-                // 		"optimizeModules",
-                // 		"optimizeChunks",
-                // 		"afterOptimizeTree",
-                // 		"afterOptimizeAssets",
-                // 		"beforeHash"
-                // 	].forEach(hook => {
-                // 		compilation.hooks[hook].tap("TestCasesTest", () =>
-                // 			compilation.checkConstraints()
-                // 		);
-                // 	});
-                // });
-            }
-        }
-    });
-    let stderr;
-    processor.before = async (context) => {
-        stderr = (0, captureStdio_1.default)(process.stderr, true);
-    };
-    processor.after = async (context) => {
-        stderr.restore();
+async function check(env, context, name, writeStatsOuptut, snapshot, stderr) {
+    const compiler = (0, common_1.getCompiler)(context, name);
+    const options = compiler.getOptions();
+    const stats = compiler.getStats();
+    if (!stats || !compiler)
+        return;
+    for (const compilation of []
+        .concat(stats.stats || stats)
+        .map((s) => s.compilation)) {
+        compilation.logging.delete("webpack.Compilation.ModuleProfile");
+    }
+    if (REG_ERROR_CASE.test(name)) {
+        env.expect(stats.hasErrors()).toBe(true);
+    }
+    else if (stats.hasErrors()) {
+        throw new Error(stats.toString({
+            all: false,
+            errors: true
+            // errorStack: true,
+            // errorDetails: true
+        }));
+    }
+    else if (writeStatsOuptut) {
+        fs_extra_1.default.writeFileSync(node_path_1.default.join(context.getDist(), "stats.txt"), stats.toString({
+            preset: "verbose",
+            // context: context.getSource(),
+            colors: false
+        }), "utf-8");
+    }
+    let toStringOptions = {
+        context: context.getSource(),
+        colors: false
     };
-    return processor;
+    let hasColorSetting = false;
+    if (typeof options.stats !== "undefined") {
+        toStringOptions = options.stats;
+        if (toStringOptions === null || typeof toStringOptions !== "object")
+            toStringOptions = { preset: toStringOptions };
+        if (!toStringOptions.context)
+            toStringOptions.context = context.getSource();
+        hasColorSetting = typeof toStringOptions.colors !== "undefined";
+    }
+    if (Array.isArray(options) && !toStringOptions.children) {
+        toStringOptions.children = options.map(o => o.stats);
+    }
+    // mock timestamps
+    for (const { compilation: s } of [].concat(stats.stats || stats)) {
+        env.expect(s.startTime).toBeGreaterThan(0);
+        env.expect(s.endTime).toBeGreaterThan(0);
+        s.endTime = new Date("04/20/1970, 12:42:42 PM").getTime();
+        s.startTime = s.endTime - 1234;
+    }
+    let actual = stats.toString(toStringOptions);
+    env.expect(typeof actual).toBe("string");
+    actual = stderr.toString() + actual;
+    if (!hasColorSetting) {
+        actual = actual
+            .replace(/\u001b\[[0-9;]*m/g, "")
+            // CHANGE: The time unit display in Rspack is second
+            .replace(/[.0-9]+(\s?s)/g, "X$1")
+            // CHANGE: Replace bundle size, since bundle sizes may differ between platforms
+            .replace(/[0-9]+\.?[0-9]+ KiB/g, "xx KiB");
+    }
+    const snapshotPath = node_path_1.default.isAbsolute(snapshot)
+        ? snapshot
+        : node_path_1.default.resolve(context.getSource(), `./__snapshots__/${snapshot}`);
+    env.expect(new RspackStats(actual)).toMatchFileSnapshot(snapshotPath);
+    const testConfig = context.getTestConfig();
+    if (typeof testConfig?.validate === "function") {
+        testConfig.validate(stats, stderr.toString());
+    }
 }
-const creator = new creator_1.BasicCaseCreator({
-    clean: true,
-    describe: false,
-    steps: ({ name }) => [createStatsProcessor(name)],
-    description: () => "should print correct stats for"
-});
-function createStatsOutputCase(name, src, dist) {
-    creator.create(name, src, dist);
+async function statsCompiler(context, compiler) {
+    const compilers = compiler.compilers
+        ? compiler.compilers
+        : [compiler];
+    for (const compiler of compilers) {
+        if (!compiler.inputFileSystem) {
+            continue;
+        }
+        const ifs = compiler.inputFileSystem;
+        const inputFileSystem = Object.create(ifs);
+        compiler.inputFileSystem = inputFileSystem;
+        inputFileSystem.readFile = (...args) => {
+            const callback = args.pop();
+            ifs.readFile.apply(ifs, args.concat([
+                (err, result) => {
+                    if (err)
+                        return callback(err);
+                    if (!/\.(js|json|txt)$/.test(args[0]))
+                        return callback(null, result);
+                    callback(null, (0, placeholder_1.normalizePlaceholder)(result.toString("utf-8")));
+                }
+            ]));
+        };
+    }
 }

package/dist/case/treeshaking.js

@@ -1,22 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTreeShakingCase = createTreeShakingCase;
-const processor_1 = require("../processor");
 const creator_1 = require("../test/creator");
-const type_1 = require("../type");
 const builtin_1 = require("./builtin");
-function overrideOptions(context, options) {
-    options.target = options.target || ["web", "es2022"];
-    options.optimization ??= {};
-    options.optimization.providedExports = true;
-    options.optimization.innerGraph = true;
-    options.optimization.usedExports = true;
-    if (!global.printLogger) {
-        options.infrastructureLogging = {
-            level: "error"
-        };
-    }
-}
+const common_1 = require("./common");
 const creator = new creator_1.BasicCaseCreator({
     clean: true,
     describe: false,
@@ -24,16 +11,40 @@ const creator = new creator_1.BasicCaseCreator({
         return `${name} with newTreeshaking should match snapshot`;
     },
     steps: ({ name }) => [
-        new processor_1.SnapshotProcessor({
-            name,
-            snapshot: "treeshaking.snap.txt",
-            compilerType: type_1.ECompilerType.Rspack,
-            runable: false,
-            defaultOptions: builtin_1.defaultOptions,
-            overrideOptions
-        })
+        {
+            config: async (context) => {
+                const compiler = (0, common_1.getCompiler)(context, name);
+                const options = (0, builtin_1.defaultOptions)(context);
+                overrideOptions(context, options);
+                compiler.setOptions(options);
+            },
+            compiler: async (context) => {
+                await (0, common_1.compiler)(context, name);
+            },
+            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, "treeshaking.snap.txt");
+            }
+        }
     ]
 });
 function createTreeShakingCase(name, src, dist) {
     creator.create(name, src, dist);
 }
+function overrideOptions(context, options) {
+    options.target = options.target || ["web", "es2022"];
+    options.optimization ??= {};
+    options.optimization.providedExports = true;
+    options.optimization.innerGraph = true;
+    options.optimization.usedExports = true;
+    if (!global.printLogger) {
+        options.infrastructureLogging = {
+            level: "error"
+        };
+    }
+}

package/dist/case/watch.d.ts

@@ -1 +1,28 @@
+import { type ECompilerType, type ITestContext, type ITestEnv, type ITestRunner } from "../type";
+export declare function createWatchInitialProcessor(name: string, tempDir: string, step: string, watchState: Record<string, any>, { incremental, nativeWatcher, ignoreNotFriendlyForIncrementalWarnings }?: {
+    incremental?: boolean | undefined;
+    nativeWatcher?: boolean | undefined;
+    ignoreNotFriendlyForIncrementalWarnings?: boolean | undefined;
+}): {
+    before: (context: ITestContext) => Promise<void>;
+    config: <T extends ECompilerType.Rspack>(context: ITestContext) => Promise<void>;
+    compiler: (context: ITestContext) => Promise<void>;
+    build: (context: ITestContext) => Promise<void>;
+    run: (env: ITestEnv, context: ITestContext) => Promise<void>;
+    check: <T extends ECompilerType.Rspack>(env: ITestEnv, context: ITestContext) => Promise<void>;
+};
+export declare function createWatchStepProcessor(name: string, tempDir: string, step: string, watchState: Record<string, any>, { incremental, nativeWatcher, ignoreNotFriendlyForIncrementalWarnings }?: {
+    incremental?: boolean | undefined;
+    nativeWatcher?: boolean | undefined;
+    ignoreNotFriendlyForIncrementalWarnings?: boolean | undefined;
+}): {
+    before: (context: ITestContext) => Promise<void>;
+    config: <T extends ECompilerType.Rspack>(context: ITestContext) => Promise<void>;
+    compiler: (context: ITestContext) => Promise<void>;
+    build: (context: ITestContext) => Promise<void>;
+    run: (env: ITestEnv, context: ITestContext) => Promise<void>;
+    check: <T extends ECompilerType.Rspack>(env: ITestEnv, context: ITestContext) => Promise<void>;
+};
 export declare function createWatchCase(name: string, src: string, dist: string, temp: string): void;
+export declare function getWatchRunnerKey(context: ITestContext, name: string, file: string): string;
+export declare function createWatchRunner<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string, file: string, env: ITestEnv): ITestRunner;