@rspack/test-tools 2.0.1 → 2.0.3

package/dist/case/common.d.ts

@@ -1,11 +1,11 @@
 import type { Compiler, RspackOptions } from '@rspack/core';
 import type { ITestContext, ITestEnv } from '../type';
-export declare function config(context: ITestContext, name: string, configFiles: string[], defaultOptions?: RspackOptions): Promise<RspackOptions>;
-export declare function compiler(context: ITestContext, name: string): Promise<Compiler>;
+export declare function config(context: ITestContext, name: string, configFiles: string[], defaultOptions?: RspackOptions): RspackOptions;
+export declare function compiler(context: ITestContext, name: string): Compiler;
 export declare function build(context: ITestContext, name: string): Promise<Compiler>;
 export declare function run(env: ITestEnv, context: ITestContext, name: string, findBundle: (context: ITestContext, options: RspackOptions) => string[] | string | void): Promise<void>;
 export declare function check(env: ITestEnv, context: ITestContext, name: string): Promise<void>;
-export declare function checkSnapshot(env: ITestEnv, context: ITestContext, name: string, snapshot: string, filter?: (file: string) => boolean): Promise<void>;
-export declare function afterExecute(context: ITestContext, name: string): Promise<void>;
+export declare function checkSnapshot(env: ITestEnv, context: ITestContext, name: string, snapshot: string, filter?: (file: string) => boolean): void;
+export declare function afterExecute(context: ITestContext, name: string): void;
 export declare function findMultiCompilerBundle(context: ITestContext, name: string, multiFindBundle: (index: number, context: ITestContext, options: RspackOptions) => string[] | string | void): string[];
 export declare function configMultiCompiler(context: ITestContext, name: string, configFiles: string[], defaultOptions: (index: number, context: ITestContext) => RspackOptions, overrideOptions: (index: number, context: ITestContext, options: RspackOptions) => void): void;

package/dist/case/common.js

@@ -1,34 +1,68 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.config = config;
-exports.compiler = compiler;
-exports.build = build;
-exports.run = run;
-exports.check = check;
-exports.checkSnapshot = checkSnapshot;
-exports.afterExecute = afterExecute;
-exports.findMultiCompilerBundle = findMultiCompilerBundle;
-exports.configMultiCompiler = configMultiCompiler;
-const node_path_1 = __importDefault(require("node:path"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const webpack_merge_1 = __importDefault(require("webpack-merge"));
-const helper_1 = require("../helper");
-const placeholder_1 = require("../helper/expect/placeholder");
-const checkArrayExpectation_1 = __importDefault(require("../helper/legacy/checkArrayExpectation"));
-const debug_1 = require("../test/debug");
-async function config(context, name, configFiles, defaultOptions = {}) {
+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__, {
+    afterExecute: ()=>afterExecute,
+    build: ()=>build,
+    check: ()=>check,
+    checkSnapshot: ()=>checkSnapshot,
+    compiler: ()=>common_compiler,
+    config: ()=>config,
+    configMultiCompiler: ()=>configMultiCompiler,
+    findMultiCompilerBundle: ()=>findMultiCompilerBundle,
+    run: ()=>run
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_fs_extra_namespaceObject = require("fs-extra");
+var external_fs_extra_default = /*#__PURE__*/ __webpack_require__.n(external_fs_extra_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 checkArrayExpectation_js_namespaceObject = require("../helper/legacy/checkArrayExpectation.js");
+const debug_js_namespaceObject = require("../test/debug.js");
+function config(context, name, configFiles, defaultOptions = {}) {
     const compiler = context.getCompiler();
     compiler.setOptions(defaultOptions);
     if (Array.isArray(configFiles)) {
-        const fileOptions = (0, helper_1.readConfigFile)(configFiles.map((i) => context.getSource(i)), context, defaultOptions)[0];
+        const fileOptions = (0, index_js_namespaceObject.readConfigFile)(configFiles.map((i)=>context.getSource(i)), context, defaultOptions)[0];
         compiler.mergeOptions(fileOptions);
     }
     return compiler.getOptions();
 }
-async function compiler(context, name) {
+function common_compiler(context, name) {
     const compiler = context.getCompiler();
     compiler.createCompiler();
     return compiler.getCompiler();
@@ -40,39 +74,25 @@ async function build(context, name) {
 }
 async function run(env, context, name, findBundle) {
     const testConfig = context.getTestConfig();
-    if (testConfig.noTests)
-        return;
+    if (testConfig.noTests) return;
     const compiler = context.getCompiler();
-    if (typeof testConfig.beforeExecute === 'function') {
-        testConfig.beforeExecute(compiler.getOptions());
-    }
+    if ('function' == typeof testConfig.beforeExecute) testConfig.beforeExecute(compiler.getOptions());
     let bundles;
-    if (typeof findBundle === 'function') {
-        bundles = findBundle(context, compiler.getOptions());
-    }
-    else {
-        bundles = [];
-    }
-    if (typeof bundles === 'string') {
-        bundles = [bundles];
-    }
-    if (__DEBUG__) {
-        context.setValue(debug_1.DEBUG_SCOPES.RunFindBundle, bundles);
-    }
-    if (!bundles || !bundles.length) {
-        return;
-    }
+    bundles = 'function' == typeof findBundle ? findBundle(context, compiler.getOptions()) : [];
+    if ('string' == typeof bundles) bundles = [
+        bundles
+    ];
+    if (__DEBUG__) context.setValue(debug_js_namespaceObject.DEBUG_SCOPES.RunFindBundle, bundles);
+    if (!bundles || !bundles.length) return;
     if (__DEBUG__) {
-        context.setValue(debug_1.DEBUG_SCOPES.RunLogs, []);
-        context.setValue(debug_1.DEBUG_SCOPES.RunErrors, []);
+        context.setValue(debug_js_namespaceObject.DEBUG_SCOPES.RunLogs, []);
+        context.setValue(debug_js_namespaceObject.DEBUG_SCOPES.RunErrors, []);
     }
-    for (const bundle of bundles) {
-        if (!bundle) {
-            continue;
-        }
+    for (const bundle of bundles){
+        if (!bundle) continue;
         const runner = context.getRunner(bundle, env);
         if (__DEBUG__) {
-            const runLogs = context.getValue(debug_1.DEBUG_SCOPES.RunLogs);
+            const runLogs = context.getValue(debug_js_namespaceObject.DEBUG_SCOPES.RunLogs);
             runLogs?.push(`Start running entry: ${bundle} in ${runner.constructor.name}(${runner.__key__})`);
         }
         const mod = runner.run(bundle);
@@ -85,37 +105,31 @@ async function run(env, context, name, findBundle) {
 }
 async function check(env, context, name) {
     const testConfig = context.getTestConfig();
-    if (testConfig.noTests)
-        return;
+    if (testConfig.noTests) return;
     const compiler = context.getCompiler();
-    const errors = (context.getError() || []).map((e) => ({
-        message: e.message,
-        stack: e.stack,
-    }));
+    const errors = (context.getError() || []).map((e)=>({
+            message: e.message,
+            stack: e.stack
+        }));
     const warnings = [];
     const stats = compiler.getStats();
     const options = compiler.getOptions();
     if (stats) {
-        if (testConfig.writeStatsOuptut) {
-            fs_extra_1.default.writeFileSync(node_path_1.default.join(context.getDist(), 'stats.txt'), stats.toString({
-                preset: 'verbose',
-                colors: false,
-            }), 'utf-8');
-        }
+        if (testConfig.writeStatsOuptut) external_fs_extra_default().writeFileSync(external_node_path_default().join(context.getDist(), 'stats.txt'), stats.toString({
+            preset: 'verbose',
+            colors: false
+        }), 'utf-8');
         if (testConfig.writeStatsJson) {
             const jsonStats = stats.toJson({
                 assets: true,
                 chunks: true,
                 entrypoints: true,
                 chunkGroups: true,
-                errorDetails: true,
+                errorDetails: true
             });
-            fs_extra_1.default.writeFileSync(node_path_1.default.join(context.getDist(), 'stats.json'), JSON.stringify(jsonStats, null, 2), 'utf-8');
+            external_fs_extra_default().writeFileSync(external_node_path_default().join(context.getDist(), 'stats.json'), JSON.stringify(jsonStats, null, 2), 'utf-8');
         }
-        if (fs_extra_1.default.existsSync(context.getSource('errors.js')) ||
-            fs_extra_1.default.existsSync(context.getSource('warnings.js')) ||
-            stats.hasErrors() ||
-            stats.hasWarnings()) {
+        if (external_fs_extra_default().existsSync(context.getSource('errors.js')) || external_fs_extra_default().existsSync(context.getSource('warnings.js')) || stats.hasErrors() || stats.hasWarnings()) {
             const statsJson = stats.toJson({
                 assets: true,
                 chunks: true,
@@ -123,106 +137,80 @@ async function check(env, context, name) {
                 modules: true,
                 entrypoints: true,
                 chunkGroups: true,
-                errorDetails: true,
+                errorDetails: true
             });
-            if (statsJson.errors) {
-                errors.push(...statsJson.errors);
-            }
-            if (statsJson.warnings) {
-                warnings.push(...statsJson.warnings);
-            }
+            if (statsJson.errors) errors.push(...statsJson.errors);
+            if (statsJson.warnings) warnings.push(...statsJson.warnings);
         }
     }
-    await (0, checkArrayExpectation_1.default)(context.getSource(), { errors }, 'error', 'errors', 'Error', options);
-    await (0, checkArrayExpectation_1.default)(context.getSource(), { warnings }, 'warning', 'warnings', 'Warning', options);
-    // clear error if checked
-    if (fs_extra_1.default.existsSync(context.getSource('errors.js'))) {
-        context.clearError();
-    }
+    await (0, checkArrayExpectation_js_namespaceObject.checkArrayExpectation)(context.getSource(), {
+        errors
+    }, 'error', 'errors', 'Error', options);
+    await (0, checkArrayExpectation_js_namespaceObject.checkArrayExpectation)(context.getSource(), {
+        warnings
+    }, 'warning', 'warnings', 'Warning', options);
+    if (external_fs_extra_default().existsSync(context.getSource('errors.js'))) context.clearError();
 }
-async function checkSnapshot(env, context, name, snapshot, filter) {
-    if (node_path_1.default.extname(snapshot) === '.snap') {
-        throw new Error('Snapshot with `.snap` will be managed by rstest, please use `.snap.txt` instead');
-    }
+function checkSnapshot(env, context, name, snapshot, filter) {
+    if ('.snap' === external_node_path_default().extname(snapshot)) throw new Error('Snapshot with `.snap` will be managed by rstest, please use `.snap.txt` instead');
     const compilerManager = context.getCompiler();
     const stats = compilerManager.getStats();
     const compiler = compilerManager.getCompiler();
-    if (!stats || !compiler)
-        return;
-    const compilers = 'compilers' in compiler
-        ? compiler.compilers
-        : [compiler];
-    const totalStats = 'stats' in stats ? stats.stats : [stats];
+    if (!stats || !compiler) return;
+    const compilers = 'compilers' in compiler ? compiler.compilers : [
+        compiler
+    ];
+    const totalStats = 'stats' in stats ? stats.stats : [
+        stats
+    ];
     const total = compilers.length;
-    for (let i = 0; i < compilers.length; i++) {
+    for(let i = 0; i < compilers.length; i++){
         const c = compilers[i];
         const stats = totalStats[i];
         if (stats.hasErrors()) {
             const errors = [];
             errors.push(...stats.compilation.errors);
-            throw new Error(`Failed to compile in fixture ${name}, Errors: ${errors
-                ?.map((i) => `${i.message}\n${i.stack}`)
-                .join('\n\n')}`);
+            throw new Error(`Failed to compile in fixture ${name}, Errors: ${errors?.map((i)=>`${i.message}\n${i.stack}`).join('\n\n')}`);
         }
-        const compilation = c._lastCompilation ||
-            c._lastCompilation;
-        const snapshotFileFilter = filter ||
-            ((file) => (file.endsWith('.js') || file.endsWith('.mjs')) &&
-                !file.includes('runtime.js'));
-        const fileContents = Object.entries(compilation.assets)
-            .filter(([file]) => snapshotFileFilter(file))
-            .map(([file, source]) => {
-            const tag = node_path_1.default.extname(file).slice(1) || 'txt';
-            let content = (0, placeholder_1.normalizePlaceholder)(source.source().toString());
+        const compilation = c._lastCompilation || c._lastCompilation;
+        const snapshotFileFilter = filter || ((file)=>(file.endsWith('.js') || file.endsWith('.mjs')) && !file.includes('runtime.js'));
+        const fileContents = Object.entries(compilation.assets).filter(([file])=>snapshotFileFilter(file)).map(([file, source])=>{
+            const tag = external_node_path_default().extname(file).slice(1) || 'txt';
+            let content = (0, placeholder_js_namespaceObject.normalizePlaceholder)(source.source().toString());
             const testConfig = context.getTestConfig();
-            if (testConfig.snapshotContent) {
-                content = testConfig.snapshotContent(content);
-            }
-            const filePath = file.replaceAll(node_path_1.default.sep, '/');
+            if (testConfig.snapshotContent) content = testConfig.snapshotContent(content);
+            const filePath = file.replaceAll(external_node_path_default().sep, '/');
             return `\`\`\`${tag} title=${filePath}\n${content}\n\`\`\``;
         });
         fileContents.sort();
         const content = fileContents.join('\n\n');
-        const snapshotPath = node_path_1.default.isAbsolute(snapshot)
-            ? snapshot
-            : node_path_1.default.resolve(context.getSource(), node_path_1.default.join('__snapshots__', `${snapshot}${total > 1 ? `-${i}` : ''}`));
+        const snapshotPath = external_node_path_default().isAbsolute(snapshot) ? snapshot : external_node_path_default().resolve(context.getSource(), external_node_path_default().join('__snapshots__', `${snapshot}${total > 1 ? `-${i}` : ''}`));
         env.expect(content).toMatchFileSnapshotSync(snapshotPath);
     }
 }
-async function afterExecute(context, name) {
+function afterExecute(context, name) {
     const compiler = context.getCompiler();
     const testConfig = context.getTestConfig();
-    if (typeof testConfig.afterExecute === 'function') {
+    if ('function' == typeof testConfig.afterExecute) {
         let options = compiler.getOptions();
-        if (Array.isArray(options) && options.length === 1) {
-            options = options[0];
-        }
+        if (Array.isArray(options) && 1 === options.length) options = options[0];
         testConfig.afterExecute(options);
     }
 }
 function findMultiCompilerBundle(context, name, multiFindBundle) {
-    if (typeof multiFindBundle !== 'function') {
-        return [];
-    }
-    const multiCompilerOptions = (context.getValue('multiCompilerOptions') ||
-        []);
+    if ('function' != typeof multiFindBundle) return [];
+    const multiCompilerOptions = context.getValue('multiCompilerOptions') || [];
     const result = [];
     const multiFileIndexMap = context.getValue('multiFileIndexMap') || {};
-    for (const [index, compilerOptions] of multiCompilerOptions.entries()) {
+    for (const [index, compilerOptions] of multiCompilerOptions.entries()){
         const curBundles = multiFindBundle(index, context, compilerOptions);
-        const bundles = Array.isArray(curBundles)
-            ? curBundles
-            : curBundles
-                ? [curBundles]
-                : [];
-        for (const bundle of bundles) {
-            if (multiFileIndexMap[bundle]) {
-                multiFileIndexMap[bundle].push(index);
-            }
-            else {
-                multiFileIndexMap[bundle] = [index];
-            }
-        }
+        const bundles = Array.isArray(curBundles) ? curBundles : curBundles ? [
+            curBundles
+        ] : [];
+        for (const bundle of bundles)if (multiFileIndexMap[bundle]) multiFileIndexMap[bundle].push(index);
+        else multiFileIndexMap[bundle] = [
+            index
+        ];
         result.push(...bundles);
     }
     context.setValue('multiFileIndexMap', multiFileIndexMap);
@@ -230,30 +218,47 @@ function findMultiCompilerBundle(context, name, multiFindBundle) {
 }
 function configMultiCompiler(context, name, configFiles, defaultOptions, overrideOptions) {
     const multiCompilerOptions = [];
-    const caseOptions = Array.isArray(configFiles)
-        ? (0, helper_1.readConfigFile)(configFiles.map((i) => context.getSource(i)), context, {}, (configs) => {
-            return configs.flatMap((c) => {
-                if (typeof c === 'function') {
-                    const options = {
-                        testPath: context.getDist(),
-                        env: undefined,
-                    };
-                    return c(options.env, options);
-                }
-                return c;
-            });
-        })
-        : [{}];
-    for (const [index, options] of caseOptions.entries()) {
-        const compilerOptions = (0, webpack_merge_1.default)(typeof defaultOptions === 'function'
-            ? defaultOptions(index, context)
-            : {}, options);
-        if (typeof overrideOptions === 'function') {
-            overrideOptions(index, context, compilerOptions);
-        }
+    const caseOptions = Array.isArray(configFiles) ? (0, index_js_namespaceObject.readConfigFile)(configFiles.map((i)=>context.getSource(i)), context, {}, (configs)=>configs.flatMap((c)=>{
+            if ('function' == typeof c) {
+                const options = {
+                    testPath: context.getDist(),
+                    env: void 0
+                };
+                return c(options.env, options);
+            }
+            return c;
+        })) : [
+        {}
+    ];
+    for (const [index, options] of caseOptions.entries()){
+        const compilerOptions = external_rspack_merge_default()('function' == typeof defaultOptions ? defaultOptions(index, context) : {}, options);
+        if ('function' == typeof overrideOptions) overrideOptions(index, context, compilerOptions);
         multiCompilerOptions.push(compilerOptions);
     }
     const compiler = context.getCompiler();
     compiler.setOptions(multiCompilerOptions);
     context.setValue('multiCompilerOptions', multiCompilerOptions);
 }
+exports.afterExecute = __webpack_exports__.afterExecute;
+exports.build = __webpack_exports__.build;
+exports.check = __webpack_exports__.check;
+exports.checkSnapshot = __webpack_exports__.checkSnapshot;
+exports.compiler = __webpack_exports__.compiler;
+exports.config = __webpack_exports__.config;
+exports.configMultiCompiler = __webpack_exports__.configMultiCompiler;
+exports.findMultiCompilerBundle = __webpack_exports__.findMultiCompilerBundle;
+exports.run = __webpack_exports__.run;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "afterExecute",
+    "build",
+    "check",
+    "checkSnapshot",
+    "compiler",
+    "config",
+    "configMultiCompiler",
+    "findMultiCompilerBundle",
+    "run"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/case/compiler.d.ts

@@ -1,19 +1,19 @@
 import type { Compilation, Compiler, RspackOptions, Stats, StatsCompilation } from '@rspack/core';
-import type { ITestContext } from '../type';
+import type { ITestContext, MaybePromise } from '../type';
 export declare function createCompilerCase(name: string, src: string, dist: string, testConfig: string): void;
 export type TCompilerCaseConfig = {
     description: string;
     error?: boolean;
     skip?: boolean;
     options?: (context: ITestContext) => RspackOptions;
-    compiler?: (context: ITestContext, compiler: Compiler) => Promise<void>;
-    build?: (context: ITestContext, compiler: Compiler) => Promise<void>;
+    compiler?: (context: ITestContext, compiler: Compiler) => MaybePromise<void>;
+    build?: (context: ITestContext, compiler: Compiler) => MaybePromise<void>;
     check?: ({ context, stats, files, compiler, compilation, }: {
         context: ITestContext;
         stats?: StatsCompilation;
         files?: Record<string, string>;
         compiler: Compiler;
         compilation?: Compilation;
-    }) => Promise<void>;
+    }) => MaybePromise<void>;
     compilerCallback?: (error: Error | null, stats: Stats | null) => void;
 };