@rspack-debug/test-tools 1.4.11 → 1.6.4

package/dist/test/creator.js

@@ -9,38 +9,42 @@ const node_path_1 = __importDefault(require("node:path"));
 const rimraf_1 = require("rimraf");
 const createLazyTestEnv_1 = __importDefault(require("../helper/legacy/createLazyTestEnv"));
 const tester_1 = require("./tester");
-const DEFAULT_MAX_CONCURRENT = 5;
+const DEFAULT_MAX_CONCURRENT = process.env.WASM ? 1 : 5;
 class BasicCaseCreator {
     constructor(_options) {
         this._options = _options;
         this.currentConcurrent = 0;
         this.tasks = [];
     }
-    create(name, src, dist, temp) {
+    create(name, src, dist, temp, caseOptions) {
+        const options = {
+            ...this._options,
+            ...caseOptions
+        };
         const testConfig = this.readTestConfig(src);
-        if (typeof this._options.testConfig === "function") {
-            this._options.testConfig(testConfig);
+        if (typeof options.testConfig === "function") {
+            options.testConfig(testConfig);
         }
-        const skipped = this.checkSkipped(src, testConfig);
+        const skipped = this.checkSkipped(src, testConfig, options);
         if (skipped) {
             this.skip(name, skipped);
             return;
         }
-        if (this._options.clean) {
+        if (options.clean) {
             this.clean([dist, temp || ""].filter(Boolean));
         }
         const run = this.shouldRun(name);
-        const tester = this.createTester(name, src, dist, temp, testConfig);
+        const tester = this.createTester(name, src, dist, temp, testConfig, options);
         const concurrent = process.env.WASM
-            ? false
-            : testConfig.concurrent || this._options.concurrent;
-        if (this._options.describe) {
+            ? 1
+            : testConfig.concurrent || options.concurrent;
+        if (options.describe) {
             if (run) {
                 if (concurrent) {
-                    describe(name, () => this.describeConcurrent(name, tester, testConfig));
+                    describe(name, () => this.describeConcurrent(name, tester, testConfig, options));
                 }
                 else {
-                    describe(name, () => this.describe(name, tester, testConfig));
+                    describe(name, () => this.describe(name, tester, testConfig, options));
                 }
             }
             else {
@@ -52,10 +56,10 @@ class BasicCaseCreator {
         else {
             if (run) {
                 if (concurrent) {
-                    this.describeConcurrent(name, tester, testConfig);
+                    this.describeConcurrent(name, tester, testConfig, options);
                 }
                 else {
-                    this.describe(name, tester, testConfig);
+                    this.describe(name, tester, testConfig, options);
                 }
             }
             else {
@@ -71,7 +75,7 @@ class BasicCaseCreator {
         }
         return name.includes(global.testFilter);
     }
-    describeConcurrent(name, tester, testConfig) {
+    describeConcurrent(name, tester, testConfig, options) {
         beforeAll(async () => {
             await tester.prepare();
         });
@@ -79,7 +83,7 @@ class BasicCaseCreator {
         let chain = new Promise((resolve, reject) => {
             starter = resolve;
         });
-        const ender = this.registerConcurrentTask(name, starter);
+        const ender = this.registerConcurrentTask(name, starter, options.concurrent);
         const env = this.createConcurrentEnv();
         for (let index = 0; index < tester.total; index++) {
             let stepSignalResolve = null;
@@ -88,22 +92,24 @@ class BasicCaseCreator {
             }).catch(() => {
                 // prevent unhandled rejection
             });
-            const description = typeof this._options.description === "function"
-                ? this._options.description(name, index)
+            const description = typeof options.description === "function"
+                ? options.description(name, index)
                 : index
                     ? `step [${index}] should pass`
                     : "should pass";
-            it(description, cb => {
-                stepSignal.then((e) => {
-                    cb(e);
-                });
-            }, this._options.timeout || 180000);
+            it(description, async () => {
+                const e = await stepSignal;
+                if (e) {
+                    throw e;
+                }
+            }, options.timeout || 300000);
             chain = chain.then(async () => {
                 try {
                     env.clear();
                     await tester.compile();
                     await tester.check(env);
                     await env.run();
+                    await tester.after();
                     const context = tester.getContext();
                     if (!tester.next() && context.hasError()) {
                         const errors = context
@@ -136,22 +142,28 @@ class BasicCaseCreator {
             await tester.resume();
         });
     }
-    describe(name, tester, testConfig) {
+    describe(name, tester, testConfig, options) {
         beforeAll(async () => {
             await tester.prepare();
         });
         let bailout = false;
         for (let index = 0; index < tester.total; index++) {
-            const description = typeof this._options.description === "function"
-                ? this._options.description(name, index)
-                : `step ${index ? `[${index}]` : ""} should pass`;
+            const description = typeof options.description === "function"
+                ? options.description(name, index)
+                : `step [${index}] should pass`;
             it(description, async () => {
                 if (bailout) {
                     throw `Case "${name}" step ${index + 1} bailout because ${tester.step + 1} failed`;
                 }
-                await tester.compile();
-                await tester.check(env);
                 const context = tester.getContext();
+                try {
+                    await tester.compile();
+                }
+                catch (e) {
+                    bailout = true;
+                    context.emitError(e);
+                }
+                await tester.check(env);
                 if (!tester.next() && context.hasError()) {
                     bailout = true;
                     const errors = context
@@ -160,8 +172,8 @@ class BasicCaseCreator {
                         .join("\n\n");
                     throw new Error(`Case "${name}" failed at step ${tester.step + 1}:\n${errors}`);
                 }
-            }, this._options.timeout || 30000);
-            const env = this.createEnv(testConfig);
+            }, options.timeout || 60000);
+            const env = this.createEnv(testConfig, options);
         }
         afterAll(async () => {
             await tester.resume();
@@ -205,8 +217,11 @@ class BasicCaseCreator {
                     try {
                         await runFn(fn);
                     }
-                    catch (e) {
-                        throw new Error(`Error: ${description} failed\n${e.stack}`);
+                    catch (err) {
+                        const e = err;
+                        const message = `Error: ${description} failed:\n${e.message}`;
+                        e.message = message;
+                        throw e;
                     }
                     for (const after of afterTasks) {
                         await runFn(after);
@@ -227,11 +242,11 @@ class BasicCaseCreator {
                 expect(typeof fn === "function");
                 afterTasks.push(fn);
             },
-            jest
+            rstest
         };
     }
-    createEnv(testConfig) {
-        if (typeof this._options.runner === "function" && !testConfig.noTest) {
+    createEnv(testConfig, options) {
+        if (options.runner && !testConfig.noTests) {
             return (0, createLazyTestEnv_1.default)(10000);
         }
         return {
@@ -239,47 +254,46 @@ class BasicCaseCreator {
             it,
             beforeEach,
             afterEach,
-            jest
+            rstest
         };
     }
     clean(folders) {
         for (const f of folders) {
             (0, rimraf_1.rimrafSync)(f);
-            node_fs_1.default.mkdirSync(f, { recursive: true });
         }
     }
     skip(name, reason) {
-        describe.skip(name, () => {
-            it(typeof reason === "string" ? `filtered by ${reason}` : "filtered", () => { });
-        });
+        it(typeof reason === "string" ? `filtered by ${reason}` : "filtered", () => { });
     }
     readTestConfig(src) {
         const testConfigFile = node_path_1.default.join(src, "test.config.js");
         return node_fs_1.default.existsSync(testConfigFile) ? require(testConfigFile) : {};
     }
-    checkSkipped(src, testConfig) {
+    checkSkipped(src, testConfig, options) {
         const filterPath = node_path_1.default.join(src, "test.filter.js");
         // no test.filter.js, should not skip
         if (!node_fs_1.default.existsSync(filterPath)) {
             return false;
         }
         // test.filter.js exists, skip if it returns false|string|array
-        const filtered = require(filterPath)(this._options, testConfig);
+        const filtered = require(filterPath)(options, testConfig);
         if (typeof filtered === "string" || Array.isArray(filtered)) {
             return true;
         }
         return !filtered;
     }
-    createTester(name, src, dist, temp, testConfig) {
+    createTester(name, src, dist, temp, testConfig, options) {
         return new tester_1.Tester({
             name,
             src,
             dist,
+            temp,
             testConfig,
-            contextValue: this._options.contextValue,
-            runnerFactory: this._options.runner,
-            steps: this._options.steps({
-                ...this._options,
+            contextValue: options.contextValue,
+            runnerCreator: options.runner,
+            createContext: options.createContext,
+            steps: options.steps({
+                ...options,
                 name,
                 src,
                 dist,
@@ -287,25 +301,23 @@ class BasicCaseCreator {
             })
         });
     }
-    tryRunTask() {
+    tryRunTask(concurrent) {
         while (this.tasks.length !== 0 &&
-            this.currentConcurrent < this.getMaxConcurrent()) {
+            this.currentConcurrent < this.getMaxConcurrent(concurrent)) {
             const [_name, starter] = this.tasks.shift();
             this.currentConcurrent++;
             starter();
         }
     }
-    getMaxConcurrent() {
-        return typeof this._options.concurrent === "number"
-            ? this._options.concurrent
-            : DEFAULT_MAX_CONCURRENT;
+    getMaxConcurrent(concurrent) {
+        return typeof concurrent === "number" ? concurrent : DEFAULT_MAX_CONCURRENT;
     }
-    registerConcurrentTask(name, starter) {
+    registerConcurrentTask(name, starter, concurrent) {
         this.tasks.push([name, starter]);
-        this.tryRunTask();
+        this.tryRunTask(concurrent);
         return () => {
             this.currentConcurrent--;
-            this.tryRunTask();
+            this.tryRunTask(concurrent);
         };
     }
 }

package/dist/test/debug.d.ts

@@ -0,0 +1,15 @@
+import type { ITestContext } from "../type";
+export declare function generateDebugReport(context: ITestContext): void;
+export declare const DEBUG_SCOPES: {
+    CompilerOptionsReadConfigFile: string;
+    CompilerOptionsFinalOptions: string;
+    CreateCompilerInstance: string;
+    CreateCompilerSetProperties: string;
+    BuildMethod: string;
+    BuildError: string;
+    BuildWarning: string;
+    RunFindBundle: string;
+    RunGetRunner: string;
+    RunLogs: string;
+    RunErrors: string;
+};

package/dist/test/debug.js

@@ -0,0 +1,205 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEBUG_SCOPES = void 0;
+exports.generateDebugReport = generateDebugReport;
+const node_path_1 = __importDefault(require("node:path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const javascript_stringify_1 = require("javascript-stringify");
+const stringify_config_1 = __importDefault(require("../helper/stringify-config"));
+function generateDebugReport(context) {
+    const report = `
+## Case Meta
+
+${generateCaseMetaPathReport(context)}
+
+${generateCaseMetaTestConfigReport(context)}
+
+## Compiler Options
+
+${generateReadConfigFileReport(context)}
+
+${generateFinalOptionsReport(context)}
+
+## Create Compiler
+
+${generateCreateCompilerInstanceReport(context)}
+
+${generateCreateCompilerSetPropertiesReport(context)}
+
+## Build
+
+${generateBuildMethodReport(context)}
+
+${generateBuildErrorReport(context)}
+
+${generateBuildWarningReport(context)}
+
+## Run
+
+${generateRunFindBundleReport(context)}
+
+${generateRunGetRunnerReport(context)}
+
+${generateRunLogsReport(context)}
+
+${generateRunErrorsReport(context)}
+
+  `;
+    const dist = context.getDist("debug.md");
+    fs_extra_1.default.ensureDirSync(node_path_1.default.dirname(dist));
+    fs_extra_1.default.writeFileSync(dist, report);
+}
+function generateCaseMetaPathReport(context) {
+    return `
+### Case Path
+
+- Source: ${context.getSource()}
+- Dist: ${context.getDist()}
+- Temp: ${context.getTemp()}
+  `;
+}
+function generateCaseMetaTestConfigReport(context) {
+    return `
+### Test Config
+
+\`\`\`js
+// ${node_path_1.default.resolve(context.getSource(), "./test.config.js")}
+${(0, javascript_stringify_1.stringify)(context.getTestConfig(), null, 2)}
+\`\`\`
+  `;
+}
+function generateReadConfigFileReport(context) {
+    const configFileInfo = context.getValue(exports.DEBUG_SCOPES.CompilerOptionsReadConfigFile);
+    if (!configFileInfo)
+        return "";
+    return `
+### Read Config File
+
+\`\`\`js
+// ${configFileInfo.file}
+${(0, stringify_config_1.default)(configFileInfo.config)}
+\`\`\`
+  `;
+}
+function generateFinalOptionsReport(context) {
+    const finalOptions = context.getCompiler().getOptions();
+    return `
+### Final Options
+
+\`\`\`js
+${(0, stringify_config_1.default)(finalOptions)}
+\`\`\`
+`;
+}
+function generateCreateCompilerInstanceReport(context) {
+    const instanceInfo = context.getValue(exports.DEBUG_SCOPES.CreateCompilerInstance);
+    if (!instanceInfo)
+        return "";
+    return `
+### Create Compiler Instance
+
+- Rspack Path: ${instanceInfo.path}
+- Callback Mode: ${instanceInfo.mode}
+`;
+}
+function generateCreateCompilerSetPropertiesReport(context) {
+    const setPropertiesInfo = context.getValue(exports.DEBUG_SCOPES.CreateCompilerSetProperties);
+    if (!setPropertiesInfo || setPropertiesInfo.length === 0)
+        return "";
+    return `
+### Set Properties
+
+${setPropertiesInfo.map(p => `- ${p}`).join("\n")}
+`;
+}
+function generateBuildMethodReport(context) {
+    const buildMethod = context.getValue(exports.DEBUG_SCOPES.BuildMethod);
+    if (!buildMethod)
+        return "";
+    return `
+### Build Method
+
+- Method: \`compiler.${buildMethod.method}()\`
+${buildMethod.options ? `- Options:\n\`\`\`js\n${(0, javascript_stringify_1.stringify)(buildMethod.options, null, 2)}\n\`\`\`` : ""}
+`;
+}
+function generateBuildErrorReport(context) {
+    const buildError = context.getValue(exports.DEBUG_SCOPES.BuildError);
+    if (!buildError)
+        return "";
+    return `
+### Build Error
+
+type: ${buildError.type}
+
+${buildError.errors.map(e => `\`\`\`\n// message:\n${e.message}\n// stack:\n${e.stack}\n\`\`\``).join("\n\n")}
+`;
+}
+function generateBuildWarningReport(context) {
+    const buildWarning = context.getValue(exports.DEBUG_SCOPES.BuildWarning);
+    if (!buildWarning)
+        return "";
+    return `
+### Build Warning
+
+${buildWarning.map(w => `\`\`\`\n// message:\n${w.message}\n// stack:\n${w.stack}\n\`\`\``).join("\n\n")}
+`;
+}
+function generateRunFindBundleReport(context) {
+    const runFindBundle = context.getValue(exports.DEBUG_SCOPES.RunFindBundle);
+    if (!runFindBundle)
+        return "";
+    return `
+### Find Bundle
+
+${runFindBundle.map(b => `- ${context.getDist(b)}`).join("\n")}
+`;
+}
+function generateRunGetRunnerReport(context) {
+    const getRunnerInfo = context.getValue(exports.DEBUG_SCOPES.RunGetRunner);
+    if (!getRunnerInfo)
+        return "";
+    return `
+### Get Runner
+
+${Object.entries(getRunnerInfo)
+        .map(([file, info]) => `- ${file}: ${info.runnerKey} (Reused: ${info.reused}, Type: \`${info.runnerType}\`)`)
+        .join("\n")}
+`;
+}
+function generateRunLogsReport(context) {
+    const runLogs = context.getValue(exports.DEBUG_SCOPES.RunLogs);
+    if (!runLogs)
+        return "";
+    return `
+### Run Logs
+
+${runLogs.map(l => `- ${l}`).join("\n")}
+`;
+}
+function generateRunErrorsReport(context) {
+    const runErrors = context.getValue(exports.DEBUG_SCOPES.RunErrors);
+    if (!runErrors)
+        return "";
+    return `
+### Run Errors
+
+${runErrors.map(e => `\`\`\`\n// message:\n${e.message}\n// stack:\n${e.stack}\n\`\`\``).join("\n\n")}
+`;
+}
+exports.DEBUG_SCOPES = {
+    CompilerOptionsReadConfigFile: "compiler-options:read-config-file",
+    CompilerOptionsFinalOptions: "compiler-options:final-options",
+    CreateCompilerInstance: "create-compiler:instance",
+    CreateCompilerSetProperties: "create-compiler:set-properties",
+    BuildMethod: "build:method",
+    BuildError: "build:error",
+    BuildWarning: "build:warning",
+    RunFindBundle: "run:find-bundle",
+    RunGetRunner: "run:get-runner",
+    RunLogs: "run:logs",
+    RunErrors: "run:errors"
+};

package/dist/test/tester.d.ts

@@ -10,6 +10,7 @@ export declare class Tester implements ITester {
     prepare(): Promise<void>;
     compile(): Promise<void>;
     check(env: ITestEnv): Promise<void>;
+    after(): Promise<void>;
     next(): boolean;
     resume(): Promise<void>;
     private runStepMethods;

package/dist/test/tester.js

@@ -1,20 +1,27 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Tester = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
 const context_1 = require("./context");
+const debug_1 = require("./debug");
 class Tester {
     constructor(config) {
         this.config = config;
         this.steps = [];
         this.step = 0;
         this.total = 0;
-        this.context = new context_1.TestContext(config);
+        this.context = config.createContext
+            ? config.createContext(config)
+            : new context_1.TestContext(config);
         this.steps = config.steps || [];
         this.step = 0;
         this.total = config.steps?.length || 0;
         if (config.contextValue) {
             for (const [key, value] of Array.from(Object.entries(config.contextValue))) {
-                this.context.setValue(config.name, key, value);
+                this.context.setValue(key, value);
             }
         }
     }
@@ -22,6 +29,11 @@ class Tester {
         return this.context;
     }
     async prepare() {
+        fs_extra_1.default.mkdirSync(this.context.getDist(), { recursive: true });
+        const tempDir = this.context.getTemp();
+        if (tempDir) {
+            fs_extra_1.default.mkdirSync(tempDir, { recursive: true });
+        }
         for (const i of this.steps) {
             if (typeof i.beforeAll === "function") {
                 await i.beforeAll(this.context);
@@ -44,6 +56,11 @@ class Tester {
         if (!currentStep)
             return;
         await this.runCheckStepMethods(currentStep, env, this.context.hasError() ? ["check"] : ["run", "check"]);
+    }
+    async after() {
+        const currentStep = this.steps[this.step];
+        if (!currentStep)
+            return;
         await this.runStepMethods(currentStep, ["after"], true);
     }
     next() {
@@ -62,6 +79,20 @@ class Tester {
                 await i.afterAll(this.context);
             }
         }
+        try {
+            await this.context.closeCompiler();
+        }
+        catch (e) {
+            console.warn(`Error occured while closing compilers of '${this.config.name}':\n${e.stack}`);
+        }
+        if (__DEBUG__) {
+            try {
+                (0, debug_1.generateDebugReport)(this.context);
+            }
+            catch (e) {
+                console.warn(`Generate debug report failed: ${e.message}`);
+            }
+        }
     }
     async runStepMethods(step, methods, force = false) {
         for (const i of methods) {
@@ -72,17 +103,24 @@ class Tester {
                     await step[i](this.context);
                 }
                 catch (e) {
-                    this.context.emitError(this.config.name, e);
+                    this.context.emitError(e);
                 }
             }
         }
     }
     async runCheckStepMethods(step, env, methods) {
-        for (const i of methods) {
-            if (typeof step[i] === "function") {
-                await step[i](env, this.context);
+        try {
+            for (const i of methods) {
+                if (typeof step[i] === "function") {
+                    await step[i](env, this.context);
+                }
             }
         }
+        catch (e) {
+            const errors = this.context.getError();
+            console.error(new Error([...errors, e].map(e => e.message).join("\n")));
+            throw e;
+        }
     }
 }
 exports.Tester = Tester;