@rspack/test-tools 0.6.3 → 0.6.4

package/dist/helper/legacy/fakeSystem.js

@@ -0,0 +1,124 @@
+"use strict";
+// @ts-nocheck
+const System = {
+    register: (name, deps, fn) => {
+        if (!System.registry) {
+            throw new Error("System is no initialized");
+        }
+        if (typeof name !== "string") {
+            fn = deps;
+            deps = name;
+            name = System._nextName;
+        }
+        if (!Array.isArray(deps)) {
+            fn = deps;
+            deps = [];
+        }
+        const dynamicExport = result => {
+            if (System.registry[name] !== entry) {
+                throw new Error(`Module ${name} calls dynamicExport too late`);
+            }
+            entry.exports = result;
+            for (const mod of Object.keys(System.registry)) {
+                const m = System.registry[mod];
+                if (!m.deps)
+                    continue;
+                for (let i = 0; i < m.deps.length; i++) {
+                    const dep = m.deps[i];
+                    if (dep !== name)
+                        continue;
+                    const setters = m.mod.setters[i];
+                    setters(result);
+                }
+            }
+        };
+        const systemContext = {
+            meta: {
+                url: `/${name}.js`
+            },
+            import() {
+                return Promise.resolve();
+            }
+        };
+        if (name in System.registry) {
+            throw new Error(`Module ${name} is already registered`);
+        }
+        const mod = fn(dynamicExport, systemContext);
+        if (deps.length > 0) {
+            if (!Array.isArray(mod.setters)) {
+                throw new Error(`Module ${name} must have setters, because it has dependencies`);
+            }
+            if (mod.setters.length !== deps.length) {
+                throw new Error(`Module ${name} has incorrect number of setters for the dependencies`);
+            }
+        }
+        const entry = {
+            name,
+            deps,
+            fn,
+            mod,
+            executed: false,
+            exports: undefined
+        };
+        System.registry[name] = entry;
+    },
+    set: (name, exports) => {
+        System.registry[name] = {
+            name,
+            executed: true,
+            exports
+        };
+    },
+    registry: undefined,
+    _require: undefined,
+    _nextName: "(anonym)",
+    setRequire: req => {
+        System._require = req;
+    },
+    init: modules => {
+        System.registry = {};
+        if (modules) {
+            for (const name of Object.keys(modules)) {
+                System.registry[name] = {
+                    executed: true,
+                    exports: modules[name]
+                };
+            }
+        }
+    },
+    execute: name => {
+        const m = System.registry[name];
+        if (!m)
+            throw new Error(`Module ${name} not registered`);
+        if (m.executed)
+            throw new Error(`Module ${name} was already executed`);
+        return System.ensureExecuted(name);
+    },
+    ensureExecuted: name => {
+        let m = System.registry[name];
+        if (!m && System._require) {
+            const oldName = System._nextName;
+            System._nextName = name;
+            System._require(name);
+            System._nextName = oldName;
+            m = System.registry[name];
+        }
+        if (!m) {
+            throw new Error(`Module ${name} not registered`);
+        }
+        if (!m.executed) {
+            m.executed = true;
+            for (let i = 0; i < m.deps.length; i++) {
+                const dep = m.deps[i];
+                const setters = m.mod.setters[i];
+                System.ensureExecuted(dep);
+                const { exports } = System.registry[dep];
+                if (exports !== undefined)
+                    setters(exports);
+            }
+            m.mod.execute();
+        }
+        return m.exports;
+    }
+};
+module.exports = System;

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

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

package/dist/helper/legacy/supportsWorker.js

@@ -0,0 +1,17 @@
+"use strict";
+// @ts-nocheck
+const nodeVersion = process.versions.node.split(".").map(Number);
+module.exports = function supportsWorker() {
+    // Verify that in the current node version new Worker() accepts URL as the first parameter:
+    // https://nodejs.org/api/worker_threads.html#worker_threads_new_worker_filename_options
+    if (nodeVersion[0] >= 14) {
+        return true;
+    }
+    else if (nodeVersion[0] === 13 && nodeVersion[1] >= 12) {
+        return true;
+    }
+    else if (nodeVersion[0] === 12 && nodeVersion[1] >= 17) {
+        return true;
+    }
+    return false;
+};

package/dist/helper/legacy/warmup-webpack.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helper/legacy/warmup-webpack.js

@@ -0,0 +1,26 @@
+"use strict";
+// @ts-nocheck
+describe("warmup", () => {
+    it("should warmup webpack", done => {
+        let webpack = require("@rspack/core");
+        let END = new Error("end warmup");
+        webpack({
+            entry: "data:text/javascript,import 'data:text/javascript,'",
+            plugins: [
+                c => c.hooks.emit.tap("Warmup", () => {
+                    throw END;
+                })
+            ]
+        }, err => {
+            webpack = undefined;
+            try {
+                // CHANGE: rspack will format error into diagnostic.
+                expect(err.message).toContain("end warmup");
+                done();
+            }
+            catch (e) {
+                done(e);
+            }
+        });
+    }, 300000);
+});

package/dist/helper/setupTestFramework.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helper/setupTestFramework.js

@@ -0,0 +1,121 @@
+"use strict";
+// @ts-nocheck
+const { toMatchFileSnapshot } = require("./jestFileSnapshot");
+expect.extend({
+    // CHANGE: new test matcher for `rspack-test-tools`
+    toMatchFileSnapshot,
+    toBeTypeOf(received, expected) {
+        const objType = typeof received;
+        const pass = objType === expected;
+        const message = pass
+            ? () => this.utils.matcherHint(".not.toBeTypeOf") +
+                "\n\n" +
+                "Expected value to not be (using typeof):\n" +
+                `  ${this.utils.printExpected(expected)}\n` +
+                "Received:\n" +
+                `  ${this.utils.printReceived(objType)}`
+            : () => this.utils.matcherHint(".toBeTypeOf") +
+                "\n\n" +
+                "Expected value to be (using typeof):\n" +
+                `  ${this.utils.printExpected(expected)}\n` +
+                "Received:\n" +
+                `  ${this.utils.printReceived(objType)}`;
+        return { message, pass };
+    },
+    toEndWith(received, expected) {
+        const pass = typeof received === "string" && received.endsWith(expected);
+        const message = pass
+            ? () => this.utils.matcherHint(".not.toEndWith") +
+                "\n\n" +
+                "Expected value to not end with:\n" +
+                `  ${this.utils.printExpected(expected)}\n` +
+                "Received:\n" +
+                `  ${this.utils.printReceived(received)}`
+            : () => this.utils.matcherHint(".toEndWith") +
+                "\n\n" +
+                "Expected value to end with:\n" +
+                `  ${this.utils.printExpected(expected)}\n` +
+                "Received:\n" +
+                `  ${this.utils.printReceived(received)}`;
+        return { message, pass };
+    }
+});
+if (process.env.ALTERNATIVE_SORT) {
+    const oldSort = Array.prototype.sort;
+    Array.prototype.sort = function (cmp) {
+        oldSort.call(this, cmp);
+        if (cmp) {
+            for (let i = 1; i < this.length; i++) {
+                if (cmp(this[i - 1], this[i]) === 0) {
+                    let j = i + 1;
+                    for (; j < this.length; j++) {
+                        if (cmp(this[j - 1], this[j]) !== 0) {
+                            break;
+                        }
+                    }
+                    for (let x = i - 1, y = j - 1; x < y; x++, y--) {
+                        const temp = this[x];
+                        this[x] = this[y];
+                        this[y] = temp;
+                    }
+                    i = j;
+                }
+            }
+        }
+        return this;
+    };
+}
+// Setup debugging info for tests
+if (process.env.DEBUG_INFO) {
+    const addDebugInfo = it => {
+        return (name, fn, timeout) => {
+            if (fn.length === 0) {
+                it(name, () => {
+                    process.stdout.write(`START1 ${name}\n`);
+                    try {
+                        const promise = fn();
+                        if (promise && promise.then) {
+                            return promise.then(r => {
+                                process.stdout.write(`DONE OK ${name}\n`);
+                                return r;
+                            }, e => {
+                                process.stdout.write(`DONE FAIL ${name}\n`);
+                                throw e;
+                            });
+                        }
+                        else {
+                            process.stdout.write(`DONE OK ${name}\n`);
+                        }
+                    }
+                    catch (e) {
+                        process.stdout.write(`DONE FAIL ${name}\n`);
+                        throw e;
+                    }
+                }, timeout);
+            }
+            else {
+                it(name, done => {
+                    process.stdout.write(`START2 ${name}\n`);
+                    return fn(err => {
+                        if (err) {
+                            process.stdout.write(`DONE FAIL ${name}\n`);
+                        }
+                        else {
+                            process.stdout.write(`DONE OK ${name}\n`);
+                        }
+                        return done(err);
+                    });
+                }, timeout);
+            }
+        };
+    };
+    // eslint-disable-next-line no-global-assign
+    it = addDebugInfo(it);
+}
+// cspell:word wabt
+// Workaround for a memory leak in wabt
+// It leaks an Error object on construction
+// so it leaks the whole stack trace
+require("wast-loader");
+process.removeAllListeners("uncaughtException");
+process.removeAllListeners("unhandledRejection");

package/dist/helper/util/checkSourceMap.d.ts

@@ -0,0 +1 @@
+export default function checkSourceMap(out: any, outCodeMap: any, toSearch: any): Promise<boolean>;

package/dist/helper/util/checkSourceMap.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-nocheck
+// Check the mapping of various key locations back to the original source
+async function checkSourceMap(out, outCodeMap, toSearch) {
+    let failed = false;
+    const recordCheck = (success, message) => {
+        if (!success) {
+            failed = true;
+            console.error(`❌ ${message}`);
+        }
+    };
+    const sourceMap = require("source-map");
+    const path = require("path");
+    const sources = JSON.parse(outCodeMap).sources;
+    for (let source of sources) {
+        if (sources.filter(s => s === source).length > 1) {
+            throw new Error(`Duplicate source ${JSON.stringify(source)} found in source map`);
+        }
+    }
+    const map = await new sourceMap.SourceMapConsumer(outCodeMap);
+    for (const id in toSearch) {
+        const outIndex = out.indexOf(id);
+        if (outIndex < 0)
+            throw new Error(`Failed to find "${id}" in output ${out}`);
+        const outLines = out.slice(0, outIndex).split("\n");
+        const outLine = outLines.length;
+        const outLastLine = outLines[outLines.length - 1];
+        let outColumn = outLastLine.length;
+        const { source, line, column } = map.originalPositionFor({
+            line: outLine,
+            column: outColumn
+        });
+        const inSource = toSearch[id];
+        recordCheck(source === inSource, `expected source: ${inSource}, observed source: ${source}@${line}:${column}, {out_source}@${outLine}:${outColumn}.`);
+        const inCode = map.sourceContentFor(source);
+        let inIndex = inCode.indexOf(id);
+        if (inIndex < 0)
+            inIndex = inCode.indexOf(`'${id}'`);
+        if (inIndex < 0)
+            throw new Error(`Failed to find "${id}" in input ${inCode}`);
+        const inLines = inCode.slice(0, inIndex).split("\n");
+        const inLine = inLines.length;
+        const inLastLine = inLines[inLines.length - 1];
+        let inColumn = inLastLine.length;
+        if (path.extname(source) === "css") {
+            const outMatch = /\s*content:\s*$/.exec(outLastLine);
+            const inMatch = /\bcontent:\s*$/.exec(inLastLine);
+            if (outMatch)
+                outColumn -= outMatch[0].length;
+            if (inMatch)
+                inColumn -= inMatch[0].length;
+        }
+        const expected = JSON.stringify({ source, line: inLine, column: inColumn });
+        const observed = JSON.stringify({ source, line, column });
+        recordCheck(expected === observed, `expected original position: ${expected}, observed original position: ${observed}, out: ${outLine + "," + outColumn + "," + outIndex + ":" + id}`);
+        // Also check the reverse mapping
+        const positions = map.allGeneratedPositionsFor({
+            source,
+            line: inLine,
+            column: inColumn
+        });
+        recordCheck(positions.length > 0, `expected generated positions: 1, observed generated positions: ${positions.length}`);
+        let found = false;
+        for (const { line, column } of positions) {
+            if (line === outLine && column === outColumn) {
+                found = true;
+                break;
+            }
+        }
+        const expectedPosition = JSON.stringify({
+            line: outLine,
+            column: outColumn
+        });
+        const observedPositions = JSON.stringify(positions);
+        recordCheck(found, `expected generated position: ${expectedPosition}, observed generated positions: ${observedPositions}`);
+    }
+    return !failed;
+}
+exports.default = checkSourceMap;

package/dist/helper/util/currentWatchStep.d.ts

@@ -0,0 +1 @@
+export { undefined as step };

package/dist/helper/util/currentWatchStep.js

@@ -0,0 +1,2 @@
+"use strict";
+exports.step = undefined;

package/dist/helper/util/expectWarningFactory.d.ts

@@ -0,0 +1,2 @@
+declare function _exports(): (...regexp: any[]) => void;
+export = _exports;

package/dist/helper/util/expectWarningFactory.js

@@ -0,0 +1,21 @@
+"use strict";
+// @ts-nocheck
+module.exports = () => {
+    let warnings = [];
+    let oldWarn;
+    beforeEach(done => {
+        oldWarn = console.warn;
+        console.warn = m => warnings.push(m);
+        done();
+    });
+    afterEach(done => {
+        expectWarning();
+        console.warn = oldWarn;
+        done();
+    });
+    const expectWarning = (...regexp) => {
+        expect(warnings).toEqual(regexp.map(r => expect.stringMatching(r)));
+        warnings.length = 0;
+    };
+    return expectWarning;
+};

package/dist/helper/util/filterUtil.d.ts

@@ -0,0 +1,8 @@
+export namespace FilteredStatus {
+    const TODO: string;
+    const PARTIAL_PASS: string;
+    const FAILED: string;
+    const NO_PLAN: string;
+}
+export function decodeFilteredTest(encoded: any): any;
+export function normalizeFilteredTestName(flag: any, testName: any): string;

package/dist/helper/util/filterUtil.js

@@ -0,0 +1,50 @@
+"use strict";
+// @ts-nocheck
+const FilteredStatus = {
+    TODO: "TODO",
+    PARTIAL_PASS: "PARTIAL_PASS",
+    FAILED: "FAILED",
+    NO_PLAN: "NO_PLAN"
+};
+function validateFilteredStatus(status) {
+    return Object.values(FilteredStatus).includes(status);
+}
+function normalizeFilterFlag(flag, testName) {
+    if (flag === false) {
+        return { status: FilteredStatus.TODO, reason: "TODO" };
+    }
+    if (flag === -1) {
+        return { status: FilteredStatus.NO_PLAN, reason: "No plan" };
+    }
+    if (typeof flag === "string") {
+        return { status: FilteredStatus.FAILED, reason: flag };
+    }
+    if (Array.isArray(flag)) {
+        const [status, reason = "empty"] = flag;
+        if (validateFilteredStatus(status)) {
+            return { status, reason };
+        }
+    }
+    throw new Error(`Unvalidate filter flag "${flag}" for "${testName}"`);
+}
+function encodeFilteredTest(status, reason) {
+    return `{{ status = ${status}, reason = ${reason} }}`;
+}
+function decodeFilteredTest(encoded) {
+    const regex = /(.*) {{ status = (.*), reason = (.*) }}$/;
+    const result = encoded.match(regex);
+    if (result === null) {
+        return result;
+    }
+    const [, fullName, status, reason] = result;
+    return { fullName, status, reason };
+}
+function normalizeFilteredTestName(flag, testName) {
+    const { status, reason } = normalizeFilterFlag(flag, testName);
+    return encodeFilteredTest(status, reason);
+}
+module.exports = {
+    FilteredStatus,
+    decodeFilteredTest,
+    normalizeFilteredTestName
+};

package/dist/helper/util/identifier.d.ts

@@ -0,0 +1,76 @@
+/**
+ * @param {string} context context used to create relative path
+ * @param {string} identifier identifier used to create relative path
+ * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+ * @returns {string} the returned relative path
+ */
+export function makePathsRelative(context: string, identifier: string, associatedObjectForCache?: Object | undefined): string;
+export namespace makePathsRelative {
+    /**
+     * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+     * @returns {function(string, string): string} cached function
+     */
+    function bindCache(associatedObjectForCache?: Object | undefined): (arg0: string, arg1: string) => string;
+    /**
+     * @param {string} context context used to create relative path
+     * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+     * @returns {function(string): string} cached function
+     */
+    function bindContextCache(context: string, associatedObjectForCache?: Object | undefined): (arg0: string) => string;
+}
+/**
+ * @param {string} context context used to create relative path
+ * @param {string} identifier identifier used to create relative path
+ * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+ * @returns {string} the returned relative path
+ */
+export function makePathsAbsolute(context: string, identifier: string, associatedObjectForCache?: Object | undefined): string;
+export namespace makePathsAbsolute { }
+/**
+ * @param {string} str the path with query and fragment
+ * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+ * @returns {ParsedResource} parsed parts
+ */
+export function parseResource(str: string, associatedObjectForCache?: Object | undefined): ParsedResource;
+export namespace parseResource {
+    function bindCache(associatedObjectForCache: any): (str: any) => any;
+}
+/**
+ * @param {string} str the path with query and fragment
+ * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+ * @returns {ParsedResource} parsed parts
+ */
+export function parseResourceWithoutFragment(str: string, associatedObjectForCache?: Object | undefined): ParsedResource;
+export namespace parseResourceWithoutFragment { }
+export function getUndoPath(filename: string, outputPath: string, enforceRelative: boolean): string;
+export type MakeRelativePathsCache = {
+    relativePaths?: Map<string, Map<string, string>> | undefined;
+};
+export type ParsedResource = {
+    resource: string;
+    path: string;
+    query: string;
+    fragment: string;
+};
+export type ParsedResourceWithoutFragment = {
+    resource: string;
+    path: string;
+    query: string;
+};
+/**
+ * @param {string} context context used to create relative path
+ * @param {string} identifier identifier used to create relative path
+ * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+ * @returns {string} the returned relative path
+ */
+export function contextify(context: string, identifier: string, associatedObjectForCache?: Object | undefined): string;
+export namespace contextify { }
+/**
+ * @param {string} context context used to create relative path
+ * @param {string} identifier identifier used to create relative path
+ * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+ * @returns {string} the returned relative path
+ */
+export function absolutify(context: string, identifier: string, associatedObjectForCache?: Object | undefined): string;
+export namespace absolutify { }
+import path = require("path");