@rspack-canary/test-tools 1.5.6-canary-e598f284-20250921173624 → 1.5.8-canary-e350b761-20250924173613

package/dist/case/defaults.d.ts

@@ -1,6 +1,14 @@
-import { type IDefaultsConfigProcessorOptions } from "../processor";
-import { ECompilerType } from "../type";
-export type TDefaultsCaseConfig = Omit<IDefaultsConfigProcessorOptions<ECompilerType.Rspack>, "name" | "compilerType"> & {
+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>;
+    cwd?: string;
+    diff: (diff: jest.JestMatchers<RspackTestDiff>, defaults: jest.JestMatchers<TCompilerOptions<ECompilerType.Rspack>>) => Promise<void>;
     description: string;
 };
-export declare function createDefaultsCase(name: string, src: string): void;
+declare class RspackTestDiff {
+    value: string;
+    constructor(value: string);
+}
+export {};

package/dist/case/defaults.js

@@ -4,16 +4,81 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createDefaultsCase = createDefaultsCase;
+exports.getRspackDefaultConfig = getRspackDefaultConfig;
 const node_path_1 = __importDefault(require("node:path"));
-const processor_1 = require("../processor");
+const node_util_1 = require("node:util");
+const jest_diff_1 = require("jest-diff");
 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;
+    const normalizedConfig = getNormalizedWebpackOptions(config);
+    applyWebpackOptionsDefaults(normalizedConfig);
+    // make snapshot stable
+    normalizedConfig.experiments.rspackFuture.bundlerInfo.version =
+        "$version$";
+    process.chdir(CURRENT_CWD);
+    return normalizedConfig;
+}
 const srcDir = node_path_1.default.resolve(__dirname, "../../tests/fixtures");
 const distDir = node_path_1.default.resolve(__dirname, "../../tests/js/defaults");
 const context = new context_1.TestContext({
     src: srcDir,
     dist: distDir
 });
+function options(context, custom) {
+    let res;
+    if (typeof custom === "function") {
+        res = custom(context);
+    }
+    else {
+        res = {};
+    }
+    if (!("mode" in res)) {
+        res.mode = "none";
+    }
+    return res;
+}
+class RspackTestDiff {
+    constructor(value) {
+        this.value = value;
+    }
+}
+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"
+    });
+    const diff = (0, node_util_1.stripVTControlCharacters)((0, jest_diff_1.diff)(defaultConfig, config, { expand: false, contextLines: 0 }));
+    await options.diff(env.expect(new RspackTestDiff(diff)), env.expect(defaultConfig));
+}
 async function run(name, processor) {
     try {
         await processor.before?.(context);
@@ -27,13 +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.DefaultsConfigProcessor({
-            name,
-            compilerType: type_1.ECompilerType.Rspack,
-            ...caseConfig
-        }));
-    });
-}

package/dist/case/diagnostic.d.ts

@@ -1 +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;
+}

package/dist/case/diagnostic.js

@@ -1,29 +1,138 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createDiagnosticCase = createDiagnosticCase;
-const processor_1 = require("../processor");
+const node_assert_1 = __importDefault(require("node:assert"));
+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 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 }) => [
-        new processor_1.DiagnosticProcessor({
-            name,
-            snapshot: "./stats.err",
-            snapshotErrors: "./raw-error.err",
-            snapshotWarning: "./raw-warning.err",
-            configFiles: ["rspack.config.js", "webpack.config.js"],
-            compilerType: type_1.ECompilerType.Rspack,
-            format: (output) => {
-                // TODO: change to stats.errorStack
-                // TODO: add `errorStack: false`
-                return output.replace(/(│.* at ).*/g, "$1xxx");
+        {
+            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",
+        context: context.getSource(),
+        entry: {
+            main: "./"
+        },
+        mode: "development",
+        devServer: {
+            hot: false
+        },
+        infrastructureLogging: {
+            debug: false
+        },
+        output: {
+            path: context.getDist()
+        },
+        experiments: {
+            css: true,
+            rspackFuture: {
+                bundlerInfo: {
+                    force: false
+                }
+            },
+            inlineConst: true,
+            lazyBarrel: true
+        }
+    };
+}
+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");
+    }
+    (0, node_assert_1.default)(stats.hasErrors() || stats.hasWarnings());
+    let output = (0, placeholder_1.normalizePlaceholder)(stats.toString({
+        all: false,
+        errors: true,
+        warnings: true
+    })).replaceAll("\\", "/");
+    const statsJson = stats.toJson({
+        all: false,
+        errors: true,
+        warnings: true
+    });
+    const errors = (statsJson.errors || []).map(e => {
+        // @ts-expect-error error message is already serialized in `stats.err`
+        delete e.message;
+        delete e.stack;
+        return e;
+    });
+    const warnings = (statsJson.warnings || []).map(e => {
+        // @ts-expect-error error message is already serialized in `stats.err`
+        delete e.message;
+        delete e.stack;
+        return e;
+    });
+    if (typeof options.format === "function") {
+        output = options.format(output);
+    }
+    env.expect.addSnapshotSerializer({
+        test(received) {
+            return typeof received === "string";
+        },
+        serialize(received) {
+            return (0, placeholder_1.normalizePlaceholder)(received.trim());
+        }
+    });
+    const errorOutputPath = node_path_1.default.resolve(context.getSource(options.snapshot));
+    const errorStatsOutputPath = node_path_1.default.resolve(context.getSource(options.snapshotErrors));
+    const warningStatsOutputPath = node_path_1.default.resolve(context.getSource(options.snapshotWarning));
+    env.expect(output).toMatchFileSnapshot(errorOutputPath);
+    env.expect(errors).toMatchFileSnapshot(errorStatsOutputPath);
+    env.expect(warnings).toMatchFileSnapshot(warningStatsOutputPath);
+}

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;
+}

package/dist/case/diff.js

@@ -7,10 +7,12 @@ exports.createDiffCase = createDiffCase;
 const node_path_1 = __importDefault(require("node:path"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const rimraf_1 = require("rimraf");
+const compare_1 = require("../compare");
 const createLazyTestEnv_1 = __importDefault(require("../helper/legacy/createLazyTestEnv"));
-const processor_1 = require("../processor");
+const plugin_1 = require("../plugin");
 const tester_1 = require("../test/tester");
 const type_1 = require("../type");
+const common_1 = require("./common");
 const DEFAULT_CASE_CONFIG = {
     webpackPath: require.resolve("webpack"),
     rspackPath: require.resolve("@rspack/core"),
@@ -63,7 +65,49 @@ function createDiffCase(name, src, dist) {
         const env = (0, createLazyTestEnv_1.default)(1000);
     });
 }
-function createDiffProcessor(config) {
+function defaultOptions(type, src, dist) {
+    return {
+        entry: node_path_1.default.join(src, "./src/index.js"),
+        context: src,
+        output: {
+            path: dist,
+            filename: "bundle.js",
+            chunkFilename: "[name].chunk.js"
+        },
+        plugins: [
+            type === type_1.ECompilerType.Webpack && new plugin_1.WebpackDiffConfigPlugin(),
+            type === type_1.ECompilerType.Rspack && new plugin_1.RspackDiffConfigPlugin()
+        ].filter(Boolean),
+        experiments: type === type_1.ECompilerType.Rspack
+            ? {
+                css: true,
+                rspackFuture: {
+                    bundlerInfo: {
+                        force: false
+                    }
+                }
+            }
+            : {}
+    };
+}
+function createFormatOptions(options, hashes) {
+    const formatOptions = {
+        ignoreModuleArguments: options.ignoreModuleArguments,
+        ignoreModuleId: options.ignoreModuleId,
+        ignorePropertyQuotationMark: options.ignorePropertyQuotationMark,
+        ignoreBlockOnlyStatement: options.ignoreBlockOnlyStatement,
+        ignoreIfCertainCondition: options.ignoreIfCertainCondition,
+        ignoreSwcHelpersPath: options.ignoreSwcHelpersPath,
+        ignoreObjectPropertySequence: options.ignoreObjectPropertySequence,
+        ignoreCssFilePath: options.ignoreCssFilePath,
+        replacements: options.replacements || []
+    };
+    for (const hash of hashes) {
+        formatOptions.replacements.push({ from: hash, to: "fullhash" });
+    }
+    return formatOptions;
+}
+function createDiffProcessor(options) {
     const fileCompareMap = new Map();
     const createCompareResultHandler = (type) => {
         return (file, results) => {
@@ -75,28 +119,132 @@ function createDiffProcessor(config) {
             fileCompareMap.set(file, fileResult);
         };
     };
-    const processor = new processor_1.DiffProcessor({
-        webpackPath: config.webpackPath,
-        rspackPath: config.rspackPath,
-        files: config.files,
-        modules: config.modules,
-        runtimeModules: config.runtimeModules,
-        renameModule: config.renameModule,
-        ignoreModuleId: config.ignoreModuleId ?? true,
-        ignoreModuleArguments: config.ignoreModuleArguments ?? true,
-        ignorePropertyQuotationMark: config.ignorePropertyQuotationMark ?? true,
-        ignoreBlockOnlyStatement: config.ignoreBlockOnlyStatement ?? true,
-        ignoreIfCertainCondition: config.ignoreIfCertainCondition ?? true,
-        ignoreSwcHelpersPath: config.ignoreSwcHelpersPath ?? true,
-        ignoreObjectPropertySequence: config.ignoreObjectPropertySequence ?? true,
-        ignoreCssFilePath: config.ignoreCssFilePath ?? true,
+    const diffOptions = {
+        webpackPath: options.webpackPath,
+        rspackPath: options.rspackPath,
+        files: options.files,
+        modules: options.modules,
+        runtimeModules: options.runtimeModules,
+        renameModule: options.renameModule,
+        ignoreModuleId: options.ignoreModuleId ?? true,
+        ignoreModuleArguments: options.ignoreModuleArguments ?? true,
+        ignorePropertyQuotationMark: options.ignorePropertyQuotationMark ?? true,
+        ignoreBlockOnlyStatement: options.ignoreBlockOnlyStatement ?? true,
+        ignoreIfCertainCondition: options.ignoreIfCertainCondition ?? true,
+        ignoreSwcHelpersPath: options.ignoreSwcHelpersPath ?? true,
+        ignoreObjectPropertySequence: options.ignoreObjectPropertySequence ?? true,
+        ignoreCssFilePath: options.ignoreCssFilePath ?? true,
         onCompareModules: createCompareResultHandler("modules"),
         onCompareRuntimeModules: createCompareResultHandler("runtimeModules"),
-        bootstrap: config.bootstrap ?? true,
-        detail: config.detail ?? true,
-        errors: config.errors ?? false,
-        replacements: config.replacements
-    });
+        bootstrap: options.bootstrap ?? true,
+        detail: options.detail ?? true,
+        errors: options.errors ?? false,
+        replacements: options.replacements
+    };
+    const hashes = [];
+    const webpackProcessor = global.updateSnapshot &&
+        {
+            config: async (context) => {
+                const compiler = (0, common_1.getCompiler)(context, type_1.ECompilerType.Webpack);
+                let options = defaultOptions(type_1.ECompilerType.Webpack, context.getSource(), node_path_1.default.join(context.getDist(), type_1.ECompilerType.Webpack));
+                options = await (0, common_1.config)(context, type_1.ECompilerType.Webpack, ["webpack.config.js", "rspack.config.js"], options);
+                compiler.setOptions(options);
+            },
+            compiler: async (context) => {
+                await (0, common_1.compiler)(context, type_1.ECompilerType.Webpack);
+            },
+            build: async (context) => {
+                await (0, common_1.build)(context, type_1.ECompilerType.Webpack);
+            },
+            run: async (env, context) => { },
+            check: async (env, context) => {
+                await (0, common_1.check)(env, context, type_1.ECompilerType.Webpack);
+            }
+        };
+    const rspackProcessor = {
+        config: async (context) => {
+            const compiler = (0, common_1.getCompiler)(context, type_1.ECompilerType.Rspack);
+            let options = defaultOptions(type_1.ECompilerType.Rspack, context.getSource(), node_path_1.default.join(context.getDist(), type_1.ECompilerType.Rspack));
+            options = await (0, common_1.config)(context, type_1.ECompilerType.Rspack, ["rspack.config.js", "webpack.config.js"], options);
+            compiler.setOptions(options);
+        },
+        compiler: async (context) => {
+            await (0, common_1.compiler)(context, type_1.ECompilerType.Rspack);
+        },
+        build: async (context) => {
+            await (0, common_1.build)(context, type_1.ECompilerType.Rspack);
+        },
+        run: async (env, context) => { },
+        check: async (env, context) => {
+            await (0, common_1.check)(env, context, type_1.ECompilerType.Rspack);
+        }
+    };
+    const processor = {
+        config: async (context) => {
+            if (webpackProcessor) {
+                await webpackProcessor.config(context);
+            }
+            await rspackProcessor.config(context);
+        },
+        compiler: async (context) => {
+            if (webpackProcessor) {
+                await webpackProcessor.compiler(context);
+            }
+            await rspackProcessor.compiler(context);
+        },
+        build: async (context) => {
+            if (webpackProcessor) {
+                await webpackProcessor.build(context);
+            }
+            await rspackProcessor.build(context);
+        },
+        run: async (env, context) => { },
+        check: async (env, context) => {
+            if (webpackProcessor) {
+                const webpackCompiler = context.getCompiler(type_1.ECompilerType.Webpack);
+                const webpackStats = webpackCompiler.getStats();
+                //TODO: handle chunk hash and content hash
+                webpackStats?.hash && hashes.push(webpackStats?.hash);
+                if (!diffOptions.errors) {
+                    env.expect(webpackStats?.hasErrors()).toBe(false);
+                }
+            }
+            const rspackCompiler = context.getCompiler(type_1.ECompilerType.Rspack);
+            const rspackStats = rspackCompiler.getStats();
+            //TODO: handle chunk hash and content hash
+            rspackStats?.hash && hashes.push(rspackStats?.hash);
+            if (!diffOptions.errors) {
+                env.expect(rspackStats?.hasErrors()).toBe(false);
+            }
+            const dist = context.getDist();
+            const snapshot = context.getSource("__snapshot__");
+            for (const file of diffOptions.files) {
+                const rspackDist = node_path_1.default.join(dist, type_1.ECompilerType.Rspack, file);
+                const webpackDist = node_path_1.default.join(dist, type_1.ECompilerType.Webpack, file);
+                const snapshotDist = node_path_1.default.join(snapshot, file.replace(/\.js$/, ".json"));
+                const result = (0, compare_1.compareFile)(rspackDist, webpackDist, {
+                    modules: diffOptions.modules,
+                    runtimeModules: diffOptions.runtimeModules,
+                    format: createFormatOptions(diffOptions, hashes),
+                    renameModule: diffOptions.renameModule,
+                    bootstrap: diffOptions.bootstrap,
+                    detail: diffOptions.detail,
+                    snapshot: snapshotDist
+                });
+                if (typeof diffOptions.onCompareFile === "function") {
+                    diffOptions.onCompareFile(file, result);
+                }
+                if (typeof diffOptions.onCompareModules === "function" &&
+                    result.modules.modules) {
+                    diffOptions.onCompareModules(file, result.modules.modules);
+                }
+                if (typeof diffOptions.onCompareRuntimeModules === "function" &&
+                    result.modules.runtimeModules) {
+                    diffOptions.onCompareRuntimeModules(file, result.modules.runtimeModules);
+                }
+            }
+        }
+    };
     return [processor, fileCompareMap];
 }
 function checkCompareResults(name, getResults) {

package/dist/case/error.d.ts

@@ -1,6 +1,16 @@
-import { type IErrorProcessorOptions } from "../processor";
-import { ECompilerType } from "../type";
-export type TErrorCaseConfig = Omit<IErrorProcessorOptions<ECompilerType.Rspack>, "name" | "compilerType"> & {
+import type { StatsError } from "@rspack/core";
+import type { ECompilerType, ITestContext, TCompiler, TCompilerOptions } from "../type";
+export declare function createErrorCase(name: string, src: string, dist: string, testConfig: string): void;
+declare class RspackStatsDiagnostics {
+    errors: StatsError[];
+    warnings: StatsError[];
+    constructor(errors: StatsError[], warnings: StatsError[]);
+}
+export type TErrorCaseConfig = {
     description: string;
+    options?: (context: ITestContext) => TCompilerOptions<ECompilerType.Rspack>;
+    compiler?: (context: ITestContext, compiler: TCompiler<ECompilerType.Rspack>) => Promise<void>;
+    build?: (context: ITestContext, compiler: TCompiler<ECompilerType.Rspack>) => Promise<void>;
+    check?: (stats: RspackStatsDiagnostics) => Promise<void>;
 };
-export declare function createErrorCase(name: string, src: string, dist: string, testConfig: string): void;
+export {};