@rspack/test-tools 1.6.0-beta.1 → 1.6.1

package/dist/compiler.js

@@ -3,10 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TestCompilerManager = exports.COMPILER_FACTORIES = exports.ECompilerEvent = void 0;
+exports.TestCompilerManager = exports.ECompilerEvent = void 0;
 const node_events_1 = __importDefault(require("node:events"));
+const core_1 = require("@rspack/core");
 const webpack_merge_1 = __importDefault(require("webpack-merge"));
-const type_1 = require("./type");
+const debug_1 = require("./test/debug");
 var ECompilerEvent;
 (function (ECompilerEvent) {
     ECompilerEvent["Build"] = "build";
@@ -14,14 +15,9 @@ var ECompilerEvent;
     ECompilerEvent["Create"] = "create";
     ECompilerEvent["Close"] = "close";
 })(ECompilerEvent || (exports.ECompilerEvent = ECompilerEvent = {}));
-exports.COMPILER_FACTORIES = {
-    [type_1.ECompilerType.Rspack]: ((options, callback) => require("@rspack/core")(options, callback)),
-    [type_1.ECompilerType.Webpack]: ((options, callback) => require("webpack")(options, callback))
-};
 class TestCompilerManager {
-    constructor(type, factories = exports.COMPILER_FACTORIES) {
-        this.type = type;
-        this.factories = factories;
+    constructor(context) {
+        this.context = context;
         this.compilerOptions = {};
         this.compilerInstance = null;
         this.compilerStats = null;
@@ -44,12 +40,58 @@ class TestCompilerManager {
         return this.compilerInstance;
     }
     createCompiler() {
-        this.compilerInstance = this.factories[this.type](this.compilerOptions);
+        this.compilerInstance = require("@rspack/core")(this.compilerOptions);
+        if (__DEBUG__) {
+            const context = this.context;
+            this.compilerInstance = new Proxy(this.compilerInstance, {
+                get(target, p, receiver) {
+                    const value = Reflect.get(target, p, receiver);
+                    if (typeof value === "function" &&
+                        core_1.Compiler.prototype.hasOwnProperty(p)) {
+                        return value.bind(target);
+                    }
+                    return value;
+                },
+                set(target, p, value, receiver) {
+                    const debugSetProperties = context.getValue(debug_1.DEBUG_SCOPES.CreateCompilerSetProperties) || [];
+                    debugSetProperties.push(`${p} ${new Error().stack?.split("\n")[2]?.trim()}`);
+                    context.setValue(debug_1.DEBUG_SCOPES.CreateCompilerSetProperties, debugSetProperties);
+                    return Reflect.set(target, p, value, receiver);
+                }
+            });
+            this.context.setValue(debug_1.DEBUG_SCOPES.CreateCompilerInstance, {
+                path: require.resolve("@rspack/core"),
+                mode: "no-callback"
+            });
+        }
         this.emitter.emit(ECompilerEvent.Create, this.compilerInstance);
         return this.compilerInstance;
     }
     createCompilerWithCallback(callback) {
-        this.compilerInstance = this.factories[this.type](this.compilerOptions, callback);
+        this.compilerInstance = require("@rspack/core")(this.compilerOptions, callback);
+        if (__DEBUG__) {
+            const context = this.context;
+            this.compilerInstance = new Proxy(this.compilerInstance, {
+                get(target, p, receiver) {
+                    const value = Reflect.get(target, p, receiver);
+                    if (typeof value === "function" &&
+                        core_1.Compiler.prototype.hasOwnProperty(p)) {
+                        return value.bind(target);
+                    }
+                    return value;
+                },
+                set(target, p, value, receiver) {
+                    const debugSetProperties = context.getValue(debug_1.DEBUG_SCOPES.CreateCompilerSetProperties) || [];
+                    debugSetProperties.push(`${p} ${new Error().stack?.split("\n")[2]?.trim()}`);
+                    context.setValue(debug_1.DEBUG_SCOPES.CreateCompilerSetProperties, debugSetProperties);
+                    return Reflect.set(target, p, value, receiver);
+                }
+            });
+            this.context.setValue(debug_1.DEBUG_SCOPES.CreateCompilerInstance, {
+                path: require.resolve("@rspack/core"),
+                mode: "callback"
+            });
+        }
         this.emitter.emit(ECompilerEvent.Create, this.compilerInstance);
         return this.compilerInstance;
     }
@@ -58,11 +100,39 @@ class TestCompilerManager {
             throw new Error("Compiler should be created before build");
         return new Promise((resolve, reject) => {
             try {
+                const context = this.context;
+                if (__DEBUG__) {
+                    context.setValue(debug_1.DEBUG_SCOPES.BuildMethod, {
+                        method: "run"
+                    });
+                }
                 this.compilerInstance.run((error, newStats) => {
                     this.emitter.emit(ECompilerEvent.Build, error, newStats);
-                    if (error)
+                    if (error) {
+                        if (__DEBUG__) {
+                            context.setValue(debug_1.DEBUG_SCOPES.BuildError, {
+                                type: "fatal",
+                                errors: [error]
+                            });
+                        }
                         return reject(error);
+                    }
                     this.compilerStats = newStats;
+                    if (__DEBUG__) {
+                        if (newStats?.hasErrors()) {
+                            context.setValue(debug_1.DEBUG_SCOPES.BuildError, {
+                                type: "stats",
+                                errors: newStats.toJson({
+                                    errors: true
+                                }).errors || []
+                            });
+                        }
+                        if (newStats?.hasWarnings()) {
+                            context.setValue(debug_1.DEBUG_SCOPES.BuildWarning, newStats.toJson({
+                                warnings: true
+                            }).warnings || []);
+                        }
+                    }
                     resolve(newStats);
                 });
             }
@@ -74,7 +144,8 @@ class TestCompilerManager {
     watch(timeout = 1000) {
         if (!this.compilerInstance)
             throw new Error("Compiler should be created before watch");
-        this.compilerInstance.watch({
+        const context = this.context;
+        const watchOptions = {
             // IMPORTANT:
             // This is a workaround for the issue that watchpack cannot detect the file change in time
             // so we set the poll to 300ms to make it more sensitive to the file change
@@ -83,11 +154,40 @@ class TestCompilerManager {
             // want to watch all files, which aligns with webpack's default behavior
             ignored: [],
             aggregateTimeout: timeout
-        }, (error, newStats) => {
+        };
+        if (__DEBUG__) {
+            context.setValue(debug_1.DEBUG_SCOPES.BuildMethod, {
+                method: "watch",
+                options: watchOptions
+            });
+        }
+        this.compilerInstance.watch(watchOptions, (error, newStats) => {
             this.emitter.emit(ECompilerEvent.Build, error, newStats);
-            if (error)
-                return error;
+            if (__DEBUG__) {
+                if (error) {
+                    context.setValue(debug_1.DEBUG_SCOPES.BuildError, {
+                        type: "fatal",
+                        errors: [error]
+                    });
+                    return error;
+                }
+            }
             if (newStats) {
+                if (__DEBUG__) {
+                    if (newStats.hasErrors()) {
+                        context.setValue(debug_1.DEBUG_SCOPES.BuildError, {
+                            type: "stats",
+                            errors: newStats.toJson({
+                                errors: true
+                            }).errors || []
+                        });
+                    }
+                    if (newStats.hasWarnings()) {
+                        context.setValue(debug_1.DEBUG_SCOPES.BuildWarning, newStats.toJson({
+                            warnings: true
+                        }).warnings || []);
+                    }
+                }
                 this.compilerStats = newStats;
             }
             return newStats;

package/dist/helper/index.d.ts

@@ -2,6 +2,7 @@ export * from "./directory";
 export * from "./is";
 export * from "./parse-modules";
 export * from "./read-config-file";
+export * from "./stringify-config";
 export * from "./update-snapshot";
 export * from "./util/checkStats";
 export * from "./win";

package/dist/helper/index.js

@@ -18,6 +18,7 @@ __exportStar(require("./directory"), exports);
 __exportStar(require("./is"), exports);
 __exportStar(require("./parse-modules"), exports);
 __exportStar(require("./read-config-file"), exports);
+__exportStar(require("./stringify-config"), exports);
 __exportStar(require("./update-snapshot"), exports);
 __exportStar(require("./util/checkStats"), exports);
 __exportStar(require("./win"), exports);

package/dist/helper/legacy/checkArrayExpectation.js

@@ -1,6 +1,6 @@
 // @ts-nocheck
 "use strict";
-const fs = require("graceful-fs");
+const fs = require("fs-extra");
 const path = require("node:path");
 const check = (expected, actual) => {
     if (expected instanceof RegExp) {

package/dist/helper/read-config-file.d.ts

@@ -1,2 +1,3 @@
-import type { ECompilerType, ITestContext, TCompilerOptions } from "../type";
-export declare function readConfigFile<T extends ECompilerType>(files: string[], context: ITestContext, prevOption?: TCompilerOptions<T>, functionApply?: (config: (TCompilerOptions<T> | ((...args: unknown[]) => TCompilerOptions<T>))[]) => TCompilerOptions<T>[]): TCompilerOptions<T>[];
+import type { RspackOptions } from "@rspack/core";
+import type { ITestContext } from "../type";
+export declare function readConfigFile(files: string[], context: ITestContext, prevOption?: RspackOptions, functionApply?: (config: (RspackOptions | ((...args: unknown[]) => RspackOptions))[]) => RspackOptions[]): RspackOptions[];

package/dist/helper/read-config-file.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readConfigFile = readConfigFile;
 const fs_extra_1 = __importDefault(require("fs-extra"));
+const debug_1 = require("../test/debug");
 function readConfigFile(files, context, prevOption, functionApply) {
     const existsFile = files.find(i => fs_extra_1.default.existsSync(i));
     let fileConfig = existsFile ? require(existsFile) : {};
@@ -12,5 +13,11 @@ function readConfigFile(files, context, prevOption, functionApply) {
         fileConfig = fileConfig({ config: prevOption }, { testPath: context.getDist(), tempPath: context.getTemp() });
     }
     const configArr = Array.isArray(fileConfig) ? fileConfig : [fileConfig];
+    if (existsFile) {
+        context.setValue(debug_1.DEBUG_SCOPES.CompilerOptionsReadConfigFile, {
+            file: existsFile,
+            config: fileConfig
+        });
+    }
     return functionApply ? functionApply(configArr) : configArr;
 }

package/dist/helper/setup-env.js

@@ -16,6 +16,7 @@ if (process.env.RSTEST) {
     global.__ROOT_PATH__ ??= process.env.__ROOT_PATH__;
     global.__RSPACK_PATH__ ??= process.env.__RSPACK_PATH__;
     global.__RSPACK_TEST_TOOLS_PATH__ ??= process.env.__RSPACK_TEST_TOOLS_PATH__;
+    global.__DEBUG__ ??= process.env.DEBUG === "test";
 }
 else {
     // Compatible with wasm tests (lazyTestEnv)

package/dist/helper/stringify-config.d.ts

@@ -0,0 +1,2 @@
+import type { RspackOptions } from "@rspack/core";
+export default function stringifyConfig(config: RspackOptions, verbose?: boolean): string | undefined;

package/dist/helper/stringify-config.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = stringifyConfig;
+const javascript_stringify_1 = require("javascript-stringify");
+function stringifyConfig(config, verbose = false) {
+    return (0, javascript_stringify_1.stringify)(config, (value, indent, stringify) => {
+        // improve plugin output
+        if (value?.__pluginName) {
+            const prefix = `/* config.${value.__pluginType}('${value.__pluginName}') */\n`;
+            const constructorExpression = value.__pluginPath
+                ? // The path is stringified to ensure special characters are escaped
+                    // (such as the backslashes in Windows-style paths).
+                    `(require(${stringify(value.__pluginPath)}))`
+                : value.__pluginConstructorName;
+            if (constructorExpression) {
+                // get correct indentation for args by stringifying the args array and
+                // discarding the square brackets.
+                const args = stringify(value.__pluginArgs)?.slice(1, -1);
+                return `${prefix}new ${constructorExpression}(${args})`;
+            }
+            return (prefix +
+                stringify(value.__pluginArgs?.length ? { args: value.__pluginArgs } : {}));
+        }
+        // improve rule/use output
+        if (value?.__ruleNames) {
+            const ruleTypes = value.__ruleTypes;
+            const prefix = `/* config.module${value.__ruleNames
+                .map((r, index) => `.${ruleTypes ? ruleTypes[index] : "rule"}('${r}')`)
+                .join("")}${value.__useName ? `.use('${value.__useName}')` : ``} */\n`;
+            return prefix + stringify(value);
+        }
+        if (value?.__expression) {
+            return value.__expression;
+        }
+        // shorten long functions
+        if (typeof value === "function") {
+            if (!verbose && value.toString().length > 100) {
+                return `function () { /* omitted long function */ }`;
+            }
+        }
+        return stringify(value);
+    }, 2);
+}

package/dist/index.d.ts

@@ -1,5 +1,4 @@
 export * from "./case";
-export * from "./compare";
 export * from "./helper";
 export * from "./plugin";
 export * from "./runner";

package/dist/index.js

@@ -15,7 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./case"), exports);
-__exportStar(require("./compare"), exports);
 __exportStar(require("./helper"), exports);
 __exportStar(require("./plugin"), exports);
 __exportStar(require("./runner"), exports);

package/dist/plugin/index.d.ts

@@ -1,4 +1 @@
 export * from "./lazy-compilation-test-plugin";
-export * from "./rspack-diff-config-plugin";
-export * from "./webpack-diff-config-plugin";
-export * from "./webpack-module-placeholder-plugin";

package/dist/plugin/index.js

@@ -15,6 +15,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./lazy-compilation-test-plugin"), exports);
-__exportStar(require("./rspack-diff-config-plugin"), exports);
-__exportStar(require("./webpack-diff-config-plugin"), exports);
-__exportStar(require("./webpack-module-placeholder-plugin"), exports);

package/dist/runner/node/index.d.ts

@@ -1,25 +1,29 @@
-import { type ECompilerType, type IGlobalContext, type IModuleScope, type ITestEnv, type ITestRunner, type TCompilerOptions, type TCompilerStatsCompilation, type TModuleObject, type TRunnerFile, type TRunnerRequirer, type TTestConfig } from "../../type";
+import type { RspackOptions, StatsCompilation } from "@rspack/core";
+import { type IGlobalContext, type IModuleScope, type ITestEnv, type ITestRunner, type TModuleObject, type TRunnerFile, type TRunnerRequirer, type TTestConfig } from "../../type";
 declare global {
     var printLogger: boolean;
 }
-export interface INodeRunnerOptions<T extends ECompilerType> {
+export interface INodeRunnerOptions {
     env: ITestEnv;
-    stats?: () => TCompilerStatsCompilation<T>;
+    stats?: () => StatsCompilation;
     name: string;
     runInNewContext?: boolean;
-    testConfig: TTestConfig<T>;
+    testConfig: TTestConfig;
     source: string;
     dist: string;
-    compilerOptions: TCompilerOptions<T>;
+    compilerOptions: RspackOptions;
     cachable?: boolean;
+    logs?: string[];
+    errors?: Error[];
 }
-export declare class NodeRunner<T extends ECompilerType = ECompilerType.Rspack> implements ITestRunner {
-    protected _options: INodeRunnerOptions<T>;
+export declare class NodeRunner implements ITestRunner {
+    protected _options: INodeRunnerOptions;
     protected requireCache: any;
     protected globalContext: IGlobalContext | null;
     protected baseModuleScope: IModuleScope | null;
     protected requirers: Map<string, TRunnerRequirer>;
-    constructor(_options: INodeRunnerOptions<T>);
+    constructor(_options: INodeRunnerOptions);
+    protected log(message: string): void;
     run(file: string): Promise<unknown>;
     getRequire(): TRunnerRequirer;
     getGlobal(name: string): unknown;

package/dist/runner/node/index.js

@@ -72,6 +72,9 @@ class NodeRunner {
         this.baseModuleScope = null;
         this.requirers = new Map();
     }
+    log(message) {
+        this._options.logs?.push(`[NodeRunner] ${message}`);
+    }
     run(file) {
         if (!this.globalContext) {
             this.globalContext = this.createGlobalContext();
@@ -81,7 +84,9 @@ class NodeRunner {
             this._options.testConfig.moduleScope(this.baseModuleScope, this._options.stats, this._options.compilerOptions);
         }
         this.createRunner();
-        const res = this.getRequire()(this._options.dist, file.startsWith("./") || file.startsWith("https://test.cases/")
+        const res = this.getRequire()(node_path_1.default.isAbsolute(file) ? node_path_1.default.dirname(file) : this._options.dist, file.startsWith("./") ||
+            file.startsWith("https://test.cases/") ||
+            node_path_1.default.isAbsolute(file)
             ? file
             : `./${file}`);
         if (typeof res === "object" && "then" in res) {
@@ -91,7 +96,15 @@ class NodeRunner {
     }
     getRequire() {
         const entryRequire = this.requirers.get("entry");
-        return (currentDirectory, modulePath, context = {}) => {
+        const runner = this;
+        return function (currentDirectory, modulePath, context = {}) {
+            const from = this?.from;
+            if (from) {
+                runner.log(`require: ${modulePath} from ${from}`);
+            }
+            else {
+                runner.log(`require: ${modulePath}`);
+            }
             const p = Array.isArray(modulePath)
                 ? modulePath
                 : modulePath.split("?")[0];
@@ -175,7 +188,10 @@ class NodeRunner {
         return baseModuleScope;
     }
     createModuleScope(requireFn, m, file) {
-        const requirer = requireFn.bind(null, node_path_1.default.dirname(file.path));
+        const requirer = requireFn.bind({
+            from: file.path,
+            module: m
+        }, node_path_1.default.dirname(file.path));
         requirer.webpackTestSuiteRequire = true;
         return {
             ...this.baseModuleScope,
@@ -244,6 +260,7 @@ class NodeRunner {
         this.requirers.set("json", this.createJsonRequirer());
         this.requirers.set("entry", (currentDirectory, modulePath, context) => {
             const file = this.getFile(modulePath, currentDirectory);
+            this.log(`entry: ${modulePath} -> ${file?.path}`);
             if (!file) {
                 return this.requirers.get("miss")(currentDirectory, modulePath);
             }
@@ -268,11 +285,14 @@ class NodeRunner {
     }
     createMissRequirer() {
         return (currentDirectory, modulePath, context = {}) => {
+            this.log(`missing: ${modulePath}`);
             const modulePathStr = modulePath;
             const modules = this._options.testConfig.modules;
             if (modules && modulePathStr in modules) {
+                this.log(`mock module: ${modulePathStr}`);
                 return modules[modulePathStr];
             }
+            this.log(`native require: ${modulePathStr}`);
             return require(modulePathStr.startsWith("node:")
                 ? modulePathStr.slice(5)
                 : modulePathStr);
@@ -284,6 +304,7 @@ class NodeRunner {
                 throw new Error("Array module path is not supported in hot cases");
             }
             const file = context.file || this.getFile(modulePath, currentDirectory);
+            this.log(`json: ${modulePath} -> ${file?.path}`);
             if (!file) {
                 return this.requirers.get("miss")(currentDirectory, modulePath);
             }
@@ -296,10 +317,12 @@ class NodeRunner {
                 return require("@rspack/test-tools");
             }
             const file = context.file || this.getFile(modulePath, currentDirectory);
+            this.log(`cjs: ${modulePath} -> ${file?.path}`);
             if (!file) {
                 return this.requirers.get("miss")(currentDirectory, modulePath);
             }
             if (file.path in this.requireCache) {
+                this.log(`cjs cache hit: ${file.path}`);
                 return this.requireCache[file.path].exports;
             }
             const m = {
@@ -326,16 +349,30 @@ class NodeRunner {
             const args = Object.keys(currentModuleScope);
             const argValues = args.map(arg => currentModuleScope[arg]);
             const code = `(function(${args.join(", ")}) {
-        ${file.content}
+				${file.content}
       })`;
             this.preExecute(code, file);
-            const fn = this._options.runInNewContext
-                ? node_vm_1.default.runInNewContext(code, this.globalContext, file.path)
-                : node_vm_1.default.runInThisContext(code, file.path);
-            fn.call(this._options.testConfig.nonEsmThis
-                ? this._options.testConfig.nonEsmThis(modulePath)
-                : m.exports, ...argValues);
+            this.log(`run mode: ${this._options.runInNewContext ? "new context" : "this context"}`);
+            try {
+                const fn = this._options.runInNewContext
+                    ? node_vm_1.default.runInNewContext(code, this.globalContext, {
+                        filename: file.path,
+                        lineOffset: -1
+                    })
+                    : node_vm_1.default.runInThisContext(code, {
+                        filename: file.path,
+                        lineOffset: -1
+                    });
+                fn.call(this._options.testConfig.nonEsmThis
+                    ? this._options.testConfig.nonEsmThis(modulePath)
+                    : m.exports, ...argValues);
+            }
+            catch (e) {
+                this._options.errors?.push(e);
+                throw e;
+            }
             this.postExecute(m, file);
+            this.log(`end cjs: ${modulePath}`);
             return m.exports;
         };
     }
@@ -351,6 +388,7 @@ class NodeRunner {
             }
             const _require = this.getRequire();
             const file = context.file || this.getFile(modulePath, currentDirectory);
+            this.log(`esm: ${modulePath} -> ${file?.path}`);
             if (!file) {
                 return this.requirers.get("miss")(currentDirectory, modulePath);
             }
@@ -376,6 +414,7 @@ class NodeRunner {
                         meta.filename = file.path;
                     },
                     importModuleDynamically: async (specifier, module) => {
+                        this.log(`import: ${specifier} from ${file?.path}`);
                         const result = await _require(node_path_1.default.dirname(file.path), specifier, {
                             esmMode: type_1.EEsmMode.Evaluated
                         });
@@ -401,6 +440,7 @@ class NodeRunner {
                     return esm;
                 }
                 const ns = esm.namespace;
+                this.log(`end esm: ${modulePath}`);
                 return ns.default && ns.default instanceof Promise ? ns.default : ns;
             })();
         };

package/dist/runner/web/index.d.ts

@@ -1,14 +1,15 @@
-import type { ECompilerType, TRunnerFile, TRunnerRequirer } from "../../type";
+import type { TRunnerFile, TRunnerRequirer } from "../../type";
 import { type INodeRunnerOptions, NodeRunner } from "../node";
-export interface IWebRunnerOptions<T extends ECompilerType = ECompilerType.Rspack> extends INodeRunnerOptions<T> {
+export interface IWebRunnerOptions extends INodeRunnerOptions {
     location: string;
 }
-export declare class WebRunner<T extends ECompilerType = ECompilerType.Rspack> extends NodeRunner<T> {
-    protected _webOptions: IWebRunnerOptions<T>;
+export declare class WebRunner extends NodeRunner {
+    protected _webOptions: IWebRunnerOptions;
     private dom;
-    constructor(_webOptions: IWebRunnerOptions<T>);
+    constructor(_webOptions: IWebRunnerOptions);
     run(file: string): Promise<unknown>;
     getGlobal(name: string): unknown;
+    protected log(message: string): void;
     protected createResourceLoader(): {
         fetch(url: string, _: {
             element: HTMLScriptElement;
@@ -20,7 +21,8 @@ export declare class WebRunner<T extends ECompilerType = ECompilerType.Rspack> e
         {
             exports: Record<string, unknown>;
         },
-        string
+        string,
+        number
     ];
     protected createJSDOMRequirer(): TRunnerRequirer;
     protected createRunner(): void;