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

package/dist/case/builtin.d.ts

@@ -1,3 +1,4 @@
-import type { ECompilerType, ITestContext, TCompilerOptions } from "../type";
+import type { RspackOptions } from "@rspack/core";
+import type { ITestContext } from "../type";
 export declare function createBuiltinCase(name: string, src: string, dist: string): void;
-export declare function defaultOptions<T extends ECompilerType.Rspack>(context: ITestContext): TCompilerOptions<T>;
+export declare function defaultOptions(context: ITestContext): RspackOptions;

package/dist/case/builtin.js

@@ -23,7 +23,7 @@ const creator = new creator_1.BasicCaseCreator({
         return [
             {
                 config: async (context) => {
-                    const compiler = (0, common_1.getCompiler)(context, name);
+                    const compiler = context.getCompiler();
                     compiler.setOptions(defaultOptions(context));
                 },
                 compiler: async (context) => {

package/dist/case/cache.d.ts

@@ -1,2 +1,2 @@
-import { type ECompilerType, type TCompilerOptions } from "../type";
-export declare function createCacheCase(name: string, src: string, dist: string, target: TCompilerOptions<ECompilerType.Rspack>["target"], temp: string): void;
+import { type RspackOptions } from "@rspack/core";
+export declare function createCacheCase(name: string, src: string, dist: string, target: RspackOptions["target"], temp: string): void;

package/dist/case/cache.js

@@ -11,7 +11,6 @@ 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 type_1 = require("../type");
 const common_1 = require("./common");
 const runner_2 = require("./runner");
 const MAX_COMPILER_INDEX = 100;
@@ -20,10 +19,10 @@ function createCacheProcessor(name, src, temp, target) {
     return {
         before: async (context) => {
             await updatePlugin.initialize();
-            context.setValue(name, "hotUpdateContext", updatePlugin);
+            context.setValue("hotUpdateContext", updatePlugin);
         },
         config: async (context) => {
-            const compiler = (0, common_1.getCompiler)(context, name);
+            const compiler = context.getCompiler();
             let options = defaultOptions(context, temp, target);
             options = await (0, common_1.config)(context, name, ["rspack.config.js", "webpack.config.js"].map(i => node_path_1.default.resolve(temp, i)), options);
             overrideOptions(options, temp, target, updatePlugin);
@@ -41,6 +40,9 @@ function createCacheProcessor(name, src, temp, target) {
         check: async (env, context) => {
             await (0, common_1.check)(env, context, name);
         },
+        after: async (context) => {
+            await (0, common_1.afterExecute)(context, name);
+        },
         afterAll: async (context) => {
             const updateIndex = updatePlugin.getUpdateIndex();
             const totalUpdates = updatePlugin.getTotalUpdates();
@@ -129,13 +131,16 @@ function overrideOptions(options, temp, target, updatePlugin) {
 function findBundle(name, target, context) {
     const files = [];
     const prefiles = [];
-    const compiler = (0, common_1.getCompiler)(context, name);
+    const compiler = context.getCompiler();
     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");
-    const info = stats.toJson({ all: false, entrypoints: true });
+    const info = stats.toJson({
+        all: false,
+        entrypoints: true
+    });
     if (target === "web" || target === "webworker") {
         for (const file of info.entrypoints.main.assets) {
             if ((0, helper_1.isJavaScript)(file.name)) {
@@ -153,16 +158,15 @@ function findBundle(name, target, context) {
     return [...prefiles, ...files];
 }
 function createRunner(context, name, file, env) {
-    const compiler = context.getCompiler(name);
+    const compiler = context.getCompiler();
     const options = compiler.getOptions();
     let compilerIndex = 0;
     const testConfig = context.getTestConfig();
     const source = context.getSource();
     const dist = context.getDist();
-    const updatePlugin = context.getValue(name, "hotUpdateContext");
+    const updatePlugin = context.getValue("hotUpdateContext");
     const getWebRunner = () => {
-        return new runner_1.WebRunner({
-            dom: context.getValue(name, "documentType") || type_1.EDocumentType.JSDOM,
+        return new runner_1.NodeRunner({
             env,
             stats: (0, runner_2.cachedStats)(context, name),
             cachable: false,

package/dist/case/common.d.ts

@@ -1,10 +1,11 @@
-import { ECompilerType, type ITestCompilerManager, type ITestContext, type ITestEnv, type TCompiler, type TCompilerOptions } from "../type";
-export declare function getCompiler<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string): ITestCompilerManager<T>;
-export declare function config<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string, configFiles: string[], defaultOptions?: TCompilerOptions<T>): Promise<TCompilerOptions<T>>;
-export declare function compiler<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string): Promise<TCompiler<T>>;
-export declare function build<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string): Promise<TCompiler<T>>;
-export declare function run<T extends ECompilerType = ECompilerType.Rspack>(env: ITestEnv, context: ITestContext, name: string, findBundle: (context: ITestContext, options: TCompilerOptions<T>) => string[] | string | void): Promise<void>;
-export declare function check<T extends ECompilerType = ECompilerType.Rspack>(env: ITestEnv, context: ITestContext, name: string): Promise<void>;
-export declare function checkSnapshot<T extends ECompilerType = ECompilerType.Rspack>(env: ITestEnv, context: ITestContext, name: string, snapshot: string, filter?: (file: string) => boolean): Promise<void>;
-export declare function findMultiCompilerBundle<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string, multiFindBundle: (index: number, context: ITestContext, options: TCompilerOptions<T>) => string[] | string | void): string[];
-export declare function configMultiCompiler<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string, configFiles: string[], defaultOptions: (index: number, context: ITestContext) => TCompilerOptions<T>, overrideOptions: (index: number, context: ITestContext, options: TCompilerOptions<T>) => void): void;
+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 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 findMultiCompilerBundle(context: ITestContext, name: string, multiFindBundle: (index: number, context: ITestContext, options: RspackOptions) => string[] | string | void): string[];
+export declare function configMultiCompiler(context: ITestContext, name: string, configFiles: string[], defaultOptions: (index: number, context: ITestContext) => RspackOptions, overrideOptions: (index: number, context: ITestContext, options: RspackOptions) => void): void;

package/dist/case/common.js

@@ -3,13 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCompiler = getCompiler;
 exports.config = config;
 exports.compiler = compiler;
 exports.build = build;
 exports.run = run;
 exports.check = check;
 exports.checkSnapshot = checkSnapshot;
+exports.afterExecute = afterExecute;
 exports.findMultiCompilerBundle = findMultiCompilerBundle;
 exports.configMultiCompiler = configMultiCompiler;
 const fs_extra_1 = __importDefault(require("fs-extra"));
@@ -18,26 +18,23 @@ const webpack_merge_1 = __importDefault(require("webpack-merge"));
 const helper_1 = require("../helper");
 const placeholder_1 = require("../helper/expect/placeholder");
 const checkArrayExpectation_1 = __importDefault(require("../helper/legacy/checkArrayExpectation"));
-const type_1 = require("../type");
-function getCompiler(context, name) {
-    return context.getCompiler(name, type_1.ECompilerType.Rspack);
-}
+const debug_1 = require("../test/debug");
 async function config(context, name, configFiles, defaultOptions = {}) {
-    const compiler = getCompiler(context, name);
+    const compiler = context.getCompiler();
     compiler.setOptions(defaultOptions);
     if (Array.isArray(configFiles)) {
-        const fileOptions = (0, helper_1.readConfigFile)(configFiles.map(i => context.getSource(i)))[0];
+        const fileOptions = (0, helper_1.readConfigFile)(configFiles.map(i => context.getSource(i)), context, defaultOptions)[0];
         compiler.mergeOptions(fileOptions);
     }
     return compiler.getOptions();
 }
 async function compiler(context, name) {
-    const compiler = getCompiler(context, name);
+    const compiler = context.getCompiler();
     compiler.createCompiler();
     return compiler.getCompiler();
 }
 async function build(context, name) {
-    const compiler = getCompiler(context, name);
+    const compiler = context.getCompiler();
     await compiler.build();
     return compiler.getCompiler();
 }
@@ -45,18 +42,12 @@ async function run(env, context, name, findBundle) {
     const testConfig = context.getTestConfig();
     if (testConfig.noTests)
         return;
-    if (testConfig.documentType) {
-        context.setValue(name, "documentType", testConfig.documentType);
-    }
-    const compiler = getCompiler(context, name);
+    const compiler = context.getCompiler();
     if (typeof testConfig.beforeExecute === "function") {
         testConfig.beforeExecute(compiler.getOptions());
     }
     let bundles;
-    if (testConfig.bundlePath) {
-        bundles = testConfig.bundlePath;
-    }
-    else if (typeof findBundle === "function") {
+    if (typeof findBundle === "function") {
         bundles = findBundle(context, compiler.getOptions());
     }
     else {
@@ -65,35 +56,39 @@ async function run(env, context, name, findBundle) {
     if (typeof bundles === "string") {
         bundles = [bundles];
     }
+    if (__DEBUG__) {
+        context.setValue(debug_1.DEBUG_SCOPES.RunFindBundle, bundles);
+    }
     if (!bundles || !bundles.length) {
         return;
     }
+    if (__DEBUG__) {
+        context.setValue(debug_1.DEBUG_SCOPES.RunLogs, []);
+        context.setValue(debug_1.DEBUG_SCOPES.RunErrors, []);
+    }
     for (const bundle of bundles) {
         if (!bundle) {
             continue;
         }
-        const runner = context.getRunner(name, bundle, env);
+        const runner = context.getRunner(bundle, env);
+        if (__DEBUG__) {
+            const runLogs = context.getValue(debug_1.DEBUG_SCOPES.RunLogs);
+            runLogs?.push(`Start running entry: ${bundle} in ${runner.constructor.name}(${runner.__key__})`);
+        }
         const mod = runner.run(bundle);
-        const result = context.getValue(name, "modules") || [];
+        const result = context.getValue("modules") || [];
         result.push(mod);
-        context.setValue(name, "modules", result);
+        context.setValue("modules", result);
     }
-    const results = context.getValue(name, "modules") || [];
+    const results = context.getValue("modules") || [];
     await Promise.all(results);
-    if (typeof testConfig.afterExecute === "function") {
-        let options = compiler.getOptions();
-        if (Array.isArray(options) && options.length === 1) {
-            options = options[0];
-        }
-        testConfig.afterExecute(options);
-    }
 }
 async function check(env, context, name) {
     const testConfig = context.getTestConfig();
     if (testConfig.noTests)
         return;
-    const compiler = getCompiler(context, name);
-    const errors = (context.getError(name) || []).map(e => ({
+    const compiler = context.getCompiler();
+    const errors = (context.getError() || []).map(e => ({
         message: e.message,
         stack: e.stack
     }));
@@ -132,14 +127,14 @@ async function check(env, context, name) {
     await (0, checkArrayExpectation_1.default)(context.getSource(), { warnings }, "warning", "warnings", "Warning", options);
     // clear error if checked
     if (fs_extra_1.default.existsSync(context.getSource("errors.js"))) {
-        context.clearError(name);
+        context.clearError();
     }
 }
 async function checkSnapshot(env, context, name, snapshot, filter) {
     if (path_1.default.extname(snapshot) === ".snap") {
         throw new Error("Snapshot with `.snap` will be managed by jest, please use `.snap.txt` instead");
     }
-    const compilerManager = getCompiler(context, name);
+    const compilerManager = context.getCompiler();
     const stats = compilerManager.getStats();
     const compiler = compilerManager.getCompiler();
     if (!stats || !compiler)
@@ -147,9 +142,7 @@ async function checkSnapshot(env, context, name, snapshot, filter) {
     const compilers = "compilers" in compiler
         ? compiler.compilers
         : [compiler];
-    const totalStats = "stats" in stats
-        ? stats.stats
-        : [stats];
+    const totalStats = "stats" in stats ? stats.stats : [stats];
     const total = compilers.length;
     for (let i = 0; i < compilers.length; i++) {
         const c = compilers[i];
@@ -175,23 +168,36 @@ async function checkSnapshot(env, context, name, snapshot, filter) {
             if (testConfig.snapshotContent) {
                 content = testConfig.snapshotContent(content);
             }
-            return `\`\`\`${tag} title=${file}\n${content}\n\`\`\``;
+            const filePath = file.replaceAll(path_1.default.sep, "/");
+            return `\`\`\`${tag} title=${filePath}\n${content}\n\`\`\``;
         });
         fileContents.sort();
         const content = fileContents.join("\n\n");
         const snapshotPath = path_1.default.isAbsolute(snapshot)
             ? snapshot
-            : path_1.default.resolve(context.getSource(), `./__snapshots__/${snapshot}${total > 1 ? `-${i}` : ""}`);
+            : path_1.default.resolve(context.getSource(), path_1.default.join("__snapshots__", `${snapshot}${total > 1 ? `-${i}` : ""}`));
         env.expect(content).toMatchFileSnapshot(snapshotPath);
     }
 }
+async function afterExecute(context, name) {
+    const compiler = context.getCompiler();
+    const testConfig = context.getTestConfig();
+    if (typeof testConfig.afterExecute === "function") {
+        let options = compiler.getOptions();
+        if (Array.isArray(options) && options.length === 1) {
+            options = options[0];
+        }
+        testConfig.afterExecute(options);
+    }
+}
 function findMultiCompilerBundle(context, name, multiFindBundle) {
     if (typeof multiFindBundle !== "function") {
         return [];
     }
-    const multiCompilerOptions = (context.getValue(name, "multiCompilerOptions") || []);
+    const multiCompilerOptions = (context.getValue("multiCompilerOptions") ||
+        []);
     const result = [];
-    const multiFileIndexMap = context.getValue(name, "multiFileIndexMap") || {};
+    const multiFileIndexMap = context.getValue("multiFileIndexMap") || {};
     for (const [index, compilerOptions] of multiCompilerOptions.entries()) {
         const curBundles = multiFindBundle(index, context, compilerOptions);
         const bundles = Array.isArray(curBundles)
@@ -209,13 +215,13 @@ function findMultiCompilerBundle(context, name, multiFindBundle) {
         }
         result.push(...bundles);
     }
-    context.setValue(name, "multiFileIndexMap", multiFileIndexMap);
+    context.setValue("multiFileIndexMap", multiFileIndexMap);
     return result;
 }
 function configMultiCompiler(context, name, configFiles, defaultOptions, overrideOptions) {
     const multiCompilerOptions = [];
     const caseOptions = Array.isArray(configFiles)
-        ? (0, helper_1.readConfigFile)(configFiles.map(i => context.getSource(i)), configs => {
+        ? (0, helper_1.readConfigFile)(configFiles.map(i => context.getSource(i)), context, {}, configs => {
             return configs.flatMap(c => {
                 if (typeof c === "function") {
                     const options = {
@@ -237,7 +243,7 @@ function configMultiCompiler(context, name, configFiles, defaultOptions, overrid
         }
         multiCompilerOptions.push(compilerOptions);
     }
-    const compiler = getCompiler(context, name);
+    const compiler = context.getCompiler();
     compiler.setOptions(multiCompilerOptions);
-    context.setValue(name, "multiCompilerOptions", multiCompilerOptions);
+    context.setValue("multiCompilerOptions", multiCompilerOptions);
 }

package/dist/case/compiler.d.ts

@@ -1,18 +1,19 @@
-import type { ECompilerType, ITestContext, TCompilation, TCompiler, TCompilerOptions, TCompilerStats, TCompilerStatsCompilation } 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;
     error?: boolean;
     skip?: boolean;
-    options?: (context: ITestContext) => TCompilerOptions<ECompilerType.Rspack>;
-    compiler?: (context: ITestContext, compiler: TCompiler<ECompilerType.Rspack>) => Promise<void>;
-    build?: (context: ITestContext, compiler: TCompiler<ECompilerType.Rspack>) => Promise<void>;
+    options?: (context: ITestContext) => RspackOptions;
+    compiler?: (context: ITestContext, compiler: Compiler) => Promise<void>;
+    build?: (context: ITestContext, compiler: Compiler) => Promise<void>;
     check?: ({ context, stats, files, compiler, compilation }: {
         context: ITestContext;
-        stats?: TCompilerStatsCompilation<ECompilerType.Rspack>;
+        stats?: StatsCompilation;
         files?: Record<string, string>;
-        compiler: TCompiler<ECompilerType.Rspack>;
-        compilation?: TCompilation<ECompilerType.Rspack>;
+        compiler: Compiler;
+        compilation?: Compilation;
     }) => Promise<void>;
-    compilerCallback?: (error: Error | null, stats: TCompilerStats<ECompilerType.Rspack> | null) => void;
+    compilerCallback?: (error: Error | null, stats: Stats | null) => void;
 };

package/dist/case/compiler.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCompilerCase = createCompilerCase;
 const creator_1 = require("../test/creator");
-const common_1 = require("./common");
 function createCompilerProcessor(name, caseConfig) {
     const logs = {
         mkdir: [],
@@ -11,7 +10,7 @@ function createCompilerProcessor(name, caseConfig) {
     const files = {};
     return {
         config: async (context) => {
-            const compiler = (0, common_1.getCompiler)(context, name);
+            const compiler = context.getCompiler();
             const options = caseConfig.options?.(context) || {};
             options.mode ??= "production";
             options.context ??= context.getSource();
@@ -24,7 +23,7 @@ function createCompilerProcessor(name, caseConfig) {
             compiler.setOptions(options);
         },
         compiler: async (context) => {
-            const compiler = (0, common_1.getCompiler)(context, name);
+            const compiler = context.getCompiler();
             if (caseConfig.compilerCallback) {
                 compiler.createCompilerWithCallback(caseConfig.compilerCallback);
             }
@@ -65,7 +64,7 @@ function createCompilerProcessor(name, caseConfig) {
             await caseConfig.compiler?.(context, c);
         },
         build: async (context) => {
-            const compiler = (0, common_1.getCompiler)(context, name);
+            const compiler = context.getCompiler();
             if (typeof caseConfig.build === "function") {
                 await caseConfig.build?.(context, compiler.getCompiler());
             }
@@ -75,7 +74,7 @@ function createCompilerProcessor(name, caseConfig) {
         },
         run: async (env, context) => { },
         check: async (env, context) => {
-            const compiler = (0, common_1.getCompiler)(context, name);
+            const compiler = context.getCompiler();
             const c = compiler.getCompiler();
             const stats = compiler.getStats();
             if (caseConfig.error) {
@@ -124,7 +123,7 @@ function createCompilerProcessor(name, caseConfig) {
             }
         },
         after: async (context) => {
-            await context.closeCompiler(name);
+            await context.closeCompiler();
         }
     };
 }

package/dist/case/config.d.ts

@@ -1,7 +1,8 @@
-import type { ECompilerType, ITestContext, ITestProcessor, TCompilerOptions, TTestConfig } from "../type";
-export type TConfigCaseConfig = Omit<TTestConfig<ECompilerType.Rspack>, "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): TCompilerOptions<ECompilerType.Rspack>;
-export declare function overrideOptions(index: number, context: ITestContext, options: TCompilerOptions<ECompilerType.Rspack>): void;
-export declare function findBundle(index: number, context: ITestContext, options: TCompilerOptions<ECompilerType.Rspack>): string | string[];
+export declare function defaultOptions(index: number, context: ITestContext): RspackOptions;
+export declare function overrideOptions(index: number, context: ITestContext, options: RspackOptions): void;
+export declare function findBundle(index: number, context: ITestContext, options: RspackOptions): string | string[];

package/dist/case/config.js

@@ -30,6 +30,9 @@ function createConfigProcessor(name) {
         },
         check: async (env, context) => {
             await (0, common_1.check)(env, context, name);
+        },
+        after: async (context) => {
+            await (0, common_1.afterExecute)(context, name);
         }
     };
 }
@@ -115,7 +118,7 @@ function findBundle(index, context, options) {
                 options.output?.cssFilename) ||
                 `bundle${index}.css`);
             if (fs_extra_1.default.existsSync(cssOutputPath)) {
-                bundlePath.push(`./bundle${index}.css`);
+                bundlePath.push(path_1.default.relative(options.output.path, cssOutputPath));
             }
         }
         bundlePath.push(`./bundle${index}${ext}`);

package/dist/case/defaults.d.ts

@@ -1,10 +1,11 @@
-import type { ECompilerType, ITestContext, TCompilerOptions } 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: TCompilerOptions<ECompilerType>): TCompilerOptions<ECompilerType>;
+export declare function getRspackDefaultConfig(cwd: string, config: RspackOptions): RspackOptions;
 export type TDefaultsCaseConfig = {
-    options?: (context: ITestContext) => TCompilerOptions<ECompilerType.Rspack>;
+    options?: (context: ITestContext) => RspackOptions;
     cwd?: string;
-    diff: (diff: jest.JestMatchers<RspackTestDiff>, defaults: jest.JestMatchers<TCompilerOptions<ECompilerType.Rspack>>) => Promise<void>;
+    diff: (diff: jest.JestMatchers<RspackTestDiff>, defaults: jest.JestMatchers<RspackOptions>) => Promise<void>;
     description: string;
 };
 declare class RspackTestDiff {

package/dist/case/defaults.js

@@ -9,18 +9,17 @@ const node_path_1 = __importDefault(require("node:path"));
 const node_util_1 = require("node:util");
 const jest_diff_1 = require("jest-diff");
 const context_1 = require("../test/context");
-const common_1 = require("./common");
 const CURRENT_CWD = process.cwd();
 function createDefaultsCase(name, src) {
     const caseConfig = require(src);
     it(`should generate the correct defaults from ${caseConfig.description}`, async () => {
         await run(name, {
             config: async (context) => {
-                const compiler = (0, common_1.getCompiler)(context, name);
+                const compiler = context.getCompiler();
                 compiler.setOptions(options(context, caseConfig.options));
             },
             compiler: async (context) => {
-                const compiler = (0, common_1.getCompiler)(context, name);
+                const compiler = context.getCompiler();
                 compiler.createCompiler();
             },
             build: async (context) => {
@@ -48,10 +47,6 @@ function getRspackDefaultConfig(cwd, config) {
 }
 const srcDir = node_path_1.default.resolve(__dirname, "../../tests/fixtures");
 const distDir = node_path_1.default.resolve(__dirname, "../../tests/js/defaults");
-const context = new context_1.TestContext({
-    src: srcDir,
-    dist: distDir
-});
 function options(context, custom) {
     let res;
     if (typeof custom === "function") {
@@ -71,7 +66,7 @@ class RspackTestDiff {
     }
 }
 async function check(env, context, name, options) {
-    const compiler = (0, common_1.getCompiler)(context, name);
+    const compiler = context.getCompiler();
     const config = getRspackDefaultConfig(options.cwd || CURRENT_CWD, compiler.getOptions());
     const defaultConfig = getRspackDefaultConfig(options.cwd || CURRENT_CWD, {
         mode: "none"
@@ -80,15 +75,20 @@ async function check(env, context, name, options) {
     await options.diff(env.expect(new RspackTestDiff(diff)), env.expect(defaultConfig));
 }
 async function run(name, processor) {
+    const context = new context_1.TestContext({
+        name: name,
+        src: srcDir,
+        dist: distDir
+    });
     try {
         await processor.before?.(context);
         await processor.config?.(context);
     }
     catch (e) {
-        context.emitError(name, e);
+        context.emitError(e);
     }
     finally {
-        await processor.check?.({ expect, it, beforeEach, afterEach, jest }, context);
+        await processor.check?.({ expect, it, beforeEach, afterEach, jest: global.jest || global.rstest }, context);
         await processor.after?.(context);
     }
 }

package/dist/case/diagnostic.js

@@ -10,16 +10,15 @@ const webpack_merge_1 = __importDefault(require("webpack-merge"));
 const helper_1 = require("../helper");
 const placeholder_1 = require("../helper/expect/placeholder");
 const creator_1 = require("../test/creator");
-const common_1 = require("./common");
 const creator = new creator_1.BasicCaseCreator({
     clean: true,
     describe: false,
     steps: ({ name }) => [
         {
             config: async (context) => {
-                const compiler = (0, common_1.getCompiler)(context, name);
+                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)))[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);
                 }
@@ -31,11 +30,11 @@ const creator = new creator_1.BasicCaseCreator({
                 compiler.setOptions(options);
             },
             compiler: async (context) => {
-                const compiler = (0, common_1.getCompiler)(context, name);
+                const compiler = context.getCompiler();
                 compiler.createCompiler();
             },
             build: async (context) => {
-                const compiler = (0, common_1.getCompiler)(context, name);
+                const compiler = context.getCompiler();
                 await compiler.build();
             },
             run: async (env, context) => {
@@ -89,7 +88,7 @@ function defaultOptions(context) {
     };
 }
 async function check(env, context, name, options) {
-    const compiler = (0, common_1.getCompiler)(context, name);
+    const compiler = context.getCompiler();
     const stats = compiler.getStats();
     if (!stats) {
         throw new Error("Stats should exists");

package/dist/case/error.d.ts

@@ -1,5 +1,5 @@
-import type { StatsError } from "@rspack/core";
-import type { ECompilerType, ITestContext, TCompiler, TCompilerOptions } 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[];
@@ -9,9 +9,9 @@ declare class RspackStatsDiagnostics {
 export type TErrorCaseConfig = {
     description: string;
     skip?: boolean;
-    options?: (context: ITestContext) => TCompilerOptions<ECompilerType.Rspack>;
-    compiler?: (context: ITestContext, compiler: TCompiler<ECompilerType.Rspack>) => Promise<void>;
-    build?: (context: ITestContext, compiler: TCompiler<ECompilerType.Rspack>) => Promise<void>;
+    options?: (context: ITestContext) => RspackOptions;
+    compiler?: (context: ITestContext, compiler: Compiler) => Promise<void>;
+    build?: (context: ITestContext, compiler: Compiler) => Promise<void>;
     check?: (stats: RspackStatsDiagnostics) => Promise<void>;
 };
 export {};

package/dist/case/error.js

@@ -7,7 +7,6 @@ exports.createErrorCase = createErrorCase;
 const node_path_1 = __importDefault(require("node:path"));
 const webpack_merge_1 = __importDefault(require("webpack-merge"));
 const creator_1 = require("../test/creator");
-const common_1 = require("./common");
 let addedSerializer = false;
 const creator = new creator_1.BasicCaseCreator({
     clean: true,
@@ -17,16 +16,16 @@ const creator = new creator_1.BasicCaseCreator({
         return [
             {
                 config: async (context) => {
-                    const compiler = (0, common_1.getCompiler)(context, name);
+                    const compiler = context.getCompiler();
                     compiler.setOptions(options(context, config.options));
                 },
                 compiler: async (context) => {
-                    const compilerManager = (0, common_1.getCompiler)(context, name);
+                    const compilerManager = context.getCompiler();
                     compilerManager.createCompiler();
                     compiler(context, compilerManager.getCompiler(), config.compiler);
                 },
                 build: async (context) => {
-                    const compiler = (0, common_1.getCompiler)(context, name);
+                    const compiler = context.getCompiler();
                     if (typeof config.build === "function") {
                         await config.build(context, compiler.getCompiler());
                     }
@@ -130,12 +129,12 @@ class RspackStatsDiagnostics {
     }
 }
 async function check(env, context, name, check) {
-    if (context.getError(name).length > 0) {
-        await check?.(new RspackStatsDiagnostics(context.getError(name), []));
-        context.clearError(name);
+    if (context.getError().length > 0) {
+        await check?.(new RspackStatsDiagnostics(context.getError(), []));
+        context.clearError();
         return;
     }
-    const compiler = (0, common_1.getCompiler)(context, name);
+    const compiler = context.getCompiler();
     const stats = compiler.getStats();
     env.expect(typeof stats).toBe("object");
     const statsResult = stats.toJson({ errorDetails: false });