@rspack/test-tools 2.0.2 → 2.0.4

package/dist/test/context.js

@@ -1,74 +1,96 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TestContext = void 0;
-const node_path_1 = __importDefault(require("node:path"));
-const compiler_1 = require("../compiler");
-const debug_1 = require("./debug");
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    TestContext: ()=>TestContext
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_compiler_js_namespaceObject = require("../compiler.js");
+const external_debug_js_namespaceObject = require("./debug.js");
 class TestContext {
-    constructor(config) {
+    config;
+    errors = [];
+    compiler = null;
+    store = new Map();
+    runners = new Map();
+    constructor(config){
         this.config = config;
-        this.errors = [];
-        this.compiler = null;
-        this.store = new Map();
-        this.runners = new Map();
     }
     getSource(sub) {
-        if (sub) {
-            return node_path_1.default.resolve(this.config.src, sub);
-        }
+        if (sub) return external_node_path_default().resolve(this.config.src, sub);
         return this.config.src;
     }
     getDist(sub) {
-        if (sub) {
-            return node_path_1.default.resolve(this.config.dist, sub);
-        }
+        if (sub) return external_node_path_default().resolve(this.config.dist, sub);
         return this.config.dist;
     }
     getTemp(sub) {
-        if (!this.config.temp)
-            return null;
-        if (sub) {
-            return node_path_1.default.resolve(this.config.temp, sub);
-        }
+        if (!this.config.temp) return null;
+        if (sub) return external_node_path_default().resolve(this.config.temp, sub);
         return this.config.temp;
     }
     getCompiler() {
-        if (!this.compiler) {
-            this.compiler = new compiler_1.TestCompilerManager(this);
-        }
+        if (!this.compiler) this.compiler = new external_compiler_js_namespaceObject.TestCompilerManager(this);
         return this.compiler;
     }
     getRunner(file, env) {
-        if (!this.config.runnerCreator) {
-            throw new Error('TestContext: Runner creator not found');
-        }
+        if (!this.config.runnerCreator) throw new Error('TestContext: Runner creator not found');
         const runnerKey = this.config.runnerCreator.key(this, this.config.name, file);
         let runner = this.runners.get(runnerKey);
         if (runner) {
             if (__DEBUG__) {
-                const getRunnerInfo = this.getValue(debug_1.DEBUG_SCOPES.RunGetRunner) || {};
+                const getRunnerInfo = this.getValue(external_debug_js_namespaceObject.DEBUG_SCOPES.RunGetRunner) || {};
                 getRunnerInfo[file] = {
                     runnerKey,
                     reused: true,
-                    runnerType: runner.constructor.name,
+                    runnerType: runner.constructor.name
                 };
-                this.setValue(debug_1.DEBUG_SCOPES.RunGetRunner, getRunnerInfo);
+                this.setValue(external_debug_js_namespaceObject.DEBUG_SCOPES.RunGetRunner, getRunnerInfo);
             }
             return runner;
         }
         runner = this.config.runnerCreator.runner(this, this.config.name, file, env);
         runner.__key__ = runnerKey;
         if (__DEBUG__) {
-            const getRunnerInfo = this.getValue(debug_1.DEBUG_SCOPES.RunGetRunner) || {};
+            const getRunnerInfo = this.getValue(external_debug_js_namespaceObject.DEBUG_SCOPES.RunGetRunner) || {};
             getRunnerInfo[file] = {
                 runnerKey,
                 reused: false,
-                runnerType: runner.constructor.name,
+                runnerType: runner.constructor.name
             };
-            this.setValue(debug_1.DEBUG_SCOPES.RunGetRunner, getRunnerInfo);
+            this.setValue(external_debug_js_namespaceObject.DEBUG_SCOPES.RunGetRunner, getRunnerInfo);
         }
         this.runners.set(runnerKey, runner);
         return runner;
@@ -86,7 +108,7 @@ class TestContext {
         return this.errors.length > 0;
     }
     emitError(err) {
-        this.errors.push(typeof err === 'string' ? new Error(err) : err);
+        this.errors.push('string' == typeof err ? new Error(err) : err);
     }
     getError() {
         return this.errors;
@@ -95,9 +117,13 @@ class TestContext {
         this.errors.length = 0;
     }
     async closeCompiler() {
-        if (this.compiler) {
-            await this.compiler.close();
-        }
+        if (this.compiler) await this.compiler.close();
     }
 }
-exports.TestContext = TestContext;
+exports.TestContext = __webpack_exports__.TestContext;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "TestContext"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/test/creator.js

@@ -1,107 +1,105 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BasicCaseCreator = void 0;
-const node_fs_1 = __importDefault(require("node:fs"));
-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");
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    BasicCaseCreator: ()=>BasicCaseCreator
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_rimraf_namespaceObject = require("rimraf");
+const createLazyTestEnv_js_namespaceObject = require("../helper/legacy/createLazyTestEnv.js");
+const external_tester_js_namespaceObject = require("./tester.js");
 const DEFAULT_MAX_CONCURRENT = Number(process.env.DEFAULT_MAX_CONCURRENT) || 5;
 class BasicCaseCreator {
-    constructor(_options) {
+    _options;
+    currentConcurrent = 0;
+    tasks = [];
+    constructor(_options){
         this._options = _options;
-        this.currentConcurrent = 0;
-        this.tasks = [];
     }
     create(name, src, dist, temp, caseOptions) {
         const options = {
             ...this._options,
-            ...caseOptions,
+            ...caseOptions
         };
         const testConfig = this.readTestConfig(src);
-        if (typeof options.testConfig === 'function') {
-            options.testConfig(testConfig);
-        }
+        if ('function' == typeof options.testConfig) options.testConfig(testConfig);
         const skipped = this.checkSkipped(src, testConfig, options);
-        if (skipped) {
-            this.skip(name, skipped);
-            return;
-        }
-        if (options.clean) {
-            this.clean([dist, temp || ''].filter(Boolean));
-        }
+        if (skipped) return void this.skip(name, skipped);
+        if (options.clean) this.clean([
+            dist,
+            temp || ''
+        ].filter(Boolean));
         const run = this.shouldRun(name);
         const tester = this.createTester(name, src, dist, temp, testConfig, options);
         const concurrent = testConfig.concurrent || options.concurrent;
-        if (options.describe) {
-            if (run) {
-                if (concurrent) {
-                    describe(name, () => this.describeConcurrent(name, tester, testConfig, options));
-                }
-                else {
-                    describe(name, () => this.describe(name, tester, testConfig, options));
-                }
-            }
-            else {
-                describe.skip(name, () => {
-                    it.skip('skipped', () => { });
-                });
-            }
-        }
-        else {
-            if (run) {
-                if (concurrent) {
-                    this.describeConcurrent(name, tester, testConfig, options);
-                }
-                else {
-                    this.describe(name, tester, testConfig, options);
-                }
-            }
-            else {
-                it.skip('skipped', () => { });
-            }
-        }
+        if (options.describe) if (run) concurrent ? describe(name, ()=>this.describeConcurrent(name, tester, testConfig, options)) : describe(name, ()=>this.describe(name, tester, testConfig, options));
+        else describe.skip(name, ()=>{
+            it.skip('skipped', ()=>{});
+        });
+        else if (run) if (concurrent) this.describeConcurrent(name, tester, testConfig, options);
+        else this.describe(name, tester, testConfig, options);
+        else it.skip('skipped', ()=>{});
         return tester;
     }
     shouldRun(name) {
-        // TODO: more flexible filter
-        if (typeof global.testFilter !== 'string' || !global.testFilter) {
-            return true;
-        }
+        if ('string' != typeof global.testFilter || !global.testFilter) return true;
         return name.includes(global.testFilter);
     }
     describeConcurrent(name, tester, testConfig, options) {
-        beforeAll(async () => {
+        beforeAll(async ()=>{
             await tester.prepare();
         });
         let starter = null;
-        let chain = new Promise((resolve, reject) => {
+        let chain = new Promise((resolve, reject)=>{
             starter = resolve;
         });
         const ender = this.registerConcurrentTask(name, starter, options.concurrent);
         const env = this.createConcurrentEnv();
-        for (let index = 0; index < tester.total; index++) {
+        for(let index = 0; index < tester.total; index++){
             let stepSignalResolve = null;
-            const stepSignal = new Promise((resolve, reject) => {
+            const stepSignal = new Promise((resolve, reject)=>{
                 stepSignalResolve = resolve;
-            }).catch(() => {
-                // prevent unhandled rejection
-            });
-            const description = typeof options.description === 'function'
-                ? options.description(name, index)
-                : index
-                    ? `step [${index}] should pass`
-                    : 'should pass';
-            it(description, async () => {
+            }).catch(()=>{});
+            const description = 'function' == typeof options.description ? options.description(name, index) : index ? `step [${index}] should pass` : 'should pass';
+            it(description, async ()=>{
                 const e = await stepSignal;
-                if (e) {
-                    throw e;
-                }
+                if (e) throw e;
             }, options.timeout);
-            chain = chain.then(async () => {
+            chain = chain.then(async ()=>{
                 try {
                     env.clear();
                     await tester.compile();
@@ -110,70 +108,52 @@ class BasicCaseCreator {
                     await tester.after();
                     const context = tester.getContext();
                     if (!tester.next() && context.hasError()) {
-                        const errors = context
-                            .getError()
-                            .map((i) => `${i.stack}`.split('\n').join('\t\n'))
-                            .join('\n\n');
+                        const errors = context.getError().map((i)=>`${i.stack}`.split('\n').join('\t\n')).join('\n\n');
                         throw new Error(`Case "${name}" failed at step ${tester.step + 1}:\n${errors}`);
                     }
                     stepSignalResolve();
-                }
-                catch (e) {
+                } catch (e) {
                     stepSignalResolve(e);
                     return Promise.reject();
                 }
-            }, () => {
-                // bailout
+            }, ()=>{
                 stepSignalResolve();
                 return Promise.reject();
             });
         }
-        chain
-            .catch(() => {
-            // bailout error
-            // prevent unhandled rejection
-        })
-            .finally(() => {
+        chain.catch(()=>{}).finally(()=>{
             ender();
         });
-        afterAll(async () => {
+        afterAll(async ()=>{
             await tester.resume();
         });
     }
     describe(name, tester, testConfig, options) {
-        beforeAll(async () => {
+        beforeAll(async ()=>{
             await tester.prepare();
         });
         let bailout = false;
-        for (let index = 0; index < tester.total; index++) {
-            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`;
-                }
+        for(let index = 0; index < tester.total; index++){
+            const description = 'function' == typeof options.description ? 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`;
                 const context = tester.getContext();
                 try {
                     await tester.compile();
-                }
-                catch (e) {
+                } catch (e) {
                     bailout = true;
                     context.emitError(e);
                 }
                 await tester.check(env);
                 if (!tester.next() && context.hasError()) {
                     bailout = true;
-                    const errors = context
-                        .getError()
-                        .map((i) => `${i.stack}`.split('\n').join('\t\n'))
-                        .join('\n\n');
+                    const errors = context.getError().map((i)=>`${i.stack}`.split('\n').join('\t\n')).join('\n\n');
                     throw new Error(`Case "${name}" failed at step ${tester.step + 1}:\n${errors}`);
                 }
             }, options.timeout || 60000);
             const env = this.createEnv(testConfig, options);
         }
-        afterAll(async () => {
+        afterAll(async ()=>{
             await tester.resume();
         });
     }
@@ -182,106 +162,86 @@ class BasicCaseCreator {
         const beforeTasks = [];
         const afterTasks = [];
         return {
-            clear: () => {
+            clear: ()=>{
                 tasks.length = 0;
                 beforeTasks.length = 0;
                 afterTasks.length = 0;
             },
-            run: async () => {
-                const runFn = async (fn) => {
-                    if (fn.length) {
-                        await new Promise((resolve, reject) => {
-                            fn((e) => {
-                                if (e) {
-                                    reject(e);
-                                }
-                                else {
-                                    resolve();
-                                }
-                            });
+            run: async ()=>{
+                const runFn = async (fn)=>{
+                    if (fn.length) await new Promise((resolve, reject)=>{
+                        fn((e)=>{
+                            if (e) reject(e);
+                            else resolve();
                         });
-                    }
+                    });
                     else {
                         const res = fn();
-                        if (typeof res?.then === 'function') {
-                            await res;
-                        }
+                        if ('function' == typeof res?.then) await res;
                     }
                 };
-                for (const [description, fn] of tasks) {
-                    for (const before of beforeTasks) {
-                        await runFn(before);
-                    }
+                for (const [description, fn] of tasks){
+                    for (const before of beforeTasks)await runFn(before);
                     try {
                         await runFn(fn);
-                    }
-                    catch (err) {
+                    } 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);
-                    }
+                    for (const after of afterTasks)await runFn(after);
                 }
             },
             expect,
-            it: (description, fn) => {
-                expect(typeof description === 'string');
-                expect(typeof fn === 'function');
-                tasks.push([description, fn]);
+            it: (description, fn)=>{
+                expect('string' == typeof description);
+                expect('function' == typeof fn);
+                tasks.push([
+                    description,
+                    fn
+                ]);
             },
-            beforeEach: (fn) => {
-                expect(typeof fn === 'function');
+            beforeEach: (fn)=>{
+                expect('function' == typeof fn);
                 beforeTasks.push(fn);
             },
-            afterEach: (fn) => {
-                expect(typeof fn === 'function');
+            afterEach: (fn)=>{
+                expect('function' == typeof fn);
                 afterTasks.push(fn);
             },
-            rstest,
+            rstest
         };
     }
     createEnv(testConfig, options) {
-        if (options.runner && !testConfig.noTests) {
-            return (0, createLazyTestEnv_1.default)(10000);
-        }
+        if (options.runner && !testConfig.noTests) return (0, createLazyTestEnv_js_namespaceObject.createLazyTestEnv)(10000);
         return {
             expect,
             it,
             beforeEach,
             afterEach,
-            rstest,
+            rstest
         };
     }
     clean(folders) {
-        for (const f of folders) {
-            (0, rimraf_1.rimrafSync)(f);
-        }
+        for (const f of folders)(0, external_rimraf_namespaceObject.rimrafSync)(f);
     }
     skip(name, reason) {
-        it(typeof reason === 'string' ? `filtered by ${reason}` : 'filtered', () => { });
+        it('string' == typeof reason ? `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) : {};
+        const testConfigFile = external_node_path_default().join(src, 'test.config.js');
+        return external_node_fs_default().existsSync(testConfigFile) ? require(testConfigFile) : {};
     }
     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 filterPath = external_node_path_default().join(src, 'test.filter.js');
+        if (!external_node_fs_default().existsSync(filterPath)) return false;
         const filtered = require(filterPath)(options, testConfig);
-        if (typeof filtered === 'string' || Array.isArray(filtered)) {
-            return true;
-        }
+        if ('string' == typeof filtered || Array.isArray(filtered)) return true;
         return !filtered;
     }
     createTester(name, src, dist, temp, testConfig, options) {
-        return new tester_1.Tester({
+        return new external_tester_js_namespaceObject.Tester({
             name,
             src,
             dist,
@@ -295,28 +255,36 @@ class BasicCaseCreator {
                 name,
                 src,
                 dist,
-                temp,
-            }),
+                temp
+            })
         });
     }
     tryRunTask(concurrent) {
-        while (this.tasks.length !== 0 &&
-            this.currentConcurrent < this.getMaxConcurrent(concurrent)) {
+        while(0 !== this.tasks.length && this.currentConcurrent < this.getMaxConcurrent(concurrent)){
             const [_name, starter] = this.tasks.shift();
             this.currentConcurrent++;
             starter();
         }
     }
     getMaxConcurrent(concurrent) {
-        return typeof concurrent === 'number' ? concurrent : DEFAULT_MAX_CONCURRENT;
+        return 'number' == typeof concurrent ? concurrent : DEFAULT_MAX_CONCURRENT;
     }
     registerConcurrentTask(name, starter, concurrent) {
-        this.tasks.push([name, starter]);
+        this.tasks.push([
+            name,
+            starter
+        ]);
         this.tryRunTask(concurrent);
-        return () => {
+        return ()=>{
             this.currentConcurrent--;
             this.tryRunTask(concurrent);
         };
     }
 }
-exports.BasicCaseCreator = BasicCaseCreator;
+exports.BasicCaseCreator = __webpack_exports__.BasicCaseCreator;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BasicCaseCreator"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});