@rspack/test-tools 2.0.2 → 2.0.3

package/dist/case/diagnostic.js

@@ -1,60 +1,87 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDiagnosticCase = createDiagnosticCase;
-const node_assert_1 = __importDefault(require("node:assert"));
-const node_path_1 = __importDefault(require("node:path"));
-const rspack_merge_1 = __importDefault(require("rspack-merge"));
-const helper_1 = require("../helper");
-const placeholder_1 = require("../helper/expect/placeholder");
-const creator_1 = require("../test/creator");
-const creator = new creator_1.BasicCaseCreator({
+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__, {
+    createDiagnosticCase: ()=>createDiagnosticCase
+});
+const external_node_assert_namespaceObject = require("node:assert");
+var external_node_assert_default = /*#__PURE__*/ __webpack_require__.n(external_node_assert_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_rspack_merge_namespaceObject = require("rspack-merge");
+var external_rspack_merge_default = /*#__PURE__*/ __webpack_require__.n(external_rspack_merge_namespaceObject);
+const index_js_namespaceObject = require("../helper/index.js");
+const placeholder_js_namespaceObject = require("../helper/expect/placeholder.js");
+const creator_js_namespaceObject = require("../test/creator.js");
+const creator = new creator_js_namespaceObject.BasicCaseCreator({
     clean: true,
     describe: false,
-    steps: ({ name }) => [
-        {
-            config: async (context) => {
-                const compiler = context.getCompiler();
-                let options = defaultOptions(context);
-                const custom = (0, helper_1.readConfigFile)(['rspack.config.js', 'webpack.config.js'].map((i) => context.getSource(i)), context, options)[0];
-                if (custom) {
-                    options = (0, rspack_merge_1.default)(options, custom);
-                }
-                if (!global.printLogger) {
-                    options.infrastructureLogging = {
-                        level: 'error',
+    steps: ({ name })=>[
+            {
+                config: (context)=>{
+                    const compiler = context.getCompiler();
+                    let options = defaultOptions(context);
+                    const custom = (0, index_js_namespaceObject.readConfigFile)([
+                        'rspack.config.js',
+                        'webpack.config.js'
+                    ].map((i)=>context.getSource(i)), context, options)[0];
+                    if (custom) options = external_rspack_merge_default()(options, custom);
+                    if (!global.printLogger) options.infrastructureLogging = {
+                        level: 'error'
                     };
+                    compiler.setOptions(options);
+                },
+                compiler: (context)=>{
+                    const compiler = context.getCompiler();
+                    compiler.createCompiler();
+                },
+                build: async (context)=>{
+                    const compiler = context.getCompiler();
+                    await compiler.build();
+                },
+                run: async (env, context)=>{},
+                check: async (env, context)=>{
+                    await check(env, context, name, {
+                        snapshot: './stats.err',
+                        snapshotErrors: './raw-error.err',
+                        snapshotWarning: './raw-warning.err',
+                        format: (output)=>output.replace(/(│.* at ).*/g, '$1xxx')
+                    });
                 }
-                compiler.setOptions(options);
-            },
-            compiler: async (context) => {
-                const compiler = context.getCompiler();
-                compiler.createCompiler();
-            },
-            build: async (context) => {
-                const compiler = context.getCompiler();
-                await compiler.build();
-            },
-            run: async (env, context) => {
-                // no need to run, just check the snapshot of diagnostics
-            },
-            check: async (env, context) => {
-                await check(env, context, name, {
-                    snapshot: './stats.err',
-                    snapshotErrors: './raw-error.err',
-                    snapshotWarning: './raw-warning.err',
-                    format: (output) => {
-                        // TODO: change to stats.errorStack
-                        // TODO: add `errorStack: false`
-                        return output.replace(/(│.* at ).*/g, '$1xxx');
-                    },
-                });
-            },
-        },
-    ],
-    concurrent: true,
+            }
+        ],
+    concurrent: true
 });
 function createDiagnosticCase(name, src, dist) {
     creator.create(name, src, dist);
@@ -64,76 +91,77 @@ function defaultOptions(context) {
         target: 'node',
         context: context.getSource(),
         entry: {
-            main: './',
+            main: './'
         },
         module: {
             defaultRules: [
                 '...',
                 {
                     test: /\.css/,
-                    type: 'css/auto',
-                },
-            ],
+                    type: 'css/auto'
+                }
+            ]
         },
         mode: 'development',
         devServer: {
-            hot: false,
+            hot: false
         },
         infrastructureLogging: {
-            debug: false,
+            debug: false
         },
         output: {
             path: context.getDist(),
             bundlerInfo: {
-                force: false,
-            },
-        },
+                force: false
+            }
+        }
     };
 }
-async function check(env, context, name, options) {
+function check(env, context, name, options) {
     const compiler = context.getCompiler();
     const stats = compiler.getStats();
-    if (!stats) {
-        throw new Error('Stats should exists');
-    }
-    (0, node_assert_1.default)(stats.hasErrors() || stats.hasWarnings());
-    let output = (0, placeholder_1.normalizePlaceholder)(stats.toString({
+    if (!stats) throw new Error('Stats should exists');
+    external_node_assert_default()(stats.hasErrors() || stats.hasWarnings());
+    let output = (0, placeholder_js_namespaceObject.normalizePlaceholder)(stats.toString({
         all: false,
         errors: true,
-        warnings: true,
+        warnings: true
     })).replaceAll('\\', '/');
     const statsJson = stats.toJson({
         all: false,
         errors: true,
-        warnings: true,
+        warnings: true
     });
-    const errors = (statsJson.errors || []).map((e) => {
-        // @ts-expect-error error message is already serialized in `stats.err`
+    const errors = (statsJson.errors || []).map((e)=>{
         delete e.message;
         delete e.stack;
         return e;
     });
-    const warnings = (statsJson.warnings || []).map((e) => {
-        // @ts-expect-error error message is already serialized in `stats.err`
+    const warnings = (statsJson.warnings || []).map((e)=>{
         delete e.message;
         delete e.stack;
         return e;
     });
-    if (typeof options.format === 'function') {
-        output = options.format(output);
-    }
+    if ('function' == typeof options.format) output = options.format(output);
     env.expect.addSnapshotSerializer({
-        test(received) {
-            return typeof received === 'string';
-        },
-        serialize(received) {
-            return (0, placeholder_1.normalizePlaceholder)(received.trim());
+        test (received) {
+            return 'string' == typeof received;
         },
+        serialize (received) {
+            return (0, placeholder_js_namespaceObject.normalizePlaceholder)(received.trim());
+        }
     });
-    const errorOutputPath = node_path_1.default.resolve(context.getSource(options.snapshot));
-    const errorStatsOutputPath = node_path_1.default.resolve(context.getSource(options.snapshotErrors));
-    const warningStatsOutputPath = node_path_1.default.resolve(context.getSource(options.snapshotWarning));
+    const errorOutputPath = external_node_path_default().resolve(context.getSource(options.snapshot));
+    const errorStatsOutputPath = external_node_path_default().resolve(context.getSource(options.snapshotErrors));
+    const warningStatsOutputPath = external_node_path_default().resolve(context.getSource(options.snapshotWarning));
     env.expect(output).toMatchFileSnapshotSync(errorOutputPath);
     env.expect(errors).toMatchFileSnapshotSync(errorStatsOutputPath);
     env.expect(warnings).toMatchFileSnapshotSync(warningStatsOutputPath);
 }
+exports.createDiagnosticCase = __webpack_exports__.createDiagnosticCase;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createDiagnosticCase"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/case/error.d.ts

@@ -1,5 +1,5 @@
 import type { Compiler, RspackOptions, StatsError } from '@rspack/core';
-import type { ITestContext } from '../type';
+import type { ITestContext, MaybePromise } from '../type';
 export declare function createErrorCase(name: string, src: string, dist: string, testConfig: string): void;
 declare class RspackStatsDiagnostics {
     errors: StatsError[];
@@ -10,8 +10,8 @@ export type TErrorCaseConfig = {
     description: string;
     skip?: boolean;
     options?: (context: ITestContext) => RspackOptions;
-    compiler?: (context: ITestContext, compiler: Compiler) => Promise<void>;
-    build?: (context: ITestContext, compiler: Compiler) => Promise<void>;
-    check?: (stats: RspackStatsDiagnostics) => Promise<void>;
+    compiler?: (context: ITestContext, compiler: Compiler) => MaybePromise<void>;
+    build?: (context: ITestContext, compiler: Compiler) => MaybePromise<void>;
+    check?: (stats: RspackStatsDiagnostics) => MaybePromise<void>;
 };
 export {};

package/dist/case/error.js

@@ -1,139 +1,146 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createErrorCase = createErrorCase;
-const node_path_1 = __importDefault(require("node:path"));
-const rspack_merge_1 = __importDefault(require("rspack-merge"));
-const creator_1 = require("../test/creator");
+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__, {
+    createErrorCase: ()=>createErrorCase
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_rspack_merge_namespaceObject = require("rspack-merge");
+var external_rspack_merge_default = /*#__PURE__*/ __webpack_require__.n(external_rspack_merge_namespaceObject);
+const creator_js_namespaceObject = require("../test/creator.js");
 let addedSerializer = false;
-const creator = new creator_1.BasicCaseCreator({
+const creator = new creator_js_namespaceObject.BasicCaseCreator({
     clean: true,
     describe: true,
-    steps: ({ name, caseConfig }) => {
+    steps: ({ name, caseConfig })=>{
         const config = caseConfig;
         return [
             {
-                config: async (context) => {
+                config: (context)=>{
                     const compiler = context.getCompiler();
-                    compiler.setOptions(options(context, config.options));
+                    compiler.setOptions(error_options(context, config.options));
                 },
-                compiler: async (context) => {
+                compiler: async (context)=>{
                     const compilerManager = context.getCompiler();
                     compilerManager.createCompiler();
-                    compiler(context, compilerManager.getCompiler(), config.compiler);
+                    await error_compiler(context, compilerManager.getCompiler(), config.compiler);
                 },
-                build: async (context) => {
+                build: async (context)=>{
                     const compiler = context.getCompiler();
-                    if (typeof config.build === 'function') {
-                        await config.build(context, compiler.getCompiler());
-                    }
-                    else {
-                        await compiler.build();
-                    }
+                    if ('function' == typeof config.build) await config.build(context, compiler.getCompiler());
+                    else await compiler.build();
                 },
-                run: async (env, context) => {
-                    // no need to run, just check the snapshot of diagnostics
-                },
-                check: async (env, context) => {
-                    await check(env, context, name, config.check);
-                },
-            },
+                run: async (env, context)=>{},
+                check: async (env, context)=>{
+                    await error_check(env, context, name, config.check);
+                }
+            }
         ];
     },
-    concurrent: true,
+    concurrent: true
 });
 function createErrorCase(name, src, dist, testConfig) {
-    if (!addedSerializer) {
-        addedSerializer = true;
-    }
+    if (!addedSerializer) addedSerializer = true;
     const caseConfigList = require(testConfig);
     function createCase(caseConfig) {
-        if (caseConfig.skip) {
-            it.skip(name, () => { });
-            return;
-        }
-        creator.create(name, src, dist, undefined, {
+        if (caseConfig.skip) return void it.skip(name, ()=>{});
+        creator.create(name, src, dist, void 0, {
             caseConfig,
-            description: () => caseConfig.description,
+            description: ()=>caseConfig.description
         });
     }
-    if (Array.isArray(caseConfigList)) {
-        for (const caseConfig of caseConfigList) {
-            createCase(caseConfig);
-        }
-    }
-    else {
-        createCase(caseConfigList);
-    }
+    if (Array.isArray(caseConfigList)) for (const caseConfig of caseConfigList)createCase(caseConfig);
+    else createCase(caseConfigList);
 }
-function options(context, custom) {
+function error_options(context, custom) {
     let options = {
-        context: node_path_1.default.resolve(__TEST_FIXTURES_PATH__, 'errors'),
+        context: external_node_path_default().resolve(__TEST_FIXTURES_PATH__, 'errors'),
         mode: 'none',
         devtool: false,
         optimization: {
             minimize: false,
             moduleIds: 'named',
-            chunkIds: 'named',
+            chunkIds: 'named'
         },
         module: {
             defaultRules: [
                 {
                     test: /\.css$/i,
-                    type: 'css/auto',
-                },
-            ],
+                    type: 'css/auto'
+                }
+            ]
         },
         otuput: {
             bundlerInfo: {
-                force: false,
-            },
-        },
+                force: false
+            }
+        }
+    };
+    if ('function' == typeof custom) options = external_rspack_merge_default()(options, custom(context, options));
+    if ('production' === options.mode) if (options.optimization) options.optimization.minimize = true;
+    else options.optimization = {
+        minimize: true
     };
-    if (typeof custom === 'function') {
-        options = (0, rspack_merge_1.default)(options, custom(context, options));
-    }
-    if (options.mode === 'production') {
-        if (options.optimization)
-            options.optimization.minimize = true;
-        else
-            options.optimization = { minimize: true };
-    }
     return options;
 }
-async function compiler(context, compiler, custom) {
-    if (compiler) {
-        compiler.outputFileSystem = {
-            // CHANGE: rspack outputFileSystem `mkdirp` uses option `{ recursive: true }`, webpack's second parameter is alway a callback
-            mkdir(dir, maybeOptionOrCallback, maybeCallback) {
-                if (typeof maybeOptionOrCallback === 'function') {
-                    maybeOptionOrCallback();
-                }
-                else if (typeof maybeCallback === 'function') {
-                    maybeCallback();
-                }
-            },
-            writeFile(file, content, callback) {
-                callback();
-            },
-            stat(file, callback) {
-                callback(new Error('ENOENT'));
-            },
-            mkdirSync() { },
-            writeFileSync() { },
-        };
-    }
+async function error_compiler(context, compiler, custom) {
+    if (compiler) compiler.outputFileSystem = {
+        mkdir (dir, maybeOptionOrCallback, maybeCallback) {
+            if ('function' == typeof maybeOptionOrCallback) maybeOptionOrCallback();
+            else if ('function' == typeof maybeCallback) maybeCallback();
+        },
+        writeFile (file, content, callback) {
+            callback();
+        },
+        stat (file, callback) {
+            callback(new Error('ENOENT'));
+        },
+        mkdirSync () {},
+        writeFileSync () {}
+    };
     await custom?.(context, compiler);
 }
 class RspackStatsDiagnostics {
-    constructor(errors, warnings) {
+    errors;
+    warnings;
+    constructor(errors, warnings){
         this.errors = errors;
         this.warnings = warnings;
     }
 }
-async function check(env, context, name, check) {
+async function error_check(env, context, name, check) {
     if (context.getError().length > 0) {
         await check?.(new RspackStatsDiagnostics(context.getError(), []));
         context.clearError();
@@ -142,10 +149,19 @@ async function check(env, context, name, check) {
     const compiler = context.getCompiler();
     const stats = compiler.getStats();
     env.expect(typeof stats).toBe('object');
-    const statsResult = stats.toJson({ errorDetails: false });
+    const statsResult = stats.toJson({
+        errorDetails: false
+    });
     env.expect(typeof statsResult).toBe('object');
     const { errors, warnings } = statsResult;
     env.expect(Array.isArray(errors)).toBe(true);
     env.expect(Array.isArray(warnings)).toBe(true);
     await check?.(new RspackStatsDiagnostics(errors, warnings));
 }
+exports.createErrorCase = __webpack_exports__.createErrorCase;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createErrorCase"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});