@rspack-canary/test-tools 1.5.7-canary-a3406c0a-20250922173625 → 1.5.8-canary-6c1a40e3-20250925175235

package/dist/case/compiler.js

@@ -1,120 +1,155 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCompilerCase = createCompilerCase;
-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");
+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 {
+                        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();
+            }
+        },
+        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];
     }
-    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, new processor_1.SimpleTaskProcessor({
-                name: name,
-                compilerType: type_1.ECompilerType.Rspack,
-                compilerCallback: caseConfig.compilerCallback,
-                build: caseConfig.build,
-                options: context => {
-                    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;
-                    return options;
-                },
-                async compiler(context, compiler) {
-                    compiler.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"));
-                        }
-                    };
-                    compiler.hooks.compilation.tap("CompilerTest", compilation => (compilation.bail = true));
-                    await caseConfig.compiler?.(context, compiler);
-                },
-                async check(env, context, compiler, stats) {
-                    if (caseConfig.error) {
-                        const statsJson = stats?.toJson({
-                            modules: true,
-                            reasons: true
-                        });
-                        const compilation = stats?.compilation;
-                        await caseConfig.check?.({
-                            context,
-                            compiler,
-                            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,
-                            compilation
-                        });
-                    }
-                    else {
-                        await caseConfig.check?.({
-                            context,
-                            files,
-                            compiler
-                        });
-                    }
-                }
-            }));
+    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/config.d.ts

@@ -1,6 +1,7 @@
-import { ECompilerType, type ITestContext, type TCompilerOptions, type TTestConfig } from "../type";
+import type { ECompilerType, ITestContext, ITestProcessor, TCompilerOptions, TTestConfig } from "../type";
 export type TConfigCaseConfig = Omit<TTestConfig<ECompilerType.Rspack>, "validate">;
+export declare function createConfigProcessor(name: string): ITestProcessor;
+export declare function createConfigCase(name: string, src: string, dist: string): void;
 export declare function defaultOptions(index: number, context: ITestContext): TCompilerOptions<ECompilerType.Rspack>;
 export declare function overrideOptions(index: number, context: ITestContext, options: TCompilerOptions<ECompilerType.Rspack>): void;
 export declare function findBundle(index: number, context: ITestContext, options: TCompilerOptions<ECompilerType.Rspack>): string | string[];
-export declare function createConfigCase(name: string, src: string, dist: string): void;

package/dist/case/config.js

@@ -3,17 +3,60 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConfigProcessor = createConfigProcessor;
+exports.createConfigCase = createConfigCase;
 exports.defaultOptions = defaultOptions;
 exports.overrideOptions = overrideOptions;
 exports.findBundle = findBundle;
-exports.createConfigCase = createConfigCase;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 const parseResource_1 = require("../helper/legacy/parseResource");
-const processor_1 = require("../processor");
-const runner_1 = require("../runner");
 const creator_1 = require("../test/creator");
-const type_1 = require("../type");
+const common_1 = require("./common");
+const runner_1 = require("./runner");
+function createConfigProcessor(name) {
+    return {
+        config: async (context) => {
+            (0, common_1.configMultiCompiler)(context, name, ["rspack.config.cjs", "rspack.config.js", "webpack.config.js"], defaultOptions, overrideOptions);
+        },
+        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, findBundle));
+        },
+        check: async (env, context) => {
+            await (0, common_1.check)(env, context, name);
+        }
+    };
+}
+const creator = new creator_1.BasicCaseCreator({
+    clean: true,
+    describe: false,
+    testConfig: testConfig => {
+        const oldModuleScope = testConfig.moduleScope;
+        testConfig.moduleScope = (ms, stats, compilerOptions) => {
+            let res = ms;
+            // TODO: modify runner module scope based on stats here
+            if (typeof oldModuleScope === "function") {
+                res = oldModuleScope(ms, stats, compilerOptions);
+            }
+            return res;
+        };
+    },
+    steps: ({ name }) => [createConfigProcessor(name)],
+    runner: {
+        key: runner_1.getMultiCompilerRunnerKey,
+        runner: runner_1.createMultiCompilerRunner
+    },
+    concurrent: true
+});
+function createConfigCase(name, src, dist) {
+    creator.create(name, src, dist);
+}
 function defaultOptions(index, context) {
     return {
         context: context.getSource(),
@@ -80,38 +123,3 @@ function findBundle(index, context, options) {
     }
     return bundlePath;
 }
-const creator = new creator_1.BasicCaseCreator({
-    clean: true,
-    describe: false,
-    testConfig: testConfig => {
-        const oldModuleScope = testConfig.moduleScope;
-        testConfig.moduleScope = (ms, stats, compilerOptions) => {
-            let res = ms;
-            // TODO: modify runner module scope based on stats here
-            if (typeof oldModuleScope === "function") {
-                res = oldModuleScope(ms, stats, compilerOptions);
-            }
-            return res;
-        };
-    },
-    steps: ({ name }) => [
-        new processor_1.MultiTaskProcessor({
-            name,
-            runable: true,
-            compilerType: type_1.ECompilerType.Rspack,
-            defaultOptions,
-            overrideOptions,
-            findBundle,
-            configFiles: [
-                "rspack.config.cjs",
-                "rspack.config.js",
-                "webpack.config.js"
-            ]
-        })
-    ],
-    runner: runner_1.MultipleRunnerFactory,
-    concurrent: true
-});
-function createConfigCase(name, src, dist) {
-    creator.create(name, src, dist);
-}

package/dist/case/defaults.d.ts

@@ -1,4 +1,5 @@
-import { ECompilerType, type ITestContext, type TCompilerOptions } from "../type";
+import type { ECompilerType, ITestContext, TCompilerOptions } from "../type";
+export declare function createDefaultsCase(name: string, src: string): void;
 export declare function getRspackDefaultConfig(cwd: string, config: TCompilerOptions<ECompilerType>): TCompilerOptions<ECompilerType>;
 export type TDefaultsCaseConfig = {
     options?: (context: ITestContext) => TCompilerOptions<ECompilerType.Rspack>;
@@ -10,5 +11,4 @@ declare class RspackTestDiff {
     value: string;
     constructor(value: string);
 }
-export declare function createDefaultsCase(name: string, src: string): void;
 export {};

package/dist/case/defaults.js

@@ -3,15 +3,38 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRspackDefaultConfig = getRspackDefaultConfig;
 exports.createDefaultsCase = createDefaultsCase;
+exports.getRspackDefaultConfig = getRspackDefaultConfig;
 const node_path_1 = __importDefault(require("node:path"));
 const node_util_1 = require("node:util");
 const jest_diff_1 = require("jest-diff");
-const processor_1 = require("../processor");
 const context_1 = require("../test/context");
-const type_1 = require("../type");
+const common_1 = require("./common");
 const CURRENT_CWD = process.cwd();
+function createDefaultsCase(name, src) {
+    const caseConfig = require(src);
+    it(`should generate the correct defaults from ${caseConfig.description}`, async () => {
+        await run(name, {
+            config: async (context) => {
+                const compiler = (0, common_1.getCompiler)(context, name);
+                compiler.setOptions(options(context, caseConfig.options));
+            },
+            compiler: async (context) => {
+                const compiler = (0, common_1.getCompiler)(context, name);
+                compiler.createCompiler();
+            },
+            build: async (context) => {
+                // no need to build, just check the snapshot of compiler options
+            },
+            run: async (env, context) => {
+                // no need to run, just check the snapshot of compiler options
+            },
+            check: async (env, context) => {
+                await check(env, context, name, caseConfig);
+            }
+        });
+    });
+}
 function getRspackDefaultConfig(cwd, config) {
     process.chdir(cwd);
     const { applyWebpackOptionsDefaults, getNormalizedWebpackOptions } = require("@rspack/core").config;
@@ -47,8 +70,8 @@ class RspackTestDiff {
         this.value = value;
     }
 }
-async function check(env, context, options) {
-    const compiler = this.getCompiler(context);
+async function check(env, context, name, options) {
+    const compiler = (0, common_1.getCompiler)(context, name);
     const config = getRspackDefaultConfig(options.cwd || CURRENT_CWD, compiler.getOptions());
     const defaultConfig = getRspackDefaultConfig(options.cwd || CURRENT_CWD, {
         mode: "none"
@@ -69,16 +92,3 @@ async function run(name, processor) {
         await processor.after?.(context);
     }
 }
-function createDefaultsCase(name, src) {
-    const caseConfig = require(src);
-    it(`should generate the correct defaults from ${caseConfig.description}`, async () => {
-        await run(name, new processor_1.SimpleTaskProcessor({
-            name,
-            compilerType: type_1.ECompilerType.Rspack,
-            options: (context) => options(context, caseConfig.options),
-            check(env, context, _compiler, _stats) {
-                return check.call(this, env, context, caseConfig);
-            }
-        }));
-    });
-}

package/dist/case/diagnostic.d.ts

@@ -1,7 +1,7 @@
+export declare function createDiagnosticCase(name: string, src: string, dist: string): void;
 export interface IDiagnosticOptions {
     snapshot: string;
     snapshotErrors: string;
     snapshotWarning: string;
     format?: (output: string) => string;
 }
-export declare function createDiagnosticCase(name: string, src: string, dist: string): void;

package/dist/case/diagnostic.js

@@ -9,9 +9,57 @@ const node_path_1 = __importDefault(require("node:path"));
 const webpack_merge_1 = __importDefault(require("webpack-merge"));
 const helper_1 = require("../helper");
 const placeholder_1 = require("../helper/expect/placeholder");
-const processor_1 = require("../processor");
 const creator_1 = require("../test/creator");
-const type_1 = require("../type");
+const common_1 = require("./common");
+const creator = new creator_1.BasicCaseCreator({
+    clean: true,
+    describe: false,
+    steps: ({ name }) => [
+        {
+            config: async (context) => {
+                const compiler = (0, common_1.getCompiler)(context, name);
+                let options = defaultOptions(context);
+                const custom = (0, helper_1.readConfigFile)(["rspack.config.js", "webpack.config.js"].map(i => context.getSource(i)))[0];
+                if (custom) {
+                    options = (0, webpack_merge_1.default)(options, custom);
+                }
+                if (!global.printLogger) {
+                    options.infrastructureLogging = {
+                        level: "error"
+                    };
+                }
+                compiler.setOptions(options);
+            },
+            compiler: async (context) => {
+                const compiler = (0, common_1.getCompiler)(context, name);
+                compiler.createCompiler();
+            },
+            build: async (context) => {
+                const compiler = (0, common_1.getCompiler)(context, name);
+                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, {
+                    snapshot: "./stats.err",
+                    snapshotErrors: "./raw-error.err",
+                    snapshotWarning: "./raw-warning.err",
+                    format: (output) => {
+                        // TODO: change to stats.errorStack
+                        // TODO: add `errorStack: false`
+                        return output.replace(/(│.* at ).*/g, "$1xxx");
+                    }
+                });
+            }
+        }
+    ],
+    concurrent: true
+});
+function createDiagnosticCase(name, src, dist) {
+    creator.create(name, src, dist);
+}
 function defaultOptions(context) {
     return {
         target: "node",
@@ -41,8 +89,8 @@ function defaultOptions(context) {
         }
     };
 }
-async function check(env, context, options) {
-    const compiler = this.getCompiler(context);
+async function check(env, context, name, options) {
+    const compiler = (0, common_1.getCompiler)(context, name);
     const stats = compiler.getStats();
     if (!stats) {
         throw new Error("Stats should exists");
@@ -88,42 +136,3 @@ async function check(env, context, options) {
     env.expect(errors).toMatchFileSnapshot(errorStatsOutputPath);
     env.expect(warnings).toMatchFileSnapshot(warningStatsOutputPath);
 }
-const creator = new creator_1.BasicCaseCreator({
-    clean: true,
-    describe: false,
-    steps: ({ name }) => [
-        new processor_1.SimpleTaskProcessor({
-            name,
-            compilerType: type_1.ECompilerType.Rspack,
-            options: context => {
-                let options = defaultOptions(context);
-                const custom = (0, helper_1.readConfigFile)(["rspack.config.js", "webpack.config.js"].map(i => context.getSource(i)))[0];
-                if (custom) {
-                    options = (0, webpack_merge_1.default)(options, custom);
-                }
-                if (!global.printLogger) {
-                    options.infrastructureLogging = {
-                        level: "error"
-                    };
-                }
-                return options;
-            },
-            check: function (env, context, compiler, stats) {
-                return check.call(this, env, context, {
-                    snapshot: "./stats.err",
-                    snapshotErrors: "./raw-error.err",
-                    snapshotWarning: "./raw-warning.err",
-                    format: (output) => {
-                        // TODO: change to stats.errorStack
-                        // TODO: add `errorStack: false`
-                        return output.replace(/(│.* at ).*/g, "$1xxx");
-                    }
-                });
-            }
-        })
-    ],
-    concurrent: true
-});
-function createDiagnosticCase(name, src, dist) {
-    creator.create(name, src, dist);
-}

package/dist/case/diff.d.ts

@@ -1,3 +1,19 @@
-import { type IDiffProcessorOptions } from "../processor";
+import { type IFormatCodeOptions, type IFormatCodeReplacement } from "../compare";
+import { type TCompareModules, type TFileCompareResult, type TModuleCompareResult } from "../type";
 export type TDiffCaseConfig = IDiffProcessorOptions;
 export declare function createDiffCase(name: string, src: string, dist: string): void;
+export interface IDiffProcessorOptions extends IFormatCodeOptions {
+    webpackPath: string;
+    rspackPath: string;
+    files?: string[];
+    modules?: TCompareModules;
+    runtimeModules?: TCompareModules;
+    bootstrap?: boolean;
+    detail?: boolean;
+    errors?: boolean;
+    replacements?: IFormatCodeReplacement[];
+    renameModule?: (file: string) => string;
+    onCompareFile?: (file: string, result: TFileCompareResult) => void;
+    onCompareModules?: (file: string, results: TModuleCompareResult[]) => void;
+    onCompareRuntimeModules?: (file: string, results: TModuleCompareResult[]) => void;
+}