@rspack/test-tools 2.0.2 → 2.0.4

package/dist/case/normal.js

@@ -1,213 +1,281 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __webpack_modules__ = {
+    "terser-webpack-plugin" (module) {
+        module.exports = require("terser-webpack-plugin");
+    }
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNormalCase = createNormalCase;
-exports.createHotNormalCase = createHotNormalCase;
-exports.createDevNormalCase = createDevNormalCase;
-exports.createProdNormalCase = createProdNormalCase;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const core_1 = require("@rspack/core");
-const creator_1 = require("../test/creator");
-const common_1 = require("./common");
-const runner_1 = require("./runner");
-const NORMAL_CASES_ROOT = node_path_1.default.resolve(__TEST_PATH__, 'normalCases');
-const createCaseOptions = (hot, mode) => {
-    return {
-        clean: true,
-        describe: false,
-        steps: ({ name }) => [
-            {
-                config: async (context) => {
-                    const compiler = context.getCompiler();
-                    let options = defaultOptions(context, {
-                        plugins: hot ? [new core_1.HotModuleReplacementPlugin()] : [],
-                    }, mode);
-                    options = await (0, common_1.config)(context, name, ['rspack.config.js', 'webpack.config.js'], options);
-                    overrideOptions(context, options);
-                    compiler.setOptions(options);
-                },
-                compiler: async (context) => {
-                    await (0, common_1.compiler)(context, name);
-                },
-                build: async (context) => {
-                    await (0, common_1.build)(context, name);
-                },
-                run: async (env, context) => {
-                    await (0, common_1.run)(env, context, name, findBundle);
-                },
-                check: async (env, context) => {
-                    await (0, common_1.check)(env, context, name);
-                },
-                after: async (context) => {
-                    await (0, common_1.afterExecute)(context, name);
-                },
-            },
-        ],
-        runner: {
-            key: (context, name, file) => name,
-            runner: runner_1.createRunner,
-        },
-        concurrent: true,
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
     };
-};
-const creator = new creator_1.BasicCaseCreator(createCaseOptions(false));
-function createNormalCase(name, src, dist) {
-    creator.create(name, src, dist);
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
 }
-const hotCreator = new creator_1.BasicCaseCreator(createCaseOptions(true));
-function createHotNormalCase(name, src, dist) {
-    hotCreator.create(name, src, dist);
-}
-const devCreator = new creator_1.BasicCaseCreator(createCaseOptions(false, 'development'));
-function createDevNormalCase(name, src, dist) {
-    devCreator.create(name, src, dist);
-}
-const prodCreator = new creator_1.BasicCaseCreator(createCaseOptions(false, 'production'));
-function createProdNormalCase(name, src, dist) {
-    prodCreator.create(name, src, dist);
-}
-function findBundle(context, options) {
-    const testConfig = context.getTestConfig();
-    if (typeof testConfig.findBundle === 'function') {
-        return testConfig.findBundle(0, options);
+(()=>{
+    __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__, {
+        createDevNormalCase: ()=>createDevNormalCase,
+        createHotNormalCase: ()=>createHotNormalCase,
+        createNormalCase: ()=>createNormalCase,
+        createProdNormalCase: ()=>createProdNormalCase
+    });
+    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 core_namespaceObject = require("@rspack/core");
+    const creator_js_namespaceObject = require("../test/creator.js");
+    const external_common_js_namespaceObject = require("./common.js");
+    const external_runner_js_namespaceObject = require("./runner.js");
+    const NORMAL_CASES_ROOT = external_node_path_default().resolve(__TEST_PATH__, 'normalCases');
+    const createCaseOptions = (hot, mode)=>({
+            clean: true,
+            describe: false,
+            steps: ({ name })=>[
+                    {
+                        config: async (context)=>{
+                            const compiler = context.getCompiler();
+                            let options = defaultOptions(context, {
+                                plugins: hot ? [
+                                    new core_namespaceObject.HotModuleReplacementPlugin()
+                                ] : []
+                            }, mode);
+                            options = await (0, external_common_js_namespaceObject.config)(context, name, [
+                                'rspack.config.js',
+                                'webpack.config.js'
+                            ], options);
+                            overrideOptions(context, options);
+                            compiler.setOptions(options);
+                        },
+                        compiler: async (context)=>{
+                            await (0, external_common_js_namespaceObject.compiler)(context, name);
+                        },
+                        build: async (context)=>{
+                            await (0, external_common_js_namespaceObject.build)(context, name);
+                        },
+                        run: async (env, context)=>{
+                            await (0, external_common_js_namespaceObject.run)(env, context, name, findBundle);
+                        },
+                        check: async (env, context)=>{
+                            await (0, external_common_js_namespaceObject.check)(env, context, name);
+                        },
+                        after: async (context)=>{
+                            await (0, external_common_js_namespaceObject.afterExecute)(context, name);
+                        }
+                    }
+                ],
+            runner: {
+                key: (context, name, file)=>name,
+                runner: external_runner_js_namespaceObject.createRunner
+            },
+            concurrent: true
+        });
+    const creator = new creator_js_namespaceObject.BasicCaseCreator(createCaseOptions(false));
+    function createNormalCase(name, src, dist) {
+        creator.create(name, src, dist);
     }
-    const filename = options.output?.filename;
-    return typeof filename === 'string' ? filename : undefined;
-}
-function defaultOptions(context, compilerOptions, mode) {
-    let testConfig = {};
-    const testConfigPath = node_path_1.default.join(context.getSource(), 'test.config.js');
-    if (node_fs_1.default.existsSync(testConfigPath)) {
-        testConfig = require(testConfigPath);
+    const hotCreator = new creator_js_namespaceObject.BasicCaseCreator(createCaseOptions(true));
+    function createHotNormalCase(name, src, dist) {
+        hotCreator.create(name, src, dist);
     }
-    const TerserPlugin = require('terser-webpack-plugin');
-    const terserForTesting = new TerserPlugin({
-        parallel: false,
-    });
-    return {
-        amd: {},
-        context: NORMAL_CASES_ROOT,
-        entry: `./${node_path_1.default.relative(NORMAL_CASES_ROOT, context.getSource())}/`,
-        target: compilerOptions?.target || 'async-node',
-        devtool: mode === 'development' ? false : compilerOptions?.devtool,
-        mode: compilerOptions?.mode || mode || 'none',
-        optimization: compilerOptions?.mode
-            ? {
+    const devCreator = new creator_js_namespaceObject.BasicCaseCreator(createCaseOptions(false, 'development'));
+    function createDevNormalCase(name, src, dist) {
+        devCreator.create(name, src, dist);
+    }
+    const prodCreator = new creator_js_namespaceObject.BasicCaseCreator(createCaseOptions(false, 'production'));
+    function createProdNormalCase(name, src, dist) {
+        prodCreator.create(name, src, dist);
+    }
+    function findBundle(context, options) {
+        const testConfig = context.getTestConfig();
+        if ('function' == typeof testConfig.findBundle) return testConfig.findBundle(0, options);
+        const filename = options.output?.filename;
+        return 'string' == typeof filename ? filename : void 0;
+    }
+    function defaultOptions(context, compilerOptions, mode) {
+        let testConfig = {};
+        const testConfigPath = external_node_path_default().join(context.getSource(), 'test.config.js');
+        if (external_node_fs_default().existsSync(testConfigPath)) testConfig = require(testConfigPath);
+        const TerserPlugin = __webpack_require__("terser-webpack-plugin");
+        const terserForTesting = new TerserPlugin({
+            parallel: false
+        });
+        return {
+            amd: {},
+            context: NORMAL_CASES_ROOT,
+            entry: `./${external_node_path_default().relative(NORMAL_CASES_ROOT, context.getSource())}/`,
+            target: compilerOptions?.target || 'async-node',
+            devtool: 'development' === mode ? false : compilerOptions?.devtool,
+            mode: compilerOptions?.mode || mode || 'none',
+            optimization: compilerOptions?.mode ? {
                 emitOnErrors: true,
-                minimizer: [terserForTesting],
+                minimizer: [
+                    terserForTesting
+                ],
                 minimize: false,
-                ...testConfig.optimization,
-            }
-            : {
+                ...testConfig.optimization
+            } : {
                 removeEmptyChunks: true,
                 mergeDuplicateChunks: true,
-                // CHANGE: rspack does not support `flagIncludedChunks` yet.
-                // flagIncludedChunks: true,
                 sideEffects: true,
                 providedExports: true,
                 usedExports: true,
                 mangleExports: true,
                 inlineExports: true,
-                // CHANGE: rspack does not support `emitOnErrors` yet.
                 emitOnErrors: true,
                 concatenateModules: !!testConfig?.optimization?.concatenateModules,
                 innerGraph: true,
-                // CHANGE: size is not supported yet
-                // moduleIds: "size",
-                // chunkIds: "size",
                 moduleIds: 'named',
                 chunkIds: 'named',
                 minimize: false,
-                minimizer: [terserForTesting],
-                ...compilerOptions?.optimization,
+                minimizer: [
+                    terserForTesting
+                ],
+                ...compilerOptions?.optimization
             },
-        // CHANGE: rspack does not support `performance` yet.
-        // performance: {
-        // 	hints: false
-        // },
-        node: {
-            __dirname: 'mock',
-            __filename: 'mock',
-        },
-        cache: compilerOptions?.cache && {
-            // cacheDirectory,
-            ...compilerOptions.cache,
-        },
-        output: {
-            pathinfo: 'verbose',
-            path: context.getDist(),
-            filename: compilerOptions?.module ? 'bundle.mjs' : 'bundle.js',
-            bundlerInfo: {
-                force: false,
+            node: {
+                __dirname: 'mock',
+                __filename: 'mock'
             },
-            ...(compilerOptions?.module ? { module: true } : {}),
-        },
-        resolve: {
-            modules: ['web_modules', 'node_modules'],
-            mainFields: ['webpack', 'browser', 'web', 'browserify', 'main'],
-            aliasFields: ['browser'],
-            extensions: ['.webpack.js', '.web.js', '.js', '.json'],
-        },
-        resolveLoader: {
-            modules: ['web_loaders', 'web_modules', 'node_loaders', 'node_modules'],
-            mainFields: ['webpackLoader', 'webLoader', 'loader', 'main'],
-            extensions: ['.webpack-loader.js', '.web-loader.js', '.loader.js', '.js'],
-        },
-        module: {
-            rules: [
-                {
-                    test: /\.coffee$/,
-                    loader: 'coffee-loader',
-                },
-                {
-                    test: /\.pug/,
-                    loader: '@webdiscus/pug-loader',
-                },
-                {
-                    test: /\.wat$/i,
-                    loader: 'wast-loader',
-                    type: 'webassembly/async',
-                },
-            ],
-            parser: {
-                javascript: {
-                    requireAlias: true,
+            cache: compilerOptions?.cache && {
+                ...compilerOptions.cache
+            },
+            output: {
+                pathinfo: 'verbose',
+                path: context.getDist(),
+                filename: compilerOptions?.module ? 'bundle.mjs' : 'bundle.js',
+                bundlerInfo: {
+                    force: false
                 },
+                ...compilerOptions?.module ? {
+                    module: true
+                } : {}
             },
-        },
-        plugins: (compilerOptions?.plugins || [])
-            .concat(testConfig.plugins || [])
-            .concat(function () {
-            this.hooks.compilation.tap('TestCasesTest', (compilation) => {
-                const hooks = [
-                // CHANGE: the following hooks are not supported yet, so comment it out
-                // "optimize",
-                // "optimizeModules",
-                // "optimizeChunks",
-                // "afterOptimizeTree",
-                // "afterOptimizeAssets"
-                ];
-                for (const hook of hooks) {
-                    compilation.hooks[hook].tap('TestCasesTest', () => compilation.checkConstraints());
+            resolve: {
+                modules: [
+                    'web_modules',
+                    'node_modules'
+                ],
+                mainFields: [
+                    'webpack',
+                    'browser',
+                    'web',
+                    'browserify',
+                    'main'
+                ],
+                aliasFields: [
+                    'browser'
+                ],
+                extensions: [
+                    '.webpack.js',
+                    '.web.js',
+                    '.js',
+                    '.json'
+                ]
+            },
+            resolveLoader: {
+                modules: [
+                    'web_loaders',
+                    'web_modules',
+                    'node_loaders',
+                    'node_modules'
+                ],
+                mainFields: [
+                    'webpackLoader',
+                    'webLoader',
+                    'loader',
+                    'main'
+                ],
+                extensions: [
+                    '.webpack-loader.js',
+                    '.web-loader.js',
+                    '.loader.js',
+                    '.js'
+                ]
+            },
+            module: {
+                rules: [
+                    {
+                        test: /\.coffee$/,
+                        loader: 'coffee-loader'
+                    },
+                    {
+                        test: /\.pug/,
+                        loader: '@webdiscus/pug-loader'
+                    },
+                    {
+                        test: /\.wat$/i,
+                        loader: 'wast-loader',
+                        type: 'webassembly/async'
+                    }
+                ],
+                parser: {
+                    javascript: {
+                        requireAlias: true
+                    }
                 }
-            });
-        }),
-        experiments: {
-            asyncWebAssembly: true,
-            // CHANGE: rspack does not support `backCompat` yet.
-            // backCompat: false,
-            // CHANGE: Rspack enables `css` by default.
-            // Turning off here to fallback to webpack's default css processing logic.
-        },
-    };
-}
-function overrideOptions(context, options) {
-    if (!global.printLogger) {
-        options.infrastructureLogging = {
-            level: 'error',
+            },
+            plugins: (compilerOptions?.plugins || []).concat(testConfig.plugins || []).concat(function() {
+                this.hooks.compilation.tap('TestCasesTest', (compilation)=>{
+                    const hooks = [];
+                    for (const hook of hooks)compilation.hooks[hook].tap('TestCasesTest', ()=>compilation.checkConstraints());
+                });
+            }),
+            experiments: {
+                asyncWebAssembly: true
+            }
         };
     }
-}
+    function overrideOptions(context, options) {
+        if (!global.printLogger) options.infrastructureLogging = {
+            level: 'error'
+        };
+    }
+})();
+exports.createDevNormalCase = __webpack_exports__.createDevNormalCase;
+exports.createHotNormalCase = __webpack_exports__.createHotNormalCase;
+exports.createNormalCase = __webpack_exports__.createNormalCase;
+exports.createProdNormalCase = __webpack_exports__.createProdNormalCase;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createDevNormalCase",
+    "createHotNormalCase",
+    "createNormalCase",
+    "createProdNormalCase"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/case/runner.js

@@ -1,26 +1,47 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cachedStats = cachedStats;
-exports.createRunner = createRunner;
-exports.getMultiCompilerRunnerKey = getMultiCompilerRunnerKey;
-exports.createMultiCompilerRunner = createMultiCompilerRunner;
-const runner_1 = require("../runner");
-const debug_1 = require("../test/debug");
-const isWebTarget = (compilerOptions) => {
+var __webpack_require__ = {};
+(()=>{
+    __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__, {
+    cachedStats: ()=>cachedStats,
+    createMultiCompilerRunner: ()=>createMultiCompilerRunner,
+    createRunner: ()=>createRunner,
+    getMultiCompilerRunnerKey: ()=>getMultiCompilerRunnerKey
+});
+const index_js_namespaceObject = require("../runner/index.js");
+const debug_js_namespaceObject = require("../test/debug.js");
+const isWebTarget = (compilerOptions)=>{
     const target = compilerOptions.target;
-    if (Array.isArray(target)) {
-        return target.some((t) => t === 'web' || t === 'webworker');
-    }
-    return target === 'web' || target === 'webworker';
+    if (Array.isArray(target)) return target.some((t)=>'web' === t || 'webworker' === t);
+    return 'web' === target || 'webworker' === target;
 };
 function cachedStats(context, name) {
     const compiler = context.getCompiler();
-    const statsGetter = (() => {
+    const statsGetter = (()=>{
         let cached = null;
-        return () => {
-            if (cached) {
-                return cached;
-            }
+        return ()=>{
+            if (cached) return cached;
             cached = compiler.getStats().toJson({
                 assets: true,
                 chunks: true,
@@ -28,7 +49,7 @@ function cachedStats(context, name) {
                 modules: true,
                 entrypoints: true,
                 chunkGroups: true,
-                errorDetails: true,
+                errorDetails: true
             });
             return cached;
         };
@@ -48,33 +69,33 @@ function createRunner(context, name, file, env) {
         testConfig: context.getTestConfig(),
         source: context.getSource(),
         dist: context.getDist(),
-        compilerOptions,
+        compilerOptions
     };
     const isWeb = isWebTarget(compilerOptions);
-    if (isWeb) {
-        return new runner_1.WebRunner({
-            ...runnerOptions,
-            runInNewContext: true,
-            location: testConfig.location || 'https://test.cases/path/index.html',
-        });
-    }
-    return new runner_1.NodeRunner(runnerOptions);
+    if (isWeb) return new index_js_namespaceObject.WebRunner({
+        ...runnerOptions,
+        runInNewContext: true,
+        location: testConfig.location || 'https://test.cases/path/index.html'
+    });
+    return new index_js_namespaceObject.NodeRunner(runnerOptions);
 }
 function getFileIndexHandler(context, name, file) {
     const multiFileIndexMap = context.getValue('multiFileIndexMap') || {};
     const runned = context.getValue('runned') || new Set();
-    if (typeof multiFileIndexMap[file] === 'undefined') {
-        throw new Error('Unexpect file in multiple runner');
-    }
+    if (void 0 === multiFileIndexMap[file]) throw new Error('Unexpect file in multiple runner');
     const indexList = multiFileIndexMap[file];
-    const seq = indexList.findIndex((index, n) => !runned.has(`${name}:${file}[${n}]`));
-    if (seq === -1) {
-        throw new Error(`File ${file} should run only ${indexList.length} times`);
-    }
-    const getIndex = () => [indexList[seq], seq];
-    const flagIndex = () => runned.add(`${name}:${file}[${seq}]`);
+    const seq = indexList.findIndex((index, n)=>!runned.has(`${name}:${file}[${n}]`));
+    if (-1 === seq) throw new Error(`File ${file} should run only ${indexList.length} times`);
+    const getIndex = ()=>[
+            indexList[seq],
+            seq
+        ];
+    const flagIndex = ()=>runned.add(`${name}:${file}[${seq}]`);
     context.setValue('runned', runned);
-    return { getIndex, flagIndex };
+    return {
+        getIndex,
+        flagIndex
+    };
 }
 function getMultiCompilerRunnerKey(context, name, file) {
     const { getIndex } = getFileIndexHandler(context, name, file);
@@ -87,14 +108,14 @@ function createMultiCompilerRunner(context, name, file, env) {
     const multiCompilerOptions = context.getValue('multiCompilerOptions') || [];
     const [index] = getIndex();
     const compilerOptions = multiCompilerOptions[index];
-    const logs = context.getValue(debug_1.DEBUG_SCOPES.RunLogs);
-    const errors = context.getValue(debug_1.DEBUG_SCOPES.RunErrors);
+    const logs = context.getValue(debug_js_namespaceObject.DEBUG_SCOPES.RunLogs);
+    const errors = context.getValue(debug_js_namespaceObject.DEBUG_SCOPES.RunErrors);
     let runner;
     const runnerOptions = {
         runInNewContext: false,
         cachable: true,
         env,
-        stats: () => {
+        stats: ()=>{
             const s = cachedStats(context, name)();
             if (s.children?.length && s.children.length > 1) {
                 s.__index__ = index;
@@ -108,19 +129,27 @@ function createMultiCompilerRunner(context, name, file, env) {
         dist: context.getDist(),
         compilerOptions,
         logs,
-        errors,
+        errors
     };
     const isWeb = isWebTarget(compilerOptions);
-    if (isWeb) {
-        runner = new runner_1.WebRunner({
-            ...runnerOptions,
-            runInNewContext: true,
-            location: testConfig.location || 'https://test.cases/path/index.html',
-        });
-    }
-    else {
-        runner = new runner_1.NodeRunner(runnerOptions);
-    }
+    runner = isWeb ? new index_js_namespaceObject.WebRunner({
+        ...runnerOptions,
+        runInNewContext: true,
+        location: testConfig.location || 'https://test.cases/path/index.html'
+    }) : new index_js_namespaceObject.NodeRunner(runnerOptions);
     flagIndex();
     return runner;
 }
+exports.cachedStats = __webpack_exports__.cachedStats;
+exports.createMultiCompilerRunner = __webpack_exports__.createMultiCompilerRunner;
+exports.createRunner = __webpack_exports__.createRunner;
+exports.getMultiCompilerRunnerKey = __webpack_exports__.getMultiCompilerRunnerKey;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "cachedStats",
+    "createMultiCompilerRunner",
+    "createRunner",
+    "getMultiCompilerRunnerKey"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});