@rspack-debug/test-tools 1.4.9 → 1.6.2

package/README.md

@@ -16,7 +16,7 @@ We expect to reuse the tests for Rspack wasm target as many as possible and we h
 2. Set `maxWorkers` to `1`, `maxConcurrency` to `1` and disable concurrent mode to avoid flaky failures.
 3. `forceExit` is needed.
 
-Also check all the skipped testcases with `!process.env.WASM` in `test.filter.js`s and the skipped testsuits in `jest.config.js`s. They are divided into two categories:
+Also check all the skipped testcases with `!process.env.WASM` in `test.filter.js`s and the skipped testsuits in `rstest.config.ts`s. They are divided into two categories:
 
 1. Skip due to lacks of api support, such as tests related to swc wasm plugins, pnp and profiling. We skip them to avoid obsolete snapshot errors.
 2. Skip temporarily and should be investigate in the future. There could be something wrong with test harness and rspack wasm itself. Since it could be time-consuming to figure out all of them so in this stage we use the wasm test ci to avoid the regression rather than improve its stability.

package/dist/case/builtin.d.ts

@@ -1 +1,4 @@
+import type { RspackOptions } from "@rspack/core";
+import type { ITestContext } from "../type";
 export declare function createBuiltinCase(name: string, src: string, dist: string): void;
+export declare function defaultOptions(context: ITestContext): RspackOptions;

package/dist/case/builtin.js

@@ -4,16 +4,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createBuiltinCase = createBuiltinCase;
+exports.defaultOptions = defaultOptions;
 const node_path_1 = __importDefault(require("node:path"));
-const processor_1 = require("../processor");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const webpack_merge_1 = require("webpack-merge");
+const helper_1 = require("../helper");
 const creator_1 = require("../test/creator");
-const type_1 = require("../type");
-const FILTERS = {
-    "plugin-css": (file) => file.endsWith(".css"),
-    "plugin-css-modules": (file) => file.endsWith(".css") ||
-        (file.endsWith(".js") && !file.includes("runtime")),
-    "plugin-html": (file) => file.endsWith(".html")
-};
+const common_1 = require("./common");
 const creator = new creator_1.BasicCaseCreator({
     clean: true,
     describe: false,
@@ -24,12 +21,24 @@ const creator = new creator_1.BasicCaseCreator({
         const cat = node_path_1.default.basename(node_path_1.default.dirname(src));
         const filter = FILTERS[cat];
         return [
-            new processor_1.BuiltinProcessor({
-                name,
-                snapshot: "output.snap.txt",
-                snapshotFileFilter: filter,
-                compilerType: type_1.ECompilerType.Rspack
-            })
+            {
+                config: async (context) => {
+                    const compiler = context.getCompiler();
+                    compiler.setOptions(defaultOptions(context));
+                },
+                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 snapshot
+                },
+                check: async (env, context) => {
+                    await (0, common_1.checkSnapshot)(env, context, name, "output.snap.txt", filter);
+                }
+            }
         ];
     },
     concurrent: true
@@ -37,3 +46,132 @@ const creator = new creator_1.BasicCaseCreator({
 function createBuiltinCase(name, src, dist) {
     creator.create(name, src, dist);
 }
+function defaultOptions(context) {
+    let defaultOptions = {
+        entry: {
+            main: {
+                import: "./index"
+            }
+        },
+        output: {
+            publicPath: "/",
+            path: context.getDist(),
+            filename: "[name].js",
+            chunkFilename: "[name].js",
+            chunkFormat: "array-push",
+            cssFilename: "[name].css",
+            cssChunkFilename: "[name].css",
+            assetModuleFilename: "[hash][ext][query]",
+            sourceMapFilename: "[file].map",
+            chunkLoadingGlobal: "webpackChunkwebpack",
+            chunkLoading: "jsonp",
+            uniqueName: "__rspack_test__",
+            enabledLibraryTypes: ["system"],
+            strictModuleErrorHandling: false,
+            iife: true,
+            module: false,
+            asyncChunks: true,
+            scriptType: false,
+            globalObject: "self",
+            importFunctionName: "import",
+            wasmLoading: "fetch",
+            webassemblyModuleFilename: "[hash].module.wasm",
+            workerChunkLoading: "import-scripts",
+            workerWasmLoading: "fetch"
+        },
+        module: {
+            rules: [
+                {
+                    test: /\.json$/,
+                    type: "json"
+                },
+                {
+                    test: /\.mjs$/,
+                    type: "javascript/esm"
+                },
+                {
+                    test: /\.cjs$/,
+                    type: "javascript/dynamic"
+                },
+                {
+                    test: /\.js$/,
+                    type: "javascript/auto"
+                },
+                {
+                    test: /\.css$/,
+                    type: "css"
+                },
+                {
+                    test: /\.wasm$/,
+                    type: "webassembly/async"
+                }
+            ]
+        },
+        node: {
+            __dirname: "mock",
+            __filename: "mock",
+            global: "warn"
+        },
+        optimization: {
+            runtimeChunk: {
+                name: "runtime"
+            },
+            minimize: false,
+            removeAvailableModules: true,
+            removeEmptyChunks: true,
+            moduleIds: "named",
+            chunkIds: "named",
+            sideEffects: false,
+            mangleExports: false,
+            usedExports: false,
+            concatenateModules: false,
+            nodeEnv: false
+        },
+        resolve: {
+            extensions: [
+                ".js",
+                ".jsx",
+                ".ts",
+                ".tsx",
+                ".json",
+                ".d.ts",
+                ".css",
+                ".wasm"
+            ]
+        },
+        resolveLoader: {
+            extensions: [".js"]
+        },
+        experiments: {
+            css: true,
+            futureDefaults: true,
+            rspackFuture: {
+                bundlerInfo: {
+                    force: false
+                }
+            }
+        },
+        devtool: false,
+        context: context.getSource(),
+        plugins: []
+    };
+    const testConfigFile = context.getSource("rspack.config.js");
+    if (fs_extra_1.default.existsSync(testConfigFile)) {
+        const caseOptions = require(testConfigFile);
+        if (caseOptions.entry) {
+            delete defaultOptions.entry;
+        }
+        defaultOptions = (0, webpack_merge_1.merge)(defaultOptions, caseOptions);
+    }
+    if (!global.printLogger) {
+        defaultOptions.infrastructureLogging = {
+            level: "error"
+        };
+    }
+    return defaultOptions;
+}
+const FILTERS = {
+    "plugin-css": (file) => file.endsWith(".css"),
+    "plugin-css-modules": (file) => file.endsWith(".css") || ((0, helper_1.isJavaScript)(file) && !file.includes("runtime")),
+    "plugin-html": (file) => file.endsWith(".html")
+};

package/dist/case/cache.d.ts

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

package/dist/case/cache.js

@@ -1,11 +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.createCacheCase = createCacheCase;
-const cache_1 = require("../processor/cache");
+const node_path_1 = __importDefault(require("node:path"));
+const core_1 = __importDefault(require("@rspack/core"));
+const helper_1 = require("../helper");
+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 creators = new Map();
+const common_1 = require("./common");
+const runner_2 = require("./runner");
+const MAX_COMPILER_INDEX = 100;
+function createCacheProcessor(name, src, temp, target) {
+    const updatePlugin = new hot_update_1.HotUpdatePlugin(src, temp);
+    return {
+        before: async (context) => {
+            await updatePlugin.initialize();
+            context.setValue("hotUpdateContext", updatePlugin);
+        },
+        config: async (context) => {
+            const compiler = context.getCompiler();
+            let options = defaultOptions(context, temp, target);
+            options = await (0, common_1.config)(context, name, ["rspack.config.js", "webpack.config.js"].map(i => node_path_1.default.resolve(temp, i)), options);
+            overrideOptions(options, temp, target, updatePlugin);
+            compiler.setOptions(options);
+        },
+        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 => findBundle(name, target, context));
+        },
+        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();
+            if (updateIndex + 1 !== totalUpdates) {
+                throw new Error(`Should run all hot steps (${updateIndex + 1} / ${totalUpdates}): ${name}`);
+            }
+        }
+    };
+}
 function getCreator(target) {
     if (!creators.has(target)) {
         creators.set(target, new creator_1.BasicCaseCreator({
@@ -13,16 +59,12 @@ function getCreator(target) {
             describe: true,
             target,
             steps: ({ name, src, target, temp }) => [
-                new cache_1.CacheProcessor({
-                    name,
-                    sourceDir: src,
-                    tempDir: temp,
-                    target: target,
-                    compilerType: type_1.ECompilerType.Rspack,
-                    configFiles: ["rspack.config.js", "webpack.config.js"]
-                })
+                createCacheProcessor(name, src, temp, target)
             ],
-            runner: runner_1.CacheRunnerFactory,
+            runner: {
+                key: (context, name, file) => name,
+                runner: createRunner
+            },
             concurrent: true
         }));
     }
@@ -32,3 +74,163 @@ function createCacheCase(name, src, dist, target, temp) {
     const creator = getCreator(target);
     creator.create(name, src, dist, temp);
 }
+const creators = new Map();
+function defaultOptions(context, temp, target) {
+    const options = {
+        context: temp,
+        mode: "production",
+        cache: true,
+        devtool: false,
+        output: {
+            path: context.getDist(),
+            filename: "bundle.js",
+            chunkFilename: "[name].chunk.[fullhash].js",
+            publicPath: "https://test.cases/path/",
+            library: { type: "commonjs2" }
+        },
+        optimization: {
+            moduleIds: "named",
+            emitOnErrors: true
+        },
+        target,
+        experiments: {
+            css: true,
+            rspackFuture: {
+                bundlerInfo: {
+                    force: false
+                }
+            },
+            inlineConst: true
+        }
+    };
+    options.plugins ??= [];
+    options.plugins.push(new core_1.default.HotModuleReplacementPlugin());
+    return options;
+}
+function overrideOptions(options, temp, target, updatePlugin) {
+    if (!options.entry) {
+        options.entry = "./index.js";
+    }
+    // rewrite context to temp dir
+    options.context = temp;
+    options.module ??= {};
+    for (const cssModuleType of ["css/auto", "css/module", "css"]) {
+        options.module.generator ??= {};
+        options.module.generator[cssModuleType] ??= {};
+        options.module.generator[cssModuleType].exportsOnly ??=
+            target === "async-node";
+    }
+    options.plugins ??= [];
+    options.plugins.push(updatePlugin);
+    if (!global.printLogger) {
+        options.infrastructureLogging = {
+            level: "error"
+        };
+    }
+}
+function findBundle(name, target, context) {
+    const files = [];
+    const prefiles = [];
+    const compiler = context.getCompiler();
+    if (!compiler)
+        throw new Error("Compiler should exists when find bundle");
+    const stats = compiler.getStats();
+    if (!stats)
+        throw new Error("Stats should exists when find bundle");
+    const info = stats.toJson({
+        all: false,
+        entrypoints: true
+    });
+    if (target === "web" || target === "webworker") {
+        for (const file of info.entrypoints.main.assets) {
+            if ((0, helper_1.isJavaScript)(file.name)) {
+                files.push(file.name);
+            }
+            else {
+                prefiles.push(file.name);
+            }
+        }
+    }
+    else {
+        const assets = info.entrypoints.main.assets.filter(s => (0, helper_1.isJavaScript)(s.name));
+        files.push(assets[assets.length - 1].name);
+    }
+    return [...prefiles, ...files];
+}
+function createRunner(context, name, file, env) {
+    const compiler = context.getCompiler();
+    const options = compiler.getOptions();
+    let compilerIndex = 0;
+    const testConfig = context.getTestConfig();
+    const source = context.getSource();
+    const dist = context.getDist();
+    const updatePlugin = context.getValue("hotUpdateContext");
+    const getWebRunner = () => {
+        return new runner_1.NodeRunner({
+            env,
+            stats: (0, runner_2.cachedStats)(context, name),
+            cachable: false,
+            name: name,
+            runInNewContext: false,
+            testConfig: {
+                ...testConfig,
+                moduleScope(ms, stats, options) {
+                    const moduleScope = typeof testConfig.moduleScope === "function"
+                        ? testConfig.moduleScope(ms, stats, options)
+                        : ms;
+                    moduleScope.COMPILER_INDEX = compilerIndex;
+                    moduleScope.NEXT_HMR = nextHmr;
+                    moduleScope.NEXT_START = nextStart;
+                    return moduleScope;
+                }
+            },
+            source,
+            dist,
+            compilerOptions: options
+        });
+    };
+    const nextHmr = async (m, options) => {
+        await updatePlugin.goNext();
+        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 updateIndex = updatePlugin.getUpdateIndex();
+        await (0, checkArrayExpectation_1.default)(source, jsonStats, "error", `errors${updateIndex}`, "Error", compilerOptions);
+        await (0, checkArrayExpectation_1.default)(source, jsonStats, "warning", `warnings${updateIndex}`, "Warning", compilerOptions);
+        const updatedModules = await m.hot.check(options || true);
+        if (!updatedModules) {
+            throw new Error("No update available");
+        }
+        return jsonStats;
+    };
+    const nextStart = async () => {
+        await compiler.close();
+        compiler.createCompiler();
+        await updatePlugin.goNext();
+        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 updateIndex = updatePlugin.getUpdateIndex();
+        await (0, checkArrayExpectation_1.default)(source, jsonStats, "error", `errors${updateIndex}`, "Error", compilerOptions);
+        await (0, checkArrayExpectation_1.default)(source, jsonStats, "warning", `warnings${updateIndex}`, "Warning", compilerOptions);
+        env.it(`NEXT_START run with compilerIndex==${compilerIndex + 1}`, async () => {
+            if (compilerIndex > MAX_COMPILER_INDEX) {
+                throw new Error("NEXT_START has been called more than the maximum times");
+            }
+            compilerIndex++;
+            return getWebRunner().run(file);
+        });
+        return jsonStats;
+    };
+    return getWebRunner();
+}

package/dist/case/common.d.ts

@@ -0,0 +1,11 @@
+import type { Compiler, RspackOptions } from "@rspack/core";
+import type { ITestContext, ITestEnv } from "../type";
+export declare function config(context: ITestContext, name: string, configFiles: string[], defaultOptions?: RspackOptions): Promise<RspackOptions>;
+export declare function compiler(context: ITestContext, name: string): Promise<Compiler>;
+export declare function build(context: ITestContext, name: string): Promise<Compiler>;
+export declare function run(env: ITestEnv, context: ITestContext, name: string, findBundle: (context: ITestContext, options: RspackOptions) => string[] | string | void): Promise<void>;
+export declare function check(env: ITestEnv, context: ITestContext, name: string): Promise<void>;
+export declare function checkSnapshot(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(context: ITestContext, name: string, multiFindBundle: (index: number, context: ITestContext, options: RspackOptions) => string[] | string | void): string[];
+export declare function configMultiCompiler(context: ITestContext, name: string, configFiles: string[], defaultOptions: (index: number, context: ITestContext) => RspackOptions, overrideOptions: (index: number, context: ITestContext, options: RspackOptions) => void): void;