@rspack/test-tools 0.6.3 → 0.6.4

package/dist/case/builtin.js

@@ -15,7 +15,7 @@ const FILTERS = {
 };
 const creator = new creator_1.BasicCaseCreator({
     clean: true,
-    describe: true,
+    describe: false,
     description(name) {
         return `${name} should match snapshot`;
     },

package/dist/case/compiler.d.ts

@@ -0,0 +1,5 @@
+import { ISimpleProcessorOptions } from "../processor";
+export type TCompilerCaseConfig = Omit<ISimpleProcessorOptions, "name" | "compilerType"> & {
+    description: string;
+};
+export declare function createCompilerCase(name: string, src: string, dist: string, testConfig: string): void;

package/dist/case/compiler.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCompilerCase = void 0;
+const type_1 = require("../type");
+const processor_1 = require("../processor");
+const simple_1 = require("../test/simple");
+function createCompilerCase(name, src, dist, testConfig) {
+    const caseConfig = require(testConfig);
+    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
+        }));
+    });
+}
+exports.createCompilerCase = createCompilerCase;

package/dist/case/config.js

@@ -6,7 +6,7 @@ const runner_1 = require("../runner");
 const creator_1 = require("../test/creator");
 const creator = new creator_1.BasicCaseCreator({
     clean: true,
-    describe: true,
+    describe: false,
     steps: ({ name }) => [
         new config_1.RspackConfigProcessor({
             name,

package/dist/case/defaults.js

@@ -7,8 +7,8 @@ exports.createDefaultsCase = void 0;
 const context_1 = require("../test/context");
 const path_1 = __importDefault(require("path"));
 const processor_1 = require("../processor");
-const srcDir = path_1.default.resolve(__dirname, "../../../rspack/tests/fixtures");
-const distDir = path_1.default.resolve(__dirname, "../../../rspack/tests/js/compiler");
+const srcDir = path_1.default.resolve(__dirname, "../../tests/fixtures");
+const distDir = path_1.default.resolve(__dirname, "../../tests/js/defaults");
 const context = new context_1.TestContext({
     src: srcDir,
     dist: distDir

package/dist/case/diagnostic.js

@@ -1,19 +1,14 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createDiagnosticCase = void 0;
-const path_1 = __importDefault(require("path"));
 const processor_1 = require("../processor");
 const creator_1 = require("../test/creator");
 const creator = new creator_1.BasicCaseCreator({
     clean: true,
-    describe: true,
+    describe: false,
     steps: ({ name }) => [
         new processor_1.RspackDiagnosticProcessor({
-            name,
-            root: path_1.default.resolve(__dirname, "../../../rspack")
+            name
         })
     ]
 });

package/dist/case/error.d.ts

@@ -0,0 +1,6 @@
+import { ECompilerType } from "../type";
+import { IErrorTaskProcessorOptions } from "../processor";
+export type TErrorCaseConfig = Omit<IErrorTaskProcessorOptions<ECompilerType.Rspack>, "name" | "compilerType"> & {
+    description: string;
+};
+export declare function createErrorCase(name: string, src: string, dist: string, testConfig: string): void;

package/dist/case/error.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createErrorCase = void 0;
+const type_1 = require("../type");
+const simple_1 = require("../test/simple");
+const processor_1 = require("../processor");
+let addedSerializer = false;
+function createErrorCase(name, src, dist, testConfig) {
+    if (!addedSerializer) {
+        processor_1.ErrorTaskProcessor.addSnapshotSerializer();
+        addedSerializer = true;
+    }
+    const caseConfig = require(testConfig);
+    const runner = (0, simple_1.getSimpleProcessorRunner)(src, dist);
+    it(caseConfig.description, async () => {
+        await runner(name, new processor_1.ErrorTaskProcessor({
+            name: name,
+            compilerType: type_1.ECompilerType.Rspack,
+            ...caseConfig
+        }));
+    });
+}
+exports.createErrorCase = createErrorCase;

package/dist/case/hook.d.ts

@@ -0,0 +1 @@
+export declare function createHookCase(name: string, src: string, dist: string, source: string): void;

package/dist/case/hook.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHookCase = void 0;
+const path_1 = __importDefault(require("path"));
+const simple_1 = require("../test/simple");
+const processor_1 = require("../processor");
+const runner_1 = require("../runner");
+const type_1 = require("../type");
+const createLazyTestEnv_1 = __importDefault(require("../helper/legacy/createLazyTestEnv"));
+function createHookCase(name, src, dist, source) {
+    const caseConfig = require(path_1.default.join(src, "test.js"));
+    const testName = path_1.default.basename(name.slice(0, name.indexOf(path_1.default.extname(name))));
+    const runner = (0, simple_1.getSimpleProcessorRunner)(source, dist, {
+        env: () => env,
+        context: () => new processor_1.HookCasesContext(src, testName, {
+            src: source,
+            dist: dist,
+            runnerFactory: runner_1.BasicRunnerFactory
+        })
+    });
+    it(caseConfig.description, async () => {
+        await runner(name, new processor_1.HookTaskProcessor({
+            name,
+            compilerType: type_1.ECompilerType.Rspack,
+            findBundle: function (i, options) {
+                return ["main.js"];
+            },
+            snapshot: path_1.default.join(src, "output.snap.txt"),
+            ...caseConfig
+        }));
+    });
+    const env = (0, createLazyTestEnv_1.default)(10000);
+}
+exports.createHookCase = createHookCase;

package/dist/case/hot-step.js

@@ -9,7 +9,7 @@ function getCreator(target) {
     if (!creators.has(target)) {
         creators.set(target, new creator_1.BasicCaseCreator({
             clean: true,
-            describe: true,
+            describe: false,
             target,
             steps: ({ name, target }) => [
                 new hot_step_1.RspackHotStepProcessor({

package/dist/case/index.d.ts

@@ -4,9 +4,13 @@ export * from "./diff";
 export * from "./hash";
 export * from "./hot";
 export * from "./normal";
-export * from "./stats";
+export * from "./stats-output";
 export * from "./watch";
 export * from "./treeshaking";
 export * from "./defaults";
 export * from "./builtin";
 export * from "./hot-step";
+export * from "./compiler";
+export * from "./stats-api";
+export * from "./error";
+export * from "./hook";

package/dist/case/index.js

@@ -20,9 +20,13 @@ __exportStar(require("./diff"), exports);
 __exportStar(require("./hash"), exports);
 __exportStar(require("./hot"), exports);
 __exportStar(require("./normal"), exports);
-__exportStar(require("./stats"), exports);
+__exportStar(require("./stats-output"), exports);
 __exportStar(require("./watch"), exports);
 __exportStar(require("./treeshaking"), exports);
 __exportStar(require("./defaults"), exports);
 __exportStar(require("./builtin"), exports);
 __exportStar(require("./hot-step"), exports);
+__exportStar(require("./compiler"), exports);
+__exportStar(require("./stats-api"), exports);
+__exportStar(require("./error"), exports);
+__exportStar(require("./hook"), exports);

package/dist/case/normal.js

@@ -10,11 +10,11 @@ const creator_1 = require("../test/creator");
 const runner_1 = require("../runner");
 const creator = new creator_1.BasicCaseCreator({
     clean: true,
-    describe: true,
+    describe: false,
     steps: ({ name }) => [
         new normal_1.RspackNormalProcessor({
             name,
-            root: path_1.default.resolve(__dirname, "../../../rspack/tests/cases"),
+            root: path_1.default.resolve(__dirname, "../../tests/normalCases"),
             compilerOptions: {},
             runable: true
         })

package/dist/case/stats-api.d.ts

@@ -0,0 +1,6 @@
+import { ECompilerType } from "../type";
+import { IStatsAPITaskProcessorOptions } from "../processor";
+export type TStatsAPICaseConfig = Omit<IStatsAPITaskProcessorOptions<ECompilerType.Rspack>, "name" | "compilerType"> & {
+    description: string;
+};
+export declare function createStatsAPICase(name: string, src: string, dist: string, testConfig: string): void;

package/dist/case/stats-api.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStatsAPICase = void 0;
+const type_1 = require("../type");
+const simple_1 = require("../test/simple");
+const processor_1 = require("../processor");
+let addedSerializer = false;
+function createStatsAPICase(name, src, dist, testConfig) {
+    if (!addedSerializer) {
+        processor_1.StatsAPITaskProcessor.addSnapshotSerializer();
+        addedSerializer = true;
+    }
+    const caseConfig = require(testConfig);
+    const runner = (0, simple_1.getSimpleProcessorRunner)(src, dist);
+    it(caseConfig.description, async () => {
+        await runner(name, new processor_1.StatsAPITaskProcessor({
+            name: name,
+            compilerType: type_1.ECompilerType.Rspack,
+            ...caseConfig
+        }));
+    });
+}
+exports.createStatsAPICase = createStatsAPICase;

package/dist/case/stats-output.d.ts

@@ -0,0 +1 @@
+export declare function createStatsOutputCase(name: string, src: string, dist: string): void;

package/dist/case/{stats.js → stats-output.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createStatsCase = void 0;
+exports.createStatsOutputCase = void 0;
 const stats_1 = require("../processor/stats");
 const creator_1 = require("../test/creator");
 const creator = new creator_1.BasicCaseCreator({
@@ -13,7 +13,7 @@ const creator = new creator_1.BasicCaseCreator({
     ],
     description: name => `should print correct stats for ${name}`
 });
-function createStatsCase(name, src, dist) {
+function createStatsOutputCase(name, src, dist) {
     creator.create(name, src, dist);
 }
-exports.createStatsCase = createStatsCase;
+exports.createStatsOutputCase = createStatsOutputCase;

package/dist/case/treeshaking.js

@@ -5,7 +5,7 @@ const treeshaking_1 = require("../processor/treeshaking");
 const creator_1 = require("../test/creator");
 const creator = new creator_1.BasicCaseCreator({
     clean: true,
-    describe: true,
+    describe: false,
     description(name, step) {
         if (step === 0) {
             return `${name} with builtin.treeShaking should match snapshot`;

package/dist/helper/directory.d.ts

@@ -1,6 +1,10 @@
 export declare const isDirectory: (p: string) => boolean;
+export declare const isFile: (p: string) => boolean;
 export declare const isValidCaseDirectory: (name: string) => boolean;
-export declare function describeByWalk(name: string, sourceBase: string, distBase: string, createCase: (name: string, src: string, dist: string) => void, whitelist?: {
-    cat?: RegExp;
-    case?: RegExp;
+export declare function describeByWalk(testFile: string, createCase: (name: string, src: string, dist: string) => void, options?: {
+    type?: "file" | "directory";
+    level?: number;
+    source?: string;
+    dist?: string;
+    absoluteDist?: boolean;
 }): void;

package/dist/helper/directory.js

@@ -3,42 +3,71 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.describeByWalk = exports.isValidCaseDirectory = exports.isDirectory = void 0;
+exports.describeByWalk = exports.isValidCaseDirectory = exports.isFile = exports.isDirectory = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const _1 = require(".");
 const isDirectory = (p) => fs_1.default.lstatSync(p).isDirectory();
 exports.isDirectory = isDirectory;
-const isValidCaseDirectory = (name) => !name.startsWith("_") && !name.startsWith(".");
+const isFile = (p) => fs_1.default.lstatSync(p).isFile();
+exports.isFile = isFile;
+const isValidCaseDirectory = (name) => !name.startsWith("_") && !name.startsWith(".") && name !== "node_modules";
 exports.isValidCaseDirectory = isValidCaseDirectory;
-function describeByWalk(name, sourceBase, distBase, createCase, whitelist = {}) {
-    const categories = fs_1.default
-        .readdirSync(sourceBase)
-        .filter(exports.isValidCaseDirectory)
-        .filter(folder => (0, exports.isDirectory)(path_1.default.join(sourceBase, folder)))
-        .filter(i => ((whitelist === null || whitelist === void 0 ? void 0 : whitelist.cat) ? whitelist.cat.test(i) : true))
-        .map(cat => {
-        return {
-            name: cat,
-            tests: fs_1.default
-                .readdirSync(path_1.default.join(sourceBase, cat))
-                .filter(exports.isValidCaseDirectory)
-                .filter(folder => (0, exports.isDirectory)(path_1.default.join(sourceBase, cat, folder)))
-                .filter(i => ((whitelist === null || whitelist === void 0 ? void 0 : whitelist.case) ? whitelist.case.test(i) : true))
-                .sort()
-        };
-    });
-    describe(name, () => {
-        for (let { name: catName, tests } of categories) {
-            if (tests.length === 0)
-                continue;
-            describe(catName, () => {
-                for (const testName of tests) {
-                    const src = path_1.default.join(sourceBase, catName, testName);
-                    const dist = path_1.default.join(distBase, catName, testName);
-                    createCase(testName, src, dist);
-                }
-            });
-        }
+function describeByWalk(testFile, createCase, options = {}) {
+    var _a;
+    const testBasename = path_1.default
+        .basename(testFile)
+        .replace(/\.(diff|hot)?test\.js/, "");
+    const testId = testBasename.charAt(0).toLowerCase() + testBasename.slice(1);
+    const sourceBase = options.source || path_1.default.join(path_1.default.dirname(testFile), `${testId}Cases`);
+    const distBase = options.dist || path_1.default.join(path_1.default.dirname(testFile), "js", testId);
+    const level = options.level || 2;
+    const type = options.type || "directory";
+    const absoluteDist = (_a = options.absoluteDist) !== null && _a !== void 0 ? _a : true;
+    function describeDirectory(dirname, currentLevel) {
+        fs_1.default.readdirSync(path_1.default.join(sourceBase, dirname))
+            .filter(exports.isValidCaseDirectory)
+            .filter(folder => {
+            const p = path_1.default.join(sourceBase, dirname, folder);
+            if (type === "file" && currentLevel === 1) {
+                return (0, exports.isFile)(p);
+            }
+            else if (type === "directory" || currentLevel > 1) {
+                return (0, exports.isDirectory)(p);
+            }
+            else {
+                return false;
+            }
+        })
+            .map(folder => {
+            const caseName = path_1.default.join(dirname, folder);
+            if (currentLevel > 1) {
+                describeDirectory(caseName, currentLevel - 1);
+            }
+            else {
+                const name = (0, _1.escapeSep)(path_1.default.join(testId, caseName).split(".").shift());
+                describe(name, () => {
+                    let source = path_1.default.join(sourceBase, caseName);
+                    let dist = "";
+                    if (absoluteDist) {
+                        dist = path_1.default.join(distBase, caseName);
+                    }
+                    else {
+                        const relativeDist = options.dist || "dist";
+                        if (path_1.default.isAbsolute(relativeDist)) {
+                            dist = path_1.default.join(relativeDist, caseName);
+                        }
+                        else {
+                            dist = path_1.default.join(sourceBase, caseName, relativeDist);
+                        }
+                    }
+                    createCase(folder, source, dist);
+                });
+            }
+        });
+    }
+    describe(testId, () => {
+        describeDirectory("", level);
     });
 }
 exports.describeByWalk = describeByWalk;

package/dist/helper/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./read-config-file";
 export * from "./parse-modules";
 export * from "./directory";
+export * from "./win";

package/dist/helper/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./read-config-file"), exports);
 __exportStar(require("./parse-modules"), exports);
 __exportStar(require("./directory"), exports);
+__exportStar(require("./win"), exports);

package/dist/helper/jestFileSnapshot.d.ts

@@ -0,0 +1,18 @@
+export function toMatchFileSnapshot(this: {
+    testPath: string;
+    currentTestName: string;
+    assertionCalls: number;
+    isNot: boolean;
+    snapshotState: {
+        added: number;
+        updated: number;
+        unmatched: number;
+        _updateSnapshot: 'none' | 'new' | 'all';
+    };
+}, content: string | Buffer, filepath?: string | undefined, options?: {
+    diff?: import('jest-diff').DiffOptions;
+}): {
+    pass: boolean;
+    message: () => string;
+};
+import { diff } from "jest-diff";

package/dist/helper/jestFileSnapshot.js

@@ -0,0 +1,112 @@
+"use strict";
+// @ts-nocheck
+/* istanbul ignore file */
+const fs = require("fs");
+const path = require("path");
+const chalk = require("chalk");
+const { diff } = require("jest-diff");
+const mkdirp = require("mkdirp");
+const filenamify = require("filenamify");
+/**
+ * Check if 2 strings or buffer are equal
+ * @param {string | Buffer} a
+ * @param {string | Buffer} b
+ */
+const isEqual = (a, b) => {
+    // @ts-ignore: TypeScript gives error if we pass string to buffer.equals
+    return Buffer.isBuffer(a) ? a.equals(b) : a === b;
+};
+/**
+ * Match given content against content of the specified file.
+ *
+ * @param {string | Buffer} content Output content to match
+ * @param {string} [filepath] Path to the file to match against
+ * @param {{ diff?: import('jest-diff').DiffOptions }} options Additional options for matching
+ * @this {{ testPath: string, currentTestName: string, assertionCalls: number, isNot: boolean, snapshotState: { added: number, updated: number, unmatched: number, _updateSnapshot: 'none' | 'new' | 'all' } }}
+ */
+exports.toMatchFileSnapshot = function toMatchFileSnapshot(content, filepath, options = {}) {
+    const { isNot, snapshotState } = this;
+    const filename = filepath === undefined
+        ? // If file name is not specified, generate one from the test title
+            path.join(path.dirname(this.testPath), "__file_snapshots__", `${filenamify(this.currentTestName, {
+                replacement: "-"
+            }).replace(/\s/g, "-")}-${this.assertionCalls}`)
+        : filepath;
+    options = {
+        // Options for jest-diff
+        diff: Object.assign({
+            expand: false,
+            contextLines: 5,
+            aAnnotation: "Snapshot"
+        }, options.diff || {})
+    };
+    if (snapshotState._updateSnapshot === "none" && !fs.existsSync(filename)) {
+        // We're probably running in CI environment
+        snapshotState.unmatched++;
+        return {
+            pass: isNot,
+            message: () => `New output file ${chalk.blue(path.basename(filename))} was ${chalk.bold.red("not written")}.\n\n` +
+                "The update flag must be explicitly passed to write a new snapshot.\n\n" +
+                `This is likely because this test is run in a ${chalk.blue("continuous integration (CI) environment")} in which snapshots are not written by default.\n\n`
+        };
+    }
+    if (fs.existsSync(filename)) {
+        const output = fs
+            .readFileSync(filename, Buffer.isBuffer(content) ? null : "utf8")
+            .replace(/\r\n/g, "\n");
+        if (isNot) {
+            // The matcher is being used with `.not`
+            if (!isEqual(content, output)) {
+                // The value of `pass` is reversed when used with `.not`
+                return { pass: false, message: () => "" };
+            }
+            else {
+                snapshotState.unmatched++;
+                return {
+                    pass: true,
+                    message: () => `Expected received content ${chalk.red("to not match")} the file ${chalk.blue(path.basename(filename))}.`
+                };
+            }
+        }
+        else {
+            if (isEqual(content, output)) {
+                return { pass: true, message: () => "" };
+            }
+            else {
+                if (snapshotState._updateSnapshot === "all") {
+                    mkdirp.sync(path.dirname(filename));
+                    fs.writeFileSync(filename, content);
+                    snapshotState.updated++;
+                    return { pass: true, message: () => "" };
+                }
+                else {
+                    snapshotState.unmatched++;
+                    const difference = Buffer.isBuffer(content) || Buffer.isBuffer(output)
+                        ? ""
+                        : `\n\n${diff(output, content, options.diff)}`;
+                    return {
+                        pass: false,
+                        message: () => `Received content ${chalk.red("doesn't match")} the file ${chalk.blue(path.basename(filename))}.${difference}`
+                    };
+                }
+            }
+        }
+    }
+    else {
+        if (!isNot &&
+            (snapshotState._updateSnapshot === "new" ||
+                snapshotState._updateSnapshot === "all")) {
+            mkdirp.sync(path.dirname(filename));
+            fs.writeFileSync(filename, content);
+            snapshotState.added++;
+            return { pass: true, message: () => "" };
+        }
+        else {
+            snapshotState.unmatched++;
+            return {
+                pass: true,
+                message: () => `The output file ${chalk.blue(path.basename(filename))} ${chalk.bold.red("doesn't exist")}.`
+            };
+        }
+    }
+};

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

@@ -0,0 +1,9 @@
+export function register(name: any, deps: any, fn: any): void;
+export function set(name: any, exports: any): void;
+export const registry: undefined;
+export const _require: undefined;
+export const _nextName: string;
+export function setRequire(req: any): void;
+export function init(modules: any): void;
+export function execute(name: any): any;
+export function ensureExecuted(name: any): any;