@rspack-debug/test-tools 1.4.11 → 1.6.4

package/dist/case/hot-step.js

@@ -1,32 +1,328 @@
 "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 runner_1 = require("../runner");
+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 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];
+    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, src, temp, target) {
+    const processor = (0, hot_1.createHotProcessor)(name, src, temp, 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.updatePlugin
+                .getModifiedFiles()
+                .map((i) => (0, helper_1.escapeSep)(node_path_1.default.relative(temp, 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 assets = stats.assets.sort((a, b) => a.name.localeCompare(b.name));
+        const fileList = 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).toMatchFileSnapshotSync(snapshotPath);
+    }
+    const originRun = processor.run;
+    processor.run = async function (env, context) {
+        context.setValue("hotUpdateStepChecker", (updateIndex, 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 = context.getCompiler();
+            const compilerOptions = compiler.getOptions();
+            matchStepSnapshot(env, context, updateIndex, compilerOptions, statsJson, runtime);
+            hashes.push(stats.hash);
+        });
+        context.setValue("hotUpdateStepErrorChecker", (updateIndex, stats, runtime) => {
+            hashes.push(stats.hash);
+        });
+        await originRun(env, context);
+    };
+    processor.check = async function (env, context) {
+        const compiler = context.getCompiler();
+        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({
             clean: true,
             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"]
-                })
+            steps: ({ name, target, src, temp, dist }) => [
+                createHotStepProcessor(name, src, temp || node_path_1.default.resolve(dist, "temp"), target)
             ],
-            runner: runner_1.HotStepRunnerFactory,
+            runner: {
+                key: (context, name, file) => name,
+                runner: hot_1.createHotRunner
+            },
             concurrent: true
         }));
     }
     return creators.get(target);
 }
-function createHotStepCase(name, src, dist, target) {
+function createHotStepCase(name, src, dist, temp, target) {
     const creator = getCreator(target);
-    creator.create(name, src, dist);
+    creator.create(name, src, dist, temp);
 }

package/dist/case/hot.d.ts

@@ -1,2 +1,11 @@
-import { ECompilerType, type TCompilerOptions } from "../type";
-export declare function createHotCase(name: string, src: string, dist: string, target: TCompilerOptions<ECompilerType.Rspack>["target"]): void;
+import { type RspackOptions } from "@rspack/core";
+import { HotUpdatePlugin } from "../helper/hot-update/plugin";
+import type { ITestContext, ITestEnv, ITestProcessor, ITestRunner } from "../type";
+type TTarget = RspackOptions["target"];
+export declare function createHotProcessor(name: string, src: string, temp: string, target: TTarget, incremental?: boolean): THotProcessor;
+export declare function createHotCase(name: string, src: string, dist: string, temp: string, target: RspackOptions["target"]): void;
+type THotProcessor = ITestProcessor & {
+    updatePlugin: HotUpdatePlugin;
+};
+export declare function createHotRunner(context: ITestContext, name: string, file: string, env: ITestEnv): ITestRunner;
+export {};

package/dist/case/hot.js

@@ -1,32 +1,237 @@
 "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");
+exports.createHotRunner = createHotRunner;
+const node_path_1 = __importDefault(require("node:path"));
+const core_1 = __importDefault(require("@rspack/core"));
+const helper_1 = require("../helper");
+const plugin_1 = require("../helper/hot-update/plugin");
+const checkArrayExpectation_1 = __importDefault(require("../helper/legacy/checkArrayExpectation"));
+const plugin_2 = require("../plugin");
 const runner_1 = require("../runner");
 const creator_1 = require("../test/creator");
-const type_1 = require("../type");
+const common_1 = require("./common");
+const runner_2 = require("./runner");
 const creators = new Map();
+function createHotProcessor(name, src, temp, target, incremental = false) {
+    const updatePlugin = new plugin_1.HotUpdatePlugin(src, temp);
+    const processor = {
+        before: async (context) => {
+            await updatePlugin.initialize();
+            context.setValue("hotUpdatePlugin", updatePlugin);
+        },
+        config: async (context) => {
+            const compiler = context.getCompiler();
+            let options = defaultOptions(context, target);
+            options = await (0, common_1.config)(context, name, ["rspack.config.js", "webpack.config.js"], options);
+            overrideOptions(context, options, target, updatePlugin);
+            if (incremental) {
+                options.experiments ??= {};
+                options.experiments.incremental ??= "advance-silent";
+            }
+            compiler.setOptions(options);
+        },
+        compiler: async (context) => {
+            await (0, common_1.compiler)(context, name);
+        },
+        build: async (context) => {
+            await (0, common_1.build)(context, name);
+        },
+        run: async (env, context) => {
+            await (0, common_1.run)(env, context, name, context => findBundle(context, name, target, updatePlugin));
+        },
+        check: async (env, context) => {
+            await (0, common_1.check)(env, context, name);
+        },
+        after: async (context) => {
+            await (0, common_1.afterExecute)(context, name);
+        },
+        afterAll: async (context) => {
+            if (context.getTestConfig().checkSteps === false) {
+                return;
+            }
+            const updateIndex = updatePlugin.getUpdateIndex();
+            const totalUpdates = updatePlugin.getTotalUpdates();
+            if (updateIndex + 1 !== totalUpdates) {
+                throw new Error(`Should run all hot steps (${updateIndex + 1} / ${totalUpdates}): ${name}`);
+            }
+        }
+    };
+    processor.updatePlugin = updatePlugin;
+    return processor;
+}
 function getCreator(target) {
     if (!creators.has(target)) {
         creators.set(target, new creator_1.BasicCaseCreator({
             clean: true,
             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"]
-                })
+            steps: ({ name, target, src, dist, temp }) => [
+                createHotProcessor(name, src, temp || node_path_1.default.resolve(dist, "temp"), target)
             ],
-            runner: runner_1.HotRunnerFactory,
+            runner: {
+                key: (context, name, file) => name,
+                runner: createHotRunner
+            },
             concurrent: true
         }));
     }
     return creators.get(target);
 }
-function createHotCase(name, src, dist, target) {
+function createHotCase(name, src, dist, temp, target) {
     const creator = getCreator(target);
-    creator.create(name, src, dist);
+    creator.create(name, src, dist, temp);
+}
+function defaultOptions(context, target) {
+    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
+        }
+    };
+    options.plugins ??= [];
+    options.plugins.push(new core_1.default.HotModuleReplacementPlugin());
+    return options;
+}
+function overrideOptions(context, options, target, updatePlugin) {
+    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.plugins ??= [];
+    options.plugins.push(updatePlugin);
+    if (!global.printLogger) {
+        options.infrastructureLogging = {
+            level: "error"
+        };
+    }
+    if (options.lazyCompilation) {
+        options.plugins.push(new plugin_2.LazyCompilationTestPlugin());
+    }
+}
+function findBundle(context, name, target, updatePlugin) {
+    const compiler = context.getCompiler();
+    if (!compiler)
+        throw new Error("Compiler should exists when find bundle");
+    const testConfig = context.getTestConfig();
+    if (typeof testConfig.findBundle === "function") {
+        return testConfig.findBundle(updatePlugin.getUpdateIndex(), 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 createHotRunner(context, name, file, env) {
+    const compiler = context.getCompiler();
+    const compilerOptions = compiler.getOptions();
+    const testConfig = context.getTestConfig();
+    const source = context.getSource();
+    const dist = context.getDist();
+    const updatePlugin = context.getValue("hotUpdatePlugin");
+    const nextHMR = async (m, options) => {
+        await updatePlugin.goNext();
+        const stats = await compiler.build();
+        if (!stats) {
+            throw new Error("Should generate stats during build");
+        }
+        const jsonStats = stats.toJson({
+        // errorDetails: true
+        });
+        const compilerOptions = compiler.getOptions();
+        const checker = context.getValue(jsonStats.errors?.length
+            ? "hotUpdateStepErrorChecker"
+            : "hotUpdateStepChecker");
+        if (checker) {
+            checker(updatePlugin.getUpdateIndex(), stats, runner.getGlobal("__HMR_UPDATED_RUNTIME__"));
+        }
+        await (0, checkArrayExpectation_1.default)(source, jsonStats, "error", `errors${updatePlugin.getUpdateIndex()}`, "Error", compilerOptions);
+        await (0, checkArrayExpectation_1.default)(source, jsonStats, "warning", `warnings${updatePlugin.getUpdateIndex()}`, "Warning", compilerOptions);
+        const updatedModules = await m.hot.check(options || true);
+        if (!updatedModules) {
+            throw new Error("No update available");
+        }
+        return jsonStats;
+    };
+    const commonOptions = {
+        env,
+        stats: (0, runner_2.cachedStats)(context, name),
+        name: name,
+        runInNewContext: false,
+        testConfig: {
+            ...testConfig,
+            moduleScope(ms, stats, options) {
+                const moduleScope = ms;
+                if (typeof testConfig.moduleScope === "function") {
+                    testConfig.moduleScope(moduleScope, stats, compilerOptions);
+                }
+                moduleScope.NEXT_HMR = nextHMR;
+                return moduleScope;
+            }
+        },
+        cachable: true,
+        source,
+        dist,
+        compilerOptions
+    };
+    let runner;
+    if (compilerOptions.target === "web" ||
+        compilerOptions.target === "webworker") {
+        runner = new runner_1.WebRunner({
+            location: testConfig.location || "https://test.cases/path/index.html",
+            ...commonOptions
+        });
+    }
+    else {
+        runner = new runner_1.NodeRunner(commonOptions);
+    }
+    return runner;
 }

package/dist/case/incremental.d.ts

@@ -1,5 +1,5 @@
-import { ECompilerType, type TCompilerOptions } from "../type";
-export declare function createHotIncrementalCase(name: string, src: string, dist: string, target: TCompilerOptions<ECompilerType.Rspack>["target"], webpackCases: boolean): void;
+import type { RspackOptions } from "@rspack/core";
+export declare function createHotIncrementalCase(name: string, src: string, dist: string, temp: string, target: RspackOptions["target"], webpackCases: boolean): void;
 export type WatchIncrementalOptions = {
     ignoreNotFriendlyForIncrementalWarnings?: boolean;
 };