@rspack/test-tools 1.7.0-beta.0 → 1.7.0

package/dist/case/multi-compiler.d.ts

@@ -1,5 +1,5 @@
-import type { Compilation, Compiler, RspackOptions, Stats, StatsCompilation } from "@rspack/core";
-import type { ITestContext } from "../type";
+import type { Compilation, Compiler, RspackOptions, Stats, StatsCompilation } from '@rspack/core';
+import type { ITestContext } from '../type';
 export declare function createMultiCompilerCase(name: string, src: string, dist: string, testConfig: string): void;
 export type TMultiCompilerCaseConfig = {
     description: string;
@@ -8,7 +8,7 @@ export type TMultiCompilerCaseConfig = {
     options?: (context: ITestContext) => RspackOptions;
     compiler?: (context: ITestContext, compiler: Compiler) => Promise<void>;
     build?: (context: ITestContext, compiler: Compiler) => Promise<void>;
-    check?: ({ context, stats, files, compiler, compilation }: {
+    check?: ({ context, stats, files, compiler, compilation, }: {
         context: ITestContext;
         stats?: StatsCompilation;
         files?: Record<string, string>;

package/dist/case/multi-compiler.js

@@ -13,15 +13,15 @@ function createMultiCompilerProcessor(name, caseConfig) {
             const compiler = context.getCompiler();
             const options = Object.assign([
                 {
-                    name: "a",
-                    context: node_path_1.default.join(__dirname, "fixtures"),
-                    entry: "./a.js"
+                    name: 'a',
+                    context: node_path_1.default.join(__dirname, 'fixtures'),
+                    entry: './a.js',
                 },
                 {
-                    name: "b",
-                    context: node_path_1.default.join(__dirname, "fixtures"),
-                    entry: "./b.js"
-                }
+                    name: 'b',
+                    context: node_path_1.default.join(__dirname, 'fixtures'),
+                    entry: './b.js',
+                },
             ], caseConfig.options?.(context) || {});
             compiler.setOptions(options);
         },
@@ -47,17 +47,17 @@ function createMultiCompilerProcessor(name, caseConfig) {
                                 changes: new Set(),
                                 removals: new Set(),
                                 fileTimeInfoEntries: new Map(),
-                                directoryTimeInfoEntries: new Map()
+                                directoryTimeInfoEntries: new Map(),
                             };
-                        }
+                        },
                     };
-                }
+                },
             };
             await caseConfig.compiler?.(context, c);
         },
         build: async (context) => {
             const compiler = context.getCompiler();
-            if (typeof caseConfig.build === "function") {
+            if (typeof caseConfig.build === 'function') {
                 await caseConfig.build?.(context, compiler.getCompiler());
             }
             else {
@@ -65,7 +65,7 @@ function createMultiCompilerProcessor(name, caseConfig) {
             }
         },
         run: async (env, context) => { },
-        check: async (env, context) => { }
+        check: async (env, context) => { },
     };
 }
 const creator = new creator_1.BasicCaseCreator({
@@ -73,10 +73,10 @@ const creator = new creator_1.BasicCaseCreator({
     describe: false,
     steps: ({ name, caseConfig }) => {
         return [
-            createMultiCompilerProcessor(name, caseConfig)
+            createMultiCompilerProcessor(name, caseConfig),
         ];
     },
-    concurrent: false
+    concurrent: false,
 });
 function createMultiCompilerCase(name, src, dist, testConfig) {
     let caseConfigList = require(testConfig);
@@ -91,7 +91,7 @@ function createMultiCompilerCase(name, src, dist, testConfig) {
         }
         creator.create(`${name}[${i}]`, src, dist, undefined, {
             caseConfig,
-            description: () => caseConfig.description
+            description: () => caseConfig.description,
         });
     }
 }

package/dist/case/native-watcher.js

@@ -12,7 +12,7 @@ const creator = new creator_1.BasicCaseCreator({
     clean: true,
     runner: {
         key: watch_1.getWatchRunnerKey,
-        runner: watch_1.createWatchRunner
+        runner: watch_1.createWatchRunner,
     },
     description: (name, index) => {
         return index === 0
@@ -25,17 +25,17 @@ const creator = new creator_1.BasicCaseCreator({
         const runs = node_fs_1.default
             .readdirSync(src)
             .sort()
-            .filter(name => node_fs_1.default.statSync(node_path_1.default.join(src, name)).isDirectory())
-            .map(name => ({ name }));
+            .filter((name) => node_fs_1.default.statSync(node_path_1.default.join(src, name)).isDirectory())
+            .map((name) => ({ name }));
         return runs.map((run, index) => index === 0
             ? (0, watch_1.createWatchInitialProcessor)(name, temp, run.name, watchState, {
-                nativeWatcher: true
+                nativeWatcher: true,
             })
             : (0, watch_1.createWatchStepProcessor)(name, temp, run.name, watchState, {
-                nativeWatcher: true
+                nativeWatcher: true,
             }));
     },
-    concurrent: true
+    concurrent: true,
 });
 function createNativeWatcher(name, src, dist, temp) {
     creator.create(name, src, dist, temp);

package/dist/case/normal.js

@@ -13,7 +13,7 @@ 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 NORMAL_CASES_ROOT = node_path_1.default.resolve(__TEST_PATH__, 'normalCases');
 const createCaseOptions = (hot, mode) => {
     return {
         clean: true,
@@ -23,9 +23,9 @@ const createCaseOptions = (hot, mode) => {
                 config: async (context) => {
                     const compiler = context.getCompiler();
                     let options = defaultOptions(context, {
-                        plugins: hot ? [new core_1.HotModuleReplacementPlugin()] : []
+                        plugins: hot ? [new core_1.HotModuleReplacementPlugin()] : [],
                     }, mode);
-                    options = await (0, common_1.config)(context, name, ["rspack.config.js", "webpack.config.js"], options);
+                    options = await (0, common_1.config)(context, name, ['rspack.config.js', 'webpack.config.js'], options);
                     overrideOptions(context, options);
                     compiler.setOptions(options);
                 },
@@ -43,14 +43,14 @@ const createCaseOptions = (hot, mode) => {
                 },
                 after: async (context) => {
                     await (0, common_1.afterExecute)(context, name);
-                }
-            }
+                },
+            },
         ],
         runner: {
             key: (context, name, file) => name,
-            runner: runner_1.createRunner
+            runner: runner_1.createRunner,
         },
-        concurrent: true
+        concurrent: true,
     };
 };
 const creator = new creator_1.BasicCaseCreator(createCaseOptions(false));
@@ -61,45 +61,45 @@ 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"));
+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"));
+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") {
+    if (typeof testConfig.findBundle === 'function') {
         return testConfig.findBundle(0, options);
     }
     const filename = options.output?.filename;
-    return typeof filename === "string" ? filename : undefined;
+    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");
+    const testConfigPath = node_path_1.default.join(context.getSource(), 'test.config.js');
     if (node_fs_1.default.existsSync(testConfigPath)) {
         testConfig = require(testConfigPath);
     }
-    const TerserPlugin = require("terser-webpack-plugin");
+    const TerserPlugin = require('terser-webpack-plugin');
     const terserForTesting = new TerserPlugin({
-        parallel: false
+        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",
+        target: compilerOptions?.target || 'async-node',
+        devtool: mode === 'development' ? false : compilerOptions?.devtool,
+        mode: compilerOptions?.mode || mode || 'none',
         optimization: compilerOptions?.mode
             ? {
                 emitOnErrors: true,
                 minimizer: [terserForTesting],
                 minimize: false,
-                ...testConfig.optimization
+                ...testConfig.optimization,
             }
             : {
                 removeAvailableModules: true,
@@ -119,61 +119,61 @@ function defaultOptions(context, compilerOptions, mode) {
                 // CHANGE: size is not supported yet
                 // moduleIds: "size",
                 // chunkIds: "size",
-                moduleIds: "named",
-                chunkIds: "named",
+                moduleIds: 'named',
+                chunkIds: 'named',
                 minimize: false,
                 minimizer: [terserForTesting],
-                ...compilerOptions?.optimization
+                ...compilerOptions?.optimization,
             },
         // CHANGE: rspack does not support `performance` yet.
         // performance: {
         // 	hints: false
         // },
         node: {
-            __dirname: "mock",
-            __filename: "mock"
+            __dirname: 'mock',
+            __filename: 'mock',
         },
         cache: compilerOptions?.cache && {
             // cacheDirectory,
-            ...compilerOptions.cache
+            ...compilerOptions.cache,
         },
         output: {
-            pathinfo: "verbose",
+            pathinfo: 'verbose',
             path: context.getDist(),
-            filename: compilerOptions?.module ? "bundle.mjs" : "bundle.js"
+            filename: compilerOptions?.module ? 'bundle.mjs' : 'bundle.js',
         },
         resolve: {
-            modules: ["web_modules", "node_modules"],
-            mainFields: ["webpack", "browser", "web", "browserify", "main"],
-            aliasFields: ["browser"],
-            extensions: [".webpack.js", ".web.js", ".js", ".json"]
+            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"]
+            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"
+                    loader: 'coffee-loader',
                 },
                 {
                     test: /\.pug/,
-                    loader: "@webdiscus/pug-loader"
+                    loader: '@webdiscus/pug-loader',
                 },
                 {
                     test: /\.wat$/i,
-                    loader: "wast-loader",
-                    type: "webassembly/async"
-                }
-            ]
+                    loader: 'wast-loader',
+                    type: 'webassembly/async',
+                },
+            ],
         },
         plugins: (compilerOptions?.plugins || [])
             .concat(testConfig.plugins || [])
             .concat(function () {
-            this.hooks.compilation.tap("TestCasesTest", compilation => {
+            this.hooks.compilation.tap('TestCasesTest', (compilation) => {
                 const hooks = [
                 // CHANGE: the following hooks are not supported yet, so comment it out
                 // "optimize",
@@ -183,7 +183,7 @@ function defaultOptions(context, compilerOptions, mode) {
                 // "afterOptimizeAssets"
                 ];
                 for (const hook of hooks) {
-                    compilation.hooks[hook].tap("TestCasesTest", () => compilation.checkConstraints());
+                    compilation.hooks[hook].tap('TestCasesTest', () => compilation.checkConstraints());
                 }
             });
         }),
@@ -191,8 +191,8 @@ function defaultOptions(context, compilerOptions, mode) {
             css: false,
             rspackFuture: {
                 bundlerInfo: {
-                    force: false
-                }
+                    force: false,
+                },
             },
             asyncWebAssembly: true,
             topLevelAwait: true,
@@ -200,14 +200,14 @@ function defaultOptions(context, compilerOptions, mode) {
             // backCompat: false,
             // CHANGE: Rspack enables `css` by default.
             // Turning off here to fallback to webpack's default css processing logic.
-            ...(compilerOptions?.module ? { outputModule: true } : {})
-        }
+            ...(compilerOptions?.module ? { outputModule: true } : {}),
+        },
     };
 }
 function overrideOptions(context, options) {
     if (!global.printLogger) {
         options.infrastructureLogging = {
-            level: "error"
+            level: 'error',
         };
     }
 }

package/dist/case/runner.d.ts

@@ -1,5 +1,5 @@
-import type { StatsCompilation } from "@rspack/core";
-import type { ITestContext, ITestEnv, ITestRunner } from "../type";
+import type { StatsCompilation } from '@rspack/core';
+import type { ITestContext, ITestEnv, ITestRunner } from '../type';
 export type THotStepRuntimeLangData = {
     outdatedModules: string[];
     outdatedDependencies: Record<string, string[]>;

package/dist/case/runner.js

@@ -6,6 +6,13 @@ exports.getMultiCompilerRunnerKey = getMultiCompilerRunnerKey;
 exports.createMultiCompilerRunner = createMultiCompilerRunner;
 const runner_1 = require("../runner");
 const debug_1 = require("../test/debug");
+const isWebTarget = (compilerOptions) => {
+    const target = compilerOptions.target;
+    if (Array.isArray(target)) {
+        return target.some((t) => t === 'web' || t === 'webworker');
+    }
+    return target === 'web' || target === 'webworker';
+};
 function cachedStats(context, name) {
     const compiler = context.getCompiler();
     const statsGetter = (() => {
@@ -15,7 +22,7 @@ function cachedStats(context, name) {
                 return cached;
             }
             cached = compiler.getStats().toJson({
-                errorDetails: true
+                errorDetails: true,
             });
             return cached;
         };
@@ -35,23 +42,23 @@ function createRunner(context, name, file, env) {
         testConfig: context.getTestConfig(),
         source: context.getSource(),
         dist: context.getDist(),
-        compilerOptions
+        compilerOptions,
     };
-    if (compilerOptions.target === "web" ||
-        compilerOptions.target === "webworker") {
+    const isWeb = isWebTarget(compilerOptions);
+    if (isWeb) {
         return new runner_1.WebRunner({
             ...runnerOptions,
             runInNewContext: true,
-            location: testConfig.location || "https://test.cases/path/index.html"
+            location: testConfig.location || 'https://test.cases/path/index.html',
         });
     }
     return new runner_1.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");
+    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');
     }
     const indexList = multiFileIndexMap[file];
     const seq = indexList.findIndex((index, n) => !runned.has(`${name}:${file}[${n}]`));
@@ -60,7 +67,7 @@ function getFileIndexHandler(context, name, file) {
     }
     const getIndex = () => [indexList[seq], seq];
     const flagIndex = () => runned.add(`${name}:${file}[${seq}]`);
-    context.setValue("runned", runned);
+    context.setValue('runned', runned);
     return { getIndex, flagIndex };
 }
 function getMultiCompilerRunnerKey(context, name, file) {
@@ -71,7 +78,7 @@ function getMultiCompilerRunnerKey(context, name, file) {
 function createMultiCompilerRunner(context, name, file, env) {
     const testConfig = context.getTestConfig();
     const { getIndex, flagIndex } = getFileIndexHandler(context, name, file);
-    const multiCompilerOptions = context.getValue("multiCompilerOptions") || [];
+    const multiCompilerOptions = context.getValue('multiCompilerOptions') || [];
     const [index] = getIndex();
     const compilerOptions = multiCompilerOptions[index];
     const logs = context.getValue(debug_1.DEBUG_SCOPES.RunLogs);
@@ -95,14 +102,14 @@ function createMultiCompilerRunner(context, name, file, env) {
         dist: context.getDist(),
         compilerOptions,
         logs,
-        errors
+        errors,
     };
-    if (compilerOptions.target === "web" ||
-        compilerOptions.target === "webworker") {
+    const isWeb = isWebTarget(compilerOptions);
+    if (isWeb) {
         runner = new runner_1.WebRunner({
             ...runnerOptions,
             runInNewContext: true,
-            location: testConfig.location || "https://test.cases/path/index.html"
+            location: testConfig.location || 'https://test.cases/path/index.html',
         });
     }
     else {

package/dist/case/serial.d.ts

@@ -1,3 +1,3 @@
-import type { TTestConfig } from "../type";
-export type TSerialCaseConfig = Omit<TTestConfig, "validate">;
+import type { TTestConfig } from '../type';
+export type TSerialCaseConfig = Omit<TTestConfig, 'validate'>;
 export declare function createSerialCase(name: string, src: string, dist: string): void;

package/dist/case/serial.js

@@ -7,12 +7,12 @@ const runner_1 = require("./runner");
 const creator = new creator_1.BasicCaseCreator({
     clean: true,
     describe: false,
-    testConfig: testConfig => {
+    testConfig: (testConfig) => {
         const oldModuleScope = testConfig.moduleScope;
         testConfig.moduleScope = (ms, stats, compilerOptions) => {
             let res = ms;
             // TODO: modify runner module scope based on stats here
-            if (typeof oldModuleScope === "function") {
+            if (typeof oldModuleScope === 'function') {
                 res = oldModuleScope(ms, stats, compilerOptions);
             }
             return res;
@@ -21,9 +21,9 @@ const creator = new creator_1.BasicCaseCreator({
     steps: ({ name }) => [(0, config_1.createConfigProcessor)(name)],
     runner: {
         key: runner_1.getMultiCompilerRunnerKey,
-        runner: runner_1.createMultiCompilerRunner
+        runner: runner_1.createMultiCompilerRunner,
     },
-    concurrent: 1
+    concurrent: 1,
 });
 function createSerialCase(name, src, dist) {
     creator.create(name, src, dist);

package/dist/case/stats-api.d.ts

@@ -1,5 +1,5 @@
-import type { Compiler, RspackOptions, Stats } from "@rspack/core";
-import type { ITestContext } from "../type";
+import type { Compiler, RspackOptions, Stats } from '@rspack/core';
+import type { ITestContext } from '../type';
 export type TStatsAPICaseConfig = {
     description: string;
     options?: (context: ITestContext) => RspackOptions;

package/dist/case/stats-api.js

@@ -22,7 +22,7 @@ const creator = new creator_1.BasicCaseCreator({
                 },
                 build: async (context) => {
                     const compiler = context.getCompiler();
-                    if (typeof config.build === "function") {
+                    if (typeof config.build === 'function') {
                         await config.build(context, compiler.getCompiler());
                     }
                     else {
@@ -34,11 +34,11 @@ const creator = new creator_1.BasicCaseCreator({
                 },
                 check: async (env, context) => {
                     await check(env, context, name, config.check);
-                }
-            }
+                },
+            },
         ];
     },
-    concurrent: true
+    concurrent: true,
 });
 function createStatsAPICase(name, src, dist, testConfig) {
     if (!addedSerializer) {
@@ -47,7 +47,7 @@ function createStatsAPICase(name, src, dist, testConfig) {
     const caseConfig = require(testConfig);
     creator.create(name, src, dist, undefined, {
         caseConfig,
-        description: () => caseConfig.description
+        description: () => caseConfig.description,
     });
 }
 function options(context, custom) {
@@ -59,7 +59,7 @@ function options(context, custom) {
     res.experiments.rspackFuture.bundlerInfo.force ??= false;
     if (!global.printLogger) {
         res.infrastructureLogging = {
-            level: "error"
+            level: 'error',
         };
     }
     return res;
@@ -75,6 +75,6 @@ async function compiler(context, compiler, custom) {
 async function check(env, context, name, custom) {
     const manager = context.getCompiler();
     const stats = manager.getStats();
-    env.expect(typeof stats).toBe("object");
+    env.expect(typeof stats).toBe('object');
     await custom?.(stats, manager.getCompiler());
 }

package/dist/case/stats-output.d.ts

@@ -1,5 +1,5 @@
-import type { RspackOptions } from "@rspack/core";
-import type { ITestContext, ITestEnv } from "../type";
+import type { RspackOptions } from '@rspack/core';
+import type { ITestContext, ITestEnv } from '../type';
 export declare function createStatsProcessor(name: string, defaultOptions: (index: number, context: ITestContext) => RspackOptions, overrideOptions: (index: number, context: ITestContext, options: RspackOptions) => void): {
     before: (context: ITestContext) => Promise<void>;
     config: (context: ITestContext) => Promise<void>;