@rspack-canary/test-tools 1.5.6-canary-e598f284-20250921173624 → 1.5.7-canary-a3406c0a-20250922173625

package/dist/processor/config.js

@@ -1,88 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfigProcessor = void 0;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const parseResource_1 = require("../helper/legacy/parseResource");
-const multi_1 = require("./multi");
-class ConfigProcessor extends multi_1.MultiTaskProcessor {
-    constructor(_configOptions) {
-        super({
-            defaultOptions: (ConfigProcessor.defaultOptions),
-            overrideOptions: (ConfigProcessor.overrideOptions),
-            findBundle: (ConfigProcessor.findBundle),
-            ..._configOptions
-        });
-        this._configOptions = _configOptions;
-    }
-    static findBundle(index, context, options) {
-        const testConfig = context.getTestConfig();
-        if (typeof testConfig.findBundle === "function") {
-            return testConfig.findBundle(index, options);
-        }
-        const ext = node_path_1.default.extname((0, parseResource_1.parseResource)(options.output?.filename).path);
-        const bundlePath = [];
-        if (options.output?.path &&
-            node_fs_1.default.existsSync(node_path_1.default.join(options.output.path, `bundle${index}${ext}`))) {
-            if (options.experiments?.css) {
-                const cssOutputPath = node_path_1.default.join(options.output.path, (typeof options.output?.cssFilename === "string" &&
-                    options.output?.cssFilename) ||
-                    `bundle${index}.css`);
-                if (node_fs_1.default.existsSync(cssOutputPath)) {
-                    bundlePath.push(`./bundle${index}.css`);
-                }
-            }
-            bundlePath.push(`./bundle${index}${ext}`);
-        }
-        return bundlePath;
-    }
-    static 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,
-                lazyBarrel: true
-            }
-        };
-    }
-    static 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"
-            };
-        }
-    }
-}
-exports.ConfigProcessor = ConfigProcessor;

package/dist/processor/defaults.d.ts

@@ -1,30 +0,0 @@
-import type { ECompilerType, ITestContext, ITestEnv, TCompilerOptions } from "../type";
-import { SimpleTaskProcessor } from "./simple";
-declare class RspackTestDiff {
-    value: string;
-    constructor(value: string);
-}
-export interface IDefaultsConfigProcessorOptions<T extends ECompilerType> {
-    options?: (context: ITestContext) => TCompilerOptions<T>;
-    cwd?: string;
-    name: string;
-    diff: (diff: jest.JestMatchers<RspackTestDiff>, defaults: jest.JestMatchers<TCompilerOptions<T>>) => Promise<void>;
-    compilerType: T;
-}
-export declare class DefaultsConfigProcessor<T extends ECompilerType> extends SimpleTaskProcessor<T> {
-    protected _defaultsConfigOptions: IDefaultsConfigProcessorOptions<T>;
-    private defaultConfig;
-    constructor(_defaultsConfigOptions: IDefaultsConfigProcessorOptions<T>);
-    compiler(context: ITestContext): Promise<void>;
-    build(context: ITestContext): Promise<void>;
-    run(env: ITestEnv, context: ITestContext): Promise<void>;
-    check(env: ITestEnv, context: ITestContext): Promise<void>;
-    before(context: ITestContext): Promise<void>;
-    after(context: ITestContext): Promise<void>;
-    beforeAll(context: ITestContext): Promise<void>;
-    afterAll(context: ITestContext): Promise<void>;
-    protected getCompiler(context: ITestContext): import("../type").ITestCompilerManager<T>;
-    static getDefaultConfig(cwd: string, config: TCompilerOptions<ECompilerType>): TCompilerOptions<ECompilerType>;
-    static overrideOptions<T extends ECompilerType>(options: TCompilerOptions<T>): void;
-}
-export {};

package/dist/processor/defaults.js

@@ -1,72 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultsConfigProcessor = void 0;
-const node_util_1 = require("node:util");
-const jest_diff_1 = require("jest-diff");
-const simple_1 = require("./simple");
-const CURRENT_CWD = process.cwd();
-class RspackTestDiff {
-    constructor(value) {
-        this.value = value;
-    }
-}
-class DefaultsConfigProcessor extends simple_1.SimpleTaskProcessor {
-    constructor(_defaultsConfigOptions) {
-        super({
-            options: context => {
-                let res;
-                if (typeof _defaultsConfigOptions.options === "function") {
-                    res = _defaultsConfigOptions.options(context);
-                }
-                else {
-                    res = {};
-                }
-                if (!("mode" in res)) {
-                    res.mode = "none";
-                }
-                return res;
-            },
-            compilerType: _defaultsConfigOptions.compilerType,
-            name: _defaultsConfigOptions.name
-        });
-        this._defaultsConfigOptions = _defaultsConfigOptions;
-        this.defaultConfig = DefaultsConfigProcessor.getDefaultConfig(CURRENT_CWD, {
-            mode: "none"
-        });
-    }
-    async compiler(context) { }
-    async build(context) { }
-    async run(env, context) { }
-    async check(env, context) {
-        const compiler = this.getCompiler(context);
-        const config = DefaultsConfigProcessor.getDefaultConfig(this._defaultsConfigOptions.cwd || CURRENT_CWD, compiler.getOptions());
-        const diff = (0, node_util_1.stripVTControlCharacters)((0, jest_diff_1.diff)(this.defaultConfig, config, { expand: false, contextLines: 0 }));
-        await this._defaultsConfigOptions.diff(env.expect(new RspackTestDiff(diff)), env.expect(this.defaultConfig));
-    }
-    async before(context) { }
-    async after(context) { }
-    async beforeAll(context) { }
-    async afterAll(context) { }
-    getCompiler(context) {
-        return context.getCompiler(this._options.name, this._options.compilerType);
-    }
-    static getDefaultConfig(cwd, config) {
-        process.chdir(cwd);
-        const { applyWebpackOptionsDefaults, getNormalizedWebpackOptions } = require("@rspack/core").config;
-        const normalizedConfig = getNormalizedWebpackOptions(config);
-        applyWebpackOptionsDefaults(normalizedConfig);
-        // make snapshot stable
-        normalizedConfig.experiments.rspackFuture.bundlerInfo.version =
-            "$version$";
-        process.chdir(CURRENT_CWD);
-        return normalizedConfig;
-    }
-    static overrideOptions(options) {
-        if (!global.printLogger) {
-            options.infrastructureLogging = {
-                level: "error"
-            };
-        }
-    }
-}
-exports.DefaultsConfigProcessor = DefaultsConfigProcessor;

package/dist/processor/diagnostic.d.ts

@@ -1,15 +0,0 @@
-import type { ECompilerType, ITestContext, ITestEnv, TCompilerOptions } from "../type";
-import { BasicProcessor, type IBasicProcessorOptions } from "./basic";
-export interface IDiagnosticProcessorOptions<T extends ECompilerType> extends Omit<IBasicProcessorOptions<T>, "runable"> {
-    snapshot: string;
-    snapshotErrors: string;
-    snapshotWarning: string;
-    format?: (output: string) => string;
-}
-export declare class DiagnosticProcessor<T extends ECompilerType> extends BasicProcessor<T> {
-    protected _diagnosticOptions: IDiagnosticProcessorOptions<T>;
-    constructor(_diagnosticOptions: IDiagnosticProcessorOptions<T>);
-    check(env: ITestEnv, context: ITestContext): Promise<void>;
-    static defaultOptions<T extends ECompilerType>(context: ITestContext): TCompilerOptions<T>;
-    static overrideOptions<T extends ECompilerType>(options: TCompilerOptions<T>): void;
-}

package/dist/processor/diagnostic.js

@@ -1,104 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiagnosticProcessor = void 0;
-const node_assert_1 = __importDefault(require("node:assert"));
-const node_path_1 = __importDefault(require("node:path"));
-const placeholder_1 = require("../helper/expect/placeholder");
-const basic_1 = require("./basic");
-class DiagnosticProcessor extends basic_1.BasicProcessor {
-    constructor(_diagnosticOptions) {
-        super({
-            defaultOptions: (DiagnosticProcessor.defaultOptions),
-            runable: false,
-            ..._diagnosticOptions
-        });
-        this._diagnosticOptions = _diagnosticOptions;
-    }
-    async check(env, context) {
-        const compiler = this.getCompiler(context);
-        const stats = compiler.getStats();
-        if (!stats) {
-            throw new Error("Stats should exists");
-        }
-        (0, node_assert_1.default)(stats.hasErrors() || stats.hasWarnings());
-        let output = (0, placeholder_1.normalizePlaceholder)(stats.toString({
-            all: false,
-            errors: true,
-            warnings: true
-        })).replaceAll("\\", "/"); // stats has some win32 paths that path-serializer can not handle
-        const statsJson = stats.toJson({
-            all: false,
-            errors: true,
-            warnings: true
-        });
-        const errors = (statsJson.errors || []).map(e => {
-            // @ts-expect-error error message is already serialized in `stats.err`
-            delete e.message;
-            delete e.stack;
-            return e;
-        });
-        const warnings = (statsJson.warnings || []).map(e => {
-            // @ts-expect-error error message is already serialized in `stats.err`
-            delete e.message;
-            delete e.stack;
-            return e;
-        });
-        if (typeof this._diagnosticOptions.format === "function") {
-            output = this._diagnosticOptions.format(output);
-        }
-        env.expect.addSnapshotSerializer({
-            test(received) {
-                return typeof received === "string";
-            },
-            serialize(received) {
-                return (0, placeholder_1.normalizePlaceholder)(received.trim());
-            }
-        });
-        const errorOutputPath = node_path_1.default.resolve(context.getSource(this._diagnosticOptions.snapshot));
-        const errorStatsOutputPath = node_path_1.default.resolve(context.getSource(this._diagnosticOptions.snapshotErrors));
-        const warningStatsOutputPath = node_path_1.default.resolve(context.getSource(this._diagnosticOptions.snapshotWarning));
-        env.expect(output).toMatchFileSnapshot(errorOutputPath);
-        env.expect(errors).toMatchFileSnapshot(errorStatsOutputPath);
-        env.expect(warnings).toMatchFileSnapshot(warningStatsOutputPath);
-    }
-    static defaultOptions(context) {
-        return {
-            target: "node",
-            context: context.getSource(),
-            entry: {
-                main: "./"
-            },
-            mode: "development",
-            devServer: {
-                hot: false
-            },
-            infrastructureLogging: {
-                debug: false
-            },
-            output: {
-                path: context.getDist()
-            },
-            experiments: {
-                css: true,
-                rspackFuture: {
-                    bundlerInfo: {
-                        force: false
-                    }
-                },
-                inlineConst: true,
-                lazyBarrel: true
-            }
-        };
-    }
-    static overrideOptions(options) {
-        if (!global.printLogger) {
-            options.infrastructureLogging = {
-                level: "error"
-            };
-        }
-    }
-}
-exports.DiagnosticProcessor = DiagnosticProcessor;

package/dist/processor/error.d.ts

@@ -1,23 +0,0 @@
-import type { StatsError } from "@rspack/core";
-import type { ECompilerType, ITestContext, ITestEnv, TCompiler, TCompilerOptions } from "../type";
-import { SimpleTaskProcessor } from "./simple";
-declare class RspackStatsDiagnostics {
-    errors: StatsError[];
-    warnings: StatsError[];
-    constructor(errors: StatsError[], warnings: StatsError[]);
-}
-export interface IErrorProcessorOptions<T extends ECompilerType> {
-    name: string;
-    compilerType: T;
-    options?: (options: TCompilerOptions<T>, context: ITestContext) => TCompilerOptions<T>;
-    build?: (context: ITestContext, compiler: TCompiler<T>) => Promise<void>;
-    check?: (stats: RspackStatsDiagnostics) => Promise<void>;
-}
-export declare class ErrorProcessor<T extends ECompilerType> extends SimpleTaskProcessor<T> {
-    protected _errorOptions: IErrorProcessorOptions<T>;
-    constructor(_errorOptions: IErrorProcessorOptions<T>);
-    compiler(context: ITestContext): Promise<void>;
-    run(env: ITestEnv, context: ITestContext): Promise<void>;
-    check(env: ITestEnv, context: ITestContext): Promise<void>;
-}
-export {};

package/dist/processor/error.js

@@ -1,95 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ErrorProcessor = void 0;
-const node_path_1 = __importDefault(require("node:path"));
-const webpack_merge_1 = __importDefault(require("webpack-merge"));
-const simple_1 = require("./simple");
-class RspackStatsDiagnostics {
-    constructor(errors, warnings) {
-        this.errors = errors;
-        this.warnings = warnings;
-    }
-}
-class ErrorProcessor extends simple_1.SimpleTaskProcessor {
-    constructor(_errorOptions) {
-        super({
-            options: (context) => {
-                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 _errorOptions.options === "function") {
-                    options = (0, webpack_merge_1.default)(options, _errorOptions.options(options, context));
-                }
-                if (options.mode === "production") {
-                    if (options.optimization)
-                        options.optimization.minimize = true;
-                    else
-                        options.optimization = { minimize: true };
-                }
-                return options;
-            },
-            build: _errorOptions.build,
-            compilerType: _errorOptions.compilerType,
-            name: _errorOptions.name
-        });
-        this._errorOptions = _errorOptions;
-    }
-    async compiler(context) {
-        await super.compiler(context);
-        const compiler = this.getCompiler(context).getCompiler();
-        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() { }
-            };
-        }
-    }
-    async run(env, context) {
-        // do nothing
-    }
-    async check(env, context) {
-        const compiler = this.getCompiler(context);
-        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 this._errorOptions.check?.(new RspackStatsDiagnostics(errors, warnings));
-    }
-}
-exports.ErrorProcessor = ErrorProcessor;

package/dist/processor/hash.d.ts

@@ -1,10 +0,0 @@
-import type { ECompilerType, ITestContext, ITestEnv, TCompilerOptions } from "../type";
-import { type IMultiTaskProcessorOptions, MultiTaskProcessor } from "./multi";
-export interface IHashProcessorOptions<T extends ECompilerType> extends Omit<IMultiTaskProcessorOptions<T>, "runable"> {
-}
-export declare class HashProcessor<T extends ECompilerType> extends MultiTaskProcessor<T> {
-    constructor(_hashOptions: IHashProcessorOptions<T>);
-    check(env: ITestEnv, context: ITestContext): Promise<void>;
-    static defaultOptions<T extends ECompilerType>(index: number, context: ITestContext): TCompilerOptions<T>;
-    static overrideOptions<T extends ECompilerType>(index: number, context: ITestContext, options: TCompilerOptions<T>): void;
-}

package/dist/processor/hash.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HashProcessor = void 0;
-const multi_1 = require("./multi");
-const REG_ERROR_CASE = /error$/;
-class HashProcessor extends multi_1.MultiTaskProcessor {
-    constructor(_hashOptions) {
-        super({
-            defaultOptions: (HashProcessor.defaultOptions),
-            overrideOptions: (HashProcessor.overrideOptions),
-            runable: false,
-            ..._hashOptions
-        });
-    }
-    async check(env, context) {
-        const compiler = this.getCompiler(context);
-        const testConfig = context.getTestConfig();
-        const stats = compiler.getStats();
-        if (!stats) {
-            env.expect(false);
-            return;
-        }
-        if (REG_ERROR_CASE.test(this._options.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");
-        }
-    }
-    static defaultOptions(index, context) {
-        return {
-            context: context.getSource(),
-            output: {
-                path: context.getDist()
-            },
-            experiments: {
-                css: true,
-                rspackFuture: {
-                    bundlerInfo: {
-                        force: false
-                    }
-                },
-                inlineConst: true,
-                lazyBarrel: true
-            }
-        };
-    }
-    static overrideOptions(index, context, options) {
-        if (!options.entry) {
-            options.entry = "./index.js";
-        }
-        if (!global.printLogger) {
-            options.infrastructureLogging = {
-                level: "error"
-            };
-        }
-    }
-}
-exports.HashProcessor = HashProcessor;

package/dist/processor/hook.d.ts

@@ -1,44 +0,0 @@
-import { TestContext, type TTestContextOptions } from "../test/context";
-import type { ECompilerType, ITestContext, ITestEnv, TCompiler, TCompilerOptions } from "../type";
-import { type ISnapshotProcessorOptions, SnapshotProcessor } from "./snapshot";
-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 interface IHookProcessorOptions<T extends ECompilerType> extends ISnapshotProcessorOptions<T> {
-    options?: (context: ITestContext) => TCompilerOptions<T>;
-    compiler?: (context: ITestContext, compiler: TCompiler<T>) => Promise<void>;
-    check?: (context: ITestContext) => Promise<void>;
-}
-export declare class HookTaskProcessor<T extends ECompilerType> extends SnapshotProcessor<T> {
-    protected _hookOptions: IHookProcessorOptions<T>;
-    constructor(_hookOptions: IHookProcessorOptions<T>);
-    config(context: ITestContext): Promise<void>;
-    compiler(context: ITestContext): Promise<void>;
-    check(env: ITestEnv, context: HookCasesContext): Promise<void>;
-    static defaultOptions<T extends ECompilerType>(context: ITestContext): TCompilerOptions<T>;
-    static overrideOptions<T extends ECompilerType>(options: TCompilerOptions<T>): void;
-}