@rspack/test-tools 0.6.3 → 0.6.4

package/dist/helper/util/identifier.js

@@ -0,0 +1,345 @@
+// @ts-nocheck
+/*
+    MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+"use strict";
+const path = require("path");
+const WINDOWS_ABS_PATH_REGEXP = /^[a-zA-Z]:[\\/]/;
+const SEGMENTS_SPLIT_REGEXP = /([|!])/;
+const WINDOWS_PATH_SEPARATOR_REGEXP = /\\/g;
+/**
+ * @typedef {Object} MakeRelativePathsCache
+ * @property {Map<string, Map<string, string>>=} relativePaths
+ */
+const relativePathToRequest = relativePath => {
+    if (relativePath === "")
+        return "./.";
+    if (relativePath === "..")
+        return "../.";
+    if (relativePath.startsWith("../"))
+        return relativePath;
+    return `./${relativePath}`;
+};
+/**
+ * @param {string} context context for relative path
+ * @param {string} maybeAbsolutePath path to make relative
+ * @returns {string} relative path in request style
+ */
+const absoluteToRequest = (context, maybeAbsolutePath) => {
+    if (maybeAbsolutePath[0] === "/") {
+        if (maybeAbsolutePath.length > 1 &&
+            maybeAbsolutePath[maybeAbsolutePath.length - 1] === "/") {
+            // this 'path' is actually a regexp generated by dynamic requires.
+            // Don't treat it as an absolute path.
+            return maybeAbsolutePath;
+        }
+        const querySplitPos = maybeAbsolutePath.indexOf("?");
+        let resource = querySplitPos === -1
+            ? maybeAbsolutePath
+            : maybeAbsolutePath.slice(0, querySplitPos);
+        resource = relativePathToRequest(path.posix.relative(context, resource));
+        return querySplitPos === -1
+            ? resource
+            : resource + maybeAbsolutePath.slice(querySplitPos);
+    }
+    if (WINDOWS_ABS_PATH_REGEXP.test(maybeAbsolutePath)) {
+        const querySplitPos = maybeAbsolutePath.indexOf("?");
+        let resource = querySplitPos === -1
+            ? maybeAbsolutePath
+            : maybeAbsolutePath.slice(0, querySplitPos);
+        resource = path.win32.relative(context, resource);
+        if (!WINDOWS_ABS_PATH_REGEXP.test(resource)) {
+            resource = relativePathToRequest(resource.replace(WINDOWS_PATH_SEPARATOR_REGEXP, "/"));
+        }
+        return querySplitPos === -1
+            ? resource
+            : resource + maybeAbsolutePath.slice(querySplitPos);
+    }
+    // not an absolute path
+    return maybeAbsolutePath;
+};
+/**
+ * @param {string} context context for relative path
+ * @param {string} relativePath path
+ * @returns {string} absolute path
+ */
+const requestToAbsolute = (context, relativePath) => {
+    if (relativePath.startsWith("./") || relativePath.startsWith("../"))
+        return path.join(context, relativePath);
+    return relativePath;
+};
+const makeCacheable = realFn => {
+    /** @type {WeakMap<object, Map<string, ParsedResource>>} */
+    const cache = new WeakMap();
+    const getCache = associatedObjectForCache => {
+        const entry = cache.get(associatedObjectForCache);
+        if (entry !== undefined)
+            return entry;
+        /** @type {Map<string, ParsedResource>} */
+        const map = new Map();
+        cache.set(associatedObjectForCache, map);
+        return map;
+    };
+    /**
+     * @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
+     */
+    const fn = (str, associatedObjectForCache) => {
+        if (!associatedObjectForCache)
+            return realFn(str);
+        const cache = getCache(associatedObjectForCache);
+        const entry = cache.get(str);
+        if (entry !== undefined)
+            return entry;
+        const result = realFn(str);
+        cache.set(str, result);
+        return result;
+    };
+    fn.bindCache = associatedObjectForCache => {
+        const cache = getCache(associatedObjectForCache);
+        return str => {
+            const entry = cache.get(str);
+            if (entry !== undefined)
+                return entry;
+            const result = realFn(str);
+            cache.set(str, result);
+            return result;
+        };
+    };
+    return fn;
+};
+const makeCacheableWithContext = fn => {
+    /** @type {WeakMap<object, Map<string, Map<string, string>>>} */
+    const cache = new WeakMap();
+    /**
+     * @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
+     */
+    const cachedFn = (context, identifier, associatedObjectForCache) => {
+        if (!associatedObjectForCache)
+            return fn(context, identifier);
+        let innerCache = cache.get(associatedObjectForCache);
+        if (innerCache === undefined) {
+            innerCache = new Map();
+            cache.set(associatedObjectForCache, innerCache);
+        }
+        let cachedResult;
+        let innerSubCache = innerCache.get(context);
+        if (innerSubCache === undefined) {
+            innerCache.set(context, (innerSubCache = new Map()));
+        }
+        else {
+            cachedResult = innerSubCache.get(identifier);
+        }
+        if (cachedResult !== undefined) {
+            return cachedResult;
+        }
+        else {
+            const result = fn(context, identifier);
+            innerSubCache.set(identifier, result);
+            return result;
+        }
+    };
+    /**
+     * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+     * @returns {function(string, string): string} cached function
+     */
+    cachedFn.bindCache = associatedObjectForCache => {
+        let innerCache;
+        if (associatedObjectForCache) {
+            innerCache = cache.get(associatedObjectForCache);
+            if (innerCache === undefined) {
+                innerCache = new Map();
+                cache.set(associatedObjectForCache, innerCache);
+            }
+        }
+        else {
+            innerCache = new Map();
+        }
+        /**
+         * @param {string} context context used to create relative path
+         * @param {string} identifier identifier used to create relative path
+         * @returns {string} the returned relative path
+         */
+        const boundFn = (context, identifier) => {
+            let cachedResult;
+            let innerSubCache = innerCache.get(context);
+            if (innerSubCache === undefined) {
+                innerCache.set(context, (innerSubCache = new Map()));
+            }
+            else {
+                cachedResult = innerSubCache.get(identifier);
+            }
+            if (cachedResult !== undefined) {
+                return cachedResult;
+            }
+            else {
+                const result = fn(context, identifier);
+                innerSubCache.set(identifier, result);
+                return result;
+            }
+        };
+        return boundFn;
+    };
+    /**
+     * @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
+     */
+    cachedFn.bindContextCache = (context, associatedObjectForCache) => {
+        let innerSubCache;
+        if (associatedObjectForCache) {
+            let innerCache = cache.get(associatedObjectForCache);
+            if (innerCache === undefined) {
+                innerCache = new Map();
+                cache.set(associatedObjectForCache, innerCache);
+            }
+            innerSubCache = innerCache.get(context);
+            if (innerSubCache === undefined) {
+                innerCache.set(context, (innerSubCache = new Map()));
+            }
+        }
+        else {
+            innerSubCache = new Map();
+        }
+        /**
+         * @param {string} identifier identifier used to create relative path
+         * @returns {string} the returned relative path
+         */
+        const boundFn = identifier => {
+            const cachedResult = innerSubCache.get(identifier);
+            if (cachedResult !== undefined) {
+                return cachedResult;
+            }
+            else {
+                const result = fn(context, identifier);
+                innerSubCache.set(identifier, result);
+                return result;
+            }
+        };
+        return boundFn;
+    };
+    return cachedFn;
+};
+/**
+ *
+ * @param {string} context context for relative path
+ * @param {string} identifier identifier for path
+ * @returns {string} a converted relative path
+ */
+const _makePathsRelative = (context, identifier) => {
+    return identifier
+        .split(SEGMENTS_SPLIT_REGEXP)
+        .map(str => absoluteToRequest(context, str))
+        .join("");
+};
+exports.makePathsRelative = makeCacheableWithContext(_makePathsRelative);
+/**
+ *
+ * @param {string} context context for relative path
+ * @param {string} identifier identifier for path
+ * @returns {string} a converted relative path
+ */
+const _makePathsAbsolute = (context, identifier) => {
+    return identifier
+        .split(SEGMENTS_SPLIT_REGEXP)
+        .map(str => requestToAbsolute(context, str))
+        .join("");
+};
+exports.makePathsAbsolute = makeCacheableWithContext(_makePathsAbsolute);
+/**
+ * @param {string} context absolute context path
+ * @param {string} request any request string may containing absolute paths, query string, etc.
+ * @returns {string} a new request string avoiding absolute paths when possible
+ */
+const _contextify = (context, request) => {
+    return request
+        .split("!")
+        .map(r => absoluteToRequest(context, r))
+        .join("!");
+};
+const contextify = makeCacheableWithContext(_contextify);
+exports.contextify = contextify;
+/**
+ * @param {string} context absolute context path
+ * @param {string} request any request string
+ * @returns {string} a new request string using absolute paths when possible
+ */
+const _absolutify = (context, request) => {
+    return request
+        .split("!")
+        .map(r => requestToAbsolute(context, r))
+        .join("!");
+};
+const absolutify = makeCacheableWithContext(_absolutify);
+exports.absolutify = absolutify;
+const PATH_QUERY_FRAGMENT_REGEXP = /^((?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
+const PATH_QUERY_REGEXP = /^((?:\0.|[^?\0])*)(\?.*)?$/;
+/** @typedef {{ resource: string, path: string, query: string, fragment: string }} ParsedResource */
+/** @typedef {{ resource: string, path: string, query: string }} ParsedResourceWithoutFragment */
+/**
+ * @param {string} str the path with query and fragment
+ * @returns {ParsedResource} parsed parts
+ */
+const _parseResource = str => {
+    const match = PATH_QUERY_FRAGMENT_REGEXP.exec(str);
+    return {
+        resource: str,
+        path: match[1].replace(/\0(.)/g, "$1"),
+        query: match[2] ? match[2].replace(/\0(.)/g, "$1") : "",
+        fragment: match[3] || ""
+    };
+};
+exports.parseResource = makeCacheable(_parseResource);
+/**
+ * Parse resource, skips fragment part
+ * @param {string} str the path with query and fragment
+ * @returns {ParsedResourceWithoutFragment} parsed parts
+ */
+const _parseResourceWithoutFragment = str => {
+    const match = PATH_QUERY_REGEXP.exec(str);
+    return {
+        resource: str,
+        path: match[1].replace(/\0(.)/g, "$1"),
+        query: match[2] ? match[2].replace(/\0(.)/g, "$1") : ""
+    };
+};
+exports.parseResourceWithoutFragment = makeCacheable(_parseResourceWithoutFragment);
+/**
+ * @param {string} filename the filename which should be undone
+ * @param {string} outputPath the output path that is restored (only relevant when filename contains "..")
+ * @param {boolean} enforceRelative true returns ./ for empty paths
+ * @returns {string} repeated ../ to leave the directory of the provided filename to be back on output dir
+ */
+exports.getUndoPath = (filename, outputPath, enforceRelative) => {
+    let depth = -1;
+    let append = "";
+    outputPath = outputPath.replace(/[\\/]$/, "");
+    for (const part of filename.split(/[/\\]+/)) {
+        if (part === "..") {
+            if (depth > -1) {
+                depth--;
+            }
+            else {
+                const i = outputPath.lastIndexOf("/");
+                const j = outputPath.lastIndexOf("\\");
+                const pos = i < 0 ? j : j < 0 ? i : Math.max(i, j);
+                if (pos < 0)
+                    return outputPath + "/";
+                append = outputPath.slice(pos + 1) + "/" + append;
+                outputPath = outputPath.slice(0, pos);
+            }
+        }
+        else if (part !== ".") {
+            depth++;
+        }
+    }
+    return depth > 0
+        ? `${"../".repeat(depth)}${append}`
+        : enforceRelative
+            ? `./${append}`
+            : append;
+};

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

@@ -0,0 +1,2 @@
+export function replace(s: any): any;
+export function replaceStack(s: any): any;

package/dist/helper/util/replaceMitteDiagnostic.js

@@ -0,0 +1,17 @@
+"use strict";
+// @ts-nocheck
+// Remove the "|" padding from miette,
+// used to ensure no line breaks with padding being returned,
+// miette generates diagnostics lines with respect to terminal size
+// and this might varies among different `process.cwd()` being used,
+// which breaks local and CI checks.
+const replace = s => s.replace(/\r?\n[ ]+│ /g, "");
+// HOW THIS WORKS:
+// 1. Remove potential line break and "|"
+// 2. Save the JS stack for each line
+// 3. If the current line was splitted because of terminal size, merge them together
+const replaceStack = s => s.replace(/(?:\s|│)*(at.*)(\s|│)*/g, "\n$1");
+module.exports = {
+    replace,
+    replaceStack
+};

package/dist/helper/win.d.ts

@@ -0,0 +1,2 @@
+export declare function escapeSep(str: string): string;
+export declare function escapeEOL(str: string): string;

package/dist/helper/win.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeEOL = exports.escapeSep = void 0;
+const path_1 = __importDefault(require("path"));
+function escapeSep(str) {
+    return str.split(path_1.default.win32.sep).join(path_1.default.posix.sep);
+}
+exports.escapeSep = escapeSep;
+function escapeEOL(str) {
+    return str.split("\r\n").join("\n").trim();
+}
+exports.escapeEOL = escapeEOL;

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./type";
 export * from "./test/tester";
 export * from "./test/context";
+export * from "./test/simple";
 export * from "./processor";
 export * from "./reporter";
 export * from "./compare";

package/dist/index.js

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./type"), exports);
 __exportStar(require("./test/tester"), exports);
 __exportStar(require("./test/context"), exports);
+__exportStar(require("./test/simple"), exports);
 __exportStar(require("./processor"), exports);
 __exportStar(require("./reporter"), exports);
 __exportStar(require("./compare"), exports);

package/dist/plugin/webpack-module-placeholder-plugin.js

@@ -90,9 +90,8 @@ class WebpackModulePlaceholderPlugin {
                 let footer = cacheEntry.footer;
                 if (header === undefined) {
                     const identifier = module.identifier();
-                    const moduleId = compilation.chunkGraph.getModuleId(module);
-                    header = new RawSource(`\n${Template.toNormalComment(`start::${moduleId}::${identifier}`)}\n`);
-                    footer = new RawSource(`\n${Template.toNormalComment(`end::${moduleId}::${identifier}`)}\n`);
+                    header = new RawSource(`\n${Template.toNormalComment(`start::${identifier}`)}\n`);
+                    footer = new RawSource(`\n${Template.toNormalComment(`end::${identifier}`)}\n`);
                     cacheEntry.header = header;
                     cacheEntry.footer = footer;
                 }

package/dist/processor/defaults.js

@@ -8,16 +8,14 @@ const simple_1 = require("./simple");
 const type_1 = require("../type");
 const jest_diff_1 = require("jest-diff");
 const strip_ansi_1 = __importDefault(require("strip-ansi"));
-const path_1 = __importDefault(require("path"));
-const CASE_CWD = path_1.default.resolve(__dirname, "../../../rspack");
 const CURRENT_CWD = process.cwd();
 const quoteMeta = (str) => str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
-const cwdRegExp = new RegExp(`${quoteMeta(CASE_CWD)}((?:\\\\)?(?:[a-zA-Z.\\-_]+\\\\)*)`, "g");
-const escapedCwd = JSON.stringify(CASE_CWD).slice(1, -1);
+const cwdRegExp = new RegExp(`${quoteMeta(CURRENT_CWD)}((?:\\\\)?(?:[a-zA-Z.\\-_]+\\\\)*)`, "g");
+const escapedCwd = JSON.stringify(CURRENT_CWD).slice(1, -1);
 const escapedCwdRegExp = new RegExp(`${quoteMeta(escapedCwd)}((?:\\\\\\\\)?(?:[a-zA-Z.\\-_]+\\\\\\\\)*)`, "g");
 const normalize = (str) => {
-    if (CASE_CWD.startsWith("/")) {
-        str = str.replace(new RegExp(quoteMeta(CASE_CWD), "g"), "<cwd>");
+    if (CURRENT_CWD.startsWith("/")) {
+        str = str.replace(new RegExp(quoteMeta(CURRENT_CWD), "g"), "<cwd>");
     }
     else {
         str = str.replace(cwdRegExp, (m, g) => `<cwd>${g.replace(/\\/g, "/")}`);
@@ -51,33 +49,23 @@ class DefaultsConfigTaskProcessor extends simple_1.SimpleTaskProcessor {
             name: _defaultsConfigOptions.name
         });
         this._defaultsConfigOptions = _defaultsConfigOptions;
-        this.defaultConfig = DefaultsConfigTaskProcessor.getDefaultConfig(CASE_CWD, {
+        this.defaultConfig = DefaultsConfigTaskProcessor.getDefaultConfig(CURRENT_CWD, {
             mode: "none"
         });
     }
-    async compiler(context) {
-        throw new Error("Not support");
-    }
-    async build(context) {
-        throw new Error("Not support");
-    }
-    async run(env, context) {
-        throw new Error("Not support");
-    }
+    async compiler(context) { }
+    async build(context) { }
+    async run(env, context) { }
     async check(env, context) {
         const compiler = this.getCompiler(context);
-        const config = DefaultsConfigTaskProcessor.getDefaultConfig(this._defaultsConfigOptions.cwd || CASE_CWD, compiler.getOptions());
+        const config = DefaultsConfigTaskProcessor.getDefaultConfig(this._defaultsConfigOptions.cwd || CURRENT_CWD, compiler.getOptions());
         const diff = (0, strip_ansi_1.default)((0, jest_diff_1.diff)(this.defaultConfig, config, { expand: false, contextLines: 0 }));
         await this._defaultsConfigOptions.diff(expect(new Diff(diff)), expect(this.defaultConfig));
     }
     async before(context) { }
     async after(context) { }
-    async beforeAll(context) {
-        throw new Error("Not support");
-    }
-    async afterAll(context) {
-        throw new Error("Not support");
-    }
+    async beforeAll(context) { }
+    async afterAll(context) { }
     getCompiler(context) {
         return context.getCompiler(this._options.name, this._options.compilerType);
     }

package/dist/processor/diagnostic.d.ts

@@ -2,13 +2,10 @@ import { ECompilerType, ITestContext, ITestEnv, TCompilerOptions } from "../type
 import { BasicTaskProcessor } from "./basic";
 export interface IRspackDiagnosticProcessorOptions {
     name: string;
-    root: string;
 }
 export declare class RspackDiagnosticProcessor extends BasicTaskProcessor<ECompilerType.Rspack> {
     protected _diagnosticOptions: IRspackDiagnosticProcessorOptions;
     constructor(_diagnosticOptions: IRspackDiagnosticProcessorOptions);
-    before(context: ITestContext): Promise<void>;
-    after(context: ITestContext): Promise<void>;
     check(env: ITestEnv, context: ITestContext): Promise<void>;
     static defaultOptions(context: ITestContext): TCompilerOptions<ECompilerType.Rspack>;
 }

package/dist/processor/diagnostic.js

@@ -9,9 +9,14 @@ const basic_1 = require("./basic");
 const assert_1 = __importDefault(require("assert"));
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
+const helper_1 = require("../helper");
 const serializer = require("jest-serializer-path");
 const normalizePaths = serializer.normalizePaths;
-const CWD = process.cwd();
+const rspackPath = path_1.default.resolve(__dirname, "../../../rspack");
+const replacePaths = (input) => {
+    const rspackRoot = normalizePaths(rspackPath);
+    return normalizePaths(input).split(rspackRoot).join("<RSPACK_ROOT>");
+};
 class RspackDiagnosticProcessor extends basic_1.BasicTaskProcessor {
     constructor(_diagnosticOptions) {
         super({
@@ -23,12 +28,6 @@ class RspackDiagnosticProcessor extends basic_1.BasicTaskProcessor {
         });
         this._diagnosticOptions = _diagnosticOptions;
     }
-    async before(context) {
-        process.chdir(this._diagnosticOptions.root);
-    }
-    async after(context) {
-        process.chdir(CWD);
-    }
     async check(env, context) {
         const compiler = this.getCompiler(context);
         const stats = compiler.getStats();
@@ -36,27 +35,25 @@ class RspackDiagnosticProcessor extends basic_1.BasicTaskProcessor {
             throw new Error("Stats should exists");
         }
         (0, assert_1.default)(stats.hasErrors() || stats.hasWarnings());
-        let output = normalizePaths(stats.toString({
+        let output = replacePaths(stats.toString({
             all: false,
             errors: true,
             warnings: true
         }));
         // TODO: change to stats.errorStack
-        if (context.getSource().includes("module-build-failed")) {
-            // Replace potential loader stack
-            output = output
-                .replaceAll("│", "")
-                .split(/\r?\n/)
-                .map((s) => s.trim())
-                .join("");
-        }
+        output = output
+            .split("│")
+            .join("")
+            .split(/\r?\n/)
+            .map((s) => s.trim())
+            .join("");
         const errorOutputPath = path_1.default.resolve(context.getSource(), `./stats.err`);
-        const updateSnapshot = process.argv.includes("-u") || process.argv.includes("--updateSnapshot");
-        if (!fs_1.default.existsSync(errorOutputPath) || updateSnapshot) {
-            fs_1.default.writeFileSync(errorOutputPath, output);
+        if (!fs_1.default.existsSync(errorOutputPath) || global.updateSnapshot) {
+            fs_1.default.writeFileSync(errorOutputPath, (0, helper_1.escapeEOL)(output));
         }
         else {
-            expect(output).toBe(fs_1.default.readFileSync(errorOutputPath, "utf-8"));
+            const expectContent = fs_1.default.readFileSync(errorOutputPath, "utf-8");
+            expect((0, helper_1.escapeEOL)(output)).toBe((0, helper_1.escapeEOL)(expectContent));
         }
     }
     static defaultOptions(context) {

package/dist/processor/error.d.ts

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