@rspack/test-tools 1.6.0-beta.0 → 1.6.0

package/dist/helper/legacy/asModule.js

@@ -18,8 +18,6 @@ module.exports = async (something, context, unlinked) => {
     if (unlinked)
         return m;
     await m.link(() => { });
-    if (m.instantiate)
-        m.instantiate();
     await m.evaluate();
     return m;
 };

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/legacy/createLazyTestEnv.d.ts

@@ -6,5 +6,6 @@ declare function _exports(globalTimeout?: number, nameSuffix?: string): {
     afterEach(...args: any[]): void;
     expect: jest.Expect;
     jest: typeof jest;
+    rstest: typeof jest;
 };
 export = _exports;

package/dist/helper/legacy/createLazyTestEnv.js

@@ -39,11 +39,10 @@ module.exports = (globalTimeout = 2000, nameSuffix = "") => {
         it("should run the exported tests", () => {
             runTests++;
         });
-        afterAll(done => {
+        afterAll(() => {
             for (const dispose of disposables) {
                 dispose();
             }
-            done();
         });
         currentDescribeBlock = state.currentDescribeBlock;
         currentlyRunningTest = state.currentlyRunningTest;
@@ -111,6 +110,8 @@ module.exports = (globalTimeout = 2000, nameSuffix = "") => {
             });
         },
         expect,
-        jest
+        jest,
+        // Compatible with rstest
+        rstest: global.rstest || global.jest
     };
 };

package/dist/helper/legacy/supportsTextDecoder.d.ts

@@ -0,0 +1,2 @@
+declare function _exports(): boolean;
+export = _exports;

package/dist/helper/legacy/supportsTextDecoder.js

@@ -0,0 +1,9 @@
+"use strict";
+module.exports = function supportsTextDecoder() {
+    try {
+        return typeof TextDecoder !== "undefined";
+    }
+    catch (_err) {
+        return false;
+    }
+};

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

@@ -1,2 +1,3 @@
-import type { ECompilerType, TCompilerOptions } from "../type";
-export declare function readConfigFile<T extends ECompilerType>(files: string[], 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,9 +5,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readConfigFile = readConfigFile;
 const fs_extra_1 = __importDefault(require("fs-extra"));
-function readConfigFile(files, functionApply) {
+const debug_1 = require("../test/debug");
+function readConfigFile(files, context, prevOption, functionApply) {
     const existsFile = files.find(i => fs_extra_1.default.existsSync(i));
-    const fileConfig = existsFile ? require(existsFile) : {};
+    let fileConfig = existsFile ? require(existsFile) : {};
+    if (typeof fileConfig === "function") {
+        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

@@ -6,6 +6,22 @@ const path = require("node:path");
 if (process.env.RSPACK_BINDING_BUILDER_TESTING) {
     process.env.RSPACK_BINDING = path.resolve(__dirname, "../../node_modules/@rspack/binding-testing");
 }
+if (process.env.RSTEST) {
+    global.printLogger ??= process.env.printLogger === "true";
+    global.__TEST_FIXTURES_PATH__ ??= process.env.__TEST_FIXTURES_PATH__;
+    global.updateSnapshot ??= process.env.updateSnapshot === "true";
+    global.testFilter ??= process.env.testFilter;
+    global.__TEST_PATH__ ??= process.env.__TEST_PATH__;
+    global.__TEST_DIST_PATH__ ??= process.env.__TEST_DIST_PATH__;
+    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)
+    global.rstest = jest;
+}
 if (process.env.ALTERNATIVE_SORT) {
     const oldSort = Array.prototype.sort;
     Array.prototype.sort = function (cmp) {
@@ -58,7 +74,8 @@ if (process.env.DEBUG_INFO) {
                 }, timeout);
             }
             else {
-                it(name, done => {
+                it(name, () => new Promise((resolve, reject) => {
+                    const done = err => (err ? reject(err) : resolve());
                     process.stdout.write(`START2 ${name}\n`);
                     return fn(err => {
                         if (err) {
@@ -69,7 +86,7 @@ if (process.env.DEBUG_INFO) {
                         }
                         return done(err);
                     });
-                }, timeout);
+                }), timeout);
             }
         };
     };

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/helper/util/expectWarningFactory.js

@@ -3,15 +3,13 @@
 module.exports = () => {
     const warnings = [];
     let oldWarn;
-    beforeEach(done => {
+    beforeEach(() => {
         oldWarn = console.warn;
         console.warn = m => warnings.push(m);
-        done();
     });
-    afterEach(done => {
+    afterEach(() => {
         expectWarning();
         console.warn = oldWarn;
-        done();
     });
     const expectWarning = (...regexp) => {
         expect(warnings).toEqual(regexp.map(r => expect.stringMatching(r)));

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;
@@ -35,3 +39,4 @@ export declare class NodeRunner<T extends ECompilerType = ECompilerType.Rspack>
     protected createCjsRequirer(): TRunnerRequirer;
     protected createEsmRequirer(): TRunnerRequirer;
 }
+export declare const createLocatedError: (collectedErrors: Error[], offset: number) => (e: Error, file: TRunnerFile) => Error;

package/dist/runner/node/index.js

@@ -36,7 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NodeRunner = void 0;
+exports.createLocatedError = exports.NodeRunner = void 0;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_url_1 = require("node:url");
@@ -45,6 +45,7 @@ const asModule_1 = __importDefault(require("../../helper/legacy/asModule"));
 const createFakeWorker_1 = __importDefault(require("../../helper/legacy/createFakeWorker"));
 const urlToRelativePath_1 = __importDefault(require("../../helper/legacy/urlToRelativePath"));
 const type_1 = require("../../type");
+const EVAL_LOCATION_REGEX = /<anonymous>:(\d+)/;
 const isRelativePath = (p) => /^\.\.?\//.test(p);
 const getSubPath = (p) => {
     const lastSlash = p.lastIndexOf("/");
@@ -72,6 +73,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 +85,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 +97,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];
@@ -164,6 +178,7 @@ class NodeRunner {
             Symbol,
             Buffer,
             setImmediate,
+            self: this.globalContext,
             __MODE__: this._options.compilerOptions.mode,
             __SNAPSHOT__: node_path_1.default.join(this._options.source, "__snapshot__"),
             Worker: (0, createFakeWorker_1.default)(this._options.env, {
@@ -174,7 +189,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,
@@ -243,6 +261,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);
             }
@@ -267,11 +286,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);
@@ -283,6 +305,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);
             }
@@ -295,10 +318,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 = {
@@ -307,7 +332,7 @@ class NodeRunner {
             };
             this.requireCache[file.path] = m;
             if (!this._options.runInNewContext) {
-                file.content = `Object.assign(global, _globalAssign);\n ${file.content}`;
+                file.content = `Object.assign(global, _globalAssign);${file.content}`;
             }
             const currentModuleScope = this.createModuleScope(this.getRequire(), m, file);
             if (this._options.testConfig.moduleScope) {
@@ -322,19 +347,39 @@ class NodeRunner {
                     currentModuleScope.__STATS_I__ = statsIndex;
                 }
             }
+            const createNodeLocatedError = (0, exports.createLocatedError)(this._options.errors || [], 2);
+            const originIt = currentModuleScope.it;
+            currentModuleScope.it = (description, fn) => {
+                originIt(description, async () => {
+                    try {
+                        await fn();
+                    }
+                    catch (err) {
+                        throw createNodeLocatedError(err, file);
+                    }
+                });
+            };
+            currentModuleScope.__CREATE_LOCATED_ERROR__ = createNodeLocatedError;
+            currentModuleScope.__FILE__ = file;
             const args = Object.keys(currentModuleScope);
             const argValues = args.map(arg => currentModuleScope[arg]);
             const code = `(function(${args.join(", ")}) {
-        ${file.content}
+				try {
+					${file.content}
+				} catch(err) {
+					throw __CREATE_LOCATED_ERROR__(err, __FILE__);
+				}
       })`;
             this.preExecute(code, file);
+            this.log(`run mode: ${this._options.runInNewContext ? "new context" : "this context"}`);
             const fn = this._options.runInNewContext
-                ? node_vm_1.default.runInNewContext(code, this.globalContext, file.path)
-                : node_vm_1.default.runInThisContext(code, file.path);
+                ? node_vm_1.default.runInNewContext(code, this.globalContext)
+                : node_vm_1.default.runInThisContext(code);
             fn.call(this._options.testConfig.nonEsmThis
                 ? this._options.testConfig.nonEsmThis(modulePath)
                 : m.exports, ...argValues);
             this.postExecute(m, file);
+            this.log(`end cjs: ${modulePath}`);
             return m.exports;
         };
     }
@@ -350,12 +395,19 @@ 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);
             }
             if (file.content.includes("__STATS__")) {
                 esmContext.__STATS__ = this._options.stats?.();
             }
+            if (file.content.includes("__STATS_I__")) {
+                const statsIndex = this._options.stats?.()?.__index__;
+                if (typeof statsIndex === "number") {
+                    esmContext.__STATS_I__ = statsIndex;
+                }
+            }
             let esm = esmCache.get(file.path);
             if (!esm) {
                 esm = new node_vm_1.SourceTextModule(file.content, {
@@ -369,6 +421,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
                         });
@@ -389,16 +442,41 @@ class NodeRunner {
                         }), referencingModule.context, true);
                     });
                 }
-                if (esm.instantiate)
-                    esm.instantiate();
                 await esm.evaluate();
                 if (context.esmMode === type_1.EEsmMode.Evaluated) {
                     return esm;
                 }
                 const ns = esm.namespace;
+                this.log(`end esm: ${modulePath}`);
                 return ns.default && ns.default instanceof Promise ? ns.default : ns;
             })();
         };
     }
 }
 exports.NodeRunner = NodeRunner;
+const createLocatedError = (collectedErrors, offset) => {
+    return (e, file) => {
+        const match = (e.stack || e.message).match(EVAL_LOCATION_REGEX);
+        if (match) {
+            const [, line] = match;
+            const realLine = Number(line) - offset;
+            const codeLines = file.content.split("\n");
+            const lineContents = [
+                ...codeLines
+                    .slice(Math.max(0, realLine - 3), Math.max(0, realLine - 1))
+                    .map(line => `│  ${line}`),
+                `│> ${codeLines[realLine - 1]}`,
+                ...codeLines.slice(realLine, realLine + 2).map(line => `│  ${line}`)
+            ];
+            const message = `Error in JSDOM when running file '${file.path}' at line ${realLine}: ${e.message}\n${lineContents.join("\n")}`;
+            const finalError = new Error(message);
+            finalError.stack = undefined;
+            collectedErrors.push(finalError);
+            return finalError;
+        }
+        else {
+            return e;
+        }
+    };
+};
+exports.createLocatedError = createLocatedError;

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

@@ -1,14 +1,28 @@
-import { type ECompilerType, EDocumentType, type ITestRunner } from "../../type";
-import type { INodeRunnerOptions, NodeRunner } from "../node";
-export interface IWebRunnerOptions<T extends ECompilerType = ECompilerType.Rspack> extends INodeRunnerOptions<T> {
-    dom: EDocumentType;
+import type { TRunnerFile, TRunnerRequirer } from "../../type";
+import { type INodeRunnerOptions, NodeRunner } from "../node";
+export interface IWebRunnerOptions extends INodeRunnerOptions {
+    location: string;
 }
-export declare class WebRunner<T extends ECompilerType = ECompilerType.Rspack> implements ITestRunner {
-    protected _webOptions: IWebRunnerOptions<T>;
-    protected originMethods: Partial<NodeRunner<T>>;
-    private implement;
-    constructor(_webOptions: IWebRunnerOptions<T>);
+export declare class WebRunner extends NodeRunner {
+    protected _webOptions: IWebRunnerOptions;
+    private dom;
+    constructor(_webOptions: IWebRunnerOptions);
     run(file: string): Promise<unknown>;
-    getRequire(): import("../../type").TRunnerRequirer;
     getGlobal(name: string): unknown;
+    protected log(message: string): void;
+    protected createResourceLoader(): {
+        fetch(url: string, _: {
+            element: HTMLScriptElement;
+        }): any;
+    };
+    private urlToPath;
+    protected createBaseModuleScope(): import("../../type").IModuleScope;
+    protected getModuleContent(file: TRunnerFile): [
+        {
+            exports: Record<string, unknown>;
+        },
+        string
+    ];
+    protected createJSDOMRequirer(): TRunnerRequirer;
+    protected createRunner(): void;
 }