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

package/dist/case/hot.js

@@ -9,27 +9,26 @@ exports.createHotRunner = createHotRunner;
 const node_path_1 = __importDefault(require("node:path"));
 const core_1 = __importDefault(require("@rspack/core"));
 const helper_1 = require("../helper");
+const plugin_1 = require("../helper/hot-update/plugin");
 const checkArrayExpectation_1 = __importDefault(require("../helper/legacy/checkArrayExpectation"));
-const plugins_1 = require("../helper/plugins");
-const plugin_1 = require("../plugin");
+const plugin_2 = require("../plugin");
 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 creators = new Map();
-function createHotProcessor(name, target, incremental = false) {
-    const hotUpdateContext = {
-        updateIndex: 0,
-        totalUpdates: 1,
-        changedFiles: []
-    };
+function createHotProcessor(name, src, temp, target, incremental = false) {
+    const updatePlugin = new plugin_1.HotUpdatePlugin(src, temp);
     const processor = {
+        before: async (context) => {
+            await updatePlugin.initialize();
+            context.setValue(name, "hotUpdatePlugin", updatePlugin);
+        },
         config: async (context) => {
             const compiler = (0, common_1.getCompiler)(context, name);
-            let options = defaultOptions(context, target, hotUpdateContext);
+            let options = defaultOptions(context, target);
             options = await (0, common_1.config)(context, name, ["rspack.config.js", "webpack.config.js"], options);
-            overrideOptions(context, options, target, hotUpdateContext);
+            overrideOptions(context, options, target, updatePlugin);
             if (incremental) {
                 options.experiments ??= {};
                 options.experiments.incremental ??= "advance-silent";
@@ -43,22 +42,26 @@ function createHotProcessor(name, target, incremental = false) {
             await (0, common_1.build)(context, name);
         },
         run: async (env, context) => {
-            context.setValue(name, "hotUpdateContext", hotUpdateContext);
-            await (0, common_1.run)(env, context, name, context => findBundle(context, name, target, hotUpdateContext));
+            await (0, common_1.run)(env, context, name, context => findBundle(context, name, target, updatePlugin));
         },
         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) => {
             if (context.getTestConfig().checkSteps === false) {
                 return;
             }
-            if (hotUpdateContext.updateIndex + 1 !== hotUpdateContext.totalUpdates) {
-                throw new Error(`Should run all hot steps (${hotUpdateContext.updateIndex + 1} / ${hotUpdateContext.totalUpdates}): ${name}`);
+            const updateIndex = updatePlugin.getUpdateIndex();
+            const totalUpdates = updatePlugin.getTotalUpdates();
+            if (updateIndex + 1 !== totalUpdates) {
+                throw new Error(`Should run all hot steps (${updateIndex + 1} / ${totalUpdates}): ${name}`);
             }
         }
     };
-    processor.hotUpdateContext = hotUpdateContext;
+    processor.updatePlugin = updatePlugin;
     return processor;
 }
 function getCreator(target) {
@@ -67,8 +70,8 @@ function getCreator(target) {
             clean: true,
             describe: true,
             target,
-            steps: ({ name, target }) => [
-                createHotProcessor(name, target)
+            steps: ({ name, target, src, dist, temp }) => [
+                createHotProcessor(name, src, temp || node_path_1.default.resolve(dist, "temp"), target)
             ],
             runner: {
                 key: (context, name, file) => name,
@@ -79,11 +82,11 @@ function getCreator(target) {
     }
     return creators.get(target);
 }
-function createHotCase(name, src, dist, target) {
+function createHotCase(name, src, dist, temp, target) {
     const creator = getCreator(target);
-    creator.create(name, src, dist);
+    creator.create(name, src, dist, temp);
 }
-function defaultOptions(context, target, updateOptions) {
+function defaultOptions(context, target) {
     const options = {
         context: context.getSource(),
         mode: "development",
@@ -108,15 +111,14 @@ function defaultOptions(context, target, updateOptions) {
                     force: false
                 }
             },
-            inlineConst: true,
-            lazyBarrel: true
+            inlineConst: true
         }
     };
     options.plugins ??= [];
-    options.plugins.push(new core_1.default.HotModuleReplacementPlugin(), new plugins_1.TestHotUpdatePlugin(updateOptions));
+    options.plugins.push(new core_1.default.HotModuleReplacementPlugin());
     return options;
 }
-function overrideOptions(context, options, target, updateOptions) {
+function overrideOptions(context, options, target, updatePlugin) {
     if (!options.entry) {
         options.entry = "./index.js";
     }
@@ -127,34 +129,24 @@ function overrideOptions(context, options, target, updateOptions) {
         options.module.generator[cssModuleType].exportsOnly ??=
             target === "async-node";
     }
-    options.module.rules ??= [];
-    options.module.rules.push({
-        use: [
-            {
-                loader: node_path_1.default.resolve(__dirname, "../helper/loaders/hot-update.js"),
-                options: updateOptions
-            }
-        ],
-        enforce: "pre"
-    });
     options.plugins ??= [];
-    options.plugins.push(new core_1.default.LoaderOptionsPlugin(updateOptions));
+    options.plugins.push(updatePlugin);
     if (!global.printLogger) {
         options.infrastructureLogging = {
             level: "error"
         };
     }
     if (options.lazyCompilation) {
-        options.plugins.push(new plugin_1.LazyCompilationTestPlugin());
+        options.plugins.push(new plugin_2.LazyCompilationTestPlugin());
     }
 }
-function findBundle(context, name, target, updateOptions) {
+function findBundle(context, name, target, updatePlugin) {
     const compiler = context.getCompiler(name);
     if (!compiler)
         throw new Error("Compiler should exists when find bundle");
     const testConfig = context.getTestConfig();
     if (typeof testConfig.findBundle === "function") {
-        return testConfig.findBundle(updateOptions.updateIndex, compiler.getOptions());
+        return testConfig.findBundle(updatePlugin.getUpdateIndex(), compiler.getOptions());
     }
     const files = [];
     const prefiles = [];
@@ -184,68 +176,43 @@ function createHotRunner(context, name, file, env) {
     const testConfig = context.getTestConfig();
     const source = context.getSource();
     const dist = context.getDist();
-    const hotUpdateContext = context.getValue(name, "hotUpdateContext");
-    const next = async (callback) => {
-        const usePromise = typeof callback === "function";
-        try {
-            hotUpdateContext.updateIndex++;
-            const stats = await compiler.build();
-            if (!stats) {
-                throw new Error("Should generate stats during build");
-            }
-            const jsonStats = stats.toJson({
-            // errorDetails: true
-            });
-            const compilerOptions = compiler.getOptions();
-            const checker = context.getValue(name, jsonStats.errors?.length
-                ? "hotUpdateStepErrorChecker"
-                : "hotUpdateStepChecker");
-            if (checker) {
-                checker(hotUpdateContext, stats, runner.getGlobal("__HMR_UPDATED_RUNTIME__"));
-            }
-            await (0, checkArrayExpectation_1.default)(source, jsonStats, "error", `errors${hotUpdateContext.updateIndex}`, "Error", compilerOptions);
-            await (0, checkArrayExpectation_1.default)(source, jsonStats, "warning", `warnings${hotUpdateContext.updateIndex}`, "Warning", compilerOptions);
-            if (usePromise) {
-                // old callback style hmr cases
-                callback(null, jsonStats);
-            }
-            else {
-                // new promise style hmr cases
-                return jsonStats;
-            }
+    const updatePlugin = context.getValue(name, "hotUpdatePlugin");
+    const nextHMR = async (m, options) => {
+        await updatePlugin.goNext();
+        const stats = await compiler.build();
+        if (!stats) {
+            throw new Error("Should generate stats during build");
         }
-        catch (e) {
-            if (usePromise) {
-                callback(e);
-            }
-            else {
-                throw e;
-            }
+        const jsonStats = stats.toJson({
+        // errorDetails: true
+        });
+        const compilerOptions = compiler.getOptions();
+        const checker = context.getValue(name, jsonStats.errors?.length
+            ? "hotUpdateStepErrorChecker"
+            : "hotUpdateStepChecker");
+        if (checker) {
+            checker(updatePlugin.getUpdateIndex(), stats, runner.getGlobal("__HMR_UPDATED_RUNTIME__"));
         }
-    };
-    const nextHMR = async (m, options) => {
-        const jsonStats = await next();
+        await (0, checkArrayExpectation_1.default)(source, jsonStats, "error", `errors${updatePlugin.getUpdateIndex()}`, "Error", compilerOptions);
+        await (0, checkArrayExpectation_1.default)(source, jsonStats, "warning", `warnings${updatePlugin.getUpdateIndex()}`, "Warning", compilerOptions);
         const updatedModules = await m.hot.check(options || true);
         if (!updatedModules) {
             throw new Error("No update available");
         }
         return jsonStats;
     };
-    const runner = new runner_1.WebRunner({
-        dom: context.getValue(name, "documentType") || type_1.EDocumentType.JSDOM,
+    const commonOptions = {
         env,
         stats: (0, runner_2.cachedStats)(context, name),
         name: name,
         runInNewContext: false,
         testConfig: {
-            documentType: testConfig.documentType || type_1.EDocumentType.Fake,
             ...testConfig,
             moduleScope(ms, stats, options) {
                 const moduleScope = ms;
                 if (typeof testConfig.moduleScope === "function") {
                     testConfig.moduleScope(moduleScope, stats, compilerOptions);
                 }
-                moduleScope.NEXT = next;
                 moduleScope.NEXT_HMR = nextHMR;
                 return moduleScope;
             }
@@ -254,6 +221,17 @@ function createHotRunner(context, name, file, env) {
         source,
         dist,
         compilerOptions
-    });
+    };
+    let runner;
+    if (compilerOptions.target === "web" ||
+        compilerOptions.target === "webworker") {
+        runner = new runner_1.WebRunner({
+            location: testConfig.location || "https://test.cases/path/index.html",
+            ...commonOptions
+        });
+    }
+    else {
+        runner = new runner_1.NodeRunner(commonOptions);
+    }
     return runner;
 }

package/dist/case/incremental.d.ts

@@ -1,5 +1,5 @@
-import { type ECompilerType, type TCompilerOptions } from "../type";
-export declare function createHotIncrementalCase(name: string, src: string, dist: string, target: TCompilerOptions<ECompilerType.Rspack>["target"], webpackCases: boolean): void;
+import type { ECompilerType, TCompilerOptions } from "../type";
+export declare function createHotIncrementalCase(name: string, src: string, dist: string, temp: string, target: TCompilerOptions<ECompilerType.Rspack>["target"], webpackCases: boolean): void;
 export type WatchIncrementalOptions = {
     ignoreNotFriendlyForIncrementalWarnings?: boolean;
 };

package/dist/case/incremental.js

@@ -8,28 +8,11 @@ exports.createWatchIncrementalCase = createWatchIncrementalCase;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const creator_1 = require("../test/creator");
-const type_1 = require("../type");
 const hot_1 = require("./hot");
 const watch_1 = require("./watch");
 const hotCreators = new Map();
-function createHotIncrementalProcessor(name, target, webpackCases) {
-    const processor = (0, hot_1.createHotProcessor)(name, target, true);
-    processor.before = async (context) => {
-        context.setValue(name, "documentType", webpackCases ? type_1.EDocumentType.Fake : type_1.EDocumentType.JSDOM);
-    };
-    const originalAfterAll = processor.afterAll;
-    processor.afterAll = async function (context) {
-        try {
-            await originalAfterAll?.(context);
-        }
-        catch (e) {
-            const isFake = context.getValue(name, "documentType") === type_1.EDocumentType.Fake;
-            if (isFake && /Should run all hot steps/.test(e.message))
-                return;
-            throw e;
-        }
-    };
-    return processor;
+function createHotIncrementalProcessor(name, src, temp, target, webpackCases) {
+    return (0, hot_1.createHotProcessor)(name, src, temp, target, true);
 }
 function getHotCreator(target, webpackCases) {
     const key = JSON.stringify({ target, webpackCases });
@@ -38,8 +21,8 @@ function getHotCreator(target, webpackCases) {
             clean: true,
             describe: true,
             target,
-            steps: ({ name, target }) => [
-                createHotIncrementalProcessor(name, target, webpackCases)
+            steps: ({ name, target, src, temp, dist }) => [
+                createHotIncrementalProcessor(name, src, temp || node_path_1.default.resolve(dist, "temp"), target, webpackCases)
             ],
             runner: {
                 key: (context, name, file) => name,
@@ -50,9 +33,9 @@ function getHotCreator(target, webpackCases) {
     }
     return hotCreators.get(key);
 }
-function createHotIncrementalCase(name, src, dist, target, webpackCases) {
+function createHotIncrementalCase(name, src, dist, temp, target, webpackCases) {
     const creator = getHotCreator(target, webpackCases);
-    creator.create(name, src, dist);
+    creator.create(name, src, dist, temp);
 }
 const watchCreators = new Map();
 function getWatchCreator(options) {
@@ -79,12 +62,10 @@ function getWatchCreator(options) {
                     .map(name => ({ name }));
                 return runs.map((run, index) => index === 0
                     ? (0, watch_1.createWatchInitialProcessor)(name, temp, run.name, watchState, {
-                        incremental: true,
-                        ignoreNotFriendlyForIncrementalWarnings: options.ignoreNotFriendlyForIncrementalWarnings
+                        incremental: true
                     })
                     : (0, watch_1.createWatchStepProcessor)(name, temp, run.name, watchState, {
-                        incremental: true,
-                        ignoreNotFriendlyForIncrementalWarnings: options.ignoreNotFriendlyForIncrementalWarnings
+                        incremental: true
                     }));
             },
             concurrent: true

package/dist/case/index.d.ts

@@ -1,20 +1,31 @@
 export { createBuiltinCase } from "./builtin";
 export { createCacheCase } from "./cache";
+export type { TCompilerCaseConfig } from "./compiler";
 export { createCompilerCase } from "./compiler";
+export type { TConfigCaseConfig } from "./config";
 export { createConfigCase } from "./config";
+export type { TDefaultsCaseConfig } from "./defaults";
 export { createDefaultsCase, getRspackDefaultConfig } from "./defaults";
+export type { TDiagnosticOptions } from "./diagnostic";
 export { createDiagnosticCase } from "./diagnostic";
 export { createDiffCase } from "./diff";
+export type { TErrorCaseConfig } from "./error";
 export { createErrorCase } from "./error";
 export { createEsmOutputCase } from "./esm-output";
+export { createExampleCase } from "./example";
+export type { THashCaseConfig } from "./hash";
 export { createHashCase } from "./hash";
+export type { THookCaseConfig } from "./hook";
 export { createHookCase } from "./hook";
 export { createHotCase } from "./hot";
 export { createHotStepCase } from "./hot-step";
 export { createHotIncrementalCase, createWatchIncrementalCase } from "./incremental";
+export type { TMultiCompilerCaseConfig } from "./multi-compiler";
+export { createMultiCompilerCase } from "./multi-compiler";
 export { createNativeWatcher } from "./native-watcher";
-export { createHotNormalCase, createNormalCase } from "./normal";
+export { createDevNormalCase, createHotNormalCase, createNormalCase, createProdNormalCase } from "./normal";
 export { createSerialCase } from "./serial";
+export type { TStatsAPICaseConfig } from "./stats-api";
 export { createStatsAPICase } from "./stats-api";
 export { createStatsOutputCase } from "./stats-output";
 export { createTreeShakingCase } from "./treeshaking";

package/dist/case/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createWatchCase = exports.createTreeShakingCase = exports.createStatsOutputCase = exports.createStatsAPICase = exports.createSerialCase = exports.createNormalCase = exports.createHotNormalCase = exports.createNativeWatcher = exports.createWatchIncrementalCase = exports.createHotIncrementalCase = exports.createHotStepCase = exports.createHotCase = exports.createHookCase = exports.createHashCase = exports.createEsmOutputCase = exports.createErrorCase = exports.createDiffCase = exports.createDiagnosticCase = exports.getRspackDefaultConfig = exports.createDefaultsCase = exports.createConfigCase = exports.createCompilerCase = exports.createCacheCase = exports.createBuiltinCase = void 0;
+exports.createWatchCase = exports.createTreeShakingCase = exports.createStatsOutputCase = exports.createStatsAPICase = exports.createSerialCase = exports.createProdNormalCase = exports.createNormalCase = exports.createHotNormalCase = exports.createDevNormalCase = exports.createNativeWatcher = exports.createMultiCompilerCase = exports.createWatchIncrementalCase = exports.createHotIncrementalCase = exports.createHotStepCase = exports.createHotCase = exports.createHookCase = exports.createHashCase = exports.createExampleCase = exports.createEsmOutputCase = exports.createErrorCase = exports.createDiffCase = exports.createDiagnosticCase = exports.getRspackDefaultConfig = exports.createDefaultsCase = exports.createConfigCase = exports.createCompilerCase = exports.createCacheCase = exports.createBuiltinCase = void 0;
 var builtin_1 = require("./builtin");
 Object.defineProperty(exports, "createBuiltinCase", { enumerable: true, get: function () { return builtin_1.createBuiltinCase; } });
 var cache_1 = require("./cache");
@@ -20,6 +20,8 @@ var error_1 = require("./error");
 Object.defineProperty(exports, "createErrorCase", { enumerable: true, get: function () { return error_1.createErrorCase; } });
 var esm_output_1 = require("./esm-output");
 Object.defineProperty(exports, "createEsmOutputCase", { enumerable: true, get: function () { return esm_output_1.createEsmOutputCase; } });
+var example_1 = require("./example");
+Object.defineProperty(exports, "createExampleCase", { enumerable: true, get: function () { return example_1.createExampleCase; } });
 var hash_1 = require("./hash");
 Object.defineProperty(exports, "createHashCase", { enumerable: true, get: function () { return hash_1.createHashCase; } });
 var hook_1 = require("./hook");
@@ -31,11 +33,15 @@ Object.defineProperty(exports, "createHotStepCase", { enumerable: true, get: fun
 var incremental_1 = require("./incremental");
 Object.defineProperty(exports, "createHotIncrementalCase", { enumerable: true, get: function () { return incremental_1.createHotIncrementalCase; } });
 Object.defineProperty(exports, "createWatchIncrementalCase", { enumerable: true, get: function () { return incremental_1.createWatchIncrementalCase; } });
+var multi_compiler_1 = require("./multi-compiler");
+Object.defineProperty(exports, "createMultiCompilerCase", { enumerable: true, get: function () { return multi_compiler_1.createMultiCompilerCase; } });
 var native_watcher_1 = require("./native-watcher");
 Object.defineProperty(exports, "createNativeWatcher", { enumerable: true, get: function () { return native_watcher_1.createNativeWatcher; } });
 var normal_1 = require("./normal");
+Object.defineProperty(exports, "createDevNormalCase", { enumerable: true, get: function () { return normal_1.createDevNormalCase; } });
 Object.defineProperty(exports, "createHotNormalCase", { enumerable: true, get: function () { return normal_1.createHotNormalCase; } });
 Object.defineProperty(exports, "createNormalCase", { enumerable: true, get: function () { return normal_1.createNormalCase; } });
+Object.defineProperty(exports, "createProdNormalCase", { enumerable: true, get: function () { return normal_1.createProdNormalCase; } });
 var serial_1 = require("./serial");
 Object.defineProperty(exports, "createSerialCase", { enumerable: true, get: function () { return serial_1.createSerialCase; } });
 var stats_api_1 = require("./stats-api");

package/dist/case/multi-compiler.d.ts

@@ -0,0 +1,18 @@
+import type { ECompilerType, ITestContext, TCompilation, TCompiler, TCompilerOptions, TCompilerStats, TCompilerStatsCompilation } from "../type";
+export declare function createMultiCompilerCase(name: string, src: string, dist: string, testConfig: string): void;
+export type TMultiCompilerCaseConfig = {
+    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>;
+        files?: Record<string, string>;
+        compiler: TCompiler<ECompilerType.Rspack>;
+        compilation?: TCompilation<ECompilerType.Rspack>;
+    }) => Promise<void>;
+    compilerCallback?: (error: Error | null, stats: TCompilerStats<ECompilerType.Rspack> | null) => void;
+};

package/dist/case/multi-compiler.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMultiCompilerCase = createMultiCompilerCase;
+const node_path_1 = __importDefault(require("node:path"));
+const memfs_1 = require("memfs");
+const creator_1 = require("../test/creator");
+const common_1 = require("./common");
+function createMultiCompilerProcessor(name, caseConfig) {
+    return {
+        config: async (context) => {
+            const compiler = (0, common_1.getCompiler)(context, name);
+            const options = Object.assign([
+                {
+                    name: "a",
+                    context: node_path_1.default.join(__dirname, "fixtures"),
+                    entry: "./a.js"
+                },
+                {
+                    name: "b",
+                    context: node_path_1.default.join(__dirname, "fixtures"),
+                    entry: "./b.js"
+                }
+            ], caseConfig.options?.(context) || {});
+            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 = (0, memfs_1.createFsFromVolume)(new memfs_1.Volume());
+            c.watchFileSystem = {
+                watch() {
+                    // watch should return a watcher instance
+                    // watcher instance should have close, pause and getInfo methods
+                    return {
+                        close: () => { },
+                        pause: () => { },
+                        getInfo: () => {
+                            return {
+                                changes: new Set(),
+                                removals: new Set(),
+                                fileTimeInfoEntries: new Map(),
+                                directoryTimeInfoEntries: new Map()
+                            };
+                        }
+                    };
+                }
+            };
+            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 creator = new creator_1.BasicCaseCreator({
+    clean: true,
+    describe: false,
+    steps: ({ name, caseConfig }) => {
+        return [
+            createMultiCompilerProcessor(name, caseConfig)
+        ];
+    },
+    concurrent: false
+});
+function createMultiCompilerCase(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/normal.d.ts

@@ -1,2 +1,4 @@
 export declare function createNormalCase(name: string, src: string, dist: string): void;
 export declare function createHotNormalCase(name: string, src: string, dist: string): void;
+export declare function createDevNormalCase(name: string, src: string, dist: string): void;
+export declare function createProdNormalCase(name: string, src: string, dist: string): void;

package/dist/case/normal.js

@@ -5,14 +5,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNormalCase = createNormalCase;
 exports.createHotNormalCase = createHotNormalCase;
+exports.createDevNormalCase = createDevNormalCase;
+exports.createProdNormalCase = createProdNormalCase;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const core_1 = require("@rspack/core");
 const creator_1 = require("../test/creator");
 const common_1 = require("./common");
 const runner_1 = require("./runner");
-const NORMAL_CASES_ROOT = node_path_1.default.resolve(__dirname, "../../../../tests/rspack-test/normalCases");
-const createCaseOptions = (hot) => {
+const NORMAL_CASES_ROOT = node_path_1.default.resolve(__TEST_PATH__, "normalCases");
+const createCaseOptions = (hot, mode) => {
     return {
         clean: true,
         describe: false,
@@ -22,7 +24,7 @@ const createCaseOptions = (hot) => {
                     const compiler = (0, common_1.getCompiler)(context, name);
                     let options = defaultOptions(context, {
                         plugins: hot ? [new core_1.HotModuleReplacementPlugin()] : []
-                    });
+                    }, mode);
                     options = await (0, common_1.config)(context, name, ["rspack.config.js", "webpack.config.js"], options);
                     overrideOptions(context, options);
                     compiler.setOptions(options);
@@ -38,6 +40,9 @@ const createCaseOptions = (hot) => {
                 },
                 check: async (env, context) => {
                     await (0, common_1.check)(env, context, name);
+                },
+                after: async (context) => {
+                    await (0, common_1.afterExecute)(context, name);
                 }
             }
         ],
@@ -56,6 +61,14 @@ const hotCreator = new creator_1.BasicCaseCreator(createCaseOptions(true));
 function createHotNormalCase(name, src, dist) {
     hotCreator.create(name, src, dist);
 }
+const devCreator = new creator_1.BasicCaseCreator(createCaseOptions(false, "development"));
+function createDevNormalCase(name, src, dist) {
+    devCreator.create(name, src, dist);
+}
+const prodCreator = new creator_1.BasicCaseCreator(createCaseOptions(false, "production"));
+function createProdNormalCase(name, src, dist) {
+    prodCreator.create(name, src, dist);
+}
 function findBundle(context, options) {
     const testConfig = context.getTestConfig();
     if (typeof testConfig.findBundle === "function") {
@@ -64,7 +77,7 @@ function findBundle(context, options) {
     const filename = options.output?.filename;
     return typeof filename === "string" ? filename : undefined;
 }
-function defaultOptions(context, compilerOptions) {
+function defaultOptions(context, compilerOptions, mode) {
     let testConfig = {};
     const testConfigPath = node_path_1.default.join(context.getSource(), "test.config.js");
     if (node_fs_1.default.existsSync(testConfigPath)) {
@@ -80,11 +93,12 @@ function defaultOptions(context, compilerOptions) {
         entry: `./${node_path_1.default.relative(NORMAL_CASES_ROOT, context.getSource())}/`,
         target: compilerOptions?.target || "async-node",
         devtool: compilerOptions?.devtool,
-        mode: compilerOptions?.mode || "none",
+        mode: compilerOptions?.mode || mode || "none",
         optimization: compilerOptions?.mode
             ? {
-                // emitOnErrors: true,
+                emitOnErrors: true,
                 minimizer: [terserForTesting],
+                minimize: false,
                 ...testConfig.optimization
             }
             : {
@@ -98,7 +112,7 @@ function defaultOptions(context, compilerOptions) {
                 usedExports: true,
                 mangleExports: true,
                 // CHANGE: rspack does not support `emitOnErrors` yet.
-                // emitOnErrors: true,
+                emitOnErrors: true,
                 concatenateModules: !!testConfig?.optimization?.concatenateModules,
                 innerGraph: true,
                 // CHANGE: size is not supported yet
@@ -106,6 +120,7 @@ function defaultOptions(context, compilerOptions) {
                 // chunkIds: "size",
                 moduleIds: "named",
                 chunkIds: "named",
+                minimize: false,
                 minimizer: [terserForTesting],
                 ...compilerOptions?.optimization
             },
@@ -181,17 +196,12 @@ function defaultOptions(context, compilerOptions) {
             asyncWebAssembly: true,
             topLevelAwait: true,
             inlineConst: true,
-            lazyBarrel: true,
             // CHANGE: rspack does not support `backCompat` yet.
             // backCompat: false,
             // CHANGE: Rspack enables `css` by default.
             // Turning off here to fallback to webpack's default css processing logic.
             ...(compilerOptions?.module ? { outputModule: true } : {})
         }
-        // infrastructureLogging: compilerOptions?.cache && {
-        //   debug: true,
-        //   console: createLogger(infraStructureLog)
-        // }
     };
 }
 function overrideOptions(context, options) {

package/dist/case/runner.d.ts

@@ -1,4 +1,4 @@
-import { type ECompilerType, type ITestContext, type ITestEnv, type ITestRunner, type TCompilerStatsCompilation } from "../type";
+import type { ECompilerType, ITestContext, ITestEnv, ITestRunner, TCompilerStatsCompilation } from "../type";
 export type THotStepRuntimeLangData = {
     outdatedModules: string[];
     outdatedDependencies: Record<string, string[]>;