@rspack/test-tools 1.5.7 → 1.6.0-beta.0

package/dist/case/builtin.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 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");
@@ -164,27 +163,6 @@ function defaultOptions(context) {
         }
         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"

package/dist/case/cache.js

@@ -98,8 +98,7 @@ function defaultOptions(context, temp, target) {
                     force: false
                 }
             },
-            inlineConst: true,
-            lazyBarrel: true
+            inlineConst: true
         }
     };
     options.plugins ??= [];

package/dist/case/common.js

@@ -81,7 +81,11 @@ async function run(env, context, name, findBundle) {
     const results = context.getValue(name, "modules") || [];
     await Promise.all(results);
     if (typeof testConfig.afterExecute === "function") {
-        testConfig.afterExecute(compiler.getOptions());
+        let options = compiler.getOptions();
+        if (Array.isArray(options) && options.length === 1) {
+            options = options[0];
+        }
+        testConfig.afterExecute(options);
     }
 }
 async function check(env, context, name) {
@@ -135,49 +139,51 @@ 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)
+    const compilerManager = getCompiler(context, name);
+    const stats = compilerManager.getStats();
+    const compiler = compilerManager.getCompiler();
+    if (!stats || !compiler)
         return;
-    if (stats.hasErrors()) {
-        const errors = [];
-        if (stats.stats) {
-            for (const s of stats.stats) {
-                if (s.hasErrors()) {
-                    errors.push(...s.compilation.errors);
-                }
-            }
+    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")}`);
         }
-        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);
+        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") {

package/dist/case/compiler.js

@@ -1,137 +1,155 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCompilerCase = createCompilerCase;
-const simple_1 = require("../test/simple");
+const creator_1 = require("../test/creator");
 const common_1 = require("./common");
-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, {
-                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);
+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 {
-                        compiler.createCompiler();
+                        const err = new Error();
+                        err.code = "EEXIST";
+                        callback(err);
                     }
-                    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();
-                    }
+                writeFile(name, content, callback) {
+                    logs.writeFile.push(name, content);
+                    files[name] = content.toString("utf-8");
+                    callback();
                 },
-                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
-                        });
-                    }
+                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];
+    }
+    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.js

@@ -77,8 +77,7 @@ function defaultOptions(index, context) {
                     force: false
                 }
             },
-            inlineConst: true,
-            lazyBarrel: true
+            inlineConst: true
         }
     };
 }

package/dist/case/diagnostic.d.ts

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

package/dist/case/diagnostic.js

@@ -84,8 +84,7 @@ function defaultOptions(context) {
                     force: false
                 }
             },
-            inlineConst: true,
-            lazyBarrel: true
+            inlineConst: true
         }
     };
 }

package/dist/case/error.d.ts

@@ -8,6 +8,7 @@ declare class RspackStatsDiagnostics {
 }
 export type TErrorCaseConfig = {
     description: string;
+    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>;

package/dist/case/error.js

@@ -6,47 +6,72 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createErrorCase = createErrorCase;
 const node_path_1 = __importDefault(require("node:path"));
 const webpack_merge_1 = __importDefault(require("webpack-merge"));
-const simple_1 = require("../test/simple");
+const creator_1 = require("../test/creator");
 const common_1 = require("./common");
 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 = (0, common_1.getCompiler)(context, name);
+                    compiler.setOptions(options(context, config.options));
+                },
+                compiler: async (context) => {
+                    const compilerManager = (0, common_1.getCompiler)(context, name);
+                    compilerManager.createCompiler();
+                    compiler(context, compilerManager.getCompiler(), config.compiler);
+                },
+                build: async (context) => {
+                    const compiler = (0, common_1.getCompiler)(context, name);
+                    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, {
-            config: async (context) => {
-                const compiler = (0, common_1.getCompiler)(context, name);
-                compiler.setOptions(options(context, caseConfig.options));
-            },
-            compiler: async (context) => {
-                const compilerManager = (0, common_1.getCompiler)(context, name);
-                compilerManager.createCompiler();
-                compiler(context, compilerManager.getCompiler(), caseConfig.compiler);
-            },
-            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) => {
-                // no need to run, just check the snapshot of diagnostics
-            },
-            check: async (env, context) => {
-                await check(env, context, name, caseConfig.check);
-            }
+    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(__dirname, "../../../../tests/rspack-test/fixtures/errors"),
+        context: node_path_1.default.resolve(__TEST_FIXTURES_PATH__, "errors"),
         mode: "none",
         devtool: false,
         optimization: {
@@ -105,6 +130,11 @@ class RspackStatsDiagnostics {
     }
 }
 async function check(env, context, name, check) {
+    if (context.getError(name).length > 0) {
+        await check?.(new RspackStatsDiagnostics(context.getError(name), []));
+        context.clearError(name);
+        return;
+    }
     const compiler = (0, common_1.getCompiler)(context, name);
     const stats = compiler.getStats();
     env.expect(typeof stats).toBe("object");

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

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