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

package/dist/case/esm-output.js

@@ -11,12 +11,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) => {
             let res = ms;
             // TODO: modify runner module scope based on stats here
-            if (typeof oldModuleScope === "function") {
+            if (typeof oldModuleScope === 'function') {
                 res = oldModuleScope(ms, stats);
             }
             return res;
@@ -25,11 +25,11 @@ const creator = new creator_1.BasicCaseCreator({
     steps: ({ name }) => [
         {
             config: async (context) => {
-                (0, common_1.configMultiCompiler)(context, name, ["rspack.config.cjs", "rspack.config.js", "webpack.config.js"], defaultOptions, (_index, context, options) => {
+                (0, common_1.configMultiCompiler)(context, name, ['rspack.config.cjs', 'rspack.config.js', 'webpack.config.js'], defaultOptions, (_index, context, options) => {
                     const testConfig = context.getTestConfig();
                     if (testConfig.esmLibPluginOptions) {
                         let target;
-                        const otherPlugins = options.plugins?.filter(plugin => {
+                        const otherPlugins = options.plugins?.filter((plugin) => {
                             const isTarget = plugin instanceof core_1.default.experiments.EsmLibraryPlugin;
                             if (isTarget) {
                                 target = plugin;
@@ -40,8 +40,8 @@ const creator = new creator_1.BasicCaseCreator({
                             ...otherPlugins,
                             new core_1.default.experiments.EsmLibraryPlugin({
                                 ...target.options,
-                                ...testConfig.esmLibPluginOptions
-                            })
+                                ...testConfig.esmLibPluginOptions,
+                            }),
                         ];
                     }
                 });
@@ -55,11 +55,11 @@ const creator = new creator_1.BasicCaseCreator({
             run: async (env, context) => {
                 await (0, common_1.run)(env, context, name, (context) => (0, common_1.findMultiCompilerBundle)(context, name, (_index, context, options) => {
                     const testConfig = context.getTestConfig();
-                    if (typeof testConfig.findBundle === "function") {
+                    if (typeof testConfig.findBundle === 'function') {
                         return testConfig.findBundle(_index, options);
                     }
-                    if (options.output?.filename === "[name].mjs") {
-                        return ["main.mjs"];
+                    if (options.output?.filename === '[name].mjs') {
+                        return ['main.mjs'];
                     }
                     else {
                         return [options.output.filename];
@@ -68,53 +68,53 @@ const creator = new creator_1.BasicCaseCreator({
             },
             check: async (env, context) => {
                 await (0, common_1.check)(env, context, name);
-                await (0, common_1.checkSnapshot)(env, context, name, "esm.snap.txt");
+                await (0, common_1.checkSnapshot)(env, context, name, 'esm.snap.txt');
             },
             after: async (context) => {
                 await (0, common_1.afterExecute)(context, name);
-            }
-        }
+            },
+        },
     ],
     runner: {
         key: runner_1.getMultiCompilerRunnerKey,
-        runner: runner_1.createMultiCompilerRunner
+        runner: runner_1.createMultiCompilerRunner,
     },
-    concurrent: 1
+    concurrent: 1,
 });
 const defaultOptions = (_index, context) => ({
     context: context.getSource(),
-    mode: "production",
-    target: "async-node",
+    mode: 'production',
+    target: 'async-node',
     devtool: false,
-    entry: "./index.js",
+    entry: './index.js',
     cache: false,
     output: {
         path: context.getDist(),
-        filename: "[name].mjs",
+        filename: '[name].mjs',
         pathinfo: true,
-        module: true
+        module: true,
     },
     bail: true,
     optimization: {
         minimize: false,
-        moduleIds: "named",
-        chunkIds: "named",
-        runtimeChunk: "single"
+        moduleIds: 'named',
+        chunkIds: 'named',
+        runtimeChunk: 'single',
     },
     externals: {
-        fs: "module-import fs",
-        path: "module-import path"
+        fs: 'module-import fs',
+        path: 'module-import path',
     },
     plugins: [new core_1.default.experiments.EsmLibraryPlugin()],
     experiments: {
         css: true,
         rspackFuture: {
             bundlerInfo: {
-                force: false
-            }
+                force: false,
+            },
         },
-        outputModule: true
-    }
+        outputModule: true,
+    },
 });
 function createEsmOutputCase(name, src, dist) {
     creator.create(name, src, dist);

package/dist/case/example.js

@@ -12,16 +12,16 @@ function overrideOptions(index, context, options) {
     options.output = options.output || {};
     options.output.pathinfo = true;
     options.output.path = context.getDist();
-    options.output.publicPath = "dist/";
+    options.output.publicPath = 'dist/';
     if (!options.entry)
-        options.entry = "./example.js";
+        options.entry = './example.js';
     if (!options.plugins)
         options.plugins = [];
 }
 function createExampleProcessor(name) {
     return {
         config: async (context) => {
-            (0, common_1.configMultiCompiler)(context, name, ["rspack.config.js", "webpack.config.js"], () => ({}), overrideOptions);
+            (0, common_1.configMultiCompiler)(context, name, ['rspack.config.js', 'webpack.config.js'], () => ({}), overrideOptions);
         },
         compiler: async (context) => {
             await (0, common_1.compiler)(context, name);
@@ -40,18 +40,18 @@ function createExampleProcessor(name) {
                     all: false,
                     errors: true,
                     errorDetails: true,
-                    errorStack: true
+                    errorStack: true,
                 }));
             }
             expect(stats?.hasErrors()).toBe(false);
-        }
+        },
     };
 }
 const creator = new creator_1.BasicCaseCreator({
     clean: true,
     steps: ({ name }) => [createExampleProcessor(name)],
-    concurrent: true
+    concurrent: true,
 });
 function createExampleCase(name, src) {
-    creator.create(name, src, node_path_1.default.join(src, "dist"));
+    creator.create(name, src, node_path_1.default.join(src, 'dist'));
 }

package/dist/case/hash.d.ts

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

package/dist/case/hash.js

@@ -20,7 +20,7 @@ const creator = new HashCaseCreator({
     steps: ({ name }) => [
         {
             config: async (context) => {
-                (0, common_1.configMultiCompiler)(context, name, ["rspack.config.js", "webpack.config.js"], defaultOptions, overrideOptions);
+                (0, common_1.configMultiCompiler)(context, name, ['rspack.config.js', 'webpack.config.js'], defaultOptions, overrideOptions);
             },
             compiler: async (context) => {
                 await (0, common_1.compiler)(context, name);
@@ -33,9 +33,9 @@ const creator = new HashCaseCreator({
             },
             check: async (env, context) => {
                 await check(env, context, name);
-            }
-        }
-    ]
+            },
+        },
+    ],
 });
 function createHashCase(name, src, dist) {
     creator.create(name, src, dist);
@@ -44,25 +44,25 @@ function defaultOptions(index, context) {
     return {
         context: context.getSource(),
         output: {
-            path: context.getDist()
+            path: context.getDist(),
         },
         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 (!global.printLogger) {
         options.infrastructureLogging = {
-            level: "error"
+            level: 'error',
         };
     }
 }
@@ -71,11 +71,11 @@ async function check(env, context, name) {
     const stats = compiler.getStats();
     const testConfig = context.getTestConfig();
     if (!stats) {
-        throw new Error("No stats found\n" +
+        throw new Error('No stats found\n' +
             context
                 .getError()
-                .map(e => e.stack)
-                .join("\n"));
+                .map((e) => e.stack)
+                .join('\n'));
     }
     if (REG_ERROR_CASE.test(name)) {
         env.expect(stats.hasErrors());
@@ -83,10 +83,10 @@ async function check(env, context, name) {
     else {
         env.expect(!stats.hasErrors());
     }
-    if (typeof testConfig.validate === "function") {
+    if (typeof testConfig.validate === 'function') {
         testConfig.validate(stats);
     }
     else {
-        throw new Error("HashTestCases should have test.config.js and a validate method");
+        throw new Error('HashTestCases should have test.config.js and a validate method');
     }
 }

package/dist/case/hook.d.ts

@@ -1,6 +1,6 @@
-import { Compiler, type RspackOptions } from "@rspack/core";
-import { TestContext, type TTestContextOptions } from "../test/context";
-import type { ITestContext, ITestEnv } from "../type";
+import { Compiler, type RspackOptions } from '@rspack/core';
+import { TestContext, type TTestContextOptions } from '../test/context';
+import type { ITestContext, ITestEnv } from '../type';
 export declare function createHookCase(name: string, src: string, dist: string, source: string): void;
 export declare class HookCasesContext extends TestContext {
     protected src: string;

package/dist/case/hook.js

@@ -15,7 +15,7 @@ const context_1 = require("../test/context");
 const creator_1 = require("../test/creator");
 const common_1 = require("./common");
 const srcDir = __TEST_FIXTURES_PATH__;
-const distDir = node_path_1.default.resolve(__TEST_DIST_PATH__, "hook");
+const distDir = node_path_1.default.resolve(__TEST_DIST_PATH__, 'hook');
 const creator = new creator_1.BasicCaseCreator({
     clean: true,
     describe: true,
@@ -26,10 +26,10 @@ const creator = new creator_1.BasicCaseCreator({
             {
                 config: async (context) => {
                     const compiler = context.getCompiler();
-                    const options = await (0, common_1.config)(context, name, ["rspack.config.js", "webpack.config.js"], defaultOptions(context, caseConfig.options));
+                    const options = await (0, common_1.config)(context, name, ['rspack.config.js', 'webpack.config.js'], defaultOptions(context, caseConfig.options));
                     if (!global.printLogger) {
                         options.infrastructureLogging = {
-                            level: "error"
+                            level: 'error',
                         };
                     }
                     compiler.setOptions(options);
@@ -47,14 +47,14 @@ const creator = new creator_1.BasicCaseCreator({
                     // no need to run, just check snapshot
                 },
                 check: async (env, context) => {
-                    await (0, common_1.checkSnapshot)(env, context, name, node_path_1.default.join(src, "output.snap.txt"), caseConfig.snapshotFileFilter);
-                }
-            }
+                    await (0, common_1.checkSnapshot)(env, context, name, node_path_1.default.join(src, 'output.snap.txt'), caseConfig.snapshotFileFilter);
+                },
+            },
         ];
-    }
+    },
 });
 function createHookCase(name, src, dist, source) {
-    const caseConfig = require(node_path_1.default.join(src, "test.js"));
+    const caseConfig = require(node_path_1.default.join(src, 'test.js'));
     const testName = node_path_1.default.basename(name.slice(0, name.indexOf(node_path_1.default.extname(name))));
     creator.create(name, src, dist, undefined, {
         caseConfig,
@@ -62,8 +62,8 @@ function createHookCase(name, src, dist, source) {
         createContext: (config) => new HookCasesContext(src, testName, {
             src: source,
             dist: dist,
-            name: name
-        })
+            name: name,
+        }),
     });
 }
 const sourceSerializer = {
@@ -72,7 +72,7 @@ const sourceSerializer = {
     },
     print(val) {
         return val.source();
-    }
+    },
 };
 const internalSerializer = {
     test(val) {
@@ -80,23 +80,23 @@ const internalSerializer = {
     },
     print(val) {
         return JSON.stringify(`${val.constructor.name}(internal ignored)`);
-    }
+    },
 };
 const testPathSerializer = (0, path_serializer_1.createSnapshotSerializer)({
     replace: [
         {
             match: srcDir,
-            mark: "<HOOK_SRC_DIR>"
+            mark: '<HOOK_SRC_DIR>',
         },
         {
             match: distDir,
-            mark: "<HOOK_DIST_DIR>"
-        }
-    ]
+            mark: '<HOOK_DIST_DIR>',
+        },
+    ],
 });
 const escapeRegex = true;
 const printFunctionName = false;
-const normalizeNewlines = (str) => str.replace(/\r\n|\r/g, "\n");
+const normalizeNewlines = (str) => str.replace(/\r\n|\r/g, '\n');
 const serialize = (val, indent = 2, formatOverrides = {}) => normalizeNewlines((0, pretty_format_1.format)(val, {
     escapeRegex,
     indent,
@@ -104,10 +104,10 @@ const serialize = (val, indent = 2, formatOverrides = {}) => normalizeNewlines((
         ...(0, jest_snapshot_1.getSerializers)(),
         sourceSerializer,
         internalSerializer,
-        testPathSerializer
+        testPathSerializer,
     ],
     printFunctionName,
-    ...formatOverrides
+    ...formatOverrides,
 }));
 class HookCasesContext extends context_1.TestContext {
     constructor(src, testName, options) {
@@ -127,28 +127,28 @@ class HookCasesContext extends context_1.TestContext {
      * @example
      * compiler.hooks.compilation("name", context.snapped((...args) => { ... }))
      */
-    snapped(cb, prefix = "") {
+    snapped(cb, prefix = '') {
         // eslint-disable-next-line
         const context = this;
         return function SNAPPED_HOOK(...args) {
             const group = prefix ? prefix : context.count++;
-            context._addSnapshot(args, "input", group);
+            context._addSnapshot(args, 'input', group);
             const output = cb.apply(this, args);
-            if (output && typeof output.then === "function") {
+            if (output && typeof output.then === 'function') {
                 let resolve;
-                context.promises.push(new Promise(r => (resolve = r)));
+                context.promises.push(new Promise((r) => (resolve = r)));
                 return output
                     .then((o) => {
-                    context._addSnapshot(o, "output (Promise resolved)", group);
+                    context._addSnapshot(o, 'output (Promise resolved)', group);
                     return o;
                 })
                     .catch((o) => {
-                    context._addSnapshot(o, "output (Promise rejected)", group);
+                    context._addSnapshot(o, 'output (Promise rejected)', group);
                     return o;
                 })
                     .finally(resolve);
             }
-            context._addSnapshot(output, "output", group);
+            context._addSnapshot(output, 'output', group);
             return output;
         };
     }
@@ -160,11 +160,11 @@ class HookCasesContext extends context_1.TestContext {
             ? content
             : serialize(content, undefined, {
                 escapeString: true,
-                printBasicPrototype: true
-            }).replace(/\r\n/g, "\n");
+                printBasicPrototype: true,
+            }).replace(/\r\n/g, '\n');
         (this.snapshots[group] = this.snapshots[group] || []).push([
             normalizedContent,
-            name
+            name,
         ]);
         if (!this.snapshotsList.includes(group)) {
             this.snapshotsList.push(group);
@@ -174,7 +174,7 @@ class HookCasesContext extends context_1.TestContext {
      * @internal
      */
     async collectSnapshots(env, options = {
-        diff: {}
+        diff: {},
     }) {
         await Promise.allSettled(this.promises);
         if (!this.snapshotsList.length)
@@ -184,37 +184,37 @@ class HookCasesContext extends context_1.TestContext {
                 name = `## ${name || `test: ${index}`}\n\n`;
                 const block = `\`\`\`javascript\n${content}\n\`\`\`\n`;
                 return `${acc}${name + block}\n`;
-            }, "");
+            }, '');
             return `${acc}# ${Number.isInteger(group) ? `Group: ${index}` : group}\n\n${block}`;
-        }, "");
+        }, '');
         env
             .expect(snapshots)
-            .toMatchFileSnapshotSync(node_path_1.default.join(this.src, "hooks.snap.txt"), options);
+            .toMatchFileSnapshotSync(node_path_1.default.join(this.src, 'hooks.snap.txt'), options);
     }
 }
 exports.HookCasesContext = HookCasesContext;
 function defaultOptions(context, custom) {
     let defaultOptions = {
         context: context.getSource(),
-        mode: "production",
-        target: "async-node",
+        mode: 'production',
+        target: 'async-node',
         devtool: false,
         cache: false,
-        entry: "./hook",
+        entry: './hook',
         output: {
-            path: context.getDist()
+            path: context.getDist(),
         },
         optimization: {
-            minimize: false
+            minimize: false,
         },
         experiments: {
             css: true,
             rspackFuture: {
                 bundlerInfo: {
-                    force: false
-                }
-            }
-        }
+                    force: false,
+                },
+            },
+        },
     };
     if (custom) {
         defaultOptions = (0, webpack_merge_1.default)(defaultOptions, custom(context));

package/dist/case/hot-step.d.ts

@@ -1,2 +1,2 @@
-import type { RspackOptions } from "@rspack/core";
-export declare function createHotStepCase(name: string, src: string, dist: string, temp: string, target: RspackOptions["target"]): void;
+import type { RspackOptions } from '@rspack/core';
+export declare function createHotStepCase(name: string, src: string, dist: string, temp: string, target: RspackOptions['target']): void;