@rspack-canary/test-tools 1.5.6-canary-e598f284-20250921173624 → 1.5.7-canary-a3406c0a-20250922173625

package/dist/case/hot-step.js

@@ -1,11 +1,310 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createHotStepCase = createHotStepCase;
-const hot_step_1 = require("../processor/hot-step");
+const node_path_1 = __importDefault(require("node:path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const helper_1 = require("../helper");
+const placeholder_1 = require("../helper/expect/placeholder");
 const runner_1 = require("../runner");
 const creator_1 = require("../test/creator");
-const type_1 = require("../type");
+const hot_1 = require("./hot");
+const NOOP_SET = new Set();
+const escapeLocalName = (str) => str.split(/[-<>:"/|?*.]/).join("_");
+const SELF_HANDLER = (file, options) => {
+    let res = [];
+    const hotUpdateGlobal = (_, modules) => {
+        res = Object.keys(modules);
+    };
+    const hotUpdateGlobalKey = escapeLocalName(`${options.output?.hotUpdateGlobal || "webpackHotUpdate"}${options.output?.uniqueName || ""}`);
+    global.self ??= {};
+    global.self[hotUpdateGlobalKey] = hotUpdateGlobal;
+    require(file);
+    delete global.self[hotUpdateGlobalKey];
+    if (!Object.keys(global.self).length) {
+        delete global.self;
+    }
+    return res;
+};
+const NODE_HANDLER = (file) => {
+    return Object.keys(require(file).modules) || [];
+};
+const GET_MODULE_HANDLER = {
+    web: SELF_HANDLER,
+    webworker: SELF_HANDLER,
+    "async-node": NODE_HANDLER,
+    node: NODE_HANDLER
+};
 const creators = new Map();
+function createHotStepProcessor(name, target) {
+    const processor = (0, hot_1.createHotProcessor)(name, target);
+    const entries = {};
+    const hashes = [];
+    function matchStepSnapshot(env, context, step, options, stats, runtime) {
+        const getModuleHandler = GET_MODULE_HANDLER[options.target];
+        env.expect(typeof getModuleHandler).toBe("function");
+        const lastHash = hashes[hashes.length - 1];
+        const snapshotPath = context.getSource(`__snapshots__/${options.target}/${step}.snap.txt`);
+        const title = `Case ${node_path_1.default.basename(name)}: Step ${step}`;
+        const hotUpdateFile = [];
+        const hotUpdateManifest = [];
+        const changedFiles = step === 0
+            ? []
+            : processor.hotUpdateContext.changedFiles.map((i) => (0, helper_1.escapeSep)(node_path_1.default.relative(context.getSource(), i)));
+        changedFiles.sort();
+        const resultHashes = {
+            [lastHash || "LAST_HASH"]: "LAST_HASH",
+            [stats.hash]: "CURRENT_HASH"
+        };
+        // TODO: find a better way
+        // replace [runtime] to [runtime of id] to prevent worker hash
+        const runtimes = {};
+        for (const [id, runtime] of Object.entries(entries)) {
+            if (typeof runtime === "string") {
+                if (runtime !== id) {
+                    runtimes[runtime] = `[runtime of ${id}]`;
+                }
+            }
+            else if (Array.isArray(runtime)) {
+                for (const r of runtime) {
+                    if (r !== id) {
+                        runtimes[r] = `[runtime of ${id}]`;
+                    }
+                }
+            }
+        }
+        const replaceContent = (rawStr) => {
+            let str = rawStr;
+            const replaceContentConfig = context.getTestConfig().snapshotContent;
+            if (replaceContentConfig) {
+                str = replaceContentConfig(str);
+            }
+            return (0, placeholder_1.normalizePlaceholder)(Object.entries(resultHashes)
+                .reduce((str, [raw, replacement]) => {
+                return str.split(raw).join(replacement);
+            }, str)
+                .replace(/\/\/ (\d+)\s+(?=var cssReload)/, "")
+                .replaceAll(/var data = "(?:.*)"/g, match => {
+                return decodeURIComponent(match).replaceAll(/\\/g, "/");
+            }));
+        };
+        const replaceFileName = (str) => {
+            return Object.entries({
+                ...resultHashes,
+                ...runtimes
+            }).reduce((str, [raw, replacement]) => {
+                return str.split(raw).join(replacement);
+            }, str);
+        };
+        const fileList = stats
+            .assets.map(i => {
+            const fileName = i.name;
+            const renderName = replaceFileName(fileName);
+            const content = replaceContent(fs_extra_1.default.readFileSync(context.getDist(fileName), "utf-8"));
+            if (fileName.endsWith("hot-update.js")) {
+                const modules = getModuleHandler(context.getDist(fileName), options);
+                const runtime = [];
+                for (const i of content.matchAll(/\/\/ (webpack\/runtime\/[\w_-]+)\s*\n/g)) {
+                    runtime.push(i[1]);
+                }
+                modules.sort();
+                runtime.sort();
+                hotUpdateFile.push({
+                    name: renderName,
+                    content,
+                    modules,
+                    runtime
+                });
+                return `- Update: ${renderName}, size: ${content.length}`;
+            }
+            if (fileName.endsWith("hot-update.json")) {
+                const manifest = JSON.parse(content);
+                manifest.c?.sort();
+                manifest.r?.sort();
+                manifest.m?.sort();
+                hotUpdateManifest.push({
+                    name: renderName,
+                    content: JSON.stringify(manifest)
+                });
+                return `- Manifest: ${renderName}, size: ${i.size}`;
+            }
+            if (fileName.endsWith(".js")) {
+                return `- Bundle: ${renderName}`;
+            }
+        })
+            .filter(Boolean);
+        fileList.sort();
+        hotUpdateManifest.sort((a, b) => (a.name > b.name ? 1 : -1));
+        hotUpdateFile.sort((a, b) => (a.name > b.name ? 1 : -1));
+        if (runtime?.javascript) {
+            runtime.javascript.outdatedModules.sort();
+            runtime.javascript.updatedModules.sort();
+            runtime.javascript.updatedRuntime.sort();
+            runtime.javascript.acceptedModules.sort();
+            runtime.javascript.disposedModules.sort();
+            for (const value of Object.values(runtime.javascript.outdatedDependencies)) {
+                value.sort();
+            }
+        }
+        const content = `
+# ${title}
+
+## Changed Files
+${changedFiles.map(i => `- ${i}`).join("\n")}
+
+## Asset Files
+${fileList.join("\n")}
+
+## Manifest
+${hotUpdateManifest
+            .map(i => `
+### ${i.name}
+
+\`\`\`json
+${i.content}
+\`\`\`
+`)
+            .join("\n\n")}
+
+## Update
+
+${hotUpdateFile
+            .map(i => `
+### ${i.name}
+
+#### Changed Modules
+${i.modules.map(i => `- ${i}`).join("\n")}
+
+#### Changed Runtime Modules
+${i.runtime.map(i => `- ${i}`).join("\n")}
+
+#### Changed Content
+\`\`\`js
+${i.content}
+\`\`\`
+`)
+            .join("\n\n")}
+
+
+${runtime
+            ? `
+## Runtime
+### Status
+
+\`\`\`txt
+${runtime.statusPath.join(" => ")}
+\`\`\`
+
+${runtime.javascript
+                ? `
+
+### JavaScript
+
+#### Outdated
+
+Outdated Modules:
+${runtime.javascript.outdatedModules.map(i => `- ${i}`).join("\n")}
+
+
+Outdated Dependencies:
+\`\`\`json
+${JSON.stringify(runtime.javascript.outdatedDependencies || {}, null, 2)}
+\`\`\`
+
+#### Updated
+
+Updated Modules:
+${runtime.javascript.updatedModules.map(i => `- ${i}`).join("\n")}
+
+Updated Runtime:
+${runtime.javascript.updatedRuntime.map(i => `- \`${i}\``).join("\n")}
+
+
+#### Callback
+
+Accepted Callback:
+${runtime.javascript.acceptedModules.map(i => `- ${i}`).join("\n")}
+
+Disposed Callback:
+${runtime.javascript.disposedModules.map(i => `- ${i}`).join("\n")}
+`
+                : ""}
+
+`
+            : ""}
+
+				`
+            .replaceAll(/%3A(\d+)%2F/g, (match, capture) => {
+            return match.replace(capture, "PORT");
+        })
+            .trim();
+        env.expect(content).toMatchFileSnapshot(snapshotPath);
+    }
+    const originRun = processor.run;
+    processor.run = async function (env, context) {
+        context.setValue(name, "hotUpdateStepChecker", (hotUpdateContext, stats, runtime) => {
+            const statsJson = stats.toJson({
+                assets: true,
+                chunks: true
+            });
+            const chunks = Array.from(
+            // Some chunk fields are missing from rspack
+            stats?.compilation.chunks || NOOP_SET);
+            for (const entry of chunks.filter(i => i.hasRuntime())) {
+                if (!entries[entry.id] && entry.runtime) {
+                    entries[entry.id] =
+                        // Webpack uses `string | SortableSet<string>` for `entry.runtime`
+                        typeof entry.runtime === "string"
+                            ? [entry.runtime]
+                            : Array.from(entry.runtime);
+                }
+            }
+            const compiler = this.getCompiler(context);
+            const compilerOptions = compiler.getOptions();
+            matchStepSnapshot(env, context, hotUpdateContext.updateIndex, compilerOptions, statsJson, runtime);
+            hashes.push(stats.hash);
+        });
+        context.setValue(name, "hotUpdateStepErrorChecker", (_, stats, runtime) => {
+            hashes.push(stats.hash);
+        });
+        await originRun.call(this, env, context);
+    };
+    processor.check = async function (env, context) {
+        const compiler = this.getCompiler(context);
+        const stats = compiler.getStats();
+        if (!stats || !stats.hash) {
+            env.expect(false);
+            return;
+        }
+        const statsJson = stats.toJson({ assets: true, chunks: true });
+        const chunks = Array.from(
+        // Some chunk fields are missing from rspack
+        stats?.compilation.chunks || NOOP_SET);
+        for (const entry of chunks.filter(i => i.hasRuntime())) {
+            if (entry.runtime) {
+                entries[entry.id] =
+                    // Webpack uses `string | SortableSet<string>` for `entry.runtime`
+                    typeof entry.runtime === "string"
+                        ? [entry.runtime]
+                        : Array.from(entry.runtime);
+            }
+        }
+        let matchFailed = null;
+        try {
+            matchStepSnapshot(env, context, 0, compiler.getOptions(), statsJson);
+        }
+        catch (e) {
+            matchFailed = e;
+        }
+        hashes.push(stats.hash);
+        if (matchFailed) {
+            throw matchFailed;
+        }
+    };
+    return processor;
+}
 function getCreator(target) {
     if (!creators.has(target)) {
         creators.set(target, new creator_1.BasicCaseCreator({
@@ -13,12 +312,7 @@ function getCreator(target) {
             describe: false,
             target,
             steps: ({ name, target }) => [
-                new hot_step_1.HotSnapshotProcessor({
-                    name,
-                    target: target,
-                    compilerType: type_1.ECompilerType.Rspack,
-                    configFiles: ["rspack.config.js", "webpack.config.js"]
-                })
+                createHotStepProcessor(name, target)
             ],
             runner: runner_1.HotRunnerFactory,
             concurrent: true

package/dist/case/hot.d.ts

@@ -1,2 +1,9 @@
-import { ECompilerType, type TCompilerOptions } from "../type";
+import { BasicProcessor } from "../processor";
+import { ECompilerType, type TCompilerOptions, type THotUpdateContext } from "../type";
+type TTarget = TCompilerOptions<ECompilerType.Rspack>["target"];
+type THotProcessor = BasicProcessor<ECompilerType.Rspack> & {
+    hotUpdateContext: THotUpdateContext;
+};
+export declare function createHotProcessor(name: string, target: TTarget, incremental?: boolean): THotProcessor;
 export declare function createHotCase(name: string, src: string, dist: string, target: TCompilerOptions<ECompilerType.Rspack>["target"]): void;
+export {};

package/dist/case/hot.js

@@ -1,11 +1,156 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHotProcessor = createHotProcessor;
 exports.createHotCase = createHotCase;
-const hot_1 = require("../processor/hot");
+const node_path_1 = __importDefault(require("node:path"));
+const core_1 = __importDefault(require("@rspack/core"));
+const helper_1 = require("../helper");
+const plugins_1 = require("../helper/plugins");
+const plugin_1 = require("../plugin");
+const processor_1 = require("../processor");
 const runner_1 = require("../runner");
 const creator_1 = require("../test/creator");
 const type_1 = require("../type");
 const creators = new Map();
+function defaultOptions(context, target, updateOptions) {
+    const options = {
+        context: context.getSource(),
+        mode: "development",
+        devtool: false,
+        output: {
+            path: context.getDist(),
+            filename: "bundle.js",
+            chunkFilename: "[name].chunk.[fullhash].js",
+            publicPath: "https://test.cases/path/",
+            library: { type: "commonjs2" }
+        },
+        optimization: {
+            moduleIds: "named"
+        },
+        target,
+        experiments: {
+            css: true,
+            // test incremental: "safe" here, we test default incremental in Incremental-*.test.js
+            incremental: "safe",
+            rspackFuture: {
+                bundlerInfo: {
+                    force: false
+                }
+            },
+            inlineConst: true,
+            lazyBarrel: true
+        }
+    };
+    options.plugins ??= [];
+    options.plugins.push(new core_1.default.HotModuleReplacementPlugin(), new plugins_1.TestHotUpdatePlugin(updateOptions));
+    return options;
+}
+function overrideOptions(context, options, target, updateOptions) {
+    if (!options.entry) {
+        options.entry = "./index.js";
+    }
+    options.module ??= {};
+    for (const cssModuleType of ["css/auto", "css/module", "css"]) {
+        options.module.generator ??= {};
+        options.module.generator[cssModuleType] ??= {};
+        options.module.generator[cssModuleType].exportsOnly ??=
+            target === "async-node";
+    }
+    options.module.rules ??= [];
+    options.module.rules.push({
+        use: [
+            {
+                loader: node_path_1.default.resolve(__dirname, "../helper/loaders/hot-update.js"),
+                options: updateOptions
+            }
+        ],
+        enforce: "pre"
+    });
+    options.plugins ??= [];
+    options.plugins.push(new core_1.default.LoaderOptionsPlugin(updateOptions));
+    if (!global.printLogger) {
+        options.infrastructureLogging = {
+            level: "error"
+        };
+    }
+    if (options.lazyCompilation) {
+        options.plugins.push(new plugin_1.LazyCompilationTestPlugin());
+    }
+}
+function findBundle(context, name, target, updateOptions) {
+    const compiler = context.getCompiler(name);
+    if (!compiler)
+        throw new Error("Compiler should exists when find bundle");
+    const testConfig = context.getTestConfig();
+    if (typeof testConfig.findBundle === "function") {
+        return testConfig.findBundle(updateOptions.updateIndex, compiler.getOptions());
+    }
+    const files = [];
+    const prefiles = [];
+    const stats = compiler.getStats();
+    if (!stats)
+        throw new Error("Stats should exists when find bundle");
+    const info = stats.toJson({ all: false, entrypoints: true });
+    if (target === "web" || target === "webworker") {
+        for (const file of info.entrypoints.main.assets) {
+            if ((0, helper_1.isJavaScript)(file.name)) {
+                files.push(file.name);
+            }
+            else {
+                prefiles.push(file.name);
+            }
+        }
+    }
+    else {
+        const assets = info.entrypoints.main.assets.filter(s => (0, helper_1.isJavaScript)(s.name));
+        files.push(assets[assets.length - 1].name);
+    }
+    return [...prefiles, ...files];
+}
+function createHotProcessor(name, target, incremental = false) {
+    const hotUpdateContext = {
+        updateIndex: 0,
+        totalUpdates: 1,
+        changedFiles: []
+    };
+    const processor = new processor_1.BasicProcessor({
+        name,
+        compilerType: type_1.ECompilerType.Rspack,
+        runable: true,
+        configFiles: ["rspack.config.js", "webpack.config.js"],
+        defaultOptions(context) {
+            return defaultOptions(context, target, hotUpdateContext);
+        },
+        overrideOptions(context, options) {
+            overrideOptions(context, options, target, hotUpdateContext);
+            if (incremental) {
+                options.experiments ??= {};
+                options.experiments.incremental ??= "advance-silent";
+            }
+        },
+        findBundle(context, options) {
+            return findBundle(context, name, target, hotUpdateContext);
+        },
+        async compiler(context, compiler) {
+            context.setValue(name, "hotUpdateContext", hotUpdateContext);
+        }
+    });
+    processor.hotUpdateContext = hotUpdateContext;
+    const originalAfterAll = processor.afterAll;
+    processor.afterAll = async function (context) {
+        await originalAfterAll.call(this, context);
+        if (context.getTestConfig().checkSteps === false) {
+            return;
+        }
+        if (hotUpdateContext.updateIndex + 1 !== hotUpdateContext.totalUpdates) {
+            throw new Error(`Should run all hot steps (${hotUpdateContext.updateIndex + 1} / ${hotUpdateContext.totalUpdates}): ${name}`);
+        }
+    };
+    return processor;
+}
 function getCreator(target) {
     if (!creators.has(target)) {
         creators.set(target, new creator_1.BasicCaseCreator({
@@ -13,12 +158,7 @@ function getCreator(target) {
             describe: true,
             target,
             steps: ({ name, target }) => [
-                new hot_1.HotProcessor({
-                    name,
-                    target: target,
-                    compilerType: type_1.ECompilerType.Rspack,
-                    configFiles: ["rspack.config.js", "webpack.config.js"]
-                })
+                createHotProcessor(name, target)
             ],
             runner: runner_1.HotRunnerFactory,
             concurrent: true

package/dist/case/incremental.js

@@ -7,12 +7,31 @@ exports.createHotIncrementalCase = createHotIncrementalCase;
 exports.createWatchIncrementalCase = createWatchIncrementalCase;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const hot_incremental_1 = require("../processor/hot-incremental");
 const watch_1 = require("../processor/watch");
 const runner_1 = require("../runner");
 const creator_1 = require("../test/creator");
 const type_1 = require("../type");
+const hot_1 = require("./hot");
 const hotCreators = new Map();
+function createHotIncrementalProcessor(name, target, webpackCases) {
+    const processor = (0, hot_1.createHotProcessor)(name, target, true);
+    processor.before = async (context) => {
+        context.setValue(name, "documentType", webpackCases ? type_1.EDocumentType.Fake : type_1.EDocumentType.JSDOM);
+    };
+    const originalAfterAll = processor.afterAll;
+    processor.afterAll = async function (context) {
+        try {
+            await originalAfterAll.call(this, context);
+        }
+        catch (e) {
+            const isFake = context.getValue(name, "documentType") === type_1.EDocumentType.Fake;
+            if (isFake && /Should run all hot steps/.test(e.message))
+                return;
+            throw e;
+        }
+    };
+    return processor;
+}
 function getHotCreator(target, webpackCases) {
     const key = JSON.stringify({ target, webpackCases });
     if (!hotCreators.has(key)) {
@@ -21,13 +40,7 @@ function getHotCreator(target, webpackCases) {
             describe: true,
             target,
             steps: ({ name, target }) => [
-                new hot_incremental_1.HotIncrementalProcessor({
-                    name,
-                    target: target,
-                    compilerType: type_1.ECompilerType.Rspack,
-                    configFiles: ["rspack.config.js", "webpack.config.js"],
-                    webpackCases
-                })
+                createHotIncrementalProcessor(name, target, webpackCases)
             ],
             runner: runner_1.HotRunnerFactory,
             concurrent: true

package/dist/case/index.d.ts

@@ -1,20 +1,20 @@
-export * from "./builtin";
-export * from "./cache";
-export * from "./compiler";
-export * from "./config";
-export * from "./defaults";
-export * from "./diagnostic";
-export * from "./diff";
-export * from "./error";
-export * from "./hash";
-export * from "./hook";
-export * from "./hot";
-export * from "./hot-step";
-export * from "./incremental";
-export * from "./native-watcher";
-export * from "./normal";
-export * from "./serial";
-export * from "./stats-api";
-export * from "./stats-output";
-export * from "./treeshaking";
-export * from "./watch";
+export { createBuiltinCase } from "./builtin";
+export { createCacheCase } from "./cache";
+export { createCompilerCase } from "./compiler";
+export { createConfigCase } from "./config";
+export { createDefaultsCase, getRspackDefaultConfig } from "./defaults";
+export { createDiagnosticCase } from "./diagnostic";
+export { createDiffCase } from "./diff";
+export { createErrorCase } from "./error";
+export { createHashCase } from "./hash";
+export { createHookCase } from "./hook";
+export { createHotCase } from "./hot";
+export { createHotStepCase } from "./hot-step";
+export { createHotIncrementalCase, createWatchIncrementalCase } from "./incremental";
+export { createNativeWatcher } from "./native-watcher";
+export { createHotNormalCase, createNormalCase } from "./normal";
+export { createSerialCase } from "./serial";
+export { createStatsAPICase } from "./stats-api";
+export { createStatsOutputCase } from "./stats-output";
+export { createTreeShakingCase } from "./treeshaking";
+export { createWatchCase } from "./watch";