@rspack-debug/test-tools 1.4.11 → 1.6.2

package/dist/case/common.js

@@ -0,0 +1,249 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = config;
+exports.compiler = compiler;
+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"));
+const path_1 = __importDefault(require("path"));
+const webpack_merge_1 = __importDefault(require("webpack-merge"));
+const helper_1 = require("../helper");
+const placeholder_1 = require("../helper/expect/placeholder");
+const checkArrayExpectation_1 = __importDefault(require("../helper/legacy/checkArrayExpectation"));
+const debug_1 = require("../test/debug");
+async function config(context, name, configFiles, defaultOptions = {}) {
+    const compiler = context.getCompiler();
+    compiler.setOptions(defaultOptions);
+    if (Array.isArray(configFiles)) {
+        const fileOptions = (0, helper_1.readConfigFile)(configFiles.map(i => context.getSource(i)), context, defaultOptions)[0];
+        compiler.mergeOptions(fileOptions);
+    }
+    return compiler.getOptions();
+}
+async function compiler(context, name) {
+    const compiler = context.getCompiler();
+    compiler.createCompiler();
+    return compiler.getCompiler();
+}
+async function build(context, name) {
+    const compiler = context.getCompiler();
+    await compiler.build();
+    return compiler.getCompiler();
+}
+async function run(env, context, name, findBundle) {
+    const testConfig = context.getTestConfig();
+    if (testConfig.noTests)
+        return;
+    const compiler = context.getCompiler();
+    if (typeof testConfig.beforeExecute === "function") {
+        testConfig.beforeExecute(compiler.getOptions());
+    }
+    let bundles;
+    if (typeof findBundle === "function") {
+        bundles = findBundle(context, compiler.getOptions());
+    }
+    else {
+        bundles = [];
+    }
+    if (typeof bundles === "string") {
+        bundles = [bundles];
+    }
+    if (__DEBUG__) {
+        context.setValue(debug_1.DEBUG_SCOPES.RunFindBundle, bundles);
+    }
+    if (!bundles || !bundles.length) {
+        return;
+    }
+    if (__DEBUG__) {
+        context.setValue(debug_1.DEBUG_SCOPES.RunLogs, []);
+        context.setValue(debug_1.DEBUG_SCOPES.RunErrors, []);
+    }
+    for (const bundle of bundles) {
+        if (!bundle) {
+            continue;
+        }
+        const runner = context.getRunner(bundle, env);
+        if (__DEBUG__) {
+            const runLogs = context.getValue(debug_1.DEBUG_SCOPES.RunLogs);
+            runLogs?.push(`Start running entry: ${bundle} in ${runner.constructor.name}(${runner.__key__})`);
+        }
+        const mod = runner.run(bundle);
+        const result = context.getValue("modules") || [];
+        result.push(mod);
+        context.setValue("modules", result);
+    }
+    const results = context.getValue("modules") || [];
+    await Promise.all(results);
+}
+async function check(env, context, name) {
+    const testConfig = context.getTestConfig();
+    if (testConfig.noTests)
+        return;
+    const compiler = context.getCompiler();
+    const errors = (context.getError() || []).map(e => ({
+        message: e.message,
+        stack: e.stack
+    }));
+    const warnings = [];
+    const stats = compiler.getStats();
+    const options = compiler.getOptions();
+    if (stats) {
+        if (testConfig.writeStatsOuptut) {
+            fs_extra_1.default.writeFileSync(path_1.default.join(context.getDist(), "stats.txt"), stats.toString({
+                preset: "verbose",
+                colors: false
+            }), "utf-8");
+        }
+        if (testConfig.writeStatsJson) {
+            const jsonStats = stats.toJson({
+                errorDetails: true
+            });
+            fs_extra_1.default.writeFileSync(path_1.default.join(context.getDist(), "stats.json"), JSON.stringify(jsonStats, null, 2), "utf-8");
+        }
+        if (fs_extra_1.default.existsSync(context.getSource("errors.js")) ||
+            fs_extra_1.default.existsSync(context.getSource("warnings.js")) ||
+            stats.hasErrors() ||
+            stats.hasWarnings()) {
+            const statsJson = stats.toJson({
+                errorDetails: true
+            });
+            if (statsJson.errors) {
+                errors.push(...statsJson.errors);
+            }
+            if (statsJson.warnings) {
+                warnings.push(...statsJson.warnings);
+            }
+        }
+    }
+    await (0, checkArrayExpectation_1.default)(context.getSource(), { errors }, "error", "errors", "Error", options);
+    await (0, checkArrayExpectation_1.default)(context.getSource(), { warnings }, "warning", "warnings", "Warning", options);
+    // clear error if checked
+    if (fs_extra_1.default.existsSync(context.getSource("errors.js"))) {
+        context.clearError();
+    }
+}
+async function checkSnapshot(env, context, name, snapshot, filter) {
+    if (path_1.default.extname(snapshot) === ".snap") {
+        throw new Error("Snapshot with `.snap` will be managed by rstest, please use `.snap.txt` instead");
+    }
+    const compilerManager = context.getCompiler();
+    const stats = compilerManager.getStats();
+    const compiler = compilerManager.getCompiler();
+    if (!stats || !compiler)
+        return;
+    const compilers = "compilers" in compiler
+        ? compiler.compilers
+        : [compiler];
+    const totalStats = "stats" in stats ? stats.stats : [stats];
+    const total = compilers.length;
+    for (let i = 0; i < compilers.length; i++) {
+        const c = compilers[i];
+        const stats = totalStats[i];
+        if (stats.hasErrors()) {
+            const errors = [];
+            errors.push(...stats.compilation.errors);
+            throw new Error(`Failed to compile in fixture ${name}, Errors: ${errors
+                ?.map(i => `${i.message}\n${i.stack}`)
+                .join("\n\n")}`);
+        }
+        const compilation = c._lastCompilation ||
+            c._lastCompilation;
+        const snapshotFileFilter = filter ||
+            ((file) => (file.endsWith(".js") || file.endsWith(".mjs")) &&
+                !file.includes("runtime.js"));
+        const fileContents = Object.entries(compilation.assets)
+            .filter(([file]) => snapshotFileFilter(file))
+            .map(([file, source]) => {
+            const tag = path_1.default.extname(file).slice(1) || "txt";
+            let content = (0, placeholder_1.normalizePlaceholder)(source.source().toString());
+            const testConfig = context.getTestConfig();
+            if (testConfig.snapshotContent) {
+                content = testConfig.snapshotContent(content);
+            }
+            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(), path_1.default.join("__snapshots__", `${snapshot}${total > 1 ? `-${i}` : ""}`));
+        env.expect(content).toMatchFileSnapshotSync(snapshotPath);
+    }
+}
+async function afterExecute(context, name) {
+    const compiler = context.getCompiler();
+    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 [];
+    }
+    const multiCompilerOptions = (context.getValue("multiCompilerOptions") ||
+        []);
+    const result = [];
+    const multiFileIndexMap = context.getValue("multiFileIndexMap") || {};
+    for (const [index, compilerOptions] of multiCompilerOptions.entries()) {
+        const curBundles = multiFindBundle(index, context, compilerOptions);
+        const bundles = Array.isArray(curBundles)
+            ? curBundles
+            : curBundles
+                ? [curBundles]
+                : [];
+        for (const bundle of bundles) {
+            if (multiFileIndexMap[bundle]) {
+                multiFileIndexMap[bundle].push(index);
+            }
+            else {
+                multiFileIndexMap[bundle] = [index];
+            }
+        }
+        result.push(...bundles);
+    }
+    context.setValue("multiFileIndexMap", multiFileIndexMap);
+    return result;
+}
+function configMultiCompiler(context, name, configFiles, defaultOptions, overrideOptions) {
+    const multiCompilerOptions = [];
+    const caseOptions = Array.isArray(configFiles)
+        ? (0, helper_1.readConfigFile)(configFiles.map(i => context.getSource(i)), context, {}, configs => {
+            return configs.flatMap(c => {
+                if (typeof c === "function") {
+                    const options = {
+                        testPath: context.getDist(),
+                        env: undefined
+                    };
+                    return c(options.env, options);
+                }
+                return c;
+            });
+        })
+        : [{}];
+    for (const [index, options] of caseOptions.entries()) {
+        const compilerOptions = (0, webpack_merge_1.default)(typeof defaultOptions === "function"
+            ? defaultOptions(index, context)
+            : {}, options);
+        if (typeof overrideOptions === "function") {
+            overrideOptions(index, context, compilerOptions);
+        }
+        multiCompilerOptions.push(compilerOptions);
+    }
+    const compiler = context.getCompiler();
+    compiler.setOptions(multiCompilerOptions);
+    context.setValue("multiCompilerOptions", multiCompilerOptions);
+}

package/dist/case/compiler.d.ts

@@ -1,6 +1,19 @@
-import { type ISimpleProcessorOptions } from "../processor";
-import { ECompilerType } from "../type";
-export type TCompilerCaseConfig = Omit<ISimpleProcessorOptions<ECompilerType.Rspack>, "name" | "compilerType"> & {
+import type { Compilation, Compiler, RspackOptions, Stats, StatsCompilation } from "@rspack/core";
+import type { ITestContext } from "../type";
+export declare function createCompilerCase(name: string, src: string, dist: string, testConfig: string): void;
+export type TCompilerCaseConfig = {
     description: string;
+    error?: boolean;
+    skip?: boolean;
+    options?: (context: ITestContext) => RspackOptions;
+    compiler?: (context: ITestContext, compiler: Compiler) => Promise<void>;
+    build?: (context: ITestContext, compiler: Compiler) => Promise<void>;
+    check?: ({ context, stats, files, compiler, compilation }: {
+        context: ITestContext;
+        stats?: StatsCompilation;
+        files?: Record<string, string>;
+        compiler: Compiler;
+        compilation?: Compilation;
+    }) => Promise<void>;
+    compilerCallback?: (error: Error | null, stats: Stats | null) => void;
 };
-export declare function createCompilerCase(name: string, src: string, dist: string, testConfig: string): void;

package/dist/case/compiler.js

@@ -1,17 +1,154 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCompilerCase = createCompilerCase;
-const processor_1 = require("../processor");
-const simple_1 = require("../test/simple");
-const type_1 = require("../type");
+const creator_1 = require("../test/creator");
+function createCompilerProcessor(name, caseConfig) {
+    const logs = {
+        mkdir: [],
+        writeFile: []
+    };
+    const files = {};
+    return {
+        config: async (context) => {
+            const compiler = context.getCompiler();
+            const options = caseConfig.options?.(context) || {};
+            options.mode ??= "production";
+            options.context ??= context.getSource();
+            options.entry ??= "./a.js";
+            options.output ??= {};
+            options.output.path ??= "/";
+            options.output.pathinfo ??= true;
+            options.optimization ??= {};
+            options.optimization.minimize ??= false;
+            compiler.setOptions(options);
+        },
+        compiler: async (context) => {
+            const compiler = context.getCompiler();
+            if (caseConfig.compilerCallback) {
+                compiler.createCompilerWithCallback(caseConfig.compilerCallback);
+            }
+            else {
+                compiler.createCompiler();
+            }
+            const c = compiler.getCompiler();
+            c.outputFileSystem = {
+                // CHANGE: Added support for the `options` parameter to enable recursive directory creation,
+                // accommodating Rspack's requirement that differs from webpack's usage
+                mkdir(path, callback) {
+                    const recursive = false;
+                    // if (typeof options === "function") {
+                    // 	callback = options;
+                    // } else if (options) {
+                    // 	if (options.recursive !== undefined) recursive = options.recursive;
+                    // }
+                    logs.mkdir.push(path);
+                    if (recursive) {
+                        callback();
+                    }
+                    else {
+                        const err = new Error();
+                        err.code = "EEXIST";
+                        callback(err);
+                    }
+                },
+                writeFile(name, content, callback) {
+                    logs.writeFile.push(name, content);
+                    files[name] = content.toString("utf-8");
+                    callback();
+                },
+                stat(path, callback) {
+                    callback(new Error("ENOENT"));
+                }
+            };
+            c.hooks.compilation.tap("CompilerTest", compilation => (compilation.bail = true));
+            await caseConfig.compiler?.(context, c);
+        },
+        build: async (context) => {
+            const compiler = context.getCompiler();
+            if (typeof caseConfig.build === "function") {
+                await caseConfig.build?.(context, compiler.getCompiler());
+            }
+            else {
+                await compiler.build();
+            }
+        },
+        run: async (env, context) => { },
+        check: async (env, context) => {
+            const compiler = context.getCompiler();
+            const c = compiler.getCompiler();
+            const stats = compiler.getStats();
+            if (caseConfig.error) {
+                const statsJson = stats?.toJson({
+                    modules: true,
+                    reasons: true
+                });
+                const compilation = stats?.compilation;
+                await caseConfig.check?.({
+                    context,
+                    compiler: c,
+                    stats: statsJson,
+                    compilation,
+                    files
+                });
+            }
+            else if (stats) {
+                expect(typeof stats).toBe("object");
+                const compilation = stats.compilation;
+                const statsJson = stats.toJson({
+                    modules: true,
+                    reasons: true
+                });
+                expect(typeof statsJson).toBe("object");
+                expect(statsJson).toHaveProperty("errors");
+                expect(Array.isArray(statsJson.errors)).toBe(true);
+                if (statsJson.errors.length > 0) {
+                    expect(statsJson.errors[0]).toBeInstanceOf(Object);
+                    throw statsJson.errors[0];
+                }
+                statsJson.logs = logs;
+                await caseConfig.check?.({
+                    context,
+                    stats: statsJson,
+                    files,
+                    compiler: c,
+                    compilation
+                });
+            }
+            else {
+                await caseConfig.check?.({
+                    context,
+                    files,
+                    compiler: c
+                });
+            }
+        },
+        after: async (context) => {
+            await context.closeCompiler();
+        }
+    };
+}
+const creator = new creator_1.BasicCaseCreator({
+    clean: true,
+    describe: false,
+    steps: ({ name, caseConfig }) => {
+        return [createCompilerProcessor(name, caseConfig)];
+    },
+    concurrent: false
+});
 function createCompilerCase(name, src, dist, testConfig) {
-    const caseConfig = require(testConfig);
-    const runner = (0, simple_1.getSimpleProcessorRunner)(src, dist);
-    it(caseConfig.description, async () => {
-        await runner(name, new processor_1.SimpleTaskProcessor({
-            name: name,
-            compilerType: type_1.ECompilerType.Rspack,
-            ...caseConfig
-        }));
-    });
+    let caseConfigList = require(testConfig);
+    if (!Array.isArray(caseConfigList)) {
+        caseConfigList = [caseConfigList];
+    }
+    for (let i = 0; i < caseConfigList.length; i++) {
+        const caseConfig = caseConfigList[i];
+        if (caseConfig.skip) {
+            it.skip(`${name}[${i}]`, () => { });
+            continue;
+        }
+        creator.create(`${name}[${i}]`, src, dist, undefined, {
+            caseConfig,
+            description: () => caseConfig.description
+        });
+    }
 }

package/dist/case/config.d.ts

@@ -1,3 +1,8 @@
-import { ECompilerType, type TTestConfig } from "../type";
-export type TConfigCaseConfig = Omit<TTestConfig<ECompilerType.Rspack>, "validate">;
+import type { RspackOptions } from "@rspack/core";
+import type { ITestContext, ITestProcessor, TTestConfig } from "../type";
+export type TConfigCaseConfig = Omit<TTestConfig, "validate">;
+export declare function createConfigProcessor(name: string): ITestProcessor;
 export declare function createConfigCase(name: string, src: string, dist: string): void;
+export declare function defaultOptions(index: number, context: ITestContext): RspackOptions;
+export declare function overrideOptions(index: number, context: ITestContext, options: RspackOptions): void;
+export declare function findBundle(index: number, context: ITestContext, options: RspackOptions): string | string[];

package/dist/case/config.js

@@ -1,39 +1,127 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConfigProcessor = createConfigProcessor;
 exports.createConfigCase = createConfigCase;
-const config_1 = require("../processor/config");
-const runner_1 = require("../runner");
+exports.defaultOptions = defaultOptions;
+exports.overrideOptions = overrideOptions;
+exports.findBundle = findBundle;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const parseResource_1 = require("../helper/legacy/parseResource");
 const creator_1 = require("../test/creator");
-const type_1 = require("../type");
+const common_1 = require("./common");
+const runner_1 = require("./runner");
+function createConfigProcessor(name) {
+    return {
+        config: async (context) => {
+            (0, common_1.configMultiCompiler)(context, name, ["rspack.config.cjs", "rspack.config.js", "webpack.config.js"], defaultOptions, 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) => {
+            await (0, common_1.run)(env, context, name, (context) => (0, common_1.findMultiCompilerBundle)(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);
+        }
+    };
+}
 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.cjs",
-                "rspack.config.js",
-                "webpack.config.js"
-            ]
-        })
-    ],
-    runner: runner_1.MultipleRunnerFactory,
+    steps: ({ name }) => [createConfigProcessor(name)],
+    runner: {
+        key: runner_1.getMultiCompilerRunnerKey,
+        runner: runner_1.createMultiCompilerRunner
+    },
     concurrent: true
 });
 function createConfigCase(name, src, dist) {
     creator.create(name, src, dist);
 }
+function defaultOptions(index, context) {
+    return {
+        context: context.getSource(),
+        mode: "production",
+        target: "async-node",
+        devtool: false,
+        cache: false,
+        output: {
+            path: context.getDist()
+        },
+        optimization: {
+            minimize: false
+        },
+        experiments: {
+            css: true,
+            rspackFuture: {
+                bundlerInfo: {
+                    force: false
+                }
+            },
+            inlineConst: true
+        }
+    };
+}
+function overrideOptions(index, context, options) {
+    if (!options.entry) {
+        options.entry = "./index.js";
+    }
+    if (options.amd === undefined) {
+        options.amd = {};
+    }
+    if (!options.output?.filename) {
+        const outputModule = options.experiments?.outputModule;
+        options.output ??= {};
+        options.output.filename = `bundle${index}${outputModule ? ".mjs" : ".js"}`;
+    }
+    if (options.cache === undefined)
+        options.cache = false;
+    if (!global.printLogger) {
+        options.infrastructureLogging = {
+            level: "error"
+        };
+    }
+}
+function findBundle(index, context, options) {
+    const testConfig = context.getTestConfig();
+    if (typeof testConfig.findBundle === "function") {
+        return testConfig.findBundle(index, options);
+    }
+    const ext = path_1.default.extname((0, parseResource_1.parseResource)(options.output?.filename).path);
+    const bundlePath = [];
+    if (options.output?.path &&
+        fs_extra_1.default.existsSync(path_1.default.join(options.output.path, `bundle${index}${ext}`))) {
+        if (options.experiments?.css) {
+            const cssOutputPath = path_1.default.join(options.output.path, (typeof options.output?.cssFilename === "string" &&
+                options.output?.cssFilename) ||
+                `bundle${index}.css`);
+            if (fs_extra_1.default.existsSync(cssOutputPath)) {
+                bundlePath.push(path_1.default.relative(options.output.path, cssOutputPath));
+            }
+        }
+        bundlePath.push(`./bundle${index}${ext}`);
+    }
+    return bundlePath;
+}

package/dist/case/defaults.d.ts

@@ -1,6 +1,15 @@
-import { type IDefaultsConfigProcessorOptions } from "../processor";
-import { ECompilerType } from "../type";
-export type TDefaultsCaseConfig = Omit<IDefaultsConfigProcessorOptions<ECompilerType.Rspack>, "name" | "compilerType"> & {
+import type { RspackOptions } from "@rspack/core";
+import type { ITestContext } from "../type";
+export declare function createDefaultsCase(name: string, src: string): void;
+export declare function getRspackDefaultConfig(cwd: string, config: RspackOptions): RspackOptions;
+export type TDefaultsCaseConfig = {
+    options?: (context: ITestContext) => RspackOptions;
+    cwd?: string;
+    diff: (diff: Assertion<RspackTestDiff>, defaults: Assertion<RspackOptions>) => Promise<void>;
     description: string;
 };
-export declare function createDefaultsCase(name: string, src: string): void;
+declare class RspackTestDiff {
+    value: string;
+    constructor(value: string);
+}
+export {};