@rspack/test-tools 1.2.6 → 1.2.7

package/dist/case/diff.js

@@ -32,49 +32,36 @@ function createDiffCase(name, src, dist) {
         dist,
         steps: [processor]
     });
-    beforeAll(async () => {
-        (0, rimraf_1.rimrafSync)(dist);
-        await tester.prepare();
-    });
-    do {
-        const prefix = node_path_1.default.basename(name);
-        describe(`${prefix}:build`, () => {
-            beforeAll(async () => {
-                await tester.compile();
-            });
-            checkBundleFiles("webpack", node_path_1.default.join(dist, "webpack"), caseConfig.files);
-            checkBundleFiles("rspack", node_path_1.default.join(dist, "rspack"), caseConfig.files);
+    (0, rimraf_1.rimrafSync)(dist);
+    const buildTask = tester.compile();
+    const prefix = node_path_1.default.basename(name);
+    describe(`${prefix}:check`, () => {
+        beforeAll(async () => {
+            await buildTask;
+            compareMap.clear();
+            await tester.check(env);
         });
-        describe(`${prefix}:check`, () => {
-            beforeAll(async () => {
-                compareMap.clear();
-                await tester.check(env);
-            });
-            for (const file of caseConfig.files) {
-                describe(`Comparing "${file}"`, () => {
-                    let moduleResults = [];
-                    let runtimeResults = [];
-                    beforeAll(() => {
-                        const fileResult = compareMap.get(file);
-                        if (!fileResult) {
-                            throw new Error(`File ${file} has no results`);
-                        }
-                        moduleResults = fileResult.modules;
-                        runtimeResults = fileResult.runtimeModules;
-                    });
-                    if (caseConfig.modules) {
-                        checkCompareResults("modules", () => moduleResults);
-                    }
-                    if (caseConfig.runtimeModules) {
-                        checkCompareResults("runtime modules", () => runtimeResults);
+        for (const file of caseConfig.files) {
+            describe(`Comparing "${file}"`, () => {
+                let moduleResults = [];
+                let runtimeResults = [];
+                beforeAll(() => {
+                    const fileResult = compareMap.get(file);
+                    if (!fileResult) {
+                        throw new Error(`File ${file} has no results`);
                     }
+                    moduleResults = fileResult.modules;
+                    runtimeResults = fileResult.runtimeModules;
                 });
-            }
-            const env = (0, createLazyTestEnv_1.default)(1000);
-        });
-    } while (tester.next());
-    afterAll(async () => {
-        await tester.resume();
+                if (caseConfig.modules) {
+                    checkCompareResults("modules", () => moduleResults);
+                }
+                if (caseConfig.runtimeModules) {
+                    checkCompareResults("runtime modules", () => runtimeResults);
+                }
+            });
+        }
+        const env = (0, createLazyTestEnv_1.default)(1000);
     });
 }
 function createDiffProcessor(config) {
@@ -113,15 +100,6 @@ function createDiffProcessor(config) {
     });
     return [processor, fileCompareMap];
 }
-function checkBundleFiles(name, dist, files) {
-    describe(`Checking ${name} dist files`, () => {
-        for (const file of files) {
-            it(`${name}: ${file} should be generated`, () => {
-                expect(fs_extra_1.default.existsSync(node_path_1.default.join(dist, file))).toBeTruthy();
-            });
-        }
-    });
-}
 function checkCompareResults(name, getResults) {
     describe(`Comparing ${name}`, () => {
         it("should not miss any module", () => {

package/dist/compare/compare.d.ts

@@ -1,5 +1,8 @@
 import { type TCompareModules, type TCompareResult, type TFileCompareResult, type TModuleCompareResult } from "../type";
 import { type IFormatCodeOptions } from "./format-code";
+declare global {
+    var updateSnapshot: boolean;
+}
 export interface ICompareOptions {
     modules?: TCompareModules;
     runtimeModules?: TCompareModules;
@@ -7,7 +10,8 @@ export interface ICompareOptions {
     renameModule?: (name: string) => string;
     bootstrap?: boolean;
     detail?: boolean;
+    snapshot?: string;
 }
 export declare function compareFile(sourceFile: string, distFile: string, compareOptions: ICompareOptions): TFileCompareResult;
-export declare function compareModules(modules: string[], sourceModules: Map<string, string>, distModules: Map<string, string>, compareOptions: ICompareOptions): TModuleCompareResult[];
+export declare function compareModules(modules: string[], sourceModules: Record<string, string>, distModules: Record<string, string>, compareOptions: ICompareOptions): TModuleCompareResult[];
 export declare function compareContent(sourceContent: string | false, distContent: string | false, compareOptions: ICompareOptions): TCompareResult;

package/dist/compare/compare.js

@@ -8,10 +8,12 @@ exports.compareModules = compareModules;
 exports.compareContent = compareContent;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const jest_diff_1 = require("jest-diff");
+const node_path_1 = __importDefault(require("node:path"));
 const helper_1 = require("../helper");
 const type_1 = require("../type");
 const format_code_1 = require("./format-code");
 const replace_runtime_module_name_1 = require("./replace-runtime-module-name");
+const WORKSPACE = node_path_1.default.resolve(__dirname, "../../../..");
 function compareFile(sourceFile, distFile, compareOptions) {
     const result = {
         type: type_1.ECompareResultType.Same,
@@ -22,7 +24,9 @@ function compareFile(sourceFile, distFile, compareOptions) {
         modules: {}
     };
     const sourceExists = fs_extra_1.default.existsSync(sourceFile);
-    const distExists = fs_extra_1.default.existsSync(distFile);
+    const distExists = compareOptions.snapshot
+        ? fs_extra_1.default.existsSync(compareOptions.snapshot)
+        : fs_extra_1.default.existsSync(distFile);
     if (!sourceExists && !distExists) {
         result.type = type_1.ECompareResultType.Missing;
         return result;
@@ -35,27 +39,53 @@ function compareFile(sourceFile, distFile, compareOptions) {
         result.type = type_1.ECompareResultType.OnlySource;
         return result;
     }
-    const sourceContent = (0, replace_runtime_module_name_1.replaceRuntimeModuleName)(fs_extra_1.default.readFileSync(sourceFile, "utf-8"));
-    const distContent = (0, replace_runtime_module_name_1.replaceRuntimeModuleName)(fs_extra_1.default.readFileSync(distFile, "utf-8"));
-    // const compareContentResult = compareContent(sourceContent, distContent);
-    // result.detail = compareContentResult.detail;
-    // result.lines = compareContentResult.lines;
-    result.type = type_1.ECompareResultType.Different;
+    function formatModules(modules) {
+        const res = {};
+        for (const [name, content] of Object.entries(modules)) {
+            const renamed = name.replaceAll(node_path_1.default.win32.sep, node_path_1.default.posix.sep);
+            if (!renamed.includes("node_modules/css-loader/dist")) {
+                res[renamed] = (0, format_code_1.formatCode)(renamed, content, compareOptions.format);
+            }
+        }
+        return res;
+    }
+    const sourceContent = (0, replace_runtime_module_name_1.replaceRuntimeModuleName)(fs_extra_1.default.readFileSync(sourceFile, "utf-8").replaceAll(WORKSPACE, "__WORKSPACE__"));
     const sourceModules = (0, helper_1.parseModules)(sourceContent, {
         bootstrap: compareOptions.bootstrap,
         renameModule: compareOptions.renameModule
     });
-    const distModules = (0, helper_1.parseModules)(distContent, {
-        bootstrap: compareOptions.bootstrap,
-        renameModule: compareOptions.renameModule
-    });
+    sourceModules.modules = formatModules(sourceModules.modules);
+    sourceModules.runtimeModules = formatModules(sourceModules.runtimeModules);
+    let distModules = {
+        modules: {},
+        runtimeModules: {}
+    };
+    if (!global.updateSnapshot &&
+        compareOptions.snapshot &&
+        fs_extra_1.default.existsSync(compareOptions.snapshot)) {
+        distModules = JSON.parse(fs_extra_1.default.readFileSync(compareOptions.snapshot, "utf-8"));
+    }
+    else {
+        const distContent = (0, replace_runtime_module_name_1.replaceRuntimeModuleName)(fs_extra_1.default.readFileSync(distFile, "utf-8").replaceAll(WORKSPACE, "__WORKSPACE__"));
+        distModules = (0, helper_1.parseModules)(distContent, {
+            bootstrap: compareOptions.bootstrap,
+            renameModule: compareOptions.renameModule
+        });
+        distModules.modules = formatModules(distModules.modules);
+        distModules.runtimeModules = formatModules(distModules.runtimeModules);
+        if (compareOptions.snapshot) {
+            fs_extra_1.default.ensureDirSync(node_path_1.default.dirname(compareOptions.snapshot));
+            fs_extra_1.default.writeFileSync(compareOptions.snapshot, JSON.stringify(distModules, null, 2));
+        }
+    }
+    result.type = type_1.ECompareResultType.Different;
     for (const type of ["modules", "runtimeModules"]) {
         const t = type;
         let moduleList = [];
         if (compareOptions[t] === true) {
             moduleList = [
-                ...sourceModules[t].keys(),
-                ...distModules[t].keys()
+                ...Object.keys(sourceModules[t]),
+                ...Object.keys(distModules[t])
             ].filter((i, idx, arr) => arr.indexOf(i) === idx);
         }
         else if (Array.isArray(compareOptions[t])) {
@@ -71,11 +101,9 @@ function compareFile(sourceFile, distFile, compareOptions) {
 function compareModules(modules, sourceModules, distModules, compareOptions) {
     const compareResults = [];
     for (const name of modules) {
-        const renamed = (0, replace_runtime_module_name_1.replaceRuntimeModuleName)(name);
-        const sourceContent = sourceModules.has(renamed) &&
-            (0, format_code_1.formatCode)(name, sourceModules.get(renamed), compareOptions.format);
-        const distContent = distModules.has(renamed) &&
-            (0, format_code_1.formatCode)(name, distModules.get(renamed), compareOptions.format);
+        const renamed = (0, replace_runtime_module_name_1.replaceRuntimeModuleName)(name).replaceAll(node_path_1.default.win32.sep, node_path_1.default.posix.sep);
+        const sourceContent = sourceModules[renamed];
+        const distContent = distModules[renamed];
         compareResults.push({
             ...compareContent(sourceContent, distContent, compareOptions),
             name

package/dist/compare/format-code.js

@@ -45,6 +45,7 @@ const replace_module_argument_1 = require("./replace-module-argument");
 const SWC_HELPER_PATH_REG = /^_swc_helpers_[a-zA-Z\d_-]+__WEBPACK_IMPORTED_MODULE_xxx__$/;
 const CSS_FILE_EXT_REG = /(le|sa|c|sc)ss$/;
 const INVALID_PATH_REG = /[<>:"/\\|?*.]/g;
+const MODULE_ID_REG = /__WEBPACK_IMPORTED_MODULE_\d+__/;
 function formatCode(name, raw, options) {
     const ast = (0, parser_1.parse)(raw, {
         sourceType: "unambiguous"
@@ -73,7 +74,9 @@ function formatCode(name, raw, options) {
         },
         Identifier(path) {
             if (options.ignoreModuleId) {
-                path.node.name = path.node.name.replace(/__WEBPACK_IMPORTED_MODULE_\d+__/g, "__WEBPACK_IMPORTED_MODULE_xxx__");
+                if (MODULE_ID_REG.test(path.node.name)) {
+                    path.node.name = "__WEBPACK_IMPORTED_MODULE_xxx__";
+                }
             }
             if (options.ignoreSwcHelpersPath) {
                 if (SWC_HELPER_PATH_REG.test(path.node.name)) {

package/dist/compare/replace-runtime-module-name.d.ts

@@ -1 +1 @@
-export declare function replaceRuntimeModuleName(name: string): string;
+export declare function replaceRuntimeModuleName(content: string): string;

package/dist/compare/replace-runtime-module-name.js

@@ -1,49 +1,52 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.replaceRuntimeModuleName = replaceRuntimeModuleName;
+const RUNTIME_MODULE_REGEX = /(webpack\/runtime\/)([a-z_]+)/g;
+const RUNTIME_MODULE_NAME_REPLACER = {
+    auto_public_path: "publicPath",
+    public_path: "publicPath",
+    async_module: "async module",
+    base_uri: "base uri",
+    chunk_name: "chunkName",
+    compat_get_default_export: "compat get default export",
+    compat: "compat",
+    create_fake_namespace_object: "create fake namespace object",
+    create_script_url: "trusted types script url",
+    create_script: "trusted types script",
+    define_property_getters: "define property getters",
+    ensure_chunk: "ensure chunk",
+    get_full_hash: "getFullHash",
+    get_trusted_types_policy: "trusted types policy",
+    global: "global",
+    has_own_property: "hasOwnProperty shorthand",
+    load_script: "load script",
+    make_namespace_object: "make namespace object",
+    nonce: "nonce",
+    on_chunk_loaded: "chunk loaded",
+    relative_url: "relative url",
+    runtime_id: "runtimeId",
+    startup_chunk_dependencies: "startup chunk dependencies",
+    startup_entrypoint: "startup entrypoint",
+    system_context: "__system_context__",
+    chunk_prefetch_startup: "startup prefetch",
+    chunk_prefetch_trigger: "chunk prefetch trigger",
+    chunk_preload_trigger: "chunk preload trigger",
+    css_loading: "css loading",
+    async_wasm_loading: "wasm loading",
+    hot_module_replacement: "hot module replacement",
+    readfile_chunk_loading: "readFile chunk loading",
+    require_chunk_loading: "require chunk loading",
+    import_scripts_chunk_loading: "importScripts chunk loading",
+    module_chunk_loading: "import chunk loading",
+    export_webpack_runtime: "export webpack runtime",
+    jsonp_chunk_loading: "jsonp chunk loading",
+    remote: "remotes loading",
+    share: "sharing",
+    consume_shared: "consumes",
+    esm_module_decorator: "harmony module decorator",
+    node_module_decorator: "node module decorator"
+};
 const RUNTIME_MODULE_NAME_MAPPING = {
-    "webpack/runtime/auto_public_path": "webpack/runtime/publicPath",
-    "webpack/runtime/public_path": "webpack/runtime/publicPath",
-    "webpack/runtime/async_module": "webpack/runtime/async module",
-    "webpack/runtime/base_uri": "webpack/runtime/base uri",
-    "webpack/runtime/chunk_name": "webpack/runtime/chunkName",
-    "webpack/runtime/compat_get_default_export": "webpack/runtime/compat get default export",
-    "webpack/runtime/compat": "webpack/runtime/compat",
-    "webpack/runtime/create_fake_namespace_object": "webpack/runtime/create fake namespace object",
-    "webpack/runtime/create_script_url": "webpack/runtime/trusted types script url",
-    "webpack/runtime/create_script": "webpack/runtime/trusted types script",
-    "webpack/runtime/define_property_getters": "webpack/runtime/define property getters",
-    "webpack/runtime/ensure_chunk": "webpack/runtime/ensure chunk",
-    "webpack/runtime/get_full_hash": "webpack/runtime/getFullHash",
-    "webpack/runtime/get_trusted_types_policy": "webpack/runtime/trusted types policy",
-    "webpack/runtime/global": "webpack/runtime/global",
-    "webpack/runtime/has_own_property": "webpack/runtime/hasOwnProperty shorthand",
-    "webpack/runtime/load_script": "webpack/runtime/load script",
-    "webpack/runtime/make_namespace_object": "webpack/runtime/make namespace object",
-    "webpack/runtime/nonce": "webpack/runtime/nonce",
-    "webpack/runtime/on_chunk_loaded": "webpack/runtime/chunk loaded",
-    "webpack/runtime/relative_url": "webpack/runtime/relative url",
-    "webpack/runtime/runtime_id": "webpack/runtime/runtimeId",
-    "webpack/runtime/startup_chunk_dependencies": "webpack/runtime/startup chunk dependencies",
-    "webpack/runtime/startup_entrypoint": "webpack/runtime/startup entrypoint",
-    "webpack/runtime/system_context": "webpack/runtime/__system_context__",
-    "webpack/runtime/chunk_prefetch_startup": "webpack/runtime/startup prefetch",
-    "webpack/runtime/chunk_prefetch_trigger": "webpack/runtime/chunk prefetch trigger",
-    "webpack/runtime/chunk_preload_trigger": "webpack/runtime/chunk preload trigger",
-    "webpack/runtime/css_loading": "webpack/runtime/css loading",
-    "webpack/runtime/async_wasm_loading": "webpack/runtime/wasm loading",
-    "webpack/runtime/hot_module_replacement": "webpack/runtime/hot module replacement",
-    "webpack/runtime/readfile_chunk_loading": "webpack/runtime/readFile chunk loading",
-    "webpack/runtime/require_chunk_loading": "webpack/runtime/require chunk loading",
-    "webpack/runtime/import_scripts_chunk_loading": "webpack/runtime/importScripts chunk loading",
-    "webpack/runtime/module_chunk_loading": "webpack/runtime/import chunk loading",
-    "webpack/runtime/export_webpack_runtime": "webpack/runtime/export webpack runtime",
-    "webpack/runtime/jsonp_chunk_loading": "webpack/runtime/jsonp chunk loading",
-    "webpack/runtime/remote": "webpack/runtime/remotes loading",
-    "webpack/runtime/share": "webpack/runtime/sharing",
-    "webpack/runtime/consume_shared": "webpack/runtime/consumes",
-    "webpack/runtime/esm_module_decorator": "webpack/runtime/harmony module decorator",
-    "webpack/runtime/node_module_decorator": "webpack/runtime/node module decorator",
     // module name with parameters
     "webpack/runtime/get_chunk_filename": "webpack/runtime/get $1 chunk filename",
     "webpack/runtime/get_main_filename": "webpack/runtime/get $1 filename",
@@ -54,13 +57,15 @@ const RUNTIME_MODULE_PARAM_REGEX = {
     "webpack/runtime/get_main_filename": /webpack\/runtime\/get_main_filename\/([\w.\-_\s]+)(\*\/)?/g,
     "webpack/runtime/chunk_prefetch_function": /webpack\/runtime\/chunk_prefetch_function\/([\w.\-_\s]+)(\*\/)?/g
 };
-function replaceRuntimeModuleName(name) {
-    return Object.entries(RUNTIME_MODULE_NAME_MAPPING).reduce((name, [rspackName, webpackName]) => {
+function replaceRuntimeModuleName(content) {
+    let res = content.replace(RUNTIME_MODULE_REGEX, (_, $1, $2) => `${$1}${RUNTIME_MODULE_NAME_REPLACER[$2] || $2}`);
+    res = Object.entries(RUNTIME_MODULE_NAME_MAPPING).reduce((res, [rspackName, webpackName]) => {
         if (RUNTIME_MODULE_PARAM_REGEX[rspackName]) {
-            return name.replace(RUNTIME_MODULE_PARAM_REGEX[rspackName], (_, $1, $2) => {
+            return res.replace(RUNTIME_MODULE_PARAM_REGEX[rspackName], (_, $1, $2) => {
                 return webpackName.replace("$1", $1.trim()) + ($2 ? " */" : "");
             });
         }
-        return name.split(rspackName).join(webpackName);
-    }, name);
+        return res.replaceAll(rspackName, webpackName);
+    }, res);
+    return res;
 }

package/dist/helper/parse-modules.d.ts

@@ -2,6 +2,6 @@ export declare function parseModules(content: string, options?: {
     bootstrap?: boolean;
     renameModule?: (name: string) => string;
 }): {
-    modules: Map<string, string>;
-    runtimeModules: Map<string, string>;
+    modules: Record<string, string>;
+    runtimeModules: Record<string, string>;
 };

package/dist/helper/parse-modules.js

@@ -35,14 +35,14 @@ function isValidModule(name) {
     return true;
 }
 function parseModules(content, options = {}) {
-    const modules = new Map();
-    const runtimeModules = new Map();
+    const modules = {};
+    const runtimeModules = {};
     let currentPosition = 0;
     if (options.bootstrap) {
         // parse bootstrap code
         const bootstrap = getStringBetween(content, 0, BOOTSTRAP_SPLIT_LINE, BOOTSTRAP_SPLIT_LINE);
         if (bootstrap.result) {
-            runtimeModules.set("webpack/runtime/bootstrap", bootstrap.result);
+            runtimeModules["webpack/runtime/bootstrap"] = bootstrap.result;
         }
     }
     // parse module & runtime module code
@@ -56,11 +56,11 @@ function parseModules(content, options = {}) {
             ? options.renameModule(moduleName)
             : moduleName;
         if (moduleName.startsWith("webpack/runtime")) {
-            runtimeModules.set(renamedModuleName, moduleContent.result);
+            runtimeModules[renamedModuleName] = moduleContent.result;
         }
         else {
             if (isValidModule(moduleName)) {
-                modules.set(renamedModuleName, moduleContent.result);
+                modules[renamedModuleName] = moduleContent.result;
             }
         }
         currentPosition = moduleContent.remain;

package/dist/processor/diff.js

@@ -13,13 +13,16 @@ class DiffProcessor {
     constructor(options) {
         this.options = options;
         this.hashes = [];
-        this.webpack = new basic_1.BasicProcessor({
-            defaultOptions: context => this.getDefaultOptions(type_1.ECompilerType.Webpack, context.getSource(), node_path_1.default.join(context.getDist(), type_1.ECompilerType.Webpack)),
-            compilerType: type_1.ECompilerType.Webpack,
-            name: type_1.ECompilerType.Webpack,
-            configFiles: ["webpack.config.js", "rspack.config.js"],
-            runable: false
-        });
+        this.webpack = null;
+        if (global.updateSnapshot) {
+            this.webpack = new basic_1.BasicProcessor({
+                defaultOptions: context => this.getDefaultOptions(type_1.ECompilerType.Webpack, context.getSource(), node_path_1.default.join(context.getDist(), type_1.ECompilerType.Webpack)),
+                compilerType: type_1.ECompilerType.Webpack,
+                name: type_1.ECompilerType.Webpack,
+                configFiles: ["webpack.config.js", "rspack.config.js"],
+                runable: false
+            });
+        }
         this.rspack = new basic_1.BasicProcessor({
             defaultOptions: context => this.getDefaultOptions(type_1.ECompilerType.Rspack, context.getSource(), node_path_1.default.join(context.getDist(), type_1.ECompilerType.Rspack)),
             compilerType: type_1.ECompilerType.Rspack,
@@ -29,24 +32,32 @@ class DiffProcessor {
         });
     }
     async config(context) {
-        await this.webpack.config(context);
+        if (this.webpack) {
+            await this.webpack.config(context);
+        }
         await this.rspack.config(context);
     }
     async compiler(context) {
-        await this.webpack.compiler(context);
+        if (this.webpack) {
+            await this.webpack.compiler(context);
+        }
         await this.rspack.compiler(context);
     }
     async build(context) {
-        await this.webpack.build(context);
+        if (this.webpack) {
+            await this.webpack.build(context);
+        }
         await this.rspack.build(context);
     }
     async check(env, context) {
-        const webpackCompiler = context.getCompiler(type_1.ECompilerType.Webpack);
-        const webpackStats = webpackCompiler.getStats();
-        //TODO: handle chunk hash and content hash
-        webpackStats?.hash && this.hashes.push(webpackStats?.hash);
-        if (!this.options.errors) {
-            env.expect(webpackStats?.hasErrors()).toBe(false);
+        if (this.webpack) {
+            const webpackCompiler = context.getCompiler(type_1.ECompilerType.Webpack);
+            const webpackStats = webpackCompiler.getStats();
+            //TODO: handle chunk hash and content hash
+            webpackStats?.hash && this.hashes.push(webpackStats?.hash);
+            if (!this.options.errors) {
+                env.expect(webpackStats?.hasErrors()).toBe(false);
+            }
         }
         const rspackCompiler = context.getCompiler(type_1.ECompilerType.Rspack);
         const rspackStats = rspackCompiler.getStats();
@@ -56,16 +67,19 @@ class DiffProcessor {
             env.expect(rspackStats?.hasErrors()).toBe(false);
         }
         const dist = context.getDist();
+        const snapshot = context.getSource("__snapshot__");
         for (const file of this.options.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: this.options.modules,
                 runtimeModules: this.options.runtimeModules,
                 format: this.createFormatOptions(),
                 renameModule: this.options.renameModule,
                 bootstrap: this.options.bootstrap,
-                detail: this.options.detail
+                detail: this.options.detail,
+                snapshot: snapshotDist
             });
             if (typeof this.options.onCompareFile === "function") {
                 this.options.onCompareFile(file, result);

package/dist/processor/watch.js

@@ -84,8 +84,19 @@ class WatchProcessor extends multi_1.MultiTaskProcessor {
                     return cached;
                 };
             })();
+            const getStringStats = (() => {
+                let cached = null;
+                return () => {
+                    if (!cached) {
+                        cached = stats.toString({
+                            logging: "verbose"
+                        });
+                    }
+                    return cached;
+                };
+            })();
             if (checkStats.length > 1) {
-                if (!checkStats(this._watchOptions.stepName, getJsonStats())) {
+                if (!checkStats(this._watchOptions.stepName, getJsonStats(), getStringStats())) {
                     throw new Error("stats check failed");
                 }
             }

package/dist/runner/basic.d.ts

@@ -3,7 +3,8 @@ export declare class BasicRunnerFactory<T extends ECompilerType> implements TRun
     protected name: string;
     protected context: ITestContext;
     constructor(name: string, context: ITestContext);
+    protected createStatsGetter(): () => TCompilerStatsCompilation<T>;
     create(file: string, compilerOptions: TCompilerOptions<T>, env: ITestEnv): ITestRunner;
     protected getRunnerKey(file: string): string;
-    protected createRunner(file: string, stats: TCompilerStatsCompilation<T>, compilerOptions: TCompilerOptions<T>, env: ITestEnv): ITestRunner;
+    protected createRunner(file: string, stats: () => TCompilerStatsCompilation<T>, compilerOptions: TCompilerOptions<T>, env: ITestEnv): ITestRunner;
 }

package/dist/runner/basic.js

@@ -9,17 +9,29 @@ class BasicRunnerFactory {
         this.name = name;
         this.context = context;
     }
+    createStatsGetter() {
+        const compiler = this.context.getCompiler(this.name);
+        const statsGetter = (() => {
+            let cached = null;
+            return () => {
+                if (cached) {
+                    return cached;
+                }
+                cached = compiler.getStats().toJson({
+                    errorDetails: true
+                });
+                return cached;
+            };
+        })();
+        return statsGetter;
+    }
     create(file, compilerOptions, env) {
         const key = this.getRunnerKey(file);
         const exists = this.context.getRunner(key);
         if (exists) {
             return exists;
         }
-        const compiler = this.context.getCompiler(this.name);
-        const stats = compiler.getStats().toJson({
-            errorDetails: true
-        });
-        const runner = this.createRunner(file, stats, compilerOptions, env);
+        const runner = this.createRunner(file, this.createStatsGetter(), compilerOptions, env);
         this.context.setRunner(key, runner);
         return runner;
     }
@@ -41,6 +53,7 @@ class BasicRunnerFactory {
             return new web_1.WebRunner({
                 ...runnerOptions,
                 runInNewContext: true,
+                cachable: true,
                 dom: this.context.getValue(this.name, "documentType") || type_1.EDocumentType.Fake
             });
         }

package/dist/runner/cache.js

@@ -23,7 +23,8 @@ class CacheRunnerFactory extends basic_1.BasicRunnerFactory {
                 dom: this.context.getValue(this.name, "documentType") ||
                     type_1.EDocumentType.JSDOM,
                 env,
-                stats,
+                stats: this.createStatsGetter(),
+                cachable: false,
                 name: this.name,
                 runInNewContext: false,
                 testConfig: {

package/dist/runner/hot-step.js

@@ -61,7 +61,7 @@ class HotStepRunnerFactory extends hot_1.HotRunnerFactory {
         const runner = new web_1.WebRunner({
             dom: this.context.getValue(this.name, "documentType") || type_1.EDocumentType.JSDOM,
             env,
-            stats,
+            stats: this.createStatsGetter(),
             name: this.name,
             runInNewContext: false,
             testConfig: {
@@ -75,6 +75,7 @@ class HotStepRunnerFactory extends hot_1.HotRunnerFactory {
                     return moduleScope;
                 }
             },
+            cachable: true,
             source,
             dist,
             compilerOptions

package/dist/runner/hot.js

@@ -57,7 +57,7 @@ class HotRunnerFactory extends basic_1.BasicRunnerFactory {
         return new web_1.WebRunner({
             dom: this.context.getValue(this.name, "documentType") || type_1.EDocumentType.JSDOM,
             env,
-            stats,
+            stats: this.createStatsGetter(),
             name: this.name,
             runInNewContext: false,
             testConfig: {
@@ -71,6 +71,7 @@ class HotRunnerFactory extends basic_1.BasicRunnerFactory {
                     return moduleScope;
                 }
             },
+            cachable: true,
             source,
             dist,
             compilerOptions

package/dist/runner/multiple.d.ts

@@ -3,7 +3,7 @@ import { BasicRunnerFactory } from "./basic";
 export declare class MultipleRunnerFactory<T extends ECompilerType> extends BasicRunnerFactory<T> {
     protected runned: Set<string>;
     protected getRunnerKey(file: string): string;
-    protected createRunner(file: string, stats: TCompilerStatsCompilation<T>, compilerOptions: TCompilerOptions<T>, env: ITestEnv): ITestRunner;
+    protected createRunner(file: string, stats: () => TCompilerStatsCompilation<T>, compilerOptions: TCompilerOptions<T>, env: ITestEnv): ITestRunner;
     protected getFileIndexHandler(file: string): {
         getIndex: () => number[];
         flagIndex: () => Set<string>;

package/dist/runner/multiple.js

@@ -16,7 +16,7 @@ class MultipleRunnerFactory extends basic_1.BasicRunnerFactory {
         const multiCompilerOptions = this.context.getValue(this.name, "multiCompilerOptions") || [];
         const { getIndex, flagIndex } = this.getFileIndexHandler(file);
         const [index] = getIndex();
-        const runner = super.createRunner(file, stats.children[index], multiCompilerOptions[index], env);
+        const runner = super.createRunner(file, () => stats().children[index], multiCompilerOptions[index], env);
         flagIndex();
         return runner;
     }

package/dist/runner/normal.d.ts

@@ -1,5 +1,5 @@
 import type { ECompilerType, ITestEnv, ITestRunner, TCompilerOptions, TCompilerStatsCompilation } from "../type";
 import { BasicRunnerFactory } from "./basic";
 export declare class NormalRunnerFactory<T extends ECompilerType> extends BasicRunnerFactory<T> {
-    protected createRunner(file: string, stats: TCompilerStatsCompilation<T>, compilerOptions: TCompilerOptions<T>, env: ITestEnv): ITestRunner;
+    protected createRunner(file: string, stats: () => TCompilerStatsCompilation<T>, compilerOptions: TCompilerOptions<T>, env: ITestEnv): ITestRunner;
 }

package/dist/runner/normal.js

@@ -7,6 +7,7 @@ class NormalRunnerFactory extends basic_1.BasicRunnerFactory {
     createRunner(file, stats, compilerOptions, env) {
         return new normal_1.NormalRunner({
             env,
+            cachable: true,
             name: this.name,
             runInNewContext: false,
             testConfig: this.context.getTestConfig(),

package/dist/runner/runner/basic.d.ts

@@ -2,13 +2,14 @@ import type { ECompilerType, ITestEnv, ITestRunner, TCompilerOptions, TCompilerS
 import type { IBasicGlobalContext, IBasicModuleScope, TBasicRunnerFile, TModuleObject, TRunnerRequirer } from "../type";
 export interface IBasicRunnerOptions<T extends ECompilerType> {
     env: ITestEnv;
-    stats?: TCompilerStatsCompilation<T>;
+    stats?: () => TCompilerStatsCompilation<T>;
     name: string;
     runInNewContext?: boolean;
     testConfig: TTestConfig<T>;
     source: string;
     dist: string;
     compilerOptions: TCompilerOptions<T>;
+    cachable?: boolean;
 }
 export declare abstract class BasicRunner<T extends ECompilerType = ECompilerType.Rspack> implements ITestRunner {
     protected _options: IBasicRunnerOptions<T>;

package/dist/runner/runner/basic.js

@@ -24,6 +24,7 @@ const getSubPath = (p) => {
     }
     return "";
 };
+const cached = new Map();
 class BasicRunner {
     constructor(_options) {
         this._options = _options;
@@ -59,8 +60,13 @@ class BasicRunner {
         return (this.globalContext || {})[name];
     }
     getFile(modulePath, currentDirectory) {
+        const cacheKey = `${currentDirectory}|${modulePath}`;
+        if (this._options.cachable && cached.has(cacheKey)) {
+            return cached.get(cacheKey);
+        }
+        let res = null;
         if (Array.isArray(modulePath)) {
-            return {
+            res = {
                 path: node_path_1.default.join(currentDirectory, ".array-require.js"),
                 content: `module.exports = (${modulePath
                     .map(arg => {
@@ -70,22 +76,25 @@ class BasicRunner {
                 subPath: ""
             };
         }
-        if (isRelativePath(modulePath)) {
+        else if (isRelativePath(modulePath)) {
             const p = node_path_1.default.join(currentDirectory, modulePath);
-            return {
+            res = {
                 path: p,
                 content: node_fs_1.default.readFileSync(p, "utf-8"),
                 subPath: getSubPath(modulePath)
             };
         }
-        if (node_path_1.default.isAbsolute(modulePath)) {
-            return {
+        else if (node_path_1.default.isAbsolute(modulePath)) {
+            res = {
                 path: modulePath,
                 content: node_fs_1.default.readFileSync(modulePath, "utf-8"),
                 subPath: "absolute_path"
             };
         }
-        return null;
+        if (this._options.cachable && res) {
+            cached.set(cacheKey, res);
+        }
+        return res;
     }
     preExecute(code, file) { }
     postExecute(m, file) { }

package/dist/runner/runner/cjs.js

@@ -36,9 +36,6 @@ class CommonJsRunner extends basic_1.BasicRunner {
             },
             ...this._options.env
         };
-        if (this._options.stats) {
-            baseModuleScope.__STATS__ = this._options.stats;
-        }
         return baseModuleScope;
     }
     createModuleScope(requireFn, m, file) {
@@ -90,11 +87,14 @@ class CommonJsRunner extends basic_1.BasicRunner {
             requireCache[file.path] = m;
             const currentModuleScope = this.createModuleScope(this.getRequire(), m, file);
             if (this._options.testConfig.moduleScope) {
-                this._options.testConfig.moduleScope(currentModuleScope, this._options.stats);
+                this._options.testConfig.moduleScope(currentModuleScope);
             }
             if (!this._options.runInNewContext) {
                 file.content = `Object.assign(global, _globalAssign);\n ${file.content}`;
             }
+            if (file.content.includes("__STATS__") && this._options.stats) {
+                currentModuleScope.__STATS__ = this._options.stats();
+            }
             const args = Object.keys(currentModuleScope);
             const argValues = args.map(arg => currentModuleScope[arg]);
             const code = `(function(${args.join(", ")}) {

package/dist/runner/runner/watch.js

@@ -17,7 +17,7 @@ class WatchRunner extends fake_1.FakeDocumentWebRunner {
         moduleScope.document = this.globalContext.document;
         moduleScope.STATE = this._watchOptions.state;
         moduleScope.WATCH_STEP = this._watchOptions.stepName;
-        moduleScope.STATS_JSON = this._options.stats;
+        moduleScope.__STATS__ = this._options.stats;
         return moduleScope;
     }
     run(file) {

package/dist/runner/runner/web/jsdom.js

@@ -133,7 +133,6 @@ class JSDOMWebRunner extends cjs_1.CommonJsRunner {
                 }
             };
         };
-        moduleScope.STATS = moduleScope.__STATS__;
         return moduleScope;
     }
     createJSDOMRequirer() {

package/dist/runner/watch.d.ts

@@ -2,5 +2,6 @@ import type { ECompilerType, ITestEnv, ITestRunner, TCompilerOptions, TCompilerS
 import { BasicRunnerFactory } from "./basic";
 export declare class WatchRunnerFactory<T extends ECompilerType> extends BasicRunnerFactory<T> {
     protected getRunnerKey(file: string): string;
-    protected createRunner(file: string, stats: TCompilerStatsCompilation<T>, compilerOptions: TCompilerOptions<T>, env: ITestEnv): ITestRunner;
+    protected createStatsGetter(): () => TCompilerStatsCompilation<T>;
+    protected createRunner(file: string, stats: () => TCompilerStatsCompilation<T>, compilerOptions: TCompilerOptions<T>, env: ITestEnv): ITestRunner;
 }

package/dist/runner/watch.js

@@ -8,6 +8,23 @@ class WatchRunnerFactory extends basic_1.BasicRunnerFactory {
         const stepName = this.context.getValue(this.name, "watchStepName");
         return `${this.name}-${stepName}`;
     }
+    createStatsGetter() {
+        const compiler = this.context.getCompiler(this.name);
+        const stepName = this.context.getValue(this.name, "watchStepName");
+        const statsGetter = (() => {
+            const cached = {};
+            return () => {
+                if (cached[stepName]) {
+                    return cached[stepName];
+                }
+                cached[stepName] = compiler.getStats().toJson({
+                    errorDetails: true
+                });
+                return cached[stepName];
+            };
+        })();
+        return statsGetter;
+    }
     createRunner(file, stats, compilerOptions, env) {
         this.context.getCompiler(this.name);
         const stepName = this.context.getValue(this.name, "watchStepName");
@@ -32,6 +49,7 @@ class WatchRunnerFactory extends basic_1.BasicRunnerFactory {
             stepName,
             runInNewContext: isWeb,
             isWeb,
+            cachable: false,
             testConfig: this.context.getTestConfig(),
             source: this.context.getSource(),
             dist: this.context.getDist(),

package/dist/type.d.ts

@@ -141,7 +141,7 @@ export type TTestConfig<T extends ECompilerType> = {
     beforeExecute?: () => void;
     afterExecute?: () => void;
     moduleScope?: (ms: IBasicModuleScope, stats?: TCompilerStatsCompilation<T>) => IBasicModuleScope;
-    checkStats?: (stepName: string, stats: TCompilerStatsCompilation<T>) => boolean;
+    checkStats?: (stepName: string, jsonStats: TCompilerStatsCompilation<T>, stringStats: String) => boolean;
     findBundle?: (index: number, options: TCompilerOptions<T>, stepName?: string) => string | string[];
     bundlePath?: string[];
     nonEsmThis?: (p: string | string[]) => Object;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack/test-tools",
-  "version": "1.2.6",
+  "version": "1.2.7",
   "license": "MIT",
   "description": "Test tools for rspack",
   "main": "dist/index.js",
@@ -97,7 +97,7 @@
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
     "react-refresh": "^0.16.0",
-    "sass-embedded": "^1.85.0",
+    "sass-embedded": "^1.85.1",
     "sass-loader": "^16.0.5",
     "source-map": "^0.7.4",
     "source-map-loader": "^5.0.0",
@@ -106,9 +106,9 @@
     "typescript": "^5.7.3",
     "wast-loader": "^1.14.1",
     "worker-rspack-loader": "^3.1.2",
-    "@rspack/cli": "1.2.6",
-    "@rspack/test-tools": "1.2.6",
-    "@rspack/core": "1.2.6"
+    "@rspack/cli": "1.2.7",
+    "@rspack/core": "1.2.7",
+    "@rspack/test-tools": "1.2.7"
   },
   "peerDependencies": {
     "@rspack/core": ">=1.0.0"