@rspack/test-tools 1.7.0-beta.1 → 1.7.1

package/dist/case/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 createCompilerCase(name: string, src: string, dist: string, testConfig: string): void;
 export type TCompilerCaseConfig = {
     description: string;
@@ -8,7 +8,7 @@ export type TCompilerCaseConfig = {
     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/compiler.js

@@ -5,18 +5,18 @@ const creator_1 = require("../test/creator");
 function createCompilerProcessor(name, caseConfig) {
     const logs = {
         mkdir: [],
-        writeFile: []
+        writeFile: [],
     };
     const files = {};
     return {
         config: async (context) => {
             const compiler = context.getCompiler();
             const options = caseConfig.options?.(context) || {};
-            options.mode ??= "production";
+            options.mode ??= 'production';
             options.context ??= context.getSource();
-            options.entry ??= "./a.js";
+            options.entry ??= './a.js';
             options.output ??= {};
-            options.output.path ??= "/";
+            options.output.path ??= '/';
             options.output.pathinfo ??= true;
             options.optimization ??= {};
             options.optimization.minimize ??= false;
@@ -47,25 +47,25 @@ function createCompilerProcessor(name, caseConfig) {
                     }
                     else {
                         const err = new Error();
-                        err.code = "EEXIST";
+                        err.code = 'EEXIST';
                         callback(err);
                     }
                 },
                 writeFile(name, content, callback) {
                     logs.writeFile.push(name, content);
-                    files[name] = content.toString("utf-8");
+                    files[name] = content.toString('utf-8');
                     callback();
                 },
                 stat(path, callback) {
-                    callback(new Error("ENOENT"));
-                }
+                    callback(new Error('ENOENT'));
+                },
             };
-            c.hooks.compilation.tap("CompilerTest", compilation => (compilation.bail = true));
+            c.hooks.compilation.tap('CompilerTest', (compilation) => (compilation.bail = true));
             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 {
@@ -80,7 +80,7 @@ function createCompilerProcessor(name, caseConfig) {
             if (caseConfig.error) {
                 const statsJson = stats?.toJson({
                     modules: true,
-                    reasons: true
+                    reasons: true,
                 });
                 const compilation = stats?.compilation;
                 await caseConfig.check?.({
@@ -88,18 +88,18 @@ function createCompilerProcessor(name, caseConfig) {
                     compiler: c,
                     stats: statsJson,
                     compilation,
-                    files
+                    files,
                 });
             }
             else if (stats) {
-                expect(typeof stats).toBe("object");
+                expect(typeof stats).toBe('object');
                 const compilation = stats.compilation;
                 const statsJson = stats.toJson({
                     modules: true,
-                    reasons: true
+                    reasons: true,
                 });
-                expect(typeof statsJson).toBe("object");
-                expect(statsJson).toHaveProperty("errors");
+                expect(typeof statsJson).toBe('object');
+                expect(statsJson).toHaveProperty('errors');
                 expect(Array.isArray(statsJson.errors)).toBe(true);
                 if (statsJson.errors.length > 0) {
                     expect(statsJson.errors[0]).toBeInstanceOf(Object);
@@ -111,20 +111,20 @@ function createCompilerProcessor(name, caseConfig) {
                     stats: statsJson,
                     files,
                     compiler: c,
-                    compilation
+                    compilation,
                 });
             }
             else {
                 await caseConfig.check?.({
                     context,
                     files,
-                    compiler: c
+                    compiler: c,
                 });
             }
         },
         after: async (context) => {
             await context.closeCompiler();
-        }
+        },
     };
 }
 const creator = new creator_1.BasicCaseCreator({
@@ -133,7 +133,7 @@ const creator = new creator_1.BasicCaseCreator({
     steps: ({ name, caseConfig }) => {
         return [createCompilerProcessor(name, caseConfig)];
     },
-    concurrent: false
+    concurrent: false,
 });
 function createCompilerCase(name, src, dist, testConfig) {
     let caseConfigList = require(testConfig);
@@ -148,7 +148,7 @@ function createCompilerCase(name, src, dist, testConfig) {
         }
         creator.create(`${name}[${i}]`, src, dist, undefined, {
             caseConfig,
-            description: () => caseConfig.description
+            description: () => caseConfig.description,
         });
     }
 }

package/dist/case/config.d.ts

@@ -1,6 +1,6 @@
-import type { RspackOptions } from "@rspack/core";
-import type { ITestContext, ITestProcessor, TTestConfig } from "../type";
-export type TConfigCaseConfig = Omit<TTestConfig, "validate">;
+import type { RspackOptions } from '@rspack/core';
+import type { ITestContext, ITestProcessor, TTestConfig } from '../type';
+export type TConfigCaseConfig = Omit<TTestConfig, 'validate'>;
 export declare function createConfigProcessor(name: string): ITestProcessor;
 export declare function createConfigCase(name: string, src: string, dist: string): void;
 export declare function defaultOptions(index: number, context: ITestContext): RspackOptions;

package/dist/case/config.js

@@ -17,7 +17,7 @@ const runner_1 = require("./runner");
 function createConfigProcessor(name) {
     return {
         config: async (context) => {
-            (0, common_1.configMultiCompiler)(context, name, ["rspack.config.cjs", "rspack.config.js", "webpack.config.js"], defaultOptions, overrideOptions);
+            (0, common_1.configMultiCompiler)(context, name, ['rspack.config.cjs', 'rspack.config.js', 'webpack.config.js'], defaultOptions, overrideOptions);
         },
         compiler: async (context) => {
             await (0, common_1.compiler)(context, name);
@@ -33,18 +33,18 @@ function createConfigProcessor(name) {
         },
         after: async (context) => {
             await (0, common_1.afterExecute)(context, name);
-        }
+        },
     };
 }
 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;
@@ -53,9 +53,9 @@ const creator = new creator_1.BasicCaseCreator({
     steps: ({ name }) => [createConfigProcessor(name)],
     runner: {
         key: runner_1.getMultiCompilerRunnerKey,
-        runner: runner_1.createMultiCompilerRunner
+        runner: runner_1.createMultiCompilerRunner,
     },
-    concurrent: true
+    concurrent: true,
 });
 function createConfigCase(name, src, dist) {
     creator.create(name, src, dist);
@@ -63,29 +63,29 @@ function createConfigCase(name, src, dist) {
 function defaultOptions(index, context) {
     return {
         context: context.getSource(),
-        mode: "production",
-        target: "async-node",
+        mode: 'production',
+        target: 'async-node',
         devtool: false,
         cache: false,
         output: {
-            path: context.getDist()
+            path: context.getDist(),
         },
         optimization: {
-            minimize: false
+            minimize: false,
         },
         experiments: {
             css: true,
             rspackFuture: {
                 bundlerInfo: {
-                    force: false
-                }
-            }
-        }
+                    force: false,
+                },
+            },
+        },
     };
 }
 function overrideOptions(index, context, options) {
     if (!options.entry) {
-        options.entry = "./index.js";
+        options.entry = './index.js';
     }
     if (options.amd === undefined) {
         options.amd = {};
@@ -93,19 +93,19 @@ function overrideOptions(index, context, options) {
     if (!options.output?.filename) {
         const outputModule = options.experiments?.outputModule;
         options.output ??= {};
-        options.output.filename = `bundle${index}${outputModule ? ".mjs" : ".js"}`;
+        options.output.filename = `bundle${index}${outputModule ? '.mjs' : '.js'}`;
     }
     if (options.cache === undefined)
         options.cache = false;
     if (!global.printLogger) {
         options.infrastructureLogging = {
-            level: "error"
+            level: 'error',
         };
     }
 }
 function findBundle(index, context, options) {
     const testConfig = context.getTestConfig();
-    if (typeof testConfig.findBundle === "function") {
+    if (typeof testConfig.findBundle === 'function') {
         return testConfig.findBundle(index, options);
     }
     const ext = path_1.default.extname((0, parseResource_1.parseResource)(options.output?.filename).path);
@@ -113,7 +113,7 @@ function findBundle(index, context, options) {
     if (options.output?.path &&
         fs_extra_1.default.existsSync(path_1.default.join(options.output.path, `bundle${index}${ext}`))) {
         if (options.experiments?.css) {
-            const cssOutputPath = path_1.default.join(options.output.path, (typeof options.output?.cssFilename === "string" &&
+            const cssOutputPath = path_1.default.join(options.output.path, (typeof options.output?.cssFilename === 'string' &&
                 options.output?.cssFilename) ||
                 `bundle${index}.css`);
             if (fs_extra_1.default.existsSync(cssOutputPath)) {

package/dist/case/defaults.d.ts

@@ -1,5 +1,5 @@
-import type { RspackOptions } from "@rspack/core";
-import type { ITestContext } from "../type";
+import type { RspackOptions } from '@rspack/core';
+import type { ITestContext } from '../type';
 export declare function createDefaultsCase(name: string, src: string): void;
 export declare function getRspackDefaultConfig(cwd: string, config: RspackOptions): RspackOptions;
 export type TDefaultsCaseConfig = {

package/dist/case/defaults.js

@@ -30,33 +30,33 @@ function createDefaultsCase(name, src) {
             },
             check: async (env, context) => {
                 await check(env, context, name, caseConfig);
-            }
+            },
         });
     });
 }
 function getRspackDefaultConfig(cwd, config) {
     process.chdir(cwd);
-    const { applyWebpackOptionsDefaults, getNormalizedWebpackOptions } = require("@rspack/core").config;
+    const { applyWebpackOptionsDefaults, getNormalizedWebpackOptions } = require('@rspack/core').config;
     const normalizedConfig = getNormalizedWebpackOptions(config);
     applyWebpackOptionsDefaults(normalizedConfig);
     // make snapshot stable
     normalizedConfig.experiments.rspackFuture.bundlerInfo.version =
-        "$version$";
+        '$version$';
     process.chdir(CURRENT_CWD);
     return normalizedConfig;
 }
-const srcDir = node_path_1.default.resolve(__dirname, "../../tests/fixtures");
-const distDir = node_path_1.default.resolve(__dirname, "../../tests/js/defaults");
+const srcDir = node_path_1.default.resolve(__dirname, '../../tests/fixtures');
+const distDir = node_path_1.default.resolve(__dirname, '../../tests/js/defaults');
 function options(context, custom) {
     let res;
-    if (typeof custom === "function") {
+    if (typeof custom === 'function') {
         res = custom(context);
     }
     else {
         res = {};
     }
-    if (!("mode" in res)) {
-        res.mode = "none";
+    if (!('mode' in res)) {
+        res.mode = 'none';
     }
     return res;
 }
@@ -69,7 +69,7 @@ async function check(env, context, name, options) {
     const compiler = context.getCompiler();
     const config = getRspackDefaultConfig(options.cwd || CURRENT_CWD, compiler.getOptions());
     const defaultConfig = getRspackDefaultConfig(options.cwd || CURRENT_CWD, {
-        mode: "none"
+        mode: 'none',
     });
     const diff = (0, node_util_1.stripVTControlCharacters)((0, jest_diff_1.diff)(defaultConfig, config, { expand: false, contextLines: 0 }));
     await options.diff(env.expect(new RspackTestDiff(diff)), env.expect(defaultConfig));
@@ -78,7 +78,7 @@ async function run(name, processor) {
     const context = new context_1.TestContext({
         name: name,
         src: srcDir,
-        dist: distDir
+        dist: distDir,
     });
     try {
         await processor.before?.(context);

package/dist/case/diagnostic.js

@@ -18,13 +18,13 @@ const creator = new creator_1.BasicCaseCreator({
             config: async (context) => {
                 const compiler = context.getCompiler();
                 let options = defaultOptions(context);
-                const custom = (0, helper_1.readConfigFile)(["rspack.config.js", "webpack.config.js"].map(i => context.getSource(i)), context, options)[0];
+                const custom = (0, helper_1.readConfigFile)(['rspack.config.js', 'webpack.config.js'].map((i) => context.getSource(i)), context, options)[0];
                 if (custom) {
                     options = (0, webpack_merge_1.default)(options, custom);
                 }
                 if (!global.printLogger) {
                     options.infrastructureLogging = {
-                        level: "error"
+                        level: 'error',
                     };
                 }
                 compiler.setOptions(options);
@@ -42,89 +42,89 @@ const creator = new creator_1.BasicCaseCreator({
             },
             check: async (env, context) => {
                 await check(env, context, name, {
-                    snapshot: "./stats.err",
-                    snapshotErrors: "./raw-error.err",
-                    snapshotWarning: "./raw-warning.err",
+                    snapshot: './stats.err',
+                    snapshotErrors: './raw-error.err',
+                    snapshotWarning: './raw-warning.err',
                     format: (output) => {
                         // TODO: change to stats.errorStack
                         // TODO: add `errorStack: false`
-                        return output.replace(/(│.* at ).*/g, "$1xxx");
-                    }
+                        return output.replace(/(│.* at ).*/g, '$1xxx');
+                    },
                 });
-            }
-        }
+            },
+        },
     ],
-    concurrent: true
+    concurrent: true,
 });
 function createDiagnosticCase(name, src, dist) {
     creator.create(name, src, dist);
 }
 function defaultOptions(context) {
     return {
-        target: "node",
+        target: 'node',
         context: context.getSource(),
         entry: {
-            main: "./"
+            main: './',
         },
-        mode: "development",
+        mode: 'development',
         devServer: {
-            hot: false
+            hot: false,
         },
         infrastructureLogging: {
-            debug: false
+            debug: false,
         },
         output: {
-            path: context.getDist()
+            path: context.getDist(),
         },
         experiments: {
             css: true,
             rspackFuture: {
                 bundlerInfo: {
-                    force: false
-                }
-            }
-        }
+                    force: false,
+                },
+            },
+        },
     };
 }
 async function check(env, context, name, options) {
     const compiler = context.getCompiler();
     const stats = compiler.getStats();
     if (!stats) {
-        throw new Error("Stats should exists");
+        throw new Error('Stats should exists');
     }
     (0, node_assert_1.default)(stats.hasErrors() || stats.hasWarnings());
     let output = (0, placeholder_1.normalizePlaceholder)(stats.toString({
         all: false,
         errors: true,
-        warnings: true
-    })).replaceAll("\\", "/");
+        warnings: true,
+    })).replaceAll('\\', '/');
     const statsJson = stats.toJson({
         all: false,
         errors: true,
-        warnings: true
+        warnings: true,
     });
-    const errors = (statsJson.errors || []).map(e => {
+    const errors = (statsJson.errors || []).map((e) => {
         // @ts-expect-error error message is already serialized in `stats.err`
         delete e.message;
         delete e.stack;
         return e;
     });
-    const warnings = (statsJson.warnings || []).map(e => {
+    const warnings = (statsJson.warnings || []).map((e) => {
         // @ts-expect-error error message is already serialized in `stats.err`
         delete e.message;
         delete e.stack;
         return e;
     });
-    if (typeof options.format === "function") {
+    if (typeof options.format === 'function') {
         output = options.format(output);
     }
     env.expect.addSnapshotSerializer({
         test(received) {
-            return typeof received === "string";
+            return typeof received === 'string';
         },
         serialize(received) {
             return (0, placeholder_1.normalizePlaceholder)(received.trim());
-        }
+        },
     });
     const errorOutputPath = node_path_1.default.resolve(context.getSource(options.snapshot));
     const errorStatsOutputPath = node_path_1.default.resolve(context.getSource(options.snapshotErrors));

package/dist/case/error.d.ts

@@ -1,5 +1,5 @@
-import type { Compiler, RspackOptions, StatsError } from "@rspack/core";
-import type { ITestContext } from "../type";
+import type { Compiler, RspackOptions, StatsError } from '@rspack/core';
+import type { ITestContext } from '../type';
 export declare function createErrorCase(name: string, src: string, dist: string, testConfig: string): void;
 declare class RspackStatsDiagnostics {
     errors: StatsError[];

package/dist/case/error.js

@@ -26,7 +26,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 {
@@ -38,11 +38,11 @@ const creator = new creator_1.BasicCaseCreator({
                 },
                 check: async (env, context) => {
                     await check(env, context, name, config.check);
-                }
-            }
+                },
+            },
         ];
     },
-    concurrent: true
+    concurrent: true,
 });
 function createErrorCase(name, src, dist, testConfig) {
     if (!addedSerializer) {
@@ -56,7 +56,7 @@ function createErrorCase(name, src, dist, testConfig) {
         }
         creator.create(name, src, dist, undefined, {
             caseConfig,
-            description: () => caseConfig.description
+            description: () => caseConfig.description,
         });
     }
     if (Array.isArray(caseConfigList)) {
@@ -70,27 +70,27 @@ function createErrorCase(name, src, dist, testConfig) {
 }
 function options(context, custom) {
     let options = {
-        context: node_path_1.default.resolve(__TEST_FIXTURES_PATH__, "errors"),
-        mode: "none",
+        context: node_path_1.default.resolve(__TEST_FIXTURES_PATH__, 'errors'),
+        mode: 'none',
         devtool: false,
         optimization: {
             minimize: false,
-            moduleIds: "named",
-            chunkIds: "named"
+            moduleIds: 'named',
+            chunkIds: 'named',
         },
         experiments: {
             css: true,
             rspackFuture: {
                 bundlerInfo: {
-                    force: false
-                }
-            }
-        }
+                    force: false,
+                },
+            },
+        },
     };
-    if (typeof custom === "function") {
+    if (typeof custom === 'function') {
         options = (0, webpack_merge_1.default)(options, custom(context, options));
     }
-    if (options.mode === "production") {
+    if (options.mode === 'production') {
         if (options.optimization)
             options.optimization.minimize = true;
         else
@@ -103,10 +103,10 @@ async function compiler(context, compiler, custom) {
         compiler.outputFileSystem = {
             // CHANGE: rspack outputFileSystem `mkdirp` uses option `{ recursive: true }`, webpack's second parameter is alway a callback
             mkdir(dir, maybeOptionOrCallback, maybeCallback) {
-                if (typeof maybeOptionOrCallback === "function") {
+                if (typeof maybeOptionOrCallback === 'function') {
                     maybeOptionOrCallback();
                 }
-                else if (typeof maybeCallback === "function") {
+                else if (typeof maybeCallback === 'function') {
                     maybeCallback();
                 }
             },
@@ -114,10 +114,10 @@ async function compiler(context, compiler, custom) {
                 callback();
             },
             stat(file, callback) {
-                callback(new Error("ENOENT"));
+                callback(new Error('ENOENT'));
             },
             mkdirSync() { },
-            writeFileSync() { }
+            writeFileSync() { },
         };
     }
     await custom?.(context, compiler);
@@ -136,9 +136,9 @@ async function check(env, context, name, check) {
     }
     const compiler = context.getCompiler();
     const stats = compiler.getStats();
-    env.expect(typeof stats).toBe("object");
+    env.expect(typeof stats).toBe('object');
     const statsResult = stats.toJson({ errorDetails: false });
-    env.expect(typeof statsResult).toBe("object");
+    env.expect(typeof statsResult).toBe('object');
     const { errors, warnings } = statsResult;
     env.expect(Array.isArray(errors)).toBe(true);
     env.expect(Array.isArray(warnings)).toBe(true);