@rspack-canary/test-tools 1.5.6-canary-e598f284-20250921173624 → 1.5.8-canary-e350b761-20250924173613

package/dist/case/error.js

@@ -1,21 +1,128 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createErrorCase = createErrorCase;
-const processor_1 = require("../processor");
-const simple_1 = require("../test/simple");
-const type_1 = require("../type");
+const node_path_1 = __importDefault(require("node:path"));
+const webpack_merge_1 = __importDefault(require("webpack-merge"));
+const creator_1 = require("../test/creator");
+const common_1 = require("./common");
 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 = (0, common_1.getCompiler)(context, name);
+                    compiler.setOptions(options(context, config.options));
+                },
+                compiler: async (context) => {
+                    const compilerManager = (0, common_1.getCompiler)(context, name);
+                    compilerManager.createCompiler();
+                    compiler(context, compilerManager.getCompiler(), config.compiler);
+                },
+                build: async (context) => {
+                    const compiler = (0, common_1.getCompiler)(context, name);
+                    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 createErrorCase(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.ErrorProcessor({
-            name: name,
-            compilerType: type_1.ECompilerType.Rspack,
-            ...caseConfig
-        }));
+    creator.create(name, src, dist, undefined, {
+        caseConfig,
+        description: () => caseConfig.description
     });
 }
+function options(context, custom) {
+    let options = {
+        context: node_path_1.default.resolve(__dirname, "../../../../tests/rspack-test/fixtures/errors"),
+        mode: "none",
+        devtool: false,
+        optimization: {
+            minimize: false,
+            moduleIds: "named",
+            chunkIds: "named"
+        },
+        experiments: {
+            css: true,
+            rspackFuture: {
+                bundlerInfo: {
+                    force: false
+                }
+            }
+        }
+    };
+    if (typeof custom === "function") {
+        options = (0, webpack_merge_1.default)(options, custom(context, options));
+    }
+    if (options.mode === "production") {
+        if (options.optimization)
+            options.optimization.minimize = true;
+        else
+            options.optimization = { minimize: true };
+    }
+    return options;
+}
+async function compiler(context, compiler, custom) {
+    if (compiler) {
+        compiler.outputFileSystem = {
+            // CHANGE: rspack outputFileSystem `mkdirp` uses option `{ recursive: true }`, webpack's second parameter is alway a callback
+            mkdir(dir, maybeOptionOrCallback, maybeCallback) {
+                if (typeof maybeOptionOrCallback === "function") {
+                    maybeOptionOrCallback();
+                }
+                else if (typeof maybeCallback === "function") {
+                    maybeCallback();
+                }
+            },
+            writeFile(file, content, callback) {
+                callback();
+            },
+            stat(file, callback) {
+                callback(new Error("ENOENT"));
+            },
+            mkdirSync() { },
+            writeFileSync() { }
+        };
+    }
+    await custom?.(context, compiler);
+}
+class RspackStatsDiagnostics {
+    constructor(errors, warnings) {
+        this.errors = errors;
+        this.warnings = warnings;
+    }
+}
+async function check(env, context, name, check) {
+    const compiler = (0, common_1.getCompiler)(context, name);
+    const stats = compiler.getStats();
+    env.expect(typeof stats).toBe("object");
+    const statsResult = stats.toJson({ errorDetails: false });
+    env.expect(typeof statsResult).toBe("object");
+    const { errors, warnings } = statsResult;
+    env.expect(Array.isArray(errors)).toBe(true);
+    env.expect(Array.isArray(warnings)).toBe(true);
+    await check?.(new RspackStatsDiagnostics(errors, warnings));
+}

package/dist/case/hash.d.ts

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

package/dist/case/hash.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createHashCase = createHashCase;
-const processor_1 = require("../processor");
 const creator_1 = require("../test/creator");
-const type_1 = require("../type");
+const common_1 = require("./common");
+const REG_ERROR_CASE = /error$/;
 class HashCaseCreator extends creator_1.BasicCaseCreator {
-    describe(name, tester, testConfig) {
+    describe(name, tester, testConfig, options) {
         it(`should print correct hash for ${name}`, async () => {
             await tester.prepare();
             await tester.compile();
-            await tester.check(this.createEnv(testConfig));
+            await tester.check(this.createEnv(testConfig, options));
             await tester.resume();
         }, 30000);
     }
@@ -18,13 +18,74 @@ const creator = new HashCaseCreator({
     clean: true,
     describe: false,
     steps: ({ name }) => [
-        new processor_1.HashProcessor({
-            name,
-            compilerType: type_1.ECompilerType.Rspack,
-            configFiles: ["rspack.config.js", "webpack.config.js"]
-        })
+        {
+            config: async (context) => {
+                (0, common_1.configMultiCompiler)(context, name, ["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) => {
+                // no need to run, just check snapshot
+            },
+            check: async (env, context) => {
+                await check(env, context, name);
+            }
+        }
     ]
 });
 function createHashCase(name, src, dist) {
     creator.create(name, src, dist);
 }
+function defaultOptions(index, context) {
+    return {
+        context: context.getSource(),
+        output: {
+            path: context.getDist()
+        },
+        experiments: {
+            css: true,
+            rspackFuture: {
+                bundlerInfo: {
+                    force: false
+                }
+            },
+            inlineConst: true,
+            lazyBarrel: true
+        }
+    };
+}
+function overrideOptions(index, context, options) {
+    if (!options.entry) {
+        options.entry = "./index.js";
+    }
+    if (!global.printLogger) {
+        options.infrastructureLogging = {
+            level: "error"
+        };
+    }
+}
+async function check(env, context, name) {
+    const compiler = (0, common_1.getCompiler)(context, name);
+    const stats = compiler.getStats();
+    const testConfig = context.getTestConfig();
+    if (!stats) {
+        env.expect(false);
+        return;
+    }
+    if (REG_ERROR_CASE.test(name)) {
+        env.expect(stats.hasErrors());
+    }
+    else {
+        env.expect(!stats.hasErrors());
+    }
+    if (typeof testConfig.validate === "function") {
+        testConfig.validate(stats);
+    }
+    else {
+        throw new Error("HashTestCases should have test.config.js and a validate method");
+    }
+}

package/dist/case/hook.d.ts

@@ -1,6 +1,37 @@
-import { type IHookProcessorOptions } from "../processor";
-import { ECompilerType } from "../type";
-export type THookCaseConfig = Omit<IHookProcessorOptions<ECompilerType.Rspack>, "name" | "compilerType" | "runable"> & {
+import { TestContext, type TTestContextOptions } from "../test/context";
+import type { ECompilerType, ITestContext, ITestEnv, TCompiler, TCompilerOptions } from "../type";
+export declare function createHookCase(name: string, src: string, dist: string, source: string): void;
+export declare class HookCasesContext extends TestContext {
+    protected src: string;
+    protected testName: string;
+    protected options: TTestContextOptions;
+    protected promises: Promise<void>[];
+    protected count: number;
+    protected snapshots: Record<string | number, Array<[string | Buffer, string]>>;
+    protected snapshotsList: Array<string | number>;
+    constructor(src: string, testName: string, options: TTestContextOptions);
+    /**
+     * Snapshot function arguments and return value.
+     * Generated snapshot is located in the same directory with the test source.
+     * @example
+     * compiler.hooks.compilation("name", context.snapped((...args) => { ... }))
+     */
+    snapped(cb: (...args: unknown[]) => Promise<unknown>, prefix?: string): (this: any, ...args: unknown[]) => Promise<unknown>;
+    /**
+     * @internal
+     */
+    _addSnapshot(content: unknown, name: string, group: string | number): void;
+    /**
+     * @internal
+     */
+    collectSnapshots(env: ITestEnv, options?: {
+        diff: {};
+    }): Promise<void>;
+}
+export type THookCaseConfig = {
+    options?: (context: ITestContext) => TCompilerOptions<ECompilerType.Rspack>;
+    compiler?: (context: ITestContext, compiler: TCompiler<ECompilerType.Rspack>) => Promise<void>;
+    check?: (context: ITestContext) => Promise<void>;
+    snapshotFileFilter?: (file: string) => boolean;
     description: string;
 };
-export declare function createHookCase(name: string, src: string, dist: string, source: string): void;

package/dist/case/hook.js

@@ -3,33 +3,222 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookCasesContext = void 0;
 exports.createHookCase = createHookCase;
 const node_path_1 = __importDefault(require("node:path"));
-const createLazyTestEnv_1 = __importDefault(require("../helper/legacy/createLazyTestEnv"));
-const processor_1 = require("../processor");
-const runner_1 = require("../runner");
-const simple_1 = require("../test/simple");
-const type_1 = require("../type");
+const core_1 = require("@rspack/core");
+const jest_snapshot_1 = require("jest-snapshot");
+const path_serializer_1 = require("path-serializer");
+const pretty_format_1 = require("pretty-format");
+const webpack_merge_1 = __importDefault(require("webpack-merge"));
+const context_1 = require("../test/context");
+const creator_1 = require("../test/creator");
+const common_1 = require("./common");
+const srcDir = node_path_1.default.resolve(__dirname, "../../../../tests/rspack-test/fixtures");
+const distDir = node_path_1.default.resolve(__dirname, "../../../../tests/rspack-test/js/hook");
+const creator = new creator_1.BasicCaseCreator({
+    clean: true,
+    describe: true,
+    createContext: (config) => new HookCasesContext(config.src, config.name, config),
+    steps: ({ name, caseConfig: _caseConfig, src }) => {
+        const caseConfig = _caseConfig;
+        return [
+            {
+                config: async (context) => {
+                    const compiler = (0, common_1.getCompiler)(context, name);
+                    const options = await (0, common_1.config)(context, name, ["rspack.config.js", "webpack.config.js"], defaultOptions(context, caseConfig.options));
+                    if (!global.printLogger) {
+                        options.infrastructureLogging = {
+                            level: "error"
+                        };
+                    }
+                    compiler.setOptions(options);
+                },
+                compiler: async (context) => {
+                    const c = await (0, common_1.compiler)(context, name);
+                    if (caseConfig.compiler) {
+                        await caseConfig.compiler(context, c);
+                    }
+                },
+                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, node_path_1.default.join(src, "output.snap.txt"), caseConfig.snapshotFileFilter);
+                }
+            }
+        ];
+    }
+});
 function createHookCase(name, src, dist, source) {
     const caseConfig = require(node_path_1.default.join(src, "test.js"));
     const testName = node_path_1.default.basename(name.slice(0, name.indexOf(node_path_1.default.extname(name))));
-    const runner = (0, simple_1.getSimpleProcessorRunner)(source, dist, {
-        env: () => env,
-        context: () => new processor_1.HookCasesContext(src, testName, {
+    creator.create(name, src, dist, undefined, {
+        caseConfig,
+        description: () => caseConfig.description,
+        createContext: (config) => new HookCasesContext(src, testName, {
             src: source,
-            dist: dist,
-            runnerFactory: runner_1.BasicRunnerFactory
+            dist: dist
         })
     });
-    it(caseConfig.description, async () => {
-        await runner(name, new processor_1.HookTaskProcessor({
-            name,
-            compilerType: type_1.ECompilerType.Rspack,
-            findBundle: () => ["main.js"],
-            snapshot: node_path_1.default.join(src, "output.snap.txt"),
-            runable: true,
-            ...caseConfig
-        }));
-    });
-    const env = (0, createLazyTestEnv_1.default)(10000);
+}
+const sourceSerializer = {
+    test(val) {
+        return val instanceof core_1.sources.Source;
+    },
+    print(val) {
+        return val.source();
+    }
+};
+const internalSerializer = {
+    test(val) {
+        return val instanceof core_1.Compiler || val instanceof core_1.Compilation;
+    },
+    print(val) {
+        return JSON.stringify(`${val.constructor.name}(internal ignored)`);
+    }
+};
+const testPathSerializer = (0, path_serializer_1.createSnapshotSerializer)({
+    replace: [
+        {
+            match: srcDir,
+            mark: "<HOOK_SRC_DIR>"
+        },
+        {
+            match: distDir,
+            mark: "<HOOK_DIST_DIR>"
+        }
+    ]
+});
+const escapeRegex = true;
+const printFunctionName = false;
+const normalizeNewlines = (str) => str.replace(/\r\n|\r/g, "\n");
+const serialize = (val, indent = 2, formatOverrides = {}) => normalizeNewlines((0, pretty_format_1.format)(val, {
+    escapeRegex,
+    indent,
+    plugins: [
+        ...(0, jest_snapshot_1.getSerializers)(),
+        sourceSerializer,
+        internalSerializer,
+        testPathSerializer
+    ],
+    printFunctionName,
+    ...formatOverrides
+}));
+class HookCasesContext extends context_1.TestContext {
+    constructor(src, testName, options) {
+        super(options);
+        this.src = src;
+        this.testName = testName;
+        this.options = options;
+        this.promises = [];
+        this.count = 0;
+        this.snapshots = {};
+        this.snapshotsList = [];
+        this.snapped = this.snapped.bind(this);
+    }
+    /**
+     * Snapshot function arguments and return value.
+     * Generated snapshot is located in the same directory with the test source.
+     * @example
+     * compiler.hooks.compilation("name", context.snapped((...args) => { ... }))
+     */
+    snapped(cb, prefix = "") {
+        // eslint-disable-next-line
+        const context = this;
+        return function SNAPPED_HOOK(...args) {
+            const group = prefix ? prefix : context.count++;
+            context._addSnapshot(args, "input", group);
+            const output = cb.apply(this, args);
+            if (output && typeof output.then === "function") {
+                let resolve;
+                context.promises.push(new Promise(r => (resolve = r)));
+                return output
+                    .then((o) => {
+                    context._addSnapshot(o, "output (Promise resolved)", group);
+                    return o;
+                })
+                    .catch((o) => {
+                    context._addSnapshot(o, "output (Promise rejected)", group);
+                    return o;
+                })
+                    .finally(resolve);
+            }
+            context._addSnapshot(output, "output", group);
+            return output;
+        };
+    }
+    /**
+     * @internal
+     */
+    _addSnapshot(content, name, group) {
+        const normalizedContent = Buffer.isBuffer(content)
+            ? content
+            : serialize(content, undefined, {
+                escapeString: true,
+                printBasicPrototype: true
+            }).replace(/\r\n/g, "\n");
+        (this.snapshots[group] = this.snapshots[group] || []).push([
+            normalizedContent,
+            name
+        ]);
+        if (!this.snapshotsList.includes(group)) {
+            this.snapshotsList.push(group);
+        }
+    }
+    /**
+     * @internal
+     */
+    async collectSnapshots(env, options = {
+        diff: {}
+    }) {
+        await Promise.allSettled(this.promises);
+        if (!this.snapshotsList.length)
+            return;
+        const snapshots = this.snapshotsList.reduce((acc, group, index) => {
+            const block = this.snapshots[group || index].reduce((acc, [content, name]) => {
+                name = `## ${name || `test: ${index}`}\n\n`;
+                const block = `\`\`\`javascript\n${content}\n\`\`\`\n`;
+                return `${acc}${name + block}\n`;
+            }, "");
+            return `${acc}# ${Number.isInteger(group) ? `Group: ${index}` : group}\n\n${block}`;
+        }, "");
+        env
+            .expect(snapshots)
+            .toMatchFileSnapshot(node_path_1.default.join(this.src, "hooks.snap.txt"), options);
+    }
+}
+exports.HookCasesContext = HookCasesContext;
+function defaultOptions(context, custom) {
+    let defaultOptions = {
+        context: context.getSource(),
+        mode: "production",
+        target: "async-node",
+        devtool: false,
+        cache: false,
+        entry: "./hook",
+        output: {
+            path: context.getDist()
+        },
+        optimization: {
+            minimize: false
+        },
+        experiments: {
+            css: true,
+            rspackFuture: {
+                bundlerInfo: {
+                    force: false
+                }
+            },
+            inlineConst: true,
+            lazyBarrel: true
+        }
+    };
+    if (custom) {
+        defaultOptions = (0, webpack_merge_1.default)(defaultOptions, custom(context));
+    }
+    return defaultOptions;
 }