@rspack-debug/test-tools 1.4.9 → 1.6.2

package/dist/case/normal.js

@@ -4,26 +4,210 @@ 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 normal_1 = require("../processor/normal");
-const runner_1 = require("../runner");
+const core_1 = require("@rspack/core");
 const creator_1 = require("../test/creator");
-const type_1 = require("../type");
-const creator = new creator_1.BasicCaseCreator({
-    clean: true,
-    describe: false,
-    steps: ({ name }) => [
-        new normal_1.NormalProcessor({
-            name,
-            root: node_path_1.default.resolve(__dirname, "../../tests/normalCases"),
-            compilerOptions: {}, // do not used in rspack
-            runable: true,
-            compilerType: type_1.ECompilerType.Rspack
-        })
-    ],
-    runner: runner_1.NormalRunnerFactory,
-    concurrent: true
-});
+const common_1 = require("./common");
+const runner_1 = require("./runner");
+const NORMAL_CASES_ROOT = node_path_1.default.resolve(__TEST_PATH__, "normalCases");
+const createCaseOptions = (hot, mode) => {
+    return {
+        clean: true,
+        describe: false,
+        steps: ({ name }) => [
+            {
+                config: async (context) => {
+                    const compiler = context.getCompiler();
+                    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);
+                },
+                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, findBundle);
+                },
+                check: async (env, context) => {
+                    await (0, common_1.check)(env, context, name);
+                },
+                after: async (context) => {
+                    await (0, common_1.afterExecute)(context, name);
+                }
+            }
+        ],
+        runner: {
+            key: (context, name, file) => name,
+            runner: runner_1.createRunner
+        },
+        concurrent: true
+    };
+};
+const creator = new creator_1.BasicCaseCreator(createCaseOptions(false));
 function createNormalCase(name, src, dist) {
     creator.create(name, src, dist);
 }
+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") {
+        return testConfig.findBundle(0, options);
+    }
+    const filename = options.output?.filename;
+    return typeof filename === "string" ? filename : undefined;
+}
+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)) {
+        testConfig = require(testConfigPath);
+    }
+    const TerserPlugin = require("terser-webpack-plugin");
+    const terserForTesting = new TerserPlugin({
+        parallel: false
+    });
+    return {
+        amd: {},
+        context: NORMAL_CASES_ROOT,
+        entry: `./${node_path_1.default.relative(NORMAL_CASES_ROOT, context.getSource())}/`,
+        target: compilerOptions?.target || "async-node",
+        devtool: mode === "development" ? false : compilerOptions?.devtool,
+        mode: compilerOptions?.mode || mode || "none",
+        optimization: compilerOptions?.mode
+            ? {
+                emitOnErrors: true,
+                minimizer: [terserForTesting],
+                minimize: false,
+                ...testConfig.optimization
+            }
+            : {
+                removeAvailableModules: true,
+                removeEmptyChunks: true,
+                mergeDuplicateChunks: true,
+                // CHANGE: rspack does not support `flagIncludedChunks` yet.
+                // flagIncludedChunks: true,
+                sideEffects: true,
+                providedExports: true,
+                usedExports: true,
+                mangleExports: true,
+                // CHANGE: rspack does not support `emitOnErrors` yet.
+                emitOnErrors: true,
+                concatenateModules: !!testConfig?.optimization?.concatenateModules,
+                innerGraph: true,
+                // CHANGE: size is not supported yet
+                // moduleIds: "size",
+                // chunkIds: "size",
+                moduleIds: "named",
+                chunkIds: "named",
+                minimize: false,
+                minimizer: [terserForTesting],
+                ...compilerOptions?.optimization
+            },
+        // CHANGE: rspack does not support `performance` yet.
+        // performance: {
+        // 	hints: false
+        // },
+        node: {
+            __dirname: "mock",
+            __filename: "mock"
+        },
+        cache: compilerOptions?.cache && {
+            // cacheDirectory,
+            ...compilerOptions.cache
+        },
+        output: {
+            pathinfo: "verbose",
+            path: context.getDist(),
+            filename: compilerOptions?.module ? "bundle.mjs" : "bundle.js"
+        },
+        resolve: {
+            modules: ["web_modules", "node_modules"],
+            mainFields: ["webpack", "browser", "web", "browserify", "main"],
+            aliasFields: ["browser"],
+            extensions: [".webpack.js", ".web.js", ".js", ".json"]
+        },
+        resolveLoader: {
+            modules: ["web_loaders", "web_modules", "node_loaders", "node_modules"],
+            mainFields: ["webpackLoader", "webLoader", "loader", "main"],
+            extensions: [".webpack-loader.js", ".web-loader.js", ".loader.js", ".js"]
+        },
+        module: {
+            rules: [
+                {
+                    test: /\.coffee$/,
+                    loader: "coffee-loader"
+                },
+                {
+                    test: /\.pug/,
+                    loader: "@webdiscus/pug-loader"
+                },
+                {
+                    test: /\.wat$/i,
+                    loader: "wast-loader",
+                    type: "webassembly/async"
+                }
+            ]
+        },
+        plugins: (compilerOptions?.plugins || [])
+            .concat(testConfig.plugins || [])
+            .concat(function () {
+            this.hooks.compilation.tap("TestCasesTest", compilation => {
+                const hooks = [
+                // CHANGE: the following hooks are not supported yet, so comment it out
+                // "optimize",
+                // "optimizeModules",
+                // "optimizeChunks",
+                // "afterOptimizeTree",
+                // "afterOptimizeAssets"
+                ];
+                for (const hook of hooks) {
+                    compilation.hooks[hook].tap("TestCasesTest", () => compilation.checkConstraints());
+                }
+            });
+        }),
+        experiments: {
+            css: false,
+            rspackFuture: {
+                bundlerInfo: {
+                    force: false
+                }
+            },
+            asyncWebAssembly: true,
+            topLevelAwait: true,
+            inlineConst: 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 } : {})
+        }
+    };
+}
+function overrideOptions(context, options) {
+    if (!global.printLogger) {
+        options.infrastructureLogging = {
+            level: "error"
+        };
+    }
+}

package/dist/case/runner.d.ts

@@ -0,0 +1,19 @@
+import type { StatsCompilation } from "@rspack/core";
+import type { ITestContext, ITestEnv, ITestRunner } from "../type";
+export type THotStepRuntimeLangData = {
+    outdatedModules: string[];
+    outdatedDependencies: Record<string, string[]>;
+    updatedModules: string[];
+    updatedRuntime: string[];
+    acceptedModules: string[];
+    disposedModules: string[];
+};
+export type THotStepRuntimeData = {
+    javascript: THotStepRuntimeLangData;
+    css: THotStepRuntimeLangData;
+    statusPath: string[];
+};
+export declare function cachedStats(context: ITestContext, name: string): () => StatsCompilation;
+export declare function createRunner(context: ITestContext, name: string, file: string, env: ITestEnv): ITestRunner;
+export declare function getMultiCompilerRunnerKey(context: ITestContext, name: string, file: string): string;
+export declare function createMultiCompilerRunner(context: ITestContext, name: string, file: string, env: ITestEnv): ITestRunner;

package/dist/case/runner.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cachedStats = cachedStats;
+exports.createRunner = createRunner;
+exports.getMultiCompilerRunnerKey = getMultiCompilerRunnerKey;
+exports.createMultiCompilerRunner = createMultiCompilerRunner;
+const runner_1 = require("../runner");
+const debug_1 = require("../test/debug");
+function cachedStats(context, name) {
+    const compiler = context.getCompiler();
+    const statsGetter = (() => {
+        let cached = null;
+        return () => {
+            if (cached) {
+                return cached;
+            }
+            cached = compiler.getStats().toJson({
+                errorDetails: true
+            });
+            return cached;
+        };
+    })();
+    return statsGetter;
+}
+function createRunner(context, name, file, env) {
+    const compiler = context.getCompiler();
+    const testConfig = context.getTestConfig();
+    const compilerOptions = compiler.getOptions();
+    const runnerOptions = {
+        runInNewContext: false,
+        cachable: true,
+        env,
+        stats: cachedStats(context, name),
+        name,
+        testConfig: context.getTestConfig(),
+        source: context.getSource(),
+        dist: context.getDist(),
+        compilerOptions
+    };
+    if (compilerOptions.target === "web" ||
+        compilerOptions.target === "webworker") {
+        return new runner_1.WebRunner({
+            ...runnerOptions,
+            runInNewContext: true,
+            location: testConfig.location || "https://test.cases/path/index.html"
+        });
+    }
+    return new runner_1.NodeRunner(runnerOptions);
+}
+function getFileIndexHandler(context, name, file) {
+    const multiFileIndexMap = context.getValue("multiFileIndexMap") || {};
+    const runned = context.getValue("runned") || new Set();
+    if (typeof multiFileIndexMap[file] === "undefined") {
+        throw new Error("Unexpect file in multiple runner");
+    }
+    const indexList = multiFileIndexMap[file];
+    const seq = indexList.findIndex((index, n) => !runned.has(`${name}:${file}[${n}]`));
+    if (seq === -1) {
+        throw new Error(`File ${file} should run only ${indexList.length} times`);
+    }
+    const getIndex = () => [indexList[seq], seq];
+    const flagIndex = () => runned.add(`${name}:${file}[${seq}]`);
+    context.setValue("runned", runned);
+    return { getIndex, flagIndex };
+}
+function getMultiCompilerRunnerKey(context, name, file) {
+    const { getIndex } = getFileIndexHandler(context, name, file);
+    const [index, seq] = getIndex();
+    return `${name}-${index}[${seq}]`;
+}
+function createMultiCompilerRunner(context, name, file, env) {
+    const testConfig = context.getTestConfig();
+    const { getIndex, flagIndex } = getFileIndexHandler(context, name, file);
+    const multiCompilerOptions = context.getValue("multiCompilerOptions") || [];
+    const [index] = getIndex();
+    const compilerOptions = multiCompilerOptions[index];
+    const logs = context.getValue(debug_1.DEBUG_SCOPES.RunLogs);
+    const errors = context.getValue(debug_1.DEBUG_SCOPES.RunErrors);
+    let runner;
+    const runnerOptions = {
+        runInNewContext: false,
+        cachable: true,
+        env,
+        stats: () => {
+            const s = cachedStats(context, name)();
+            if (s.children?.length && s.children.length > 1) {
+                s.__index__ = index;
+                return s;
+            }
+            return s.children[index];
+        },
+        name,
+        testConfig: context.getTestConfig(),
+        source: context.getSource(),
+        dist: context.getDist(),
+        compilerOptions,
+        logs,
+        errors
+    };
+    if (compilerOptions.target === "web" ||
+        compilerOptions.target === "webworker") {
+        runner = new runner_1.WebRunner({
+            ...runnerOptions,
+            runInNewContext: true,
+            location: testConfig.location || "https://test.cases/path/index.html"
+        });
+    }
+    else {
+        runner = new runner_1.NodeRunner(runnerOptions);
+    }
+    flagIndex();
+    return runner;
+}

package/dist/case/serial.d.ts

@@ -1,3 +1,3 @@
-import { ECompilerType, type TTestConfig } from "../type";
-export type TSerialCaseConfig = Omit<TTestConfig<ECompilerType.Rspack>, "validate">;
+import type { TTestConfig } from "../type";
+export type TSerialCaseConfig = Omit<TTestConfig, "validate">;
 export declare function createSerialCase(name: string, src: string, dist: string): void;

package/dist/case/serial.js

@@ -1,33 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSerialCase = createSerialCase;
-const config_1 = require("../processor/config");
-const runner_1 = require("../runner");
 const creator_1 = require("../test/creator");
-const type_1 = require("../type");
+const config_1 = require("./config");
+const runner_1 = require("./runner");
 const creator = new creator_1.BasicCaseCreator({
     clean: true,
     describe: false,
     testConfig: testConfig => {
         const oldModuleScope = testConfig.moduleScope;
-        testConfig.moduleScope = (ms, stats) => {
+        testConfig.moduleScope = (ms, stats, compilerOptions) => {
             let res = ms;
             // TODO: modify runner module scope based on stats here
             if (typeof oldModuleScope === "function") {
-                res = oldModuleScope(ms, stats);
+                res = oldModuleScope(ms, stats, compilerOptions);
             }
             return res;
         };
     },
-    steps: ({ name }) => [
-        new config_1.ConfigProcessor({
-            name,
-            runable: true,
-            compilerType: type_1.ECompilerType.Rspack,
-            configFiles: ["rspack.config.js", "webpack.config.js"]
-        })
-    ],
-    runner: runner_1.MultipleRunnerFactory
+    steps: ({ name }) => [(0, config_1.createConfigProcessor)(name)],
+    runner: {
+        key: runner_1.getMultiCompilerRunnerKey,
+        runner: runner_1.createMultiCompilerRunner
+    },
+    concurrent: 1
 });
 function createSerialCase(name, src, dist) {
     creator.create(name, src, dist);

package/dist/case/stats-api.d.ts

@@ -1,6 +1,11 @@
-import { type IStatsAPIProcessorOptions } from "../processor";
-import { ECompilerType } from "../type";
-export type TStatsAPICaseConfig = Omit<IStatsAPIProcessorOptions<ECompilerType.Rspack>, "name" | "compilerType"> & {
+import type { Compiler, RspackOptions, Stats } from "@rspack/core";
+import type { ITestContext } from "../type";
+export type TStatsAPICaseConfig = {
     description: string;
+    options?: (context: ITestContext) => RspackOptions;
+    snapshotName?: string;
+    compiler?: (context: ITestContext, compiler: Compiler) => Promise<void>;
+    build?: (context: ITestContext, compiler: Compiler) => Promise<void>;
+    check?: (stats: Stats, compiler: Compiler) => Promise<void>;
 };
 export declare function createStatsAPICase(name: string, src: string, dist: string, testConfig: string): void;

package/dist/case/stats-api.js

@@ -1,21 +1,80 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStatsAPICase = createStatsAPICase;
-const processor_1 = require("../processor");
-const simple_1 = require("../test/simple");
-const type_1 = require("../type");
+const memfs_1 = require("memfs");
+const creator_1 = require("../test/creator");
 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 = context.getCompiler();
+                    compiler.setOptions(options(context, config.options));
+                },
+                compiler: async (context) => {
+                    const compilerManager = context.getCompiler();
+                    compilerManager.createCompiler();
+                    compiler(context, compilerManager.getCompiler(), config.compiler);
+                },
+                build: async (context) => {
+                    const compiler = context.getCompiler();
+                    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 createStatsAPICase(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, new processor_1.StatsAPIProcessor({
-            name: name,
-            compilerType: type_1.ECompilerType.Rspack,
-            ...caseConfig
-        }));
+    creator.create(name, src, dist, undefined, {
+        caseConfig,
+        description: () => caseConfig.description
     });
 }
+function options(context, custom) {
+    const res = (custom?.(context) || {});
+    res.experiments ??= {};
+    res.experiments.css ??= true;
+    res.experiments.rspackFuture ??= {};
+    res.experiments.rspackFuture.bundlerInfo ??= {};
+    res.experiments.rspackFuture.bundlerInfo.force ??= false;
+    if (!global.printLogger) {
+        res.infrastructureLogging = {
+            level: "error"
+        };
+    }
+    return res;
+}
+async function compiler(context, compiler, custom) {
+    if (custom) {
+        await custom(context, compiler);
+    }
+    if (compiler) {
+        compiler.outputFileSystem = (0, memfs_1.createFsFromVolume)(new memfs_1.Volume());
+    }
+}
+async function check(env, context, name, custom) {
+    const manager = context.getCompiler();
+    const stats = manager.getStats();
+    env.expect(typeof stats).toBe("object");
+    await custom?.(stats, manager.getCompiler());
+}

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

@@ -1 +1,12 @@
+import type { RspackOptions } from "@rspack/core";
+import type { ITestContext, ITestEnv } from "../type";
+export declare function createStatsProcessor(name: string, defaultOptions: (index: number, context: ITestContext) => RspackOptions, overrideOptions: (index: number, context: ITestContext, options: RspackOptions) => void): {
+    before: (context: ITestContext) => Promise<void>;
+    config: (context: ITestContext) => Promise<void>;
+    compiler: (context: ITestContext) => Promise<void>;
+    build: (context: ITestContext) => Promise<void>;
+    run: (env: ITestEnv, context: ITestContext) => Promise<void>;
+    check: (env: ITestEnv, context: ITestContext) => Promise<void>;
+    after: (context: ITestContext) => Promise<void>;
+};
 export declare function createStatsOutputCase(name: string, src: string, dist: string): void;