@rspack/test-tools 1.5.6 → 1.5.8

package/dist/case/common.js

@@ -0,0 +1,239 @@
+"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 compilerManager = getCompiler(context, name);
+    const stats = compilerManager.getStats();
+    const compiler = compilerManager.getCompiler();
+    if (!stats || !compiler)
+        return;
+    const compilers = "compilers" in compiler
+        ? compiler.compilers
+        : [compiler];
+    const totalStats = "stats" in stats
+        ? stats.stats
+        : [stats];
+    const total = compilers.length;
+    for (let i = 0; i < compilers.length; i++) {
+        const c = compilers[i];
+        const stats = totalStats[i];
+        if (stats.hasErrors()) {
+            const errors = [];
+            errors.push(...stats.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.endsWith(".mjs")) &&
+                !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}${total > 1 ? `-${i}` : ""}`);
+        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;

package/dist/case/compiler.js

@@ -1,120 +1,155 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCompilerCase = createCompilerCase;
-const processor_1 = require("../processor");
-const simple_1 = require("../test/simple");
-const type_1 = require("../type");
+const creator_1 = require("../test/creator");
+const common_1 = require("./common");
+function createCompilerProcessor(name, caseConfig) {
+    const logs = {
+        mkdir: [],
+        writeFile: []
+    };
+    const files = {};
+    return {
+        config: async (context) => {
+            const compiler = (0, common_1.getCompiler)(context, name);
+            const options = caseConfig.options?.(context) || {};
+            options.mode ??= "production";
+            options.context ??= context.getSource();
+            options.entry ??= "./a.js";
+            options.output ??= {};
+            options.output.path ??= "/";
+            options.output.pathinfo ??= true;
+            options.optimization ??= {};
+            options.optimization.minimize ??= false;
+            compiler.setOptions(options);
+        },
+        compiler: async (context) => {
+            const compiler = (0, common_1.getCompiler)(context, name);
+            if (caseConfig.compilerCallback) {
+                compiler.createCompilerWithCallback(caseConfig.compilerCallback);
+            }
+            else {
+                compiler.createCompiler();
+            }
+            const c = compiler.getCompiler();
+            c.outputFileSystem = {
+                // CHANGE: Added support for the `options` parameter to enable recursive directory creation,
+                // accommodating Rspack's requirement that differs from webpack's usage
+                mkdir(path, callback) {
+                    const recursive = false;
+                    // if (typeof options === "function") {
+                    // 	callback = options;
+                    // } else if (options) {
+                    // 	if (options.recursive !== undefined) recursive = options.recursive;
+                    // }
+                    logs.mkdir.push(path);
+                    if (recursive) {
+                        callback();
+                    }
+                    else {
+                        const err = new Error();
+                        err.code = "EEXIST";
+                        callback(err);
+                    }
+                },
+                writeFile(name, content, callback) {
+                    logs.writeFile.push(name, content);
+                    files[name] = content.toString("utf-8");
+                    callback();
+                },
+                stat(path, callback) {
+                    callback(new Error("ENOENT"));
+                }
+            };
+            c.hooks.compilation.tap("CompilerTest", compilation => (compilation.bail = true));
+            await caseConfig.compiler?.(context, c);
+        },
+        build: async (context) => {
+            const compiler = (0, common_1.getCompiler)(context, name);
+            if (typeof caseConfig.build === "function") {
+                await caseConfig.build?.(context, compiler.getCompiler());
+            }
+            else {
+                await compiler.build();
+            }
+        },
+        run: async (env, context) => { },
+        check: async (env, context) => {
+            const compiler = (0, common_1.getCompiler)(context, name);
+            const c = compiler.getCompiler();
+            const stats = compiler.getStats();
+            if (caseConfig.error) {
+                const statsJson = stats?.toJson({
+                    modules: true,
+                    reasons: true
+                });
+                const compilation = stats?.compilation;
+                await caseConfig.check?.({
+                    context,
+                    compiler: c,
+                    stats: statsJson,
+                    compilation,
+                    files
+                });
+            }
+            else if (stats) {
+                expect(typeof stats).toBe("object");
+                const compilation = stats.compilation;
+                const statsJson = stats.toJson({
+                    modules: true,
+                    reasons: true
+                });
+                expect(typeof statsJson).toBe("object");
+                expect(statsJson).toHaveProperty("errors");
+                expect(Array.isArray(statsJson.errors)).toBe(true);
+                if (statsJson.errors.length > 0) {
+                    expect(statsJson.errors[0]).toBeInstanceOf(Object);
+                    throw statsJson.errors[0];
+                }
+                statsJson.logs = logs;
+                await caseConfig.check?.({
+                    context,
+                    stats: statsJson,
+                    files,
+                    compiler: c,
+                    compilation
+                });
+            }
+            else {
+                await caseConfig.check?.({
+                    context,
+                    files,
+                    compiler: c
+                });
+            }
+        },
+        after: async (context) => {
+            await context.closeCompiler(name);
+        }
+    };
+}
+const creator = new creator_1.BasicCaseCreator({
+    clean: true,
+    describe: false,
+    steps: ({ name, caseConfig }) => {
+        return [createCompilerProcessor(name, caseConfig)];
+    },
+    concurrent: false
+});
 function createCompilerCase(name, src, dist, testConfig) {
     let caseConfigList = require(testConfig);
     if (!Array.isArray(caseConfigList)) {
         caseConfigList = [caseConfigList];
     }
-    const runner = (0, simple_1.getSimpleProcessorRunner)(src, dist);
-    for (const caseConfig of caseConfigList) {
-        const testFn = caseConfig.skip ? it.skip : it;
-        testFn(caseConfig.description, async () => {
-            const logs = {
-                mkdir: [],
-                writeFile: []
-            };
-            const files = {};
-            await runner(name, new processor_1.SimpleTaskProcessor({
-                name: name,
-                compilerType: type_1.ECompilerType.Rspack,
-                compilerCallback: caseConfig.compilerCallback,
-                build: caseConfig.build,
-                options: context => {
-                    const options = caseConfig.options?.(context) || {};
-                    options.mode ??= "production";
-                    options.context ??= context.getSource();
-                    options.entry ??= "./a.js";
-                    options.output ??= {};
-                    options.output.path ??= "/";
-                    options.output.pathinfo ??= true;
-                    options.optimization ??= {};
-                    options.optimization.minimize ??= false;
-                    return options;
-                },
-                async compiler(context, compiler) {
-                    compiler.outputFileSystem = {
-                        // CHANGE: Added support for the `options` parameter to enable recursive directory creation,
-                        // accommodating Rspack's requirement that differs from webpack's usage
-                        mkdir(path, callback) {
-                            const recursive = false;
-                            // if (typeof options === "function") {
-                            // 	callback = options;
-                            // } else if (options) {
-                            // 	if (options.recursive !== undefined) recursive = options.recursive;
-                            // }
-                            logs.mkdir.push(path);
-                            if (recursive) {
-                                callback();
-                            }
-                            else {
-                                const err = new Error();
-                                err.code = "EEXIST";
-                                callback(err);
-                            }
-                        },
-                        writeFile(name, content, callback) {
-                            logs.writeFile.push(name, content);
-                            files[name] = content.toString("utf-8");
-                            callback();
-                        },
-                        stat(path, callback) {
-                            callback(new Error("ENOENT"));
-                        }
-                    };
-                    compiler.hooks.compilation.tap("CompilerTest", compilation => (compilation.bail = true));
-                    await caseConfig.compiler?.(context, compiler);
-                },
-                async check(context, compiler, stats) {
-                    if (caseConfig.error) {
-                        const statsJson = stats?.toJson({
-                            modules: true,
-                            reasons: true
-                        });
-                        const compilation = stats?.compilation;
-                        await caseConfig.check?.({
-                            context,
-                            compiler,
-                            stats: statsJson,
-                            compilation,
-                            files
-                        });
-                    }
-                    else if (stats) {
-                        expect(typeof stats).toBe("object");
-                        const compilation = stats.compilation;
-                        const statsJson = stats.toJson({
-                            modules: true,
-                            reasons: true
-                        });
-                        expect(typeof statsJson).toBe("object");
-                        expect(statsJson).toHaveProperty("errors");
-                        expect(Array.isArray(statsJson.errors)).toBe(true);
-                        if (statsJson.errors.length > 0) {
-                            expect(statsJson.errors[0]).toBeInstanceOf(Object);
-                            throw statsJson.errors[0];
-                        }
-                        statsJson.logs = logs;
-                        await caseConfig.check?.({
-                            context,
-                            stats: statsJson,
-                            files,
-                            compiler,
-                            compilation
-                        });
-                    }
-                    else {
-                        await caseConfig.check?.({
-                            context,
-                            files,
-                            compiler
-                        });
-                    }
-                }
-            }));
+    for (let i = 0; i < caseConfigList.length; i++) {
+        const caseConfig = caseConfigList[i];
+        if (caseConfig.skip) {
+            it.skip(`${name}[${i}]`, () => { });
+            continue;
+        }
+        creator.create(`${name}[${i}]`, src, dist, undefined, {
+            caseConfig,
+            description: () => caseConfig.description
         });
     }
 }

package/dist/case/config.d.ts

@@ -1,3 +1,7 @@
-import { ECompilerType, type TTestConfig } from "../type";
+import type { ECompilerType, ITestContext, ITestProcessor, TCompilerOptions, TTestConfig } from "../type";
 export type TConfigCaseConfig = Omit<TTestConfig<ECompilerType.Rspack>, "validate">;
+export declare function createConfigProcessor(name: string): ITestProcessor;
 export declare function createConfigCase(name: string, src: string, dist: string): void;
+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[];

package/dist/case/config.js

@@ -1,10 +1,38 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConfigProcessor = createConfigProcessor;
 exports.createConfigCase = createConfigCase;
-const config_1 = require("../processor/config");
-const runner_1 = require("../runner");
+exports.defaultOptions = defaultOptions;
+exports.overrideOptions = overrideOptions;
+exports.findBundle = findBundle;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const parseResource_1 = require("../helper/legacy/parseResource");
 const creator_1 = require("../test/creator");
-const type_1 = require("../type");
+const common_1 = require("./common");
+const runner_1 = require("./runner");
+function createConfigProcessor(name) {
+    return {
+        config: async (context) => {
+            (0, common_1.configMultiCompiler)(context, name, ["rspack.config.cjs", "rspack.config.js", "webpack.config.js"], defaultOptions, 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) => {
+            await (0, common_1.run)(env, context, name, (context) => (0, common_1.findMultiCompilerBundle)(context, name, findBundle));
+        },
+        check: async (env, context) => {
+            await (0, common_1.check)(env, context, name);
+        }
+    };
+}
 const creator = new creator_1.BasicCaseCreator({
     clean: true,
     describe: false,
@@ -19,21 +47,79 @@ const creator = new creator_1.BasicCaseCreator({
             return res;
         };
     },
-    steps: ({ name }) => [
-        new config_1.ConfigProcessor({
-            name,
-            runable: true,
-            compilerType: type_1.ECompilerType.Rspack,
-            configFiles: [
-                "rspack.config.cjs",
-                "rspack.config.js",
-                "webpack.config.js"
-            ]
-        })
-    ],
-    runner: runner_1.MultipleRunnerFactory,
+    steps: ({ name }) => [createConfigProcessor(name)],
+    runner: {
+        key: runner_1.getMultiCompilerRunnerKey,
+        runner: runner_1.createMultiCompilerRunner
+    },
     concurrent: true
 });
 function createConfigCase(name, src, dist) {
     creator.create(name, src, dist);
 }
+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;
+}