@rspack-canary/test-tools 1.5.6-canary-7c0091e4-20250920173916 → 1.5.7-canary-a3406c0a-20250922173625

package/dist/case/builtin.d.ts

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

package/dist/case/builtin.js

@@ -3,12 +3,161 @@ 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;
 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");
+function defaultOptions(context) {
+    let defaultOptions = {
+        entry: {
+            main: {
+                import: "./index"
+            }
+        },
+        output: {
+            publicPath: "/",
+            path: context.getDist(),
+            filename: "[name].js",
+            chunkFilename: "[name].js",
+            chunkFormat: "array-push",
+            cssFilename: "[name].css",
+            cssChunkFilename: "[name].css",
+            assetModuleFilename: "[hash][ext][query]",
+            sourceMapFilename: "[file].map",
+            chunkLoadingGlobal: "webpackChunkwebpack",
+            chunkLoading: "jsonp",
+            uniqueName: "__rspack_test__",
+            enabledLibraryTypes: ["system"],
+            strictModuleErrorHandling: false,
+            iife: true,
+            module: false,
+            asyncChunks: true,
+            scriptType: false,
+            globalObject: "self",
+            importFunctionName: "import",
+            wasmLoading: "fetch",
+            webassemblyModuleFilename: "[hash].module.wasm",
+            workerChunkLoading: "import-scripts",
+            workerWasmLoading: "fetch"
+        },
+        module: {
+            rules: [
+                {
+                    test: /\.json$/,
+                    type: "json"
+                },
+                {
+                    test: /\.mjs$/,
+                    type: "javascript/esm"
+                },
+                {
+                    test: /\.cjs$/,
+                    type: "javascript/dynamic"
+                },
+                {
+                    test: /\.js$/,
+                    type: "javascript/auto"
+                },
+                {
+                    test: /\.css$/,
+                    type: "css"
+                },
+                {
+                    test: /\.wasm$/,
+                    type: "webassembly/async"
+                }
+            ]
+        },
+        node: {
+            __dirname: "mock",
+            __filename: "mock",
+            global: "warn"
+        },
+        optimization: {
+            runtimeChunk: {
+                name: "runtime"
+            },
+            minimize: false,
+            removeAvailableModules: true,
+            removeEmptyChunks: true,
+            moduleIds: "named",
+            chunkIds: "named",
+            sideEffects: false,
+            mangleExports: false,
+            usedExports: false,
+            concatenateModules: false,
+            nodeEnv: false
+        },
+        resolve: {
+            extensions: [
+                ".js",
+                ".jsx",
+                ".ts",
+                ".tsx",
+                ".json",
+                ".d.ts",
+                ".css",
+                ".wasm"
+            ]
+        },
+        resolveLoader: {
+            extensions: [".js"]
+        },
+        experiments: {
+            css: true,
+            futureDefaults: true,
+            rspackFuture: {
+                bundlerInfo: {
+                    force: false
+                }
+            }
+        },
+        devtool: false,
+        context: context.getSource(),
+        plugins: []
+    };
+    const testConfigFile = context.getSource("rspack.config.js");
+    if (fs_extra_1.default.existsSync(testConfigFile)) {
+        const caseOptions = require(testConfigFile);
+        if (caseOptions.entry) {
+            delete defaultOptions.entry;
+        }
+        defaultOptions = (0, webpack_merge_1.merge)(defaultOptions, caseOptions);
+    }
+    // TODO: remove builtin compatible code
+    const defineOptions = defaultOptions.builtins?.define;
+    if (defineOptions) {
+        defaultOptions.plugins.push(new core_1.rspack.DefinePlugin(defineOptions));
+    }
+    const provideOptions = defaultOptions.builtins?.provide;
+    if (provideOptions) {
+        defaultOptions.plugins.push(new core_1.rspack.ProvidePlugin(provideOptions));
+    }
+    const htmlOptions = defaultOptions.builtins?.html;
+    if (htmlOptions) {
+        if (Array.isArray(htmlOptions)) {
+            for (const item of htmlOptions) {
+                defaultOptions.plugins.push(new core_1.rspack.HtmlRspackPlugin(item));
+            }
+        }
+        else {
+            defaultOptions.plugins.push(new core_1.rspack.HtmlRspackPlugin(htmlOptions));
+        }
+    }
+    delete defaultOptions.builtins;
+    if (!global.printLogger) {
+        defaultOptions.infrastructureLogging = {
+            level: "error"
+        };
+    }
+    return defaultOptions;
+}
 const FILTERS = {
     "plugin-css": (file) => file.endsWith(".css"),
     "plugin-css-modules": (file) => file.endsWith(".css") || ((0, helper_1.isJavaScript)(file) && !file.includes("runtime")),
@@ -24,11 +173,13 @@ const creator = new creator_1.BasicCaseCreator({
         const cat = node_path_1.default.basename(node_path_1.default.dirname(src));
         const filter = FILTERS[cat];
         return [
-            new processor_1.BuiltinProcessor({
+            new processor_1.SnapshotProcessor({
                 name,
                 snapshot: "output.snap.txt",
                 snapshotFileFilter: filter,
-                compilerType: type_1.ECompilerType.Rspack
+                compilerType: type_1.ECompilerType.Rspack,
+                defaultOptions,
+                runable: false
             })
         ];
     },

package/dist/case/cache.js

@@ -1,11 +1,124 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCacheCase = createCacheCase;
-const cache_1 = require("../processor/cache");
+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 runner_1 = require("../runner");
 const creator_1 = require("../test/creator");
 const type_1 = require("../type");
 const creators = new Map();
+function defaultOptions(context, temp, target) {
+    const options = {
+        context: temp,
+        mode: "production",
+        cache: true,
+        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",
+            emitOnErrors: true
+        },
+        target,
+        experiments: {
+            css: true,
+            rspackFuture: {
+                bundlerInfo: {
+                    force: false
+                }
+            },
+            inlineConst: true,
+            lazyBarrel: true
+        }
+    };
+    options.plugins ??= [];
+    options.plugins.push(new core_1.default.HotModuleReplacementPlugin());
+    return options;
+}
+function overrideOptions(options, temp, target, updatePlugin) {
+    if (!options.entry) {
+        options.entry = "./index.js";
+    }
+    // rewrite context to temp dir
+    options.context = temp;
+    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"
+        };
+    }
+}
+function findBundle(name, target, context) {
+    const files = [];
+    const prefiles = [];
+    const compiler = context.getCompiler(name);
+    if (!compiler)
+        throw new Error("Compiler should exists when find bundle");
+    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 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);
+    };
+    const originalAfterAll = processor.afterAll;
+    processor.afterAll = async function (context) {
+        await originalAfterAll.call(this, context);
+        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}`);
+        }
+    };
+    return processor;
+}
 function getCreator(target) {
     if (!creators.has(target)) {
         creators.set(target, new creator_1.BasicCaseCreator({
@@ -13,14 +126,7 @@ function getCreator(target) {
             describe: true,
             target,
             steps: ({ name, src, target, temp }) => [
-                new cache_1.CacheProcessor({
-                    name,
-                    sourceDir: src,
-                    tempDir: temp,
-                    target: target,
-                    compilerType: type_1.ECompilerType.Rspack,
-                    configFiles: ["rspack.config.js", "webpack.config.js"]
-                })
+                createCacheProcessor(name, src, temp, target)
             ],
             runner: runner_1.CacheRunnerFactory,
             concurrent: true

package/dist/case/compiler.js

@@ -68,7 +68,7 @@ function createCompilerCase(name, src, dist, testConfig) {
                     compiler.hooks.compilation.tap("CompilerTest", compilation => (compilation.bail = true));
                     await caseConfig.compiler?.(context, compiler);
                 },
-                async check(context, compiler, stats) {
+                async check(env, context, compiler, stats) {
                     if (caseConfig.error) {
                         const statsJson = stats?.toJson({
                             modules: true,

package/dist/case/config.d.ts

@@ -1,3 +1,6 @@
-import { ECompilerType, type TTestConfig } from "../type";
+import { ECompilerType, type ITestContext, type TCompilerOptions, type TTestConfig } from "../type";
 export type TConfigCaseConfig = Omit<TTestConfig<ECompilerType.Rspack>, "validate">;
+export declare function defaultOptions(index: number, context: ITestContext): TCompilerOptions<ECompilerType.Rspack>;
+export declare function overrideOptions(index: number, context: ITestContext, options: TCompilerOptions<ECompilerType.Rspack>): void;
+export declare function findBundle(index: number, context: ITestContext, options: TCompilerOptions<ECompilerType.Rspack>): string | string[];
 export declare function createConfigCase(name: string, src: string, dist: string): void;

package/dist/case/config.js

@@ -1,10 +1,85 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultOptions = defaultOptions;
+exports.overrideOptions = overrideOptions;
+exports.findBundle = findBundle;
 exports.createConfigCase = createConfigCase;
-const config_1 = require("../processor/config");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const parseResource_1 = require("../helper/legacy/parseResource");
+const processor_1 = require("../processor");
 const runner_1 = require("../runner");
 const creator_1 = require("../test/creator");
 const type_1 = require("../type");
+function defaultOptions(index, context) {
+    return {
+        context: context.getSource(),
+        mode: "production",
+        target: "async-node",
+        devtool: false,
+        cache: false,
+        output: {
+            path: context.getDist()
+        },
+        optimization: {
+            minimize: false
+        },
+        experiments: {
+            css: true,
+            rspackFuture: {
+                bundlerInfo: {
+                    force: false
+                }
+            },
+            inlineConst: true,
+            lazyBarrel: true
+        }
+    };
+}
+function overrideOptions(index, context, options) {
+    if (!options.entry) {
+        options.entry = "./index.js";
+    }
+    if (options.amd === undefined) {
+        options.amd = {};
+    }
+    if (!options.output?.filename) {
+        const outputModule = options.experiments?.outputModule;
+        options.output ??= {};
+        options.output.filename = `bundle${index}${outputModule ? ".mjs" : ".js"}`;
+    }
+    if (options.cache === undefined)
+        options.cache = false;
+    if (!global.printLogger) {
+        options.infrastructureLogging = {
+            level: "error"
+        };
+    }
+}
+function findBundle(index, context, options) {
+    const testConfig = context.getTestConfig();
+    if (typeof testConfig.findBundle === "function") {
+        return testConfig.findBundle(index, options);
+    }
+    const ext = path_1.default.extname((0, parseResource_1.parseResource)(options.output?.filename).path);
+    const bundlePath = [];
+    if (options.output?.path &&
+        fs_extra_1.default.existsSync(path_1.default.join(options.output.path, `bundle${index}${ext}`))) {
+        if (options.experiments?.css) {
+            const cssOutputPath = path_1.default.join(options.output.path, (typeof options.output?.cssFilename === "string" &&
+                options.output?.cssFilename) ||
+                `bundle${index}.css`);
+            if (fs_extra_1.default.existsSync(cssOutputPath)) {
+                bundlePath.push(`./bundle${index}.css`);
+            }
+        }
+        bundlePath.push(`./bundle${index}${ext}`);
+    }
+    return bundlePath;
+}
 const creator = new creator_1.BasicCaseCreator({
     clean: true,
     describe: false,
@@ -20,10 +95,13 @@ const creator = new creator_1.BasicCaseCreator({
         };
     },
     steps: ({ name }) => [
-        new config_1.ConfigProcessor({
+        new processor_1.MultiTaskProcessor({
             name,
             runable: true,
             compilerType: type_1.ECompilerType.Rspack,
+            defaultOptions,
+            overrideOptions,
+            findBundle,
             configFiles: [
                 "rspack.config.cjs",
                 "rspack.config.js",

package/dist/case/defaults.d.ts

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

package/dist/case/defaults.js

@@ -3,17 +3,59 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRspackDefaultConfig = getRspackDefaultConfig;
 exports.createDefaultsCase = createDefaultsCase;
 const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const jest_diff_1 = require("jest-diff");
 const processor_1 = require("../processor");
 const context_1 = require("../test/context");
 const type_1 = require("../type");
+const CURRENT_CWD = process.cwd();
+function getRspackDefaultConfig(cwd, config) {
+    process.chdir(cwd);
+    const { applyWebpackOptionsDefaults, getNormalizedWebpackOptions } = require("@rspack/core").config;
+    const normalizedConfig = getNormalizedWebpackOptions(config);
+    applyWebpackOptionsDefaults(normalizedConfig);
+    // make snapshot stable
+    normalizedConfig.experiments.rspackFuture.bundlerInfo.version =
+        "$version$";
+    process.chdir(CURRENT_CWD);
+    return normalizedConfig;
+}
 const srcDir = node_path_1.default.resolve(__dirname, "../../tests/fixtures");
 const distDir = node_path_1.default.resolve(__dirname, "../../tests/js/defaults");
 const context = new context_1.TestContext({
     src: srcDir,
     dist: distDir
 });
+function options(context, custom) {
+    let res;
+    if (typeof custom === "function") {
+        res = custom(context);
+    }
+    else {
+        res = {};
+    }
+    if (!("mode" in res)) {
+        res.mode = "none";
+    }
+    return res;
+}
+class RspackTestDiff {
+    constructor(value) {
+        this.value = value;
+    }
+}
+async function check(env, context, options) {
+    const compiler = this.getCompiler(context);
+    const config = getRspackDefaultConfig(options.cwd || CURRENT_CWD, compiler.getOptions());
+    const defaultConfig = getRspackDefaultConfig(options.cwd || CURRENT_CWD, {
+        mode: "none"
+    });
+    const diff = (0, node_util_1.stripVTControlCharacters)((0, jest_diff_1.diff)(defaultConfig, config, { expand: false, contextLines: 0 }));
+    await options.diff(env.expect(new RspackTestDiff(diff)), env.expect(defaultConfig));
+}
 async function run(name, processor) {
     try {
         await processor.before?.(context);
@@ -30,10 +72,13 @@ async function run(name, processor) {
 function createDefaultsCase(name, src) {
     const caseConfig = require(src);
     it(`should generate the correct defaults from ${caseConfig.description}`, async () => {
-        await run(name, new processor_1.DefaultsConfigProcessor({
+        await run(name, new processor_1.SimpleTaskProcessor({
             name,
             compilerType: type_1.ECompilerType.Rspack,
-            ...caseConfig
+            options: (context) => options(context, caseConfig.options),
+            check(env, context, _compiler, _stats) {
+                return check.call(this, env, context, caseConfig);
+            }
         }));
     });
 }

package/dist/case/diagnostic.d.ts

@@ -1 +1,7 @@
+export interface IDiagnosticOptions {
+    snapshot: string;
+    snapshotErrors: string;
+    snapshotWarning: string;
+    format?: (output: string) => string;
+}
 export declare function createDiagnosticCase(name: string, src: string, dist: string): void;

package/dist/case/diagnostic.js

@@ -1,24 +1,124 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createDiagnosticCase = createDiagnosticCase;
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_path_1 = __importDefault(require("node:path"));
+const webpack_merge_1 = __importDefault(require("webpack-merge"));
+const helper_1 = require("../helper");
+const placeholder_1 = require("../helper/expect/placeholder");
 const processor_1 = require("../processor");
 const creator_1 = require("../test/creator");
 const type_1 = require("../type");
+function defaultOptions(context) {
+    return {
+        target: "node",
+        context: context.getSource(),
+        entry: {
+            main: "./"
+        },
+        mode: "development",
+        devServer: {
+            hot: false
+        },
+        infrastructureLogging: {
+            debug: false
+        },
+        output: {
+            path: context.getDist()
+        },
+        experiments: {
+            css: true,
+            rspackFuture: {
+                bundlerInfo: {
+                    force: false
+                }
+            },
+            inlineConst: true,
+            lazyBarrel: true
+        }
+    };
+}
+async function check(env, context, options) {
+    const compiler = this.getCompiler(context);
+    const stats = compiler.getStats();
+    if (!stats) {
+        throw new Error("Stats should exists");
+    }
+    (0, node_assert_1.default)(stats.hasErrors() || stats.hasWarnings());
+    let output = (0, placeholder_1.normalizePlaceholder)(stats.toString({
+        all: false,
+        errors: true,
+        warnings: true
+    })).replaceAll("\\", "/");
+    const statsJson = stats.toJson({
+        all: false,
+        errors: true,
+        warnings: true
+    });
+    const errors = (statsJson.errors || []).map(e => {
+        // @ts-expect-error error message is already serialized in `stats.err`
+        delete e.message;
+        delete e.stack;
+        return e;
+    });
+    const warnings = (statsJson.warnings || []).map(e => {
+        // @ts-expect-error error message is already serialized in `stats.err`
+        delete e.message;
+        delete e.stack;
+        return e;
+    });
+    if (typeof options.format === "function") {
+        output = options.format(output);
+    }
+    env.expect.addSnapshotSerializer({
+        test(received) {
+            return typeof received === "string";
+        },
+        serialize(received) {
+            return (0, placeholder_1.normalizePlaceholder)(received.trim());
+        }
+    });
+    const errorOutputPath = node_path_1.default.resolve(context.getSource(options.snapshot));
+    const errorStatsOutputPath = node_path_1.default.resolve(context.getSource(options.snapshotErrors));
+    const warningStatsOutputPath = node_path_1.default.resolve(context.getSource(options.snapshotWarning));
+    env.expect(output).toMatchFileSnapshot(errorOutputPath);
+    env.expect(errors).toMatchFileSnapshot(errorStatsOutputPath);
+    env.expect(warnings).toMatchFileSnapshot(warningStatsOutputPath);
+}
 const creator = new creator_1.BasicCaseCreator({
     clean: true,
     describe: false,
     steps: ({ name }) => [
-        new processor_1.DiagnosticProcessor({
+        new processor_1.SimpleTaskProcessor({
             name,
-            snapshot: "./stats.err",
-            snapshotErrors: "./raw-error.err",
-            snapshotWarning: "./raw-warning.err",
-            configFiles: ["rspack.config.js", "webpack.config.js"],
             compilerType: type_1.ECompilerType.Rspack,
-            format: (output) => {
-                // TODO: change to stats.errorStack
-                // TODO: add `errorStack: false`
-                return output.replace(/(│.* at ).*/g, "$1xxx");
+            options: context => {
+                let options = defaultOptions(context);
+                const custom = (0, helper_1.readConfigFile)(["rspack.config.js", "webpack.config.js"].map(i => context.getSource(i)))[0];
+                if (custom) {
+                    options = (0, webpack_merge_1.default)(options, custom);
+                }
+                if (!global.printLogger) {
+                    options.infrastructureLogging = {
+                        level: "error"
+                    };
+                }
+                return options;
+            },
+            check: function (env, context, compiler, stats) {
+                return check.call(this, env, context, {
+                    snapshot: "./stats.err",
+                    snapshotErrors: "./raw-error.err",
+                    snapshotWarning: "./raw-warning.err",
+                    format: (output) => {
+                        // TODO: change to stats.errorStack
+                        // TODO: add `errorStack: false`
+                        return output.replace(/(│.* at ).*/g, "$1xxx");
+                    }
+                });
             }
         })
     ],