@rspack-debug/test-tools 1.4.11 → 1.6.2

package/dist/case/defaults.js

@@ -4,36 +4,91 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createDefaultsCase = createDefaultsCase;
+exports.getRspackDefaultConfig = getRspackDefaultConfig;
 const node_path_1 = __importDefault(require("node:path"));
-const processor_1 = require("../processor");
+const node_util_1 = require("node:util");
+const jest_diff_1 = require("jest-diff");
 const context_1 = require("../test/context");
-const type_1 = require("../type");
+const CURRENT_CWD = process.cwd();
+function createDefaultsCase(name, src) {
+    const caseConfig = require(src);
+    it(`should generate the correct defaults from ${caseConfig.description}`, async () => {
+        await run(name, {
+            config: async (context) => {
+                const compiler = context.getCompiler();
+                compiler.setOptions(options(context, caseConfig.options));
+            },
+            compiler: async (context) => {
+                const compiler = context.getCompiler();
+                compiler.createCompiler();
+            },
+            build: async (context) => {
+                // no need to build, just check the snapshot of compiler options
+            },
+            run: async (env, context) => {
+                // no need to run, just check the snapshot of compiler options
+            },
+            check: async (env, context) => {
+                await check(env, context, name, caseConfig);
+            }
+        });
+    });
+}
+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, name, options) {
+    const compiler = context.getCompiler();
+    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) {
+    const context = new context_1.TestContext({
+        name: name,
+        src: srcDir,
+        dist: distDir
+    });
     try {
         await processor.before?.(context);
         await processor.config?.(context);
     }
     catch (e) {
-        context.emitError(name, e);
+        context.emitError(e);
     }
     finally {
-        await processor.check?.({ expect, it, beforeEach, afterEach, jest }, context);
+        await processor.check?.({ expect, it, beforeEach, afterEach, rstest }, context);
         await processor.after?.(context);
     }
 }
-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({
-            name,
-            compilerType: type_1.ECompilerType.Rspack,
-            ...caseConfig
-        }));
-    });
-}

package/dist/case/diagnostic.d.ts

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

package/dist/case/diagnostic.js

@@ -1,29 +1,136 @@
 "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 processor_1 = require("../processor");
+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 creator_1 = require("../test/creator");
-const type_1 = require("../type");
 const creator = new creator_1.BasicCaseCreator({
     clean: true,
     describe: false,
     steps: ({ name }) => [
-        new processor_1.DiagnosticProcessor({
-            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");
+        {
+            config: async (context) => {
+                const compiler = context.getCompiler();
+                let options = defaultOptions(context);
+                const custom = (0, helper_1.readConfigFile)(["rspack.config.js", "webpack.config.js"].map(i => context.getSource(i)), context, options)[0];
+                if (custom) {
+                    options = (0, webpack_merge_1.default)(options, custom);
+                }
+                if (!global.printLogger) {
+                    options.infrastructureLogging = {
+                        level: "error"
+                    };
+                }
+                compiler.setOptions(options);
+            },
+            compiler: async (context) => {
+                const compiler = context.getCompiler();
+                compiler.createCompiler();
+            },
+            build: async (context) => {
+                const compiler = context.getCompiler();
+                await compiler.build();
+            },
+            run: async (env, context) => {
+                // no need to run, just check the snapshot of diagnostics
+            },
+            check: async (env, context) => {
+                await check(env, context, name, {
+                    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");
+                    }
+                });
             }
-        })
+        }
     ],
     concurrent: true
 });
 function createDiagnosticCase(name, src, dist) {
     creator.create(name, src, dist);
 }
+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
+        }
+    };
+}
+async function check(env, context, name, options) {
+    const compiler = context.getCompiler();
+    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).toMatchFileSnapshotSync(errorOutputPath);
+    env.expect(errors).toMatchFileSnapshotSync(errorStatsOutputPath);
+    env.expect(warnings).toMatchFileSnapshotSync(warningStatsOutputPath);
+}

package/dist/case/error.d.ts

@@ -1,6 +1,17 @@
-import { type IErrorProcessorOptions } from "../processor";
-import { ECompilerType } from "../type";
-export type TErrorCaseConfig = Omit<IErrorProcessorOptions<ECompilerType.Rspack>, "name" | "compilerType"> & {
+import type { Compiler, RspackOptions, StatsError } from "@rspack/core";
+import type { ITestContext } from "../type";
+export declare function createErrorCase(name: string, src: string, dist: string, testConfig: string): void;
+declare class RspackStatsDiagnostics {
+    errors: StatsError[];
+    warnings: StatsError[];
+    constructor(errors: StatsError[], warnings: StatsError[]);
+}
+export type TErrorCaseConfig = {
     description: string;
+    skip?: boolean;
+    options?: (context: ITestContext) => RspackOptions;
+    compiler?: (context: ITestContext, compiler: Compiler) => Promise<void>;
+    build?: (context: ITestContext, compiler: Compiler) => Promise<void>;
+    check?: (stats: RspackStatsDiagnostics) => Promise<void>;
 };
-export declare function createErrorCase(name: string, src: string, dist: string, testConfig: string): void;
+export {};

package/dist/case/error.js

@@ -1,21 +1,146 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createErrorCase = createErrorCase;
-const processor_1 = require("../processor");
-const simple_1 = require("../test/simple");
-const type_1 = require("../type");
+const node_path_1 = __importDefault(require("node:path"));
+const webpack_merge_1 = __importDefault(require("webpack-merge"));
+const creator_1 = require("../test/creator");
 let addedSerializer = false;
+const creator = new creator_1.BasicCaseCreator({
+    clean: true,
+    describe: true,
+    steps: ({ name, caseConfig }) => {
+        const config = caseConfig;
+        return [
+            {
+                config: async (context) => {
+                    const compiler = context.getCompiler();
+                    compiler.setOptions(options(context, config.options));
+                },
+                compiler: async (context) => {
+                    const compilerManager = context.getCompiler();
+                    compilerManager.createCompiler();
+                    compiler(context, compilerManager.getCompiler(), config.compiler);
+                },
+                build: async (context) => {
+                    const compiler = context.getCompiler();
+                    if (typeof config.build === "function") {
+                        await config.build(context, compiler.getCompiler());
+                    }
+                    else {
+                        await compiler.build();
+                    }
+                },
+                run: async (env, context) => {
+                    // no need to run, just check the snapshot of diagnostics
+                },
+                check: async (env, context) => {
+                    await check(env, context, name, config.check);
+                }
+            }
+        ];
+    },
+    concurrent: true
+});
 function createErrorCase(name, src, dist, testConfig) {
     if (!addedSerializer) {
         addedSerializer = true;
     }
-    const caseConfig = require(testConfig);
-    const runner = (0, simple_1.getSimpleProcessorRunner)(src, dist);
-    it(caseConfig.description, async () => {
-        await runner(name, new processor_1.ErrorProcessor({
-            name: name,
-            compilerType: type_1.ECompilerType.Rspack,
-            ...caseConfig
-        }));
-    });
+    const caseConfigList = require(testConfig);
+    function createCase(caseConfig) {
+        if (caseConfig.skip) {
+            it.skip(name, () => { });
+            return;
+        }
+        creator.create(name, src, dist, undefined, {
+            caseConfig,
+            description: () => caseConfig.description
+        });
+    }
+    if (Array.isArray(caseConfigList)) {
+        for (const caseConfig of caseConfigList) {
+            createCase(caseConfig);
+        }
+    }
+    else {
+        createCase(caseConfigList);
+    }
+}
+function options(context, custom) {
+    let options = {
+        context: node_path_1.default.resolve(__TEST_FIXTURES_PATH__, "errors"),
+        mode: "none",
+        devtool: false,
+        optimization: {
+            minimize: false,
+            moduleIds: "named",
+            chunkIds: "named"
+        },
+        experiments: {
+            css: true,
+            rspackFuture: {
+                bundlerInfo: {
+                    force: false
+                }
+            }
+        }
+    };
+    if (typeof custom === "function") {
+        options = (0, webpack_merge_1.default)(options, custom(context, options));
+    }
+    if (options.mode === "production") {
+        if (options.optimization)
+            options.optimization.minimize = true;
+        else
+            options.optimization = { minimize: true };
+    }
+    return options;
+}
+async function compiler(context, compiler, custom) {
+    if (compiler) {
+        compiler.outputFileSystem = {
+            // CHANGE: rspack outputFileSystem `mkdirp` uses option `{ recursive: true }`, webpack's second parameter is alway a callback
+            mkdir(dir, maybeOptionOrCallback, maybeCallback) {
+                if (typeof maybeOptionOrCallback === "function") {
+                    maybeOptionOrCallback();
+                }
+                else if (typeof maybeCallback === "function") {
+                    maybeCallback();
+                }
+            },
+            writeFile(file, content, callback) {
+                callback();
+            },
+            stat(file, callback) {
+                callback(new Error("ENOENT"));
+            },
+            mkdirSync() { },
+            writeFileSync() { }
+        };
+    }
+    await custom?.(context, compiler);
+}
+class RspackStatsDiagnostics {
+    constructor(errors, warnings) {
+        this.errors = errors;
+        this.warnings = warnings;
+    }
+}
+async function check(env, context, name, check) {
+    if (context.getError().length > 0) {
+        await check?.(new RspackStatsDiagnostics(context.getError(), []));
+        context.clearError();
+        return;
+    }
+    const compiler = context.getCompiler();
+    const stats = compiler.getStats();
+    env.expect(typeof stats).toBe("object");
+    const statsResult = stats.toJson({ errorDetails: false });
+    env.expect(typeof statsResult).toBe("object");
+    const { errors, warnings } = statsResult;
+    env.expect(Array.isArray(errors)).toBe(true);
+    env.expect(Array.isArray(warnings)).toBe(true);
+    await check?.(new RspackStatsDiagnostics(errors, warnings));
 }

package/dist/case/esm-output.d.ts

@@ -0,0 +1 @@
+export declare function createEsmOutputCase(name: string, src: string, dist: string): void;

package/dist/case/esm-output.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEsmOutputCase = createEsmOutputCase;
+const core_1 = __importDefault(require("@rspack/core"));
+const creator_1 = require("../test/creator");
+const common_1 = require("./common");
+const runner_1 = require("./runner");
+const creator = new creator_1.BasicCaseCreator({
+    clean: true,
+    describe: false,
+    testConfig: testConfig => {
+        const oldModuleScope = testConfig.moduleScope;
+        testConfig.moduleScope = (ms, stats) => {
+            let res = ms;
+            // TODO: modify runner module scope based on stats here
+            if (typeof oldModuleScope === "function") {
+                res = oldModuleScope(ms, stats);
+            }
+            return res;
+        };
+    },
+    steps: ({ name }) => [
+        {
+            config: async (context) => {
+                (0, common_1.configMultiCompiler)(context, name, ["rspack.config.cjs", "rspack.config.js", "webpack.config.js"], defaultOptions, (_index, context, options) => {
+                    const testConfig = context.getTestConfig();
+                    if (testConfig.esmLibPluginOptions) {
+                        let target;
+                        const otherPlugins = options.plugins?.filter(plugin => {
+                            const isTarget = plugin instanceof core_1.default.experiments.EsmLibraryPlugin;
+                            if (isTarget) {
+                                target = plugin;
+                            }
+                            return !isTarget;
+                        }) ?? [];
+                        options.plugins = [
+                            ...otherPlugins,
+                            new core_1.default.experiments.EsmLibraryPlugin({
+                                ...target.options,
+                                ...testConfig.esmLibPluginOptions
+                            })
+                        ];
+                    }
+                });
+            },
+            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) => (0, common_1.findMultiCompilerBundle)(context, name, (_index, context, options) => {
+                    const testConfig = context.getTestConfig();
+                    if (typeof testConfig.findBundle === "function") {
+                        return testConfig.findBundle(_index, options);
+                    }
+                    if (options.output?.filename === "[name].mjs") {
+                        return ["main.mjs"];
+                    }
+                    else {
+                        return [options.output.filename];
+                    }
+                }));
+            },
+            check: async (env, context) => {
+                await (0, common_1.check)(env, context, name);
+                await (0, common_1.checkSnapshot)(env, context, name, "esm.snap.txt");
+            },
+            after: async (context) => {
+                await (0, common_1.afterExecute)(context, name);
+            }
+        }
+    ],
+    runner: {
+        key: runner_1.getMultiCompilerRunnerKey,
+        runner: runner_1.createMultiCompilerRunner
+    },
+    concurrent: 1
+});
+const defaultOptions = (_index, context) => ({
+    context: context.getSource(),
+    mode: "production",
+    target: "async-node",
+    devtool: false,
+    entry: "./index.js",
+    cache: false,
+    output: {
+        path: context.getDist(),
+        filename: "[name].mjs",
+        pathinfo: true,
+        module: true
+    },
+    bail: true,
+    optimization: {
+        minimize: false,
+        moduleIds: "named",
+        chunkIds: "named",
+        runtimeChunk: "single"
+    },
+    plugins: [new core_1.default.experiments.EsmLibraryPlugin()],
+    experiments: {
+        css: true,
+        rspackFuture: {
+            bundlerInfo: {
+                force: false
+            }
+        },
+        outputModule: true
+    }
+});
+function createEsmOutputCase(name, src, dist) {
+    creator.create(name, src, dist);
+}

package/dist/case/example.d.ts

@@ -0,0 +1 @@
+export declare function createExampleCase(name: string, src: string): void;

package/dist/case/example.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExampleCase = createExampleCase;
+const node_path_1 = __importDefault(require("node:path"));
+const creator_1 = require("../test/creator");
+const common_1 = require("./common");
+function overrideOptions(index, context, options) {
+    options.context = context.getSource();
+    options.output = options.output || {};
+    options.output.pathinfo = true;
+    options.output.path = context.getDist();
+    options.output.publicPath = "dist/";
+    if (!options.entry)
+        options.entry = "./example.js";
+    if (!options.plugins)
+        options.plugins = [];
+}
+function createExampleProcessor(name) {
+    return {
+        config: async (context) => {
+            (0, common_1.configMultiCompiler)(context, name, ["rspack.config.js", "webpack.config.js"], () => ({}), overrideOptions);
+        },
+        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 the building
+        },
+        check: async (env, context) => {
+            const compiler = context.getCompiler();
+            const stats = compiler.getStats();
+            if (stats?.hasErrors()) {
+                console.log(stats.toString({
+                    all: false,
+                    errors: true,
+                    errorDetails: true,
+                    errorStack: true
+                }));
+            }
+            expect(stats?.hasErrors()).toBe(false);
+        }
+    };
+}
+const creator = new creator_1.BasicCaseCreator({
+    clean: true,
+    steps: ({ name }) => [createExampleProcessor(name)],
+    concurrent: true
+});
+function createExampleCase(name, src) {
+    creator.create(name, src, node_path_1.default.join(src, "dist"));
+}

package/dist/case/hash.d.ts

@@ -1,3 +1,3 @@
-import { ECompilerType, type TTestConfig } from "../type";
-export type THashCaseConfig = Pick<TTestConfig<ECompilerType.Rspack>, "validate">;
+import type { TTestConfig } from "../type";
+export type THashCaseConfig = Pick<TTestConfig, "validate">;
 export declare function createHashCase(name: string, src: string, dist: string): void;