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

package/dist/case/builtin.d.ts

@@ -1,3 +1,3 @@
-import { ECompilerType, type ITestContext, type TCompilerOptions } from "../type";
-export declare function defaultOptions<T extends ECompilerType.Rspack>(context: ITestContext): TCompilerOptions<T>;
+import type { ECompilerType, ITestContext, TCompilerOptions } from "../type";
 export declare function createBuiltinCase(name: string, src: string, dist: string): void;
+export declare function defaultOptions<T extends ECompilerType.Rspack>(context: ITestContext): TCompilerOptions<T>;

package/dist/case/builtin.js

@@ -3,16 +3,50 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultOptions = defaultOptions;
 exports.createBuiltinCase = createBuiltinCase;
+exports.defaultOptions = defaultOptions;
 const node_path_1 = __importDefault(require("node:path"));
 const core_1 = require("@rspack/core");
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const webpack_merge_1 = require("webpack-merge");
 const helper_1 = require("../helper");
-const processor_1 = require("../processor");
 const creator_1 = require("../test/creator");
-const type_1 = require("../type");
+const common_1 = require("./common");
+const creator = new creator_1.BasicCaseCreator({
+    clean: true,
+    describe: false,
+    description(name) {
+        return `${name} should match snapshot`;
+    },
+    steps: ({ name, src }) => {
+        const cat = node_path_1.default.basename(node_path_1.default.dirname(src));
+        const filter = FILTERS[cat];
+        return [
+            {
+                config: async (context) => {
+                    const compiler = (0, common_1.getCompiler)(context, name);
+                    compiler.setOptions(defaultOptions(context));
+                },
+                compiler: async (context) => {
+                    await (0, common_1.compiler)(context, name);
+                },
+                build: async (context) => {
+                    await (0, common_1.build)(context, name);
+                },
+                run: async (env, context) => {
+                    // no need to run, just check snapshot
+                },
+                check: async (env, context) => {
+                    await (0, common_1.checkSnapshot)(env, context, name, "output.snap.txt", filter);
+                }
+            }
+        ];
+    },
+    concurrent: true
+});
+function createBuiltinCase(name, src, dist) {
+    creator.create(name, src, dist);
+}
 function defaultOptions(context) {
     let defaultOptions = {
         entry: {
@@ -163,28 +197,3 @@ const FILTERS = {
     "plugin-css-modules": (file) => file.endsWith(".css") || ((0, helper_1.isJavaScript)(file) && !file.includes("runtime")),
     "plugin-html": (file) => file.endsWith(".html")
 };
-const creator = new creator_1.BasicCaseCreator({
-    clean: true,
-    describe: false,
-    description(name) {
-        return `${name} should match snapshot`;
-    },
-    steps: ({ name, src }) => {
-        const cat = node_path_1.default.basename(node_path_1.default.dirname(src));
-        const filter = FILTERS[cat];
-        return [
-            new processor_1.SnapshotProcessor({
-                name,
-                snapshot: "output.snap.txt",
-                snapshotFileFilter: filter,
-                compilerType: type_1.ECompilerType.Rspack,
-                defaultOptions,
-                runable: false
-            })
-        ];
-    },
-    concurrent: true
-});
-function createBuiltinCase(name, src, dist) {
-    creator.create(name, src, dist);
-}

package/dist/case/cache.d.ts

@@ -1,2 +1,2 @@
-import { ECompilerType, type TCompilerOptions } from "../type";
+import { type ECompilerType, type TCompilerOptions } from "../type";
 export declare function createCacheCase(name: string, src: string, dist: string, target: TCompilerOptions<ECompilerType.Rspack>["target"], temp: string): void;

package/dist/case/cache.js

@@ -8,10 +8,70 @@ const node_path_1 = __importDefault(require("node:path"));
 const core_1 = __importDefault(require("@rspack/core"));
 const helper_1 = require("../helper");
 const hot_update_1 = require("../helper/hot-update");
-const processor_1 = require("../processor");
+const checkArrayExpectation_1 = __importDefault(require("../helper/legacy/checkArrayExpectation"));
 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 MAX_COMPILER_INDEX = 100;
+function createCacheProcessor(name, src, temp, target) {
+    const updatePlugin = new hot_update_1.HotUpdatePlugin(src, temp);
+    return {
+        before: async (context) => {
+            await updatePlugin.initialize();
+            context.setValue(name, "hotUpdateContext", updatePlugin);
+        },
+        config: async (context) => {
+            const compiler = (0, common_1.getCompiler)(context, name);
+            let options = defaultOptions(context, temp, target);
+            options = await (0, common_1.config)(context, name, ["rspack.config.js", "webpack.config.js"].map(i => node_path_1.default.resolve(temp, i)), options);
+            overrideOptions(options, temp, target, updatePlugin);
+            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(name, target, context));
+        },
+        check: async (env, context) => {
+            await (0, common_1.check)(env, context, name);
+        },
+        afterAll: async (context) => {
+            const updateIndex = updatePlugin.getUpdateIndex();
+            const totalUpdates = updatePlugin.getTotalUpdates();
+            if (updateIndex + 1 !== totalUpdates) {
+                throw new Error(`Should run all hot steps (${updateIndex + 1} / ${totalUpdates}): ${name}`);
+            }
+        }
+    };
+}
+function getCreator(target) {
+    if (!creators.has(target)) {
+        creators.set(target, new creator_1.BasicCaseCreator({
+            clean: true,
+            describe: true,
+            target,
+            steps: ({ name, src, target, temp }) => [
+                createCacheProcessor(name, src, temp, target)
+            ],
+            runner: {
+                key: (context, name, file) => name,
+                runner: createRunner
+            },
+            concurrent: true
+        }));
+    }
+    return creators.get(target);
+}
+function createCacheCase(name, src, dist, target, temp) {
+    const creator = getCreator(target);
+    creator.create(name, src, dist, temp);
+}
 const creators = new Map();
 function defaultOptions(context, temp, target) {
     const options = {
@@ -70,7 +130,7 @@ function overrideOptions(options, temp, target, updatePlugin) {
 function findBundle(name, target, context) {
     const files = [];
     const prefiles = [];
-    const compiler = context.getCompiler(name);
+    const compiler = (0, common_1.getCompiler)(context, name);
     if (!compiler)
         throw new Error("Compiler should exists when find bundle");
     const stats = compiler.getStats();
@@ -93,48 +153,81 @@ function findBundle(name, target, context) {
     }
     return [...prefiles, ...files];
 }
-function createCacheProcessor(name, src, temp, target) {
-    const updatePlugin = new hot_update_1.HotUpdatePlugin(src, temp);
-    const processor = new processor_1.BasicProcessor({
-        name,
-        runable: true,
-        compilerType: type_1.ECompilerType.Rspack,
-        configFiles: ["rspack.config.js", "webpack.config.js"].map(i => node_path_1.default.resolve(temp, i)),
-        defaultOptions: context => defaultOptions(context, temp, target),
-        overrideOptions: (context, options) => overrideOptions(options, temp, target, updatePlugin),
-        findBundle: context => findBundle(name, target, context)
-    });
-    processor.before = async (context) => {
-        await updatePlugin.initialize();
-        context.setValue(name, "hotUpdateContext", updatePlugin);
+function createRunner(context, name, file, env) {
+    const compiler = context.getCompiler(name);
+    const options = compiler.getOptions();
+    let compilerIndex = 0;
+    const testConfig = context.getTestConfig();
+    const source = context.getSource();
+    const dist = context.getDist();
+    const updatePlugin = context.getValue(name, "hotUpdateContext");
+    const getWebRunner = () => {
+        return new runner_1.WebRunner({
+            dom: context.getValue(name, "documentType") || type_1.EDocumentType.JSDOM,
+            env,
+            stats: (0, runner_2.cachedStats)(context, name),
+            cachable: false,
+            name: name,
+            runInNewContext: false,
+            testConfig: {
+                ...testConfig,
+                moduleScope(ms, stats, options) {
+                    const moduleScope = typeof testConfig.moduleScope === "function"
+                        ? testConfig.moduleScope(ms, stats, options)
+                        : ms;
+                    moduleScope.COMPILER_INDEX = compilerIndex;
+                    moduleScope.NEXT_HMR = nextHmr;
+                    moduleScope.NEXT_START = nextStart;
+                    return moduleScope;
+                }
+            },
+            source,
+            dist,
+            compilerOptions: options
+        });
     };
-    const originalAfterAll = processor.afterAll;
-    processor.afterAll = async function (context) {
-        await originalAfterAll.call(this, context);
+    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 updateIndex = updatePlugin.getUpdateIndex();
-        const totalUpdates = updatePlugin.getTotalUpdates();
-        if (updateIndex + 1 !== totalUpdates) {
-            throw new Error(`Should run all hot steps (${updateIndex + 1} / ${totalUpdates}): ${this._options.name}`);
+        await (0, checkArrayExpectation_1.default)(source, jsonStats, "error", `errors${updateIndex}`, "Error", compilerOptions);
+        await (0, checkArrayExpectation_1.default)(source, jsonStats, "warning", `warnings${updateIndex}`, "Warning", compilerOptions);
+        const updatedModules = await m.hot.check(options || true);
+        if (!updatedModules) {
+            throw new Error("No update available");
         }
+        return jsonStats;
     };
-    return processor;
-}
-function getCreator(target) {
-    if (!creators.has(target)) {
-        creators.set(target, new creator_1.BasicCaseCreator({
-            clean: true,
-            describe: true,
-            target,
-            steps: ({ name, src, target, temp }) => [
-                createCacheProcessor(name, src, temp, target)
-            ],
-            runner: runner_1.CacheRunnerFactory,
-            concurrent: true
-        }));
-    }
-    return creators.get(target);
-}
-function createCacheCase(name, src, dist, target, temp) {
-    const creator = getCreator(target);
-    creator.create(name, src, dist, temp);
+    const nextStart = async () => {
+        await compiler.close();
+        compiler.createCompiler();
+        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 updateIndex = updatePlugin.getUpdateIndex();
+        await (0, checkArrayExpectation_1.default)(source, jsonStats, "error", `errors${updateIndex}`, "Error", compilerOptions);
+        await (0, checkArrayExpectation_1.default)(source, jsonStats, "warning", `warnings${updateIndex}`, "Warning", compilerOptions);
+        env.it(`NEXT_START run with compilerIndex==${compilerIndex + 1}`, async () => {
+            if (compilerIndex > MAX_COMPILER_INDEX) {
+                throw new Error("NEXT_START has been called more than the maximum times");
+            }
+            compilerIndex++;
+            return getWebRunner().run(file);
+        });
+        return jsonStats;
+    };
+    return getWebRunner();
 }

package/dist/case/common.d.ts

@@ -0,0 +1,10 @@
+import { ECompilerType, type ITestCompilerManager, type ITestContext, type ITestEnv, type TCompiler, type TCompilerOptions } from "../type";
+export declare function getCompiler<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string): ITestCompilerManager<T>;
+export declare function config<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string, configFiles: string[], defaultOptions?: TCompilerOptions<T>): Promise<TCompilerOptions<T>>;
+export declare function compiler<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string): Promise<TCompiler<T>>;
+export declare function build<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string): Promise<TCompiler<T>>;
+export declare function run<T extends ECompilerType = ECompilerType.Rspack>(env: ITestEnv, context: ITestContext, name: string, findBundle: (context: ITestContext, options: TCompilerOptions<T>) => string[] | string | void): Promise<void>;
+export declare function check<T extends ECompilerType = ECompilerType.Rspack>(env: ITestEnv, context: ITestContext, name: string): Promise<void>;
+export declare function checkSnapshot<T extends ECompilerType = ECompilerType.Rspack>(env: ITestEnv, context: ITestContext, name: string, snapshot: string, filter?: (file: string) => boolean): Promise<void>;
+export declare function findMultiCompilerBundle<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string, multiFindBundle: (index: number, context: ITestContext, options: TCompilerOptions<T>) => string[] | string | void): string[];
+export declare function configMultiCompiler<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string, configFiles: string[], defaultOptions: (index: number, context: ITestContext) => TCompilerOptions<T>, overrideOptions: (index: number, context: ITestContext, options: TCompilerOptions<T>) => void): void;

package/dist/case/common.js

@@ -0,0 +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.getCompiler = getCompiler;
+exports.config = config;
+exports.compiler = compiler;
+exports.build = build;
+exports.run = run;
+exports.check = check;
+exports.checkSnapshot = checkSnapshot;
+exports.findMultiCompilerBundle = findMultiCompilerBundle;
+exports.configMultiCompiler = configMultiCompiler;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const webpack_merge_1 = __importDefault(require("webpack-merge"));
+const helper_1 = require("../helper");
+const placeholder_1 = require("../helper/expect/placeholder");
+const checkArrayExpectation_1 = __importDefault(require("../helper/legacy/checkArrayExpectation"));
+const type_1 = require("../type");
+function getCompiler(context, name) {
+    return context.getCompiler(name, type_1.ECompilerType.Rspack);
+}
+async function config(context, name, configFiles, defaultOptions = {}) {
+    const compiler = getCompiler(context, name);
+    compiler.setOptions(defaultOptions);
+    if (Array.isArray(configFiles)) {
+        const fileOptions = (0, helper_1.readConfigFile)(configFiles.map(i => context.getSource(i)))[0];
+        compiler.mergeOptions(fileOptions);
+    }
+    return compiler.getOptions();
+}
+async function compiler(context, name) {
+    const compiler = getCompiler(context, name);
+    compiler.createCompiler();
+    return compiler.getCompiler();
+}
+async function build(context, name) {
+    const compiler = getCompiler(context, name);
+    await compiler.build();
+    return compiler.getCompiler();
+}
+async function run(env, context, name, findBundle) {
+    const testConfig = context.getTestConfig();
+    if (testConfig.noTests)
+        return;
+    if (testConfig.documentType) {
+        context.setValue(name, "documentType", testConfig.documentType);
+    }
+    const compiler = getCompiler(context, name);
+    if (typeof testConfig.beforeExecute === "function") {
+        testConfig.beforeExecute(compiler.getOptions());
+    }
+    let bundles;
+    if (testConfig.bundlePath) {
+        bundles = testConfig.bundlePath;
+    }
+    else if (typeof findBundle === "function") {
+        bundles = findBundle(context, compiler.getOptions());
+    }
+    else {
+        bundles = [];
+    }
+    if (typeof bundles === "string") {
+        bundles = [bundles];
+    }
+    if (!bundles || !bundles.length) {
+        return;
+    }
+    for (const bundle of bundles) {
+        if (!bundle) {
+            continue;
+        }
+        const runner = context.getRunner(name, bundle, env);
+        const mod = runner.run(bundle);
+        const result = context.getValue(name, "modules") || [];
+        result.push(mod);
+        context.setValue(name, "modules", result);
+    }
+    const results = context.getValue(name, "modules") || [];
+    await Promise.all(results);
+    if (typeof testConfig.afterExecute === "function") {
+        testConfig.afterExecute(compiler.getOptions());
+    }
+}
+async function check(env, context, name) {
+    const testConfig = context.getTestConfig();
+    if (testConfig.noTests)
+        return;
+    const compiler = getCompiler(context, name);
+    const errors = (context.getError(name) || []).map(e => ({
+        message: e.message,
+        stack: e.stack
+    }));
+    const warnings = [];
+    const stats = compiler.getStats();
+    const options = compiler.getOptions();
+    if (stats) {
+        if (testConfig.writeStatsOuptut) {
+            fs_extra_1.default.writeFileSync(path_1.default.join(context.getDist(), "stats.txt"), stats.toString({
+                preset: "verbose",
+                colors: false
+            }), "utf-8");
+        }
+        if (testConfig.writeStatsJson) {
+            const jsonStats = stats.toJson({
+                errorDetails: true
+            });
+            fs_extra_1.default.writeFileSync(path_1.default.join(context.getDist(), "stats.json"), JSON.stringify(jsonStats, null, 2), "utf-8");
+        }
+        if (fs_extra_1.default.existsSync(context.getSource("errors.js")) ||
+            fs_extra_1.default.existsSync(context.getSource("warnings.js")) ||
+            stats.hasErrors() ||
+            stats.hasWarnings()) {
+            const statsJson = stats.toJson({
+                errorDetails: true
+            });
+            if (statsJson.errors) {
+                errors.push(...statsJson.errors);
+            }
+            if (statsJson.warnings) {
+                warnings.push(...statsJson.warnings);
+            }
+        }
+    }
+    await (0, checkArrayExpectation_1.default)(context.getSource(), { errors }, "error", "errors", "Error", options);
+    await (0, checkArrayExpectation_1.default)(context.getSource(), { warnings }, "warning", "warnings", "Warning", options);
+    // clear error if checked
+    if (fs_extra_1.default.existsSync(context.getSource("errors.js"))) {
+        context.clearError(name);
+    }
+}
+async function checkSnapshot(env, context, name, snapshot, filter) {
+    if (path_1.default.extname(snapshot) === ".snap") {
+        throw new Error("Snapshot with `.snap` will be managed by jest, please use `.snap.txt` instead");
+    }
+    const compiler = getCompiler(context, name);
+    const stats = compiler.getStats();
+    const c = compiler.getCompiler();
+    if (!stats || !c)
+        return;
+    if (stats.hasErrors()) {
+        const errors = [];
+        if (stats.stats) {
+            for (const s of stats.stats) {
+                if (s.hasErrors()) {
+                    errors.push(...s.compilation.errors);
+                }
+            }
+        }
+        else {
+            const s = stats;
+            errors.push(...s.compilation.errors);
+        }
+        throw new Error(`Failed to compile in fixture ${name}, Errors: ${errors
+            ?.map(i => `${i.message}\n${i.stack}`)
+            .join("\n\n")}`);
+    }
+    const compilation = c._lastCompilation ||
+        c._lastCompilation;
+    const snapshotFileFilter = filter ||
+        ((file) => file.endsWith(".js") && !file.includes("runtime.js"));
+    const fileContents = Object.entries(compilation.assets)
+        .filter(([file]) => snapshotFileFilter(file))
+        .map(([file, source]) => {
+        const tag = path_1.default.extname(file).slice(1) || "txt";
+        let content = (0, placeholder_1.normalizePlaceholder)(source.source().toString());
+        const testConfig = context.getTestConfig();
+        if (testConfig.snapshotContent) {
+            content = testConfig.snapshotContent(content);
+        }
+        return `\`\`\`${tag} title=${file}\n${content}\n\`\`\``;
+    });
+    fileContents.sort();
+    const content = fileContents.join("\n\n");
+    const snapshotPath = path_1.default.isAbsolute(snapshot)
+        ? snapshot
+        : path_1.default.resolve(context.getSource(), `./__snapshots__/${snapshot}`);
+    env.expect(content).toMatchFileSnapshot(snapshotPath);
+}
+function findMultiCompilerBundle(context, name, multiFindBundle) {
+    if (typeof multiFindBundle !== "function") {
+        return [];
+    }
+    const multiCompilerOptions = (context.getValue(name, "multiCompilerOptions") || []);
+    const result = [];
+    const multiFileIndexMap = context.getValue(name, "multiFileIndexMap") || {};
+    for (const [index, compilerOptions] of multiCompilerOptions.entries()) {
+        const curBundles = multiFindBundle(index, context, compilerOptions);
+        const bundles = Array.isArray(curBundles)
+            ? curBundles
+            : curBundles
+                ? [curBundles]
+                : [];
+        for (const bundle of bundles) {
+            if (multiFileIndexMap[bundle]) {
+                multiFileIndexMap[bundle].push(index);
+            }
+            else {
+                multiFileIndexMap[bundle] = [index];
+            }
+        }
+        result.push(...bundles);
+    }
+    context.setValue(name, "multiFileIndexMap", multiFileIndexMap);
+    return result;
+}
+function configMultiCompiler(context, name, configFiles, defaultOptions, overrideOptions) {
+    const multiCompilerOptions = [];
+    const caseOptions = Array.isArray(configFiles)
+        ? (0, helper_1.readConfigFile)(configFiles.map(i => context.getSource(i)), configs => {
+            return configs.flatMap(c => {
+                if (typeof c === "function") {
+                    const options = {
+                        testPath: context.getDist(),
+                        env: undefined
+                    };
+                    return c(options.env, options);
+                }
+                return c;
+            });
+        })
+        : [{}];
+    for (const [index, options] of caseOptions.entries()) {
+        const compilerOptions = (0, webpack_merge_1.default)(typeof defaultOptions === "function"
+            ? defaultOptions(index, context)
+            : {}, options);
+        if (typeof overrideOptions === "function") {
+            overrideOptions(index, context, compilerOptions);
+        }
+        multiCompilerOptions.push(compilerOptions);
+    }
+    const compiler = getCompiler(context, name);
+    compiler.setOptions(multiCompilerOptions);
+    context.setValue(name, "multiCompilerOptions", multiCompilerOptions);
+}

package/dist/case/compiler.d.ts

@@ -1,9 +1,12 @@
-import { type ISimpleProcessorOptions } from "../processor";
-import { ECompilerType, type ITestContext, type TCompilation, type TCompiler, type TCompilerStatsCompilation } from "../type";
-export type TCompilerCaseConfig = Omit<ISimpleProcessorOptions<ECompilerType.Rspack>, "name" | "compilerType" | "check"> & {
+import type { ECompilerType, ITestContext, TCompilation, TCompiler, TCompilerOptions, TCompilerStats, TCompilerStatsCompilation } from "../type";
+export declare function createCompilerCase(name: string, src: string, dist: string, testConfig: string): void;
+export type TCompilerCaseConfig = {
     description: string;
     error?: boolean;
     skip?: boolean;
+    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?: ({ context, stats, files, compiler, compilation }: {
         context: ITestContext;
         stats?: TCompilerStatsCompilation<ECompilerType.Rspack>;
@@ -11,5 +14,5 @@ export type TCompilerCaseConfig = Omit<ISimpleProcessorOptions<ECompilerType.Rsp
         compiler: TCompiler<ECompilerType.Rspack>;
         compilation?: TCompilation<ECompilerType.Rspack>;
     }) => Promise<void>;
+    compilerCallback?: (error: Error | null, stats: TCompilerStats<ECompilerType.Rspack> | null) => void;
 };
-export declare function createCompilerCase(name: string, src: string, dist: string, testConfig: string): void;