@rspack/test-tools 1.5.3 → 1.5.5

package/dist/case/compiler.d.ts

@@ -1,6 +1,15 @@
 import { type ISimpleProcessorOptions } from "../processor";
-import { ECompilerType } from "../type";
-export type TCompilerCaseConfig = Omit<ISimpleProcessorOptions<ECompilerType.Rspack>, "name" | "compilerType"> & {
+import { ECompilerType, type ITestContext, type TCompilation, type TCompiler, type TCompilerStatsCompilation } from "../type";
+export type TCompilerCaseConfig = Omit<ISimpleProcessorOptions<ECompilerType.Rspack>, "name" | "compilerType" | "check"> & {
     description: string;
+    error?: boolean;
+    skip?: boolean;
+    check?: ({ context, stats, files, compiler, compilation }: {
+        context: ITestContext;
+        stats?: TCompilerStatsCompilation<ECompilerType.Rspack>;
+        files?: Record<string, string>;
+        compiler: TCompiler<ECompilerType.Rspack>;
+        compilation?: TCompilation<ECompilerType.Rspack>;
+    }) => Promise<void>;
 };
 export declare function createCompilerCase(name: string, src: string, dist: string, testConfig: string): void;

package/dist/case/compiler.js

@@ -5,13 +5,116 @@ const processor_1 = require("../processor");
 const simple_1 = require("../test/simple");
 const type_1 = require("../type");
 function createCompilerCase(name, src, dist, testConfig) {
-    const caseConfig = require(testConfig);
+    let caseConfigList = require(testConfig);
+    if (!Array.isArray(caseConfigList)) {
+        caseConfigList = [caseConfigList];
+    }
     const runner = (0, simple_1.getSimpleProcessorRunner)(src, dist);
-    it(caseConfig.description, async () => {
-        await runner(name, new processor_1.SimpleTaskProcessor({
-            name: name,
-            compilerType: type_1.ECompilerType.Rspack,
-            ...caseConfig
-        }));
-    });
+    for (const caseConfig of caseConfigList) {
+        const testFn = caseConfig.skip ? it.skip : it;
+        testFn(caseConfig.description, async () => {
+            const logs = {
+                mkdir: [],
+                writeFile: []
+            };
+            const files = {};
+            await runner(name, new processor_1.SimpleTaskProcessor({
+                name: name,
+                compilerType: type_1.ECompilerType.Rspack,
+                compilerCallback: caseConfig.compilerCallback,
+                build: caseConfig.build,
+                options: context => {
+                    const options = caseConfig.options?.(context) || {};
+                    options.mode ??= "production";
+                    options.context ??= context.getSource();
+                    options.entry ??= "./a.js";
+                    options.output ??= {};
+                    options.output.path ??= "/";
+                    options.output.pathinfo ??= true;
+                    options.optimization ??= {};
+                    options.optimization.minimize ??= false;
+                    return options;
+                },
+                async compiler(context, compiler) {
+                    compiler.outputFileSystem = {
+                        // CHANGE: Added support for the `options` parameter to enable recursive directory creation,
+                        // accommodating Rspack's requirement that differs from webpack's usage
+                        mkdir(path, callback) {
+                            const recursive = false;
+                            // if (typeof options === "function") {
+                            // 	callback = options;
+                            // } else if (options) {
+                            // 	if (options.recursive !== undefined) recursive = options.recursive;
+                            // }
+                            logs.mkdir.push(path);
+                            if (recursive) {
+                                callback();
+                            }
+                            else {
+                                const err = new Error();
+                                err.code = "EEXIST";
+                                callback(err);
+                            }
+                        },
+                        writeFile(name, content, callback) {
+                            logs.writeFile.push(name, content);
+                            files[name] = content.toString("utf-8");
+                            callback();
+                        },
+                        stat(path, callback) {
+                            callback(new Error("ENOENT"));
+                        }
+                    };
+                    compiler.hooks.compilation.tap("CompilerTest", compilation => (compilation.bail = true));
+                    await caseConfig.compiler?.(context, compiler);
+                },
+                async check(context, compiler, stats) {
+                    if (caseConfig.error) {
+                        const statsJson = stats?.toJson({
+                            modules: true,
+                            reasons: true
+                        });
+                        const compilation = stats?.compilation;
+                        await caseConfig.check?.({
+                            context,
+                            compiler,
+                            stats: statsJson,
+                            compilation,
+                            files
+                        });
+                    }
+                    else if (stats) {
+                        expect(typeof stats).toBe("object");
+                        const compilation = stats.compilation;
+                        const statsJson = stats.toJson({
+                            modules: true,
+                            reasons: true
+                        });
+                        expect(typeof statsJson).toBe("object");
+                        expect(statsJson).toHaveProperty("errors");
+                        expect(Array.isArray(statsJson.errors)).toBe(true);
+                        if (statsJson.errors.length > 0) {
+                            expect(statsJson.errors[0]).toBeInstanceOf(Object);
+                            throw statsJson.errors[0];
+                        }
+                        statsJson.logs = logs;
+                        await caseConfig.check?.({
+                            context,
+                            stats: statsJson,
+                            files,
+                            compiler,
+                            compilation
+                        });
+                    }
+                    else {
+                        await caseConfig.check?.({
+                            context,
+                            files,
+                            compiler
+                        });
+                    }
+                }
+            }));
+        });
+    }
 }

package/dist/case/config.js

@@ -10,11 +10,11 @@ const creator = new creator_1.BasicCaseCreator({
     describe: false,
     testConfig: testConfig => {
         const oldModuleScope = testConfig.moduleScope;
-        testConfig.moduleScope = (ms, stats) => {
+        testConfig.moduleScope = (ms, stats, compilerOptions) => {
             let res = ms;
             // TODO: modify runner module scope based on stats here
             if (typeof oldModuleScope === "function") {
-                res = oldModuleScope(ms, stats);
+                res = oldModuleScope(ms, stats, compilerOptions);
             }
             return res;
         };

package/dist/case/normal.d.ts

@@ -1 +1,2 @@
 export declare function createNormalCase(name: string, src: string, dist: string): void;
+export declare function createHotNormalCase(name: string, src: string, dist: string): void;

package/dist/case/normal.js

@@ -4,26 +4,38 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNormalCase = createNormalCase;
+exports.createHotNormalCase = createHotNormalCase;
 const node_path_1 = __importDefault(require("node:path"));
+const core_1 = require("@rspack/core");
 const normal_1 = require("../processor/normal");
 const runner_1 = require("../runner");
 const creator_1 = require("../test/creator");
 const type_1 = require("../type");
-const creator = new creator_1.BasicCaseCreator({
-    clean: true,
-    describe: false,
-    steps: ({ name }) => [
-        new normal_1.NormalProcessor({
-            name,
-            root: node_path_1.default.resolve(__dirname, "../../tests/normalCases"),
-            compilerOptions: {}, // do not used in rspack
-            runable: true,
-            compilerType: type_1.ECompilerType.Rspack
-        })
-    ],
-    runner: runner_1.NormalRunnerFactory,
-    concurrent: true
-});
+const NORMAL_CASES_ROOT = node_path_1.default.resolve(__dirname, "../../../../tests/rspack-test/normalCases");
+const createCaseOptions = (hot) => {
+    return {
+        clean: true,
+        describe: false,
+        steps: ({ name }) => [
+            new normal_1.NormalProcessor({
+                name,
+                root: NORMAL_CASES_ROOT,
+                compilerOptions: {
+                    plugins: hot ? [new core_1.HotModuleReplacementPlugin()] : []
+                },
+                runable: true,
+                compilerType: type_1.ECompilerType.Rspack
+            })
+        ],
+        runner: runner_1.NormalRunnerFactory,
+        concurrent: true
+    };
+};
+const creator = new creator_1.BasicCaseCreator(createCaseOptions(false));
 function createNormalCase(name, src, dist) {
     creator.create(name, src, dist);
 }
+const hotCreator = new creator_1.BasicCaseCreator(createCaseOptions(true));
+function createHotNormalCase(name, src, dist) {
+    hotCreator.create(name, src, dist);
+}

package/dist/case/serial.js

@@ -10,11 +10,11 @@ const creator = new creator_1.BasicCaseCreator({
     describe: false,
     testConfig: testConfig => {
         const oldModuleScope = testConfig.moduleScope;
-        testConfig.moduleScope = (ms, stats) => {
+        testConfig.moduleScope = (ms, stats, compilerOptions) => {
             let res = ms;
             // TODO: modify runner module scope based on stats here
             if (typeof oldModuleScope === "function") {
-                res = oldModuleScope(ms, stats);
+                res = oldModuleScope(ms, stats, compilerOptions);
             }
             return res;
         };

package/dist/compiler.d.ts

@@ -6,20 +6,21 @@ export declare enum ECompilerEvent {
     Create = "create",
     Close = "close"
 }
-export declare const COMPILER_FACTORIES: TCompilerFactories;
+export declare const COMPILER_FACTORIES: TCompilerFactories<ECompilerType>;
 export declare class TestCompilerManager<T extends ECompilerType> implements ITestCompilerManager<T> {
     protected type: T;
-    protected factories: TCompilerFactories;
+    protected factories: TCompilerFactories<T>;
     protected compilerOptions: TCompilerOptions<T>;
     protected compilerInstance: TCompiler<T> | null;
     protected compilerStats: TCompilerStats<T> | null;
     protected emitter: EventEmitter;
-    constructor(type: T, factories?: TCompilerFactories);
+    constructor(type: T, factories?: TCompilerFactories<T>);
     getOptions(): TCompilerOptions<T>;
     setOptions(newOptions: TCompilerOptions<T>): TCompilerOptions<T>;
     mergeOptions(newOptions: TCompilerOptions<T>): TCompilerOptions<T>;
     getCompiler(): TCompiler<T> | null;
     createCompiler(): TCompiler<T>;
+    createCompilerWithCallback(callback: (error: Error | null, stats: TCompilerStats<T> | null) => void): TCompiler<T>;
     build(): Promise<TCompilerStats<T>>;
     watch(timeout?: number): void;
     getStats(): TCompilerStats<T> | null;

package/dist/compiler.js

@@ -15,8 +15,8 @@ var ECompilerEvent;
     ECompilerEvent["Close"] = "close";
 })(ECompilerEvent || (exports.ECompilerEvent = ECompilerEvent = {}));
 exports.COMPILER_FACTORIES = {
-    [type_1.ECompilerType.Rspack]: ((options) => require("@rspack/core")(options)),
-    [type_1.ECompilerType.Webpack]: ((options) => require("webpack")(options))
+    [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) {
@@ -48,6 +48,11 @@ class TestCompilerManager {
         this.emitter.emit(ECompilerEvent.Create, this.compilerInstance);
         return this.compilerInstance;
     }
+    createCompilerWithCallback(callback) {
+        this.compilerInstance = this.factories[this.type](this.compilerOptions, callback);
+        this.emitter.emit(ECompilerEvent.Create, this.compilerInstance);
+        return this.compilerInstance;
+    }
     build() {
         if (!this.compilerInstance)
             throw new Error("Compiler should be created before build");

package/dist/helper/expect/placeholder.js

@@ -16,7 +16,7 @@ const placeholderSerializer = (0, path_serializer_1.createSnapshotSerializer)({
         : node_path_1.default.resolve(__dirname, "../../../../../"),
     replace: [
         {
-            match: node_path_1.default.resolve(__dirname, "../../../"),
+            match: node_path_1.default.resolve(__dirname, "../../../../../tests/rspack-test"),
             mark: "test_tools_root"
         },
         {

package/dist/helper/legacy/FakeDocument.js

@@ -223,12 +223,15 @@ class FakeSheet {
                 currentRule[property] = value;
             }
         };
-        const filepath = /file:\/\//.test(this._element.href)
-            ? new URL(this._element.href)
+        let filepath = /file:\/\//.test(this._element.href)
+            ? new URL(this._element.href).pathname
             : path.resolve(this._basePath, this._element.href
                 .replace(/^https:\/\/test\.cases\/path\//, "")
                 .replace(/^https:\/\/example\.com\/public\/path\//, "")
                 .replace(/^https:\/\/example\.com\//, ""));
+        if (require("os").platform() === "win32" && filepath.startsWith("/")) {
+            filepath = filepath.slice(1);
+        }
         let css = fs.readFileSync(filepath.replace(/\?hmr=\d*/, ""), "utf-8");
         css = css.replace(/@import url\("([^"]+)"\);/g, (match, url) => {
             if (!/^https:\/\/test\.cases\/path\//.test(url)) {
@@ -239,8 +242,7 @@ class FakeSheet {
             }
             return fs.readFileSync(path.resolve(this._basePath, url.replace(/^https:\/\/test\.cases\/path\//, "")), "utf-8");
         })
-            .replace(/\/\*[\s\S]*?\*\//g, '')
-            .replace("//", "");
+            .replace(/\/\*[\s\S]*?\*\//g, '');
         walkCssTokens(css, {
             isSelector() {
                 return selector === undefined;

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

@@ -1,7 +1,7 @@
 declare function _exports(env: any, { outputDirectory }: {
     outputDirectory: any;
 }): {
-    new (url: any, options?: {}): {
+    new (resource: any, options?: {}): {
         url: any;
         worker: import("worker_threads").Worker;
         _onmessage: ((data: any) => void) | undefined;

package/dist/helper/legacy/createFakeWorker.js

@@ -1,28 +1,38 @@
-"use strict";
 // @ts-nocheck
-const path = require("node:path");
+"use strict";
+const path = require("path");
 module.exports = (env, { outputDirectory }) => class Worker {
-    constructor(url, options = {}) {
-        env.expect(url).toBeInstanceOf(URL);
-        env.expect(url.origin).toBe("https://test.cases");
-        env.expect(url.pathname.startsWith("/path/")).toBe(true);
-        this.url = url;
-        const file = url.pathname.slice(6);
+    constructor(resource, options = {}) {
+        const isFileURL = /^file:/i.test(resource);
+        const isBlobURL = /^blob:/i.test(resource);
+        if (!isFileURL && !isBlobURL) {
+            env.expect(resource.origin).toBe("https://test.cases");
+            env.expect(resource.pathname.startsWith("/path/")).toBe(true);
+        }
+        this.url = resource;
+        const file = isFileURL
+            ? resource
+            : path.resolve(outputDirectory, isBlobURL
+                ? options.originalURL.pathname.slice(6)
+                : resource.pathname.slice(6));
         const workerBootstrap = `
 const { parentPort } = require("worker_threads");
-const { URL } = require("url");
+const { URL, fileURLToPath } = require("url");
 const path = require("path");
 const fs = require("fs");
 global.self = global;
 self.URL = URL;
-self.location = new URL(${JSON.stringify(url.toString())});
+self.location = new URL(${JSON.stringify(isBlobURL
+            ? resource.toString().replace("nodedata:", "https://test.cases/path/")
+            : resource.toString())});
 const urlToPath = url => {
-	if(url.startsWith("https://test.cases/path/")) url = url.slice(24);
+  if (/^file:/i.test(url)) return fileURLToPath(url);
+	if (url.startsWith("https://test.cases/path/")) url = url.slice(24);
 	return path.resolve(${JSON.stringify(outputDirectory)}, \`./\${url}\`);
 };
 self.importScripts = url => {
 	${options.type === "module"
-            ? `throw new Error("importScripts is not supported in module workers")`
+            ? 'throw new Error("importScripts is not supported in module workers")'
             : "require(urlToPath(url))"};
 };
 self.fetch = async url => {
@@ -33,8 +43,10 @@ self.fetch = async url => {
 			)
 		);
 		return {
+		  headers: { get(name) { } },
 			status: 200,
 			ok: true,
+			arrayBuffer() { return buffer; },
 			json: async () => JSON.parse(buffer.toString("utf-8"))
 		};
 	} catch(err) {
@@ -47,25 +59,37 @@ self.fetch = async url => {
 		throw err;
 	}
 };
-parentPort.on("message", data => {
-	if(self.onmessage) self.onmessage({
-		data
-	});
-});
+
 self.postMessage = data => {
 	parentPort.postMessage(data);
 };
-require(${JSON.stringify(path.resolve(outputDirectory, file))});
+if (${options.type === "module"}) {
+	import(${JSON.stringify(file)}).then(() => {
+		parentPort.on("message", data => {
+			if(self.onmessage) self.onmessage({
+				data
+			});
+		});
+	});
+} else {
+	parentPort.on("message", data => {
+		if(self.onmessage) self.onmessage({
+			data
+		});
+	});
+	require(${JSON.stringify(file)});
+}
 `;
-        this.worker = new (require("node:worker_threads").Worker)(workerBootstrap, {
+        this.worker = new (require("worker_threads").Worker)(workerBootstrap, {
             eval: true
         });
         this._onmessage = undefined;
     }
+    // eslint-disable-next-line accessor-pairs
     set onmessage(value) {
         if (this._onmessage)
             this.worker.off("message", this._onmessage);
-        this.worker.on("message", (this._onmessage = data => {
+        this.worker.on("message", (this._onmessage = (data) => {
             value({
                 data
             });

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

@@ -0,0 +1 @@
+export function start(handler: any): () => any[];

package/dist/helper/legacy/deprecationTracking.js

@@ -0,0 +1,41 @@
+// @ts-nocheck
+/*
+    MIT License http://www.opensource.org/licenses/mit-license.php
+    Author Tobias Koppers @sokra
+*/
+"use strict";
+const util = require("util");
+let interception = undefined;
+const originalDeprecate = util.deprecate;
+util.deprecate = (fn, message, code) => {
+    const original = originalDeprecate(fn, message, code);
+    return function (...args) {
+        if (interception) {
+            interception.set(`${code}: ${message}`, {
+                code,
+                message,
+                stack: new Error(message).stack
+            });
+            return fn.apply(this, args);
+        }
+        else {
+            return original.apply(this, args);
+        }
+    };
+};
+exports.start = handler => {
+    interception = new Map();
+    return () => {
+        const map = interception;
+        interception = undefined;
+        return Array.from(map || [])
+            .sort(([a], [b]) => {
+            if (a < b)
+                return -1;
+            if (a > b)
+                return 1;
+            return 0;
+        })
+            .map(([key, data]) => data);
+    };
+};

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

@@ -0,0 +1,10 @@
+/**
+ * @param {string} source value
+ * @param {string} str string for searching
+ */
+export function expectSourceToContain(source: string, str: string): void;
+/**
+ * @param {string} source value
+ * @param {RegExp} regexStr regexp
+ */
+export function expectSourceToMatch(source: string, regexStr: RegExp): void;

package/dist/helper/legacy/expectSource.js

@@ -0,0 +1,23 @@
+// @ts-nocheck
+"use strict";
+const regexEscape = require("./regexEscape");
+// These expect* methods are necessary because 'source' contains the code for this test file, which will always contain the string
+// being tested for, so we have to use the "DO NOT MATCH BELOW..." technique to exclude the actual testing code from the test.
+// Place your jest 'expect' calls below a line containing the DO NOT MATCH BELOW... string constructed below.  See other tests for examples.
+// Break up the match string so we don't match it in these expect* functions either.
+const doNotMatch = ["DO", "NOT", "MATCH", "BELOW", "THIS", "LINE"].join(" ");
+/**
+ * @param {string} source value
+ * @param {string} str string for searching
+ */
+function expectSourceToContain(source, str) {
+    expect(source).toMatch(new RegExp(`${regexEscape(str)}.*${doNotMatch}`, "s"));
+}
+/**
+ * @param {string} source value
+ * @param {RegExp} regexStr regexp
+ */
+function expectSourceToMatch(source, regexStr) {
+    expect(source).toMatch(new RegExp(`${regexStr}.*${doNotMatch}`, "s"));
+}
+module.exports = { expectSourceToContain, expectSourceToMatch };

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

@@ -0,0 +1,6 @@
+declare function _exports(options: {
+    output: {
+        path: string;
+    };
+}, regexp: RegExp, subpath?: string | undefined): string[];
+export = _exports;

package/dist/helper/legacy/findOutputFiles.js

@@ -0,0 +1,14 @@
+// @ts-nocheck
+"use strict";
+const fs = require("fs");
+const path = require("path");
+/**
+ * @param {{output: {path: string}}} options options
+ * @param {RegExp} regexp regexp
+ * @param {string=} subpath path in output directory
+ * @returns {string[]} files
+ */
+module.exports = function findOutputFiles(options, regexp, subpath) {
+    const files = fs.readdirSync(subpath ? path.join(options.output.path, subpath) : options.output.path);
+    return files.filter(file => regexp.test(file));
+};

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

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

package/dist/helper/legacy/regexEscape.js

@@ -0,0 +1,5 @@
+// @ts-nocheck
+"use strict";
+module.exports = function regexEscape(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string
+};

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

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

package/dist/helper/legacy/supportDefaultAssignment.js

@@ -0,0 +1,13 @@
+"use strict";
+// @ts-nocheck
+module.exports = function supportDefaultAssignment() {
+    try {
+        // eslint-disable-next-line no-unused-vars
+        var E = eval("class E { toString() { return 'default' } }");
+        var f1 = eval("(function f1({a, b = E}) {return new b().toString();})");
+        return f1({ a: "test" }) === "default";
+    }
+    catch (e) {
+        return false;
+    }
+};

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

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

package/dist/helper/legacy/supportsBlob.js

@@ -0,0 +1,10 @@
+"use strict";
+// @ts-nocheck
+module.exports = function supportsBlob() {
+    try {
+        return typeof Blob !== "undefined";
+    }
+    catch (_err) {
+        return false;
+    }
+};

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

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

package/dist/helper/legacy/supportsClassFields.js

@@ -0,0 +1,11 @@
+"use strict";
+// @ts-nocheck
+module.exports = function supportsES6() {
+    try {
+        eval("class A { #field = 1 }");
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};

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

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

package/dist/helper/legacy/supportsES6.js

@@ -0,0 +1,11 @@
+"use strict";
+// @ts-nocheck
+module.exports = function supportsES6() {
+    try {
+        eval("class A {}");
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};

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

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

package/dist/helper/legacy/supportsForOf.js

@@ -0,0 +1,11 @@
+"use strict";
+// @ts-nocheck
+module.exports = function supportDefaultAssignment() {
+    try {
+        var f = eval("(function f() { for(var x of ['ok', 'fail']) return x; })");
+        return f() === "ok";
+    }
+    catch (e) {
+        return false;
+    }
+};

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

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