@rspack/test-tools 2.0.2 → 2.0.3

package/dist/case/builtin.js

@@ -1,57 +1,88 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createBuiltinCase = createBuiltinCase;
-exports.defaultOptions = defaultOptions;
-const node_path_1 = __importDefault(require("node:path"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const rspack_merge_1 = require("rspack-merge");
-const helper_1 = require("../helper");
-const creator_1 = require("../test/creator");
-const common_1 = require("./common");
-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__, {
+    createBuiltinCase: ()=>createBuiltinCase,
+    defaultOptions: ()=>builtin_defaultOptions
+});
+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");
+const index_js_namespaceObject = require("../helper/index.js");
+const creator_js_namespaceObject = require("../test/creator.js");
+const external_common_js_namespaceObject = require("./common.js");
+const creator = new creator_js_namespaceObject.BasicCaseCreator({
     clean: true,
     describe: false,
-    description(name) {
+    description (name) {
         return `${name} should match snapshot`;
     },
-    steps: ({ name, src }) => {
-        const cat = node_path_1.default.basename(node_path_1.default.dirname(src));
+    steps: ({ name, src })=>{
+        const cat = external_node_path_default().basename(external_node_path_default().dirname(src));
         const filter = FILTERS[cat];
         return [
             {
-                config: async (context) => {
+                config: (context)=>{
                     const compiler = context.getCompiler();
-                    compiler.setOptions(defaultOptions(context));
+                    compiler.setOptions(builtin_defaultOptions(context));
                 },
-                compiler: async (context) => {
-                    await (0, common_1.compiler)(context, name);
+                compiler: async (context)=>{
+                    await (0, external_common_js_namespaceObject.compiler)(context, name);
                 },
-                build: async (context) => {
-                    await (0, common_1.build)(context, name);
+                build: async (context)=>{
+                    await (0, external_common_js_namespaceObject.build)(context, name);
                 },
-                run: async (env, context) => {
-                    // no need to run, just check snapshot
-                },
-                check: async (env, context) => {
-                    await (0, common_1.checkSnapshot)(env, context, name, 'output.snap.txt', filter);
-                },
-            },
+                run: async (env, context)=>{},
+                check: async (env, context)=>{
+                    await (0, external_common_js_namespaceObject.checkSnapshot)(env, context, name, 'output.snap.txt', filter);
+                }
+            }
         ];
     },
-    concurrent: true,
+    concurrent: true
 });
 function createBuiltinCase(name, src, dist) {
     creator.create(name, src, dist);
 }
-function defaultOptions(context) {
+function builtin_defaultOptions(context) {
     let defaultOptions = {
         entry: {
             main: {
-                import: './index',
-            },
+                import: './index'
+            }
         },
         output: {
             publicPath: '/',
@@ -66,7 +97,9 @@ function defaultOptions(context) {
             chunkLoadingGlobal: 'rspackChunk',
             chunkLoading: 'jsonp',
             uniqueName: '__rspack_test__',
-            enabledLibraryTypes: ['system'],
+            enabledLibraryTypes: [
+                'system'
+            ],
             strictModuleErrorHandling: false,
             iife: true,
             module: false,
@@ -76,48 +109,48 @@ function defaultOptions(context) {
             importFunctionName: 'import',
             wasmLoading: 'fetch',
             webassemblyModuleFilename: '[hash].module.wasm',
-            workerChunkLoading: 'import-scripts',
+            workerChunkLoading: "import-scripts",
             workerWasmLoading: 'fetch',
             bundlerInfo: {
-                force: false,
-            },
+                force: false
+            }
         },
         module: {
             rules: [
                 {
                     test: /\.json$/,
-                    type: 'json',
+                    type: 'json'
                 },
                 {
                     test: /\.mjs$/,
-                    type: 'javascript/esm',
+                    type: "javascript/esm"
                 },
                 {
                     test: /\.cjs$/,
-                    type: 'javascript/dynamic',
+                    type: "javascript/dynamic"
                 },
                 {
                     test: /\.js$/,
-                    type: 'javascript/auto',
+                    type: "javascript/auto"
                 },
                 {
                     test: /\.css$/,
-                    type: 'css',
+                    type: 'css'
                 },
                 {
                     test: /\.wasm$/,
-                    type: 'webassembly/async',
-                },
-            ],
+                    type: 'webassembly/async'
+                }
+            ]
         },
         node: {
             __dirname: 'mock',
             __filename: 'mock',
-            global: 'warn',
+            global: 'warn'
         },
         optimization: {
             runtimeChunk: {
-                name: 'runtime',
+                name: 'runtime'
             },
             minimize: false,
             removeEmptyChunks: true,
@@ -128,7 +161,7 @@ function defaultOptions(context) {
             inlineExports: false,
             usedExports: false,
             concatenateModules: false,
-            nodeEnv: false,
+            nodeEnv: false
         },
         resolve: {
             extensions: [
@@ -139,36 +172,43 @@ function defaultOptions(context) {
                 '.json',
                 '.d.ts',
                 '.css',
-                '.wasm',
-            ],
+                '.wasm'
+            ]
         },
         resolveLoader: {
-            extensions: ['.js'],
+            extensions: [
+                '.js'
+            ]
         },
         experiments: {
-            futureDefaults: true,
+            futureDefaults: true
         },
         devtool: false,
         context: context.getSource(),
-        plugins: [],
+        plugins: []
     };
     const testConfigFile = context.getSource('rspack.config.js');
-    if (fs_extra_1.default.existsSync(testConfigFile)) {
+    if (external_fs_extra_default().existsSync(testConfigFile)) {
         const caseOptions = require(testConfigFile);
-        if (caseOptions.entry) {
-            delete defaultOptions.entry;
-        }
-        defaultOptions = (0, rspack_merge_1.merge)(defaultOptions, caseOptions);
-    }
-    if (!global.printLogger) {
-        defaultOptions.infrastructureLogging = {
-            level: 'error',
-        };
+        if (caseOptions.entry) delete defaultOptions.entry;
+        defaultOptions = (0, external_rspack_merge_namespaceObject.merge)(defaultOptions, caseOptions);
     }
+    if (!global.printLogger) defaultOptions.infrastructureLogging = {
+        level: 'error'
+    };
     return defaultOptions;
 }
 const FILTERS = {
-    'plugin-css': (file) => file.endsWith('.css'),
-    'plugin-css-modules': (file) => file.endsWith('.css') || ((0, helper_1.isJavaScript)(file) && !file.includes('runtime')),
-    'plugin-html': (file) => file.endsWith('.html'),
+    'plugin-css': (file)=>file.endsWith('.css'),
+    'plugin-css-modules': (file)=>file.endsWith('.css') || (0, index_js_namespaceObject.isJavaScript)(file) && !file.includes('runtime'),
+    'plugin-html': (file)=>file.endsWith('.html')
 };
+exports.createBuiltinCase = __webpack_exports__.createBuiltinCase;
+exports.defaultOptions = __webpack_exports__.defaultOptions;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createBuiltinCase",
+    "defaultOptions"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/case/cache.js

@@ -1,75 +1,102 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCacheCase = createCacheCase;
-const node_path_1 = __importDefault(require("node:path"));
-const core_1 = __importDefault(require("@rspack/core"));
-const helper_1 = require("../helper");
-const placeholder_1 = require("../helper/expect/placeholder");
-const hot_update_1 = require("../helper/hot-update");
-const checkArrayExpectation_1 = __importDefault(require("../helper/legacy/checkArrayExpectation"));
-const runner_1 = require("../runner");
-const creator_1 = require("../test/creator");
-const common_1 = require("./common");
-const runner_2 = require("./runner");
+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__, {
+    createCacheCase: ()=>createCacheCase
+});
+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");
+var core_default = /*#__PURE__*/ __webpack_require__.n(core_namespaceObject);
+const index_js_namespaceObject = require("../helper/index.js");
+const placeholder_js_namespaceObject = require("../helper/expect/placeholder.js");
+const hot_update_index_js_namespaceObject = require("../helper/hot-update/index.js");
+const checkArrayExpectation_js_namespaceObject = require("../helper/legacy/checkArrayExpectation.js");
+const external_runner_index_js_namespaceObject = require("../runner/index.js");
+const creator_js_namespaceObject = require("../test/creator.js");
+const external_common_js_namespaceObject = require("./common.js");
+const external_runner_js_namespaceObject = require("./runner.js");
 function createCacheProcessor(name, src, temp, target) {
-    const updatePlugin = new hot_update_1.HotUpdatePlugin(src, temp);
+    const updatePlugin = new hot_update_index_js_namespaceObject.HotUpdatePlugin(src, temp);
     return {
-        before: async (context) => {
+        before: async (context)=>{
             await updatePlugin.initialize();
             context.setValue('hotUpdateContext', updatePlugin);
         },
-        config: async (context) => {
+        config: async (context)=>{
             const compiler = context.getCompiler();
             const options = await generateOptions(context, temp, target, updatePlugin);
             compiler.setOptions(options);
         },
-        compiler: async (context) => {
-            await (0, common_1.compiler)(context, name);
+        compiler: async (context)=>{
+            await (0, external_common_js_namespaceObject.compiler)(context, name);
         },
-        build: async (context) => {
-            await (0, common_1.build)(context, name);
+        build: async (context)=>{
+            await (0, external_common_js_namespaceObject.build)(context, name);
         },
-        run: async (env, context) => {
-            await (0, common_1.run)(env, context, name, (context) => findBundle(name, target, context));
+        run: async (env, context)=>{
+            await (0, external_common_js_namespaceObject.run)(env, context, name, (context)=>findBundle(name, target, context));
         },
-        check: async (env, context) => {
-            await (0, common_1.check)(env, context, name);
+        check: async (env, context)=>{
+            await (0, external_common_js_namespaceObject.check)(env, context, name);
             const stats = context.getCompiler().getStats();
-            if (stats) {
-                matchStatsSnapshot(env, context.getSource(), updatePlugin.getUpdateIndex(), stats);
-            }
+            if (stats) matchStatsSnapshot(env, context.getSource(), updatePlugin.getUpdateIndex(), stats);
         },
-        after: async (context) => {
-            await (0, common_1.afterExecute)(context, name);
+        after: async (context)=>{
+            await (0, external_common_js_namespaceObject.afterExecute)(context, name);
         },
-        afterAll: async (context) => {
+        afterAll: (context)=>{
             const updateIndex = updatePlugin.getUpdateIndex();
             const totalUpdates = updatePlugin.getTotalUpdates();
-            if (updateIndex + 1 !== totalUpdates) {
-                throw new Error(`Should run all hot steps (${updateIndex + 1} / ${totalUpdates}): ${name}`);
-            }
-        },
+            if (updateIndex + 1 !== totalUpdates) throw new Error(`Should run all hot steps (${updateIndex + 1} / ${totalUpdates}): ${name}`);
+        }
     };
 }
 function getCreator(target) {
-    if (!creators.has(target)) {
-        creators.set(target, new creator_1.BasicCaseCreator({
-            clean: true,
-            describe: true,
-            target,
-            steps: ({ name, src, target, temp }) => [
-                createCacheProcessor(name, src, temp, target),
+    if (!creators.has(target)) creators.set(target, new creator_js_namespaceObject.BasicCaseCreator({
+        clean: true,
+        describe: true,
+        target,
+        steps: ({ name, src, target, temp })=>[
+                createCacheProcessor(name, src, temp, target)
             ],
-            runner: {
-                key: (context, name, file) => name,
-                runner: createRunner,
-            },
-            concurrent: true,
-        }));
-    }
+        runner: {
+            key: (context, name, file)=>name,
+            runner: createRunner
+        },
+        concurrent: true
+    }));
     return creators.get(target);
 }
 function createCacheCase(name, src, dist, target, temp) {
@@ -78,17 +105,13 @@ function createCacheCase(name, src, dist, target, temp) {
 }
 const creators = new Map();
 function matchStatsSnapshot(env, source, updateIndex, stats) {
-    const content = (0, placeholder_1.normalizePlaceholder)(stats.toString({
+    const content = (0, placeholder_js_namespaceObject.normalizePlaceholder)(stats.toString({
         all: false,
         logging: 'info',
-        colors: false,
+        colors: false
     })).trim();
-    if (!content.includes('rspack.persistentCache')) {
-        return;
-    }
-    env
-        .expect(content)
-        .toMatchFileSnapshotSync(node_path_1.default.resolve(source, '__snapshots__', `stats-${updateIndex}.txt`));
+    if (!content.includes('rspack.persistentCache')) return;
+    env.expect(content).toMatchFileSnapshotSync(external_node_path_default().resolve(source, '__snapshots__', `stats-${updateIndex}.txt`));
 }
 async function generateOptions(context, temp, target, updatePlugin) {
     let options = {
@@ -100,70 +123,65 @@ async function generateOptions(context, temp, target, updatePlugin) {
             filename: 'bundle.js',
             chunkFilename: '[name].chunk.[fullhash].js',
             publicPath: 'https://test.cases/path/',
-            library: { type: 'commonjs2' },
-            bundlerInfo: {
-                force: false,
+            library: {
+                type: 'commonjs2'
             },
+            bundlerInfo: {
+                force: false
+            }
         },
         optimization: {
             moduleIds: 'named',
-            emitOnErrors: true,
+            emitOnErrors: true
         },
-        target,
+        target
     };
     options.plugins ??= [];
-    options.plugins.push(new core_1.default.HotModuleReplacementPlugin());
-    options = await (0, common_1.config)(context, 'cacheCase', ['rspack.config.js', 'webpack.config.js'].map((i) => node_path_1.default.resolve(temp, i)), options);
-    // overwrite
-    if (!options.entry) {
-        options.entry = './index.js';
-    }
-    // rewrite context to temp dir
+    options.plugins.push(new (core_default()).HotModuleReplacementPlugin());
+    options = await (0, external_common_js_namespaceObject.config)(context, 'cacheCase', [
+        'rspack.config.js',
+        'webpack.config.js'
+    ].map((i)=>external_node_path_default().resolve(temp, i)), options);
+    if (!options.entry) options.entry = './index.js';
     options.context = temp;
     options.module ??= {};
-    for (const cssModuleType of ['css/auto', 'css/module', 'css']) {
+    for (const cssModuleType of [
+        'css/auto',
+        'css/module',
+        'css'
+    ]){
         options.module.generator ??= {};
         options.module.generator[cssModuleType] ??= {};
-        options.module.generator[cssModuleType].exportsOnly ??=
-            target === 'async-node';
+        options.module.generator[cssModuleType].exportsOnly ??= 'async-node' === target;
     }
     options.plugins ??= [];
     options.plugins.push(updatePlugin);
-    if (!global.printLogger) {
-        options.infrastructureLogging = {
-            level: 'error',
-        };
-    }
+    if (!global.printLogger) options.infrastructureLogging = {
+        level: 'error'
+    };
     return options;
 }
 function findBundle(name, target, context) {
     const files = [];
     const prefiles = [];
     const compiler = context.getCompiler();
-    if (!compiler)
-        throw new Error('Compiler should exists when find bundle');
+    if (!compiler) throw new Error('Compiler should exists when find bundle');
     const stats = compiler.getStats();
-    if (!stats)
-        throw new Error('Stats should exists when find bundle');
+    if (!stats) throw new Error('Stats should exists when find bundle');
     const info = stats.toJson({
         all: false,
-        entrypoints: true,
+        entrypoints: true
     });
-    if (target === 'web' || target === 'webworker') {
-        for (const file of info.entrypoints.main.assets) {
-            if ((0, helper_1.isJavaScript)(file.name)) {
-                files.push(file.name);
-            }
-            else {
-                prefiles.push(file.name);
-            }
-        }
-    }
+    if ('web' === target || 'webworker' === target) for (const file of info.entrypoints.main.assets)if ((0, index_js_namespaceObject.isJavaScript)(file.name)) files.push(file.name);
+    else prefiles.push(file.name);
     else {
-        const assets = info.entrypoints.main.assets.filter((s) => (0, helper_1.isJavaScript)(s.name));
+        const assets = info.entrypoints.main.assets.filter((s)=>(0, index_js_namespaceObject.isJavaScript)(s.name));
         files.push(assets[assets.length - 1].name);
     }
-    return [...prefiles, ...files];
+    return [
+        ...prefiles,
+        ...files
+    ];
 }
 function createRunner(context, name, file, env) {
     const compiler = context.getCompiler();
@@ -173,32 +191,28 @@ function createRunner(context, name, file, env) {
     const source = context.getSource();
     const dist = context.getDist();
     const updatePlugin = context.getValue('hotUpdateContext');
-    const getWebRunner = () => {
-        return new runner_1.NodeRunner({
+    const getWebRunner = ()=>new external_runner_index_js_namespaceObject.NodeRunner({
             env,
-            stats: (0, runner_2.cachedStats)(context, name),
+            stats: (0, external_runner_js_namespaceObject.cachedStats)(context, name),
             cachable: false,
             name: name,
             runInNewContext: false,
             testConfig: {
                 ...testConfig,
-                moduleScope(ms, stats, options) {
-                    const moduleScope = typeof testConfig.moduleScope === 'function'
-                        ? testConfig.moduleScope(ms, stats, options)
-                        : ms;
+                moduleScope (ms, stats, options) {
+                    const moduleScope = 'function' == typeof testConfig.moduleScope ? testConfig.moduleScope(ms, stats, options) : ms;
                     moduleScope.COMPILER_INDEX = compilerIndex;
                     moduleScope.NEXT_HMR = nextHmr;
                     moduleScope.NEXT_START = nextStart;
                     moduleScope.NEXT_MOVE_DIR_START = nextMoveDirStart;
                     return moduleScope;
-                },
+                }
             },
             source,
             dist,
-            compilerOptions: options,
+            compilerOptions: options
         });
-    };
-    const checkStats = async (stats) => {
+    const checkStats = async (stats)=>{
         matchStatsSnapshot(env, source, updatePlugin.getUpdateIndex(), stats);
         const jsonStats = stats.toJson({
             assets: true,
@@ -206,38 +220,33 @@ function createRunner(context, name, file, env) {
             chunkModules: true,
             modules: true,
             entrypoints: true,
-            chunkGroups: true,
-            // errorDetails: true
+            chunkGroups: true
         });
         const compilerOptions = compiler.getOptions();
         const updateIndex = updatePlugin.getUpdateIndex();
-        await (0, checkArrayExpectation_1.default)(source, jsonStats, 'error', `errors${updateIndex}`, 'Error', compilerOptions);
-        await (0, checkArrayExpectation_1.default)(source, jsonStats, 'warning', `warnings${updateIndex}`, 'Warning', compilerOptions);
+        await (0, checkArrayExpectation_js_namespaceObject.checkArrayExpectation)(source, jsonStats, 'error', `errors${updateIndex}`, 'Error', compilerOptions);
+        await (0, checkArrayExpectation_js_namespaceObject.checkArrayExpectation)(source, jsonStats, 'warning', `warnings${updateIndex}`, 'Warning', compilerOptions);
         return jsonStats;
     };
-    const nextHmr = async (m, options) => {
+    const nextHmr = async (m, options)=>{
         await updatePlugin.goNext();
         const stats = await compiler.build();
         const jsonStats = await checkStats(stats);
         const updatedModules = await m.hot.check(options || true);
-        if (!updatedModules) {
-            throw new Error('No update available');
-        }
+        if (!updatedModules) throw new Error('No update available');
         return jsonStats;
     };
-    const nextStart = async () => {
+    const nextStart = async ()=>{
         await compiler.close();
         await updatePlugin.goNext();
         compilerIndex++;
         compiler.createCompiler();
         const stats = await compiler.build();
         const jsonStats = await checkStats(stats);
-        env.it(`NEXT_START run with compilerIndex==${compilerIndex}`, async () => {
-            return getWebRunner().run(file);
-        });
+        env.it(`NEXT_START run with compilerIndex==${compilerIndex}`, async ()=>getWebRunner().run(file));
         return jsonStats;
     };
-    const nextMoveDirStart = async () => {
+    const nextMoveDirStart = async ()=>{
         await compiler.close();
         const tempDir = await updatePlugin.moveTempDir();
         const options = await generateOptions(context, tempDir, compiler.getOptions().target, updatePlugin);
@@ -247,10 +256,15 @@ function createRunner(context, name, file, env) {
         compiler.createCompiler();
         const stats = await compiler.build();
         const jsonStats = await checkStats(stats);
-        env.it(`NEXT_MOVE_DIR_START run with compilerIndex==${compilerIndex}`, async () => {
-            return getWebRunner().run(file);
-        });
+        env.it(`NEXT_MOVE_DIR_START run with compilerIndex==${compilerIndex}`, async ()=>getWebRunner().run(file));
         return jsonStats;
     };
     return getWebRunner();
 }
+exports.createCacheCase = __webpack_exports__.createCacheCase;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createCacheCase"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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;