@rspack/test-tools 1.5.8 → 1.6.0-beta.1

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.d.ts

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

package/dist/case/cache.js

@@ -11,7 +11,6 @@ const hot_update_1 = require("../helper/hot-update");
 const checkArrayExpectation_1 = __importDefault(require("../helper/legacy/checkArrayExpectation"));
 const runner_1 = require("../runner");
 const creator_1 = require("../test/creator");
-const type_1 = require("../type");
 const common_1 = require("./common");
 const runner_2 = require("./runner");
 const MAX_COMPILER_INDEX = 100;
@@ -41,6 +40,9 @@ function createCacheProcessor(name, src, temp, target) {
         check: async (env, context) => {
             await (0, common_1.check)(env, context, name);
         },
+        after: async (context) => {
+            await (0, common_1.afterExecute)(context, name);
+        },
         afterAll: async (context) => {
             const updateIndex = updatePlugin.getUpdateIndex();
             const totalUpdates = updatePlugin.getTotalUpdates();
@@ -98,8 +100,7 @@ function defaultOptions(context, temp, target) {
                     force: false
                 }
             },
-            inlineConst: true,
-            lazyBarrel: true
+            inlineConst: true
         }
     };
     options.plugins ??= [];
@@ -162,8 +163,7 @@ function createRunner(context, name, file, env) {
     const dist = context.getDist();
     const updatePlugin = context.getValue(name, "hotUpdateContext");
     const getWebRunner = () => {
-        return new runner_1.WebRunner({
-            dom: context.getValue(name, "documentType") || type_1.EDocumentType.JSDOM,
+        return new runner_1.NodeRunner({
             env,
             stats: (0, runner_2.cachedStats)(context, name),
             cachable: false,

package/dist/case/common.d.ts

@@ -6,5 +6,6 @@ export declare function build<T extends ECompilerType = ECompilerType.Rspack>(co
 export declare function run<T extends ECompilerType = ECompilerType.Rspack>(env: ITestEnv, context: ITestContext, name: string, findBundle: (context: ITestContext, options: TCompilerOptions<T>) => string[] | string | void): Promise<void>;
 export declare function check<T extends ECompilerType = ECompilerType.Rspack>(env: ITestEnv, context: ITestContext, name: string): Promise<void>;
 export declare function checkSnapshot<T extends ECompilerType = ECompilerType.Rspack>(env: ITestEnv, context: ITestContext, name: string, snapshot: string, filter?: (file: string) => boolean): Promise<void>;
+export declare function afterExecute(context: ITestContext, name: string): Promise<void>;
 export declare function findMultiCompilerBundle<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string, multiFindBundle: (index: number, context: ITestContext, options: TCompilerOptions<T>) => string[] | string | void): string[];
 export declare function configMultiCompiler<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string, configFiles: string[], defaultOptions: (index: number, context: ITestContext) => TCompilerOptions<T>, overrideOptions: (index: number, context: ITestContext, options: TCompilerOptions<T>) => void): void;

package/dist/case/common.js

@@ -10,6 +10,7 @@ exports.build = build;
 exports.run = run;
 exports.check = check;
 exports.checkSnapshot = checkSnapshot;
+exports.afterExecute = afterExecute;
 exports.findMultiCompilerBundle = findMultiCompilerBundle;
 exports.configMultiCompiler = configMultiCompiler;
 const fs_extra_1 = __importDefault(require("fs-extra"));
@@ -26,7 +27,7 @@ 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];
+        const fileOptions = (0, helper_1.readConfigFile)(configFiles.map(i => context.getSource(i)), context, defaultOptions)[0];
         compiler.mergeOptions(fileOptions);
     }
     return compiler.getOptions();
@@ -45,9 +46,6 @@ 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());
@@ -80,9 +78,6 @@ 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());
-    }
 }
 async function check(env, context, name) {
     const testConfig = context.getTestConfig();
@@ -171,16 +166,28 @@ async function checkSnapshot(env, context, name, snapshot, filter) {
             if (testConfig.snapshotContent) {
                 content = testConfig.snapshotContent(content);
             }
-            return `\`\`\`${tag} title=${file}\n${content}\n\`\`\``;
+            const filePath = file.replaceAll(path_1.default.sep, "/");
+            return `\`\`\`${tag} title=${filePath}\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}` : ""}`);
+            : path_1.default.resolve(context.getSource(), path_1.default.join("__snapshots__", `${snapshot}${total > 1 ? `-${i}` : ""}`));
         env.expect(content).toMatchFileSnapshot(snapshotPath);
     }
 }
+async function afterExecute(context, name) {
+    const compiler = getCompiler(context, name);
+    const testConfig = context.getTestConfig();
+    if (typeof testConfig.afterExecute === "function") {
+        let options = compiler.getOptions();
+        if (Array.isArray(options) && options.length === 1) {
+            options = options[0];
+        }
+        testConfig.afterExecute(options);
+    }
+}
 function findMultiCompilerBundle(context, name, multiFindBundle) {
     if (typeof multiFindBundle !== "function") {
         return [];
@@ -211,7 +218,7 @@ function findMultiCompilerBundle(context, name, multiFindBundle) {
 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 => {
+        ? (0, helper_1.readConfigFile)(configFiles.map(i => context.getSource(i)), context, {}, configs => {
             return configs.flatMap(c => {
                 if (typeof c === "function") {
                     const options = {

package/dist/case/config.js

@@ -30,6 +30,9 @@ function createConfigProcessor(name) {
         },
         check: async (env, context) => {
             await (0, common_1.check)(env, context, name);
+        },
+        after: async (context) => {
+            await (0, common_1.afterExecute)(context, name);
         }
     };
 }
@@ -77,8 +80,7 @@ function defaultOptions(index, context) {
                     force: false
                 }
             },
-            inlineConst: true,
-            lazyBarrel: true
+            inlineConst: true
         }
     };
 }
@@ -116,7 +118,7 @@ function findBundle(index, context, options) {
                 options.output?.cssFilename) ||
                 `bundle${index}.css`);
             if (fs_extra_1.default.existsSync(cssOutputPath)) {
-                bundlePath.push(`./bundle${index}.css`);
+                bundlePath.push(path_1.default.relative(options.output.path, cssOutputPath));
             }
         }
         bundlePath.push(`./bundle${index}${ext}`);

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

@@ -19,7 +19,7 @@ const creator = new creator_1.BasicCaseCreator({
             config: async (context) => {
                 const compiler = (0, common_1.getCompiler)(context, name);
                 let options = defaultOptions(context);
-                const custom = (0, helper_1.readConfigFile)(["rspack.config.js", "webpack.config.js"].map(i => context.getSource(i)))[0];
+                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);
                 }
@@ -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

@@ -49,15 +49,29 @@ function createErrorCase(name, src, dist, testConfig) {
     if (!addedSerializer) {
         addedSerializer = true;
     }
-    const caseConfig = require(testConfig);
-    creator.create(name, src, dist, undefined, {
-        caseConfig,
-        description: () => caseConfig.description
-    });
+    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: {
@@ -116,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.js

@@ -25,7 +25,26 @@ const creator = new creator_1.BasicCaseCreator({
     steps: ({ name }) => [
         {
             config: async (context) => {
-                (0, common_1.configMultiCompiler)(context, name, ["rspack.config.cjs", "rspack.config.js", "webpack.config.js"], defaultOptions, () => { });
+                (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);
@@ -34,7 +53,11 @@ const creator = new creator_1.BasicCaseCreator({
                 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) => {
+                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"];
                     }
@@ -46,6 +69,9 @@ const creator = new creator_1.BasicCaseCreator({
             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);
             }
         }
     ],

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 = (0, common_1.getCompiler)(context, name);
+            const stats = compiler.getStats();
+            if (stats?.hasErrors()) {
+                console.log(stats.toString({
+                    all: false,
+                    errors: true,
+                    errorDetails: true,
+                    errorStacks: 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.js

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

package/dist/case/hook.js

@@ -14,8 +14,8 @@ const webpack_merge_1 = __importDefault(require("webpack-merge"));
 const context_1 = require("../test/context");
 const creator_1 = require("../test/creator");
 const common_1 = require("./common");
-const srcDir = node_path_1.default.resolve(__dirname, "../../../../tests/rspack-test/fixtures");
-const distDir = node_path_1.default.resolve(__dirname, "../../../../tests/rspack-test/js/hook");
+const srcDir = __TEST_FIXTURES_PATH__;
+const distDir = node_path_1.default.resolve(__TEST_DIST_PATH__, "hook");
 const creator = new creator_1.BasicCaseCreator({
     clean: true,
     describe: true,
@@ -213,8 +213,7 @@ function defaultOptions(context, custom) {
                     force: false
                 }
             },
-            inlineConst: true,
-            lazyBarrel: true
+            inlineConst: true
         }
     };
     if (custom) {

package/dist/case/hot-step.d.ts

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

package/dist/case/hot-step.js

@@ -24,9 +24,6 @@ const SELF_HANDLER = (file, options) => {
     global.self[hotUpdateGlobalKey] = hotUpdateGlobal;
     require(file);
     delete global.self[hotUpdateGlobalKey];
-    if (!Object.keys(global.self).length) {
-        delete global.self;
-    }
     return res;
 };
 const NODE_HANDLER = (file) => {
@@ -39,8 +36,8 @@ const GET_MODULE_HANDLER = {
     node: NODE_HANDLER
 };
 const creators = new Map();
-function createHotStepProcessor(name, target) {
-    const processor = (0, hot_1.createHotProcessor)(name, target);
+function createHotStepProcessor(name, src, temp, target) {
+    const processor = (0, hot_1.createHotProcessor)(name, src, temp, target);
     const entries = {};
     const hashes = [];
     function matchStepSnapshot(env, context, step, options, stats, runtime) {
@@ -53,7 +50,9 @@ function createHotStepProcessor(name, target) {
         const hotUpdateManifest = [];
         const changedFiles = step === 0
             ? []
-            : processor.hotUpdateContext.changedFiles.map((i) => (0, helper_1.escapeSep)(node_path_1.default.relative(context.getSource(), i)));
+            : processor.updatePlugin
+                .getModifiedFiles()
+                .map((i) => (0, helper_1.escapeSep)(node_path_1.default.relative(temp, i)));
         changedFiles.sort();
         const resultHashes = {
             [lastHash || "LAST_HASH"]: "LAST_HASH",
@@ -245,7 +244,7 @@ ${runtime.javascript.disposedModules.map(i => `- ${i}`).join("\n")}
     }
     const originRun = processor.run;
     processor.run = async function (env, context) {
-        context.setValue(name, "hotUpdateStepChecker", (hotUpdateContext, stats, runtime) => {
+        context.setValue(name, "hotUpdateStepChecker", (updateIndex, stats, runtime) => {
             const statsJson = stats.toJson({
                 assets: true,
                 chunks: true
@@ -264,10 +263,10 @@ ${runtime.javascript.disposedModules.map(i => `- ${i}`).join("\n")}
             }
             const compiler = context.getCompiler(name, type_1.ECompilerType.Rspack);
             const compilerOptions = compiler.getOptions();
-            matchStepSnapshot(env, context, hotUpdateContext.updateIndex, compilerOptions, statsJson, runtime);
+            matchStepSnapshot(env, context, updateIndex, compilerOptions, statsJson, runtime);
             hashes.push(stats.hash);
         });
-        context.setValue(name, "hotUpdateStepErrorChecker", (_, stats, runtime) => {
+        context.setValue(name, "hotUpdateStepErrorChecker", (updateIndex, stats, runtime) => {
             hashes.push(stats.hash);
         });
         await originRun(env, context);
@@ -312,8 +311,8 @@ function getCreator(target) {
             clean: true,
             describe: false,
             target,
-            steps: ({ name, target }) => [
-                createHotStepProcessor(name, target)
+            steps: ({ name, target, src, temp, dist }) => [
+                createHotStepProcessor(name, src, temp || node_path_1.default.resolve(dist, "temp"), target)
             ],
             runner: {
                 key: (context, name, file) => name,
@@ -324,7 +323,7 @@ function getCreator(target) {
     }
     return creators.get(target);
 }
-function createHotStepCase(name, src, dist, target) {
+function createHotStepCase(name, src, dist, temp, target) {
     const creator = getCreator(target);
-    creator.create(name, src, dist);
+    creator.create(name, src, dist, temp);
 }

package/dist/case/hot.d.ts

@@ -1,9 +1,10 @@
-import { type ECompilerType, type ITestContext, type ITestEnv, type ITestProcessor, type ITestRunner, type TCompilerOptions, type THotUpdateContext } from "../type";
+import { HotUpdatePlugin } from "../helper/hot-update/plugin";
+import type { ECompilerType, ITestContext, ITestEnv, ITestProcessor, ITestRunner, TCompilerOptions } from "../type";
 type TTarget = TCompilerOptions<ECompilerType.Rspack>["target"];
-export declare function createHotProcessor(name: string, target: TTarget, incremental?: boolean): THotProcessor;
-export declare function createHotCase(name: string, src: string, dist: string, target: TCompilerOptions<ECompilerType.Rspack>["target"]): void;
+export declare function createHotProcessor(name: string, src: string, temp: string, target: TTarget, incremental?: boolean): THotProcessor;
+export declare function createHotCase(name: string, src: string, dist: string, temp: string, target: TCompilerOptions<ECompilerType.Rspack>["target"]): void;
 type THotProcessor = ITestProcessor & {
-    hotUpdateContext: THotUpdateContext;
+    updatePlugin: HotUpdatePlugin;
 };
 export declare function createHotRunner<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string, file: string, env: ITestEnv): ITestRunner;
 export {};