@rspack-canary/test-tools 1.5.6-canary-e598f284-20250921173624 → 1.5.8-canary-e350b761-20250924173613

package/dist/case/watch.js

@@ -3,16 +3,205 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWatchInitialProcessor = createWatchInitialProcessor;
+exports.createWatchStepProcessor = createWatchStepProcessor;
 exports.createWatchCase = createWatchCase;
+exports.getWatchRunnerKey = getWatchRunnerKey;
+exports.createWatchRunner = createWatchRunner;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const watch_1 = require("../processor/watch");
+const webpack_merge_1 = __importDefault(require("webpack-merge"));
+const compiler_1 = require("../compiler");
+const helper_1 = require("../helper");
+const checkArrayExpectation_1 = __importDefault(require("../helper/legacy/checkArrayExpectation"));
+const copyDiff_1 = __importDefault(require("../helper/legacy/copyDiff"));
 const runner_1 = require("../runner");
 const creator_1 = require("../test/creator");
 const type_1 = require("../type");
+const common_1 = require("./common");
+// This file is used to port step number to rspack.config.js/webpack.config.js
+const currentWatchStepModulePath = node_path_1.default.resolve(__dirname, "../helper/util/currentWatchStep");
+function createWatchInitialProcessor(name, tempDir, step, watchState, { incremental = false, nativeWatcher = false, ignoreNotFriendlyForIncrementalWarnings = false } = {}) {
+    const watchContext = {
+        currentTriggerFilename: null,
+        lastHash: null,
+        step,
+        tempDir,
+        nativeWatcher,
+        watchState
+    };
+    return {
+        before: async (context) => {
+            context.setValue(name, "watchContext", watchContext);
+        },
+        config: async (context) => {
+            const multiCompilerOptions = [];
+            const caseOptions = (0, helper_1.readConfigFile)(["rspack.config.js", "webpack.config.js"].map(i => context.getSource(i)));
+            for (const [index, options] of caseOptions.entries()) {
+                const compilerOptions = (0, webpack_merge_1.default)(defaultOptions({
+                    incremental,
+                    ignoreNotFriendlyForIncrementalWarnings
+                }), options);
+                overrideOptions(index, context, compilerOptions, tempDir, nativeWatcher);
+                multiCompilerOptions.push(compilerOptions);
+            }
+            const compilerOptions = multiCompilerOptions.length === 1
+                ? multiCompilerOptions[0]
+                : multiCompilerOptions;
+            const compiler = (0, common_1.getCompiler)(context, name);
+            compiler.setOptions(compilerOptions);
+            context.setValue(name, "multiCompilerOptions", multiCompilerOptions);
+        },
+        compiler: async (context) => {
+            const c = await (0, common_1.compiler)(context, name);
+            c.hooks.invalid.tap("WatchTestCasesTest", (filename, mtime) => {
+                watchContext.currentTriggerFilename = filename;
+            });
+        },
+        build: async (context) => {
+            const compiler = (0, common_1.getCompiler)(context, name);
+            const currentWatchStepModule = require(currentWatchStepModulePath);
+            currentWatchStepModule.step[name] = watchContext.step;
+            node_fs_1.default.mkdirSync(watchContext.tempDir, { recursive: true });
+            (0, copyDiff_1.default)(node_path_1.default.join(context.getSource(), watchContext.step), watchContext.tempDir, true);
+            const task = new Promise((resolve, reject) => {
+                compiler.getEmitter().once(compiler_1.ECompilerEvent.Build, (e, stats) => {
+                    if (e)
+                        return reject(e);
+                    resolve(stats);
+                });
+            });
+            compiler.watch();
+            await task;
+        },
+        run: async (env, context) => {
+            await (0, common_1.run)(env, context, name, (context) => (0, common_1.findMultiCompilerBundle)(context, name, (index, context, options) => findBundle(index, context, options, step)));
+        },
+        check: async (env, context) => {
+            const testConfig = context.getTestConfig();
+            if (testConfig.noTests)
+                return;
+            const errors = (context.getError(name) || []).map(e => ({
+                message: e.message,
+                stack: e.stack
+            }));
+            const warnings = [];
+            const compiler = (0, common_1.getCompiler)(context, name);
+            const stats = compiler.getStats();
+            const options = compiler.getOptions();
+            const checkStats = testConfig.checkStats || (() => true);
+            if (stats) {
+                if (testConfig.writeStatsOuptut) {
+                    node_fs_1.default.writeFileSync(node_path_1.default.join(context.getDist(), "stats.txt"), stats.toString({
+                        preset: "verbose",
+                        colors: false
+                    }), "utf-8");
+                }
+                const getJsonStats = (() => {
+                    let cached = null;
+                    return () => {
+                        if (!cached) {
+                            cached = stats.toJson({
+                                errorDetails: true
+                            });
+                        }
+                        return cached;
+                    };
+                })();
+                const getStringStats = (() => {
+                    let cached = null;
+                    return () => {
+                        if (!cached) {
+                            cached = stats.toString({
+                                logging: "verbose"
+                            });
+                        }
+                        return cached;
+                    };
+                })();
+                if (checkStats.length > 1) {
+                    if (!checkStats(watchContext.step, getJsonStats(), getStringStats())) {
+                        throw new Error("stats check failed");
+                    }
+                }
+                else {
+                    // @ts-expect-error only one param
+                    if (!checkStats(watchContext.step)) {
+                        throw new Error("stats check failed");
+                    }
+                }
+                if (testConfig.writeStatsJson) {
+                    node_fs_1.default.writeFileSync(node_path_1.default.join(context.getDist(), "stats.json"), JSON.stringify(getJsonStats(), null, 2), "utf-8");
+                }
+                if (node_fs_1.default.existsSync(context.getSource(`${watchContext.step}/errors.js`)) ||
+                    node_fs_1.default.existsSync(context.getSource(`${watchContext.step}/warnings.js`)) ||
+                    stats.hasErrors() ||
+                    stats.hasWarnings()) {
+                    const statsJson = stats.toJson({
+                        errorDetails: true
+                    });
+                    if (statsJson.errors) {
+                        errors.push(...statsJson.errors);
+                    }
+                    if (statsJson.warnings) {
+                        warnings.push(...statsJson.warnings);
+                    }
+                }
+            }
+            await (0, checkArrayExpectation_1.default)(node_path_1.default.join(context.getSource(), watchContext.step), { errors }, "error", "errors", "Error", options);
+            await (0, checkArrayExpectation_1.default)(node_path_1.default.join(context.getSource(), watchContext.step), { warnings }, "warning", "warnings", "Warning", options);
+            // clear error if checked
+            if (node_fs_1.default.existsSync(context.getSource("errors.js"))) {
+                context.clearError(name);
+            }
+            // check hash
+            if (testConfig.writeStatsOuptut) {
+                node_fs_1.default.renameSync(node_path_1.default.join(context.getDist(), "stats.txt"), node_path_1.default.join(context.getDist(), `stats.${watchContext.step}.txt`));
+            }
+            if (testConfig.writeStatsJson) {
+                node_fs_1.default.renameSync(node_path_1.default.join(context.getDist(), "stats.json"), node_path_1.default.join(context.getDist(), `stats.${watchContext.step}.json`));
+            }
+        }
+    };
+}
+function createWatchStepProcessor(name, tempDir, step, watchState, { incremental = false, nativeWatcher = false, ignoreNotFriendlyForIncrementalWarnings = false } = {}) {
+    const processor = createWatchInitialProcessor(name, tempDir, step, watchState, { incremental, ignoreNotFriendlyForIncrementalWarnings });
+    processor.compiler = async (context) => {
+        // do nothing
+    };
+    processor.build = async (context) => {
+        const watchContext = context.getValue(name, "watchContext");
+        const compiler = (0, common_1.getCompiler)(context, name);
+        const currentWatchStepModule = require(currentWatchStepModulePath);
+        currentWatchStepModule.step[name] = watchContext.step;
+        const task = new Promise((resolve, reject) => {
+            compiler.getEmitter().once(compiler_1.ECompilerEvent.Build, (e, stats) => {
+                if (e)
+                    return reject(e);
+                resolve(stats);
+            });
+        });
+        // wait compiler to ready watch the files and diretories
+        // Native Watcher using [notify](https://github.com/notify-rs/notify) to watch files.
+        // After tests, notify will cost many milliseconds to watch in windows OS when jest run concurrently.
+        // So we need to wait a while to ensure the watcher is ready.
+        // If we don't wait, copyDiff will happen before the watcher is ready,
+        // which will cause the compiler not rebuild when the files change.
+        // The timeout is set to 400ms for windows OS and 100ms for other OS.
+        // TODO: This is a workaround, we can remove it when notify support windows better.
+        const timeout = nativeWatcher && process.platform === "win32" ? 400 : 100;
+        await new Promise(resolve => setTimeout(resolve, timeout));
+        (0, copyDiff_1.default)(node_path_1.default.join(context.getSource(), step), tempDir, false);
+        await task;
+    };
+    return processor;
+}
 const creator = new creator_1.BasicCaseCreator({
     clean: true,
-    runner: runner_1.WatchRunnerFactory,
+    runner: {
+        key: getWatchRunnerKey,
+        runner: createWatchRunner
+    },
     description: (name, index) => {
         return index === 0
             ? `${name} should compile`
@@ -24,30 +213,141 @@ const creator = new creator_1.BasicCaseCreator({
         const runs = node_fs_1.default
             .readdirSync(src)
             .sort()
-            .filter(name => {
-            return node_fs_1.default.statSync(node_path_1.default.join(src, name)).isDirectory();
-        })
+            .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
-            ? new watch_1.WatchProcessor({
-                name,
-                stepName: run.name,
-                tempDir: temp,
-                runable: true,
-                compilerType: type_1.ECompilerType.Rspack,
-                configFiles: ["rspack.config.js", "webpack.config.js"]
-            }, watchState)
-            : new watch_1.WatchStepProcessor({
-                name,
-                stepName: run.name,
-                tempDir: temp,
-                runable: true,
-                compilerType: type_1.ECompilerType.Rspack,
-                configFiles: ["rspack.config.js", "webpack.config.js"]
-            }, watchState));
+            ? createWatchInitialProcessor(name, temp, run.name, watchState)
+            : createWatchStepProcessor(name, temp, run.name, watchState));
     },
     concurrent: true
 });
 function createWatchCase(name, src, dist, temp) {
     creator.create(name, src, dist, temp);
 }
+function overrideOptions(index, context, options, tempDir, nativeWatcher) {
+    if (!options.mode)
+        options.mode = "development";
+    if (!options.context)
+        options.context = tempDir;
+    if (!options.entry)
+        options.entry = "./index.js";
+    if (!options.target)
+        options.target = "async-node";
+    if (!options.devtool)
+        options.devtool = false;
+    if (!options.output)
+        options.output = {};
+    if (!options.output.path)
+        options.output.path = context.getDist();
+    if (typeof options.output.pathinfo === "undefined")
+        options.output.pathinfo = false;
+    if (!options.output.filename)
+        options.output.filename = "bundle.js";
+    if (options.cache && options.cache.type === "filesystem") {
+        const cacheDirectory = node_path_1.default.join(tempDir, ".cache");
+        options.cache.cacheDirectory = cacheDirectory;
+        options.cache.name = `config-${index}`;
+    }
+    options.optimization ??= {};
+    options.experiments ??= {};
+    options.experiments.css ??= true;
+    if (nativeWatcher) {
+        options.experiments.nativeWatcher ??= true;
+    }
+    options.experiments.rspackFuture ??= {};
+    options.experiments.rspackFuture.bundlerInfo ??= {};
+    options.experiments.rspackFuture.bundlerInfo.force ??= false;
+    // test incremental: "safe" here, we test default incremental in Incremental-*.test.js
+    options.experiments.incremental ??= "safe";
+    if (!global.printLogger) {
+        options.infrastructureLogging = {
+            level: "error"
+        };
+    }
+}
+function findBundle(index, context, options, stepName) {
+    const testConfig = context.getTestConfig();
+    if (typeof testConfig.findBundle === "function") {
+        return testConfig.findBundle(index, options, stepName);
+    }
+    return "./bundle.js";
+}
+function defaultOptions({ incremental = false, ignoreNotFriendlyForIncrementalWarnings = false } = {}) {
+    if (incremental) {
+        return {
+            experiments: {
+                incremental: "advance"
+            },
+            ignoreWarnings: ignoreNotFriendlyForIncrementalWarnings
+                ? [/is not friendly for incremental/]
+                : undefined
+        };
+    }
+    return {};
+}
+function getWatchRunnerKey(context, name, file) {
+    const watchContext = context.getValue(name, "watchContext");
+    const stepName = watchContext?.step;
+    return `${name}-${stepName}`;
+}
+function cachedWatchStats(context, name) {
+    const compiler = context.getCompiler(name);
+    const watchContext = context.getValue(name, "watchContext");
+    const stepName = watchContext?.step;
+    const statsGetter = (() => {
+        const cached = {};
+        return () => {
+            if (cached[stepName]) {
+                return cached[stepName];
+            }
+            cached[stepName] = compiler.getStats().toJson({
+                errorDetails: true
+            });
+            return cached[stepName];
+        };
+    })();
+    return statsGetter;
+}
+function createWatchRunner(context, name, file, env) {
+    const compiler = context.getCompiler(name);
+    const compilerOptions = compiler.getOptions();
+    const watchContext = context.getValue(name, "watchContext");
+    const stepName = watchContext?.step;
+    if (!stepName) {
+        throw new Error("Can not get watch step name from context");
+    }
+    const state = watchContext?.watchState;
+    if (!state) {
+        throw new Error("Can not get watch state from context");
+    }
+    const isWeb = Array.isArray(compilerOptions)
+        ? compilerOptions.some(option => {
+            return option.target === "web" || option.target === "webworker";
+        })
+        : compilerOptions.target === "web" ||
+            compilerOptions.target === "webworker";
+    const testConfig = context.getTestConfig();
+    const documentType = context.getValue(name, "documentType") || type_1.EDocumentType.Fake;
+    return new runner_1.WebRunner({
+        dom: documentType,
+        env,
+        stats: cachedWatchStats(context, name),
+        name: name,
+        runInNewContext: isWeb,
+        cachable: false,
+        testConfig: {
+            ...(testConfig || {}),
+            moduleScope: (ms, stats, options) => {
+                ms.STATE = state;
+                ms.WATCH_STEP = stepName;
+                if (typeof testConfig.moduleScope === "function") {
+                    return testConfig.moduleScope(ms, stats, options);
+                }
+                return ms;
+            }
+        },
+        source: context.getSource(),
+        dist: context.getDist(),
+        compilerOptions
+    });
+}

package/dist/helper/plugins/hot-update.d.ts

@@ -1,7 +1,7 @@
 import type { Compiler } from "@rspack/core";
-import type { TUpdateOptions } from "../../type";
+import type { THotUpdateContext } from "../../type";
 export declare class TestHotUpdatePlugin {
     private updateOptions;
-    constructor(updateOptions: TUpdateOptions);
+    constructor(updateOptions: THotUpdateContext);
     apply(compiler: Compiler): void;
 }

package/dist/index.d.ts

@@ -2,11 +2,9 @@ export * from "./case";
 export * from "./compare";
 export * from "./helper";
 export * from "./plugin";
-export * from "./processor";
 export * from "./reporter";
 export * from "./runner";
 export * from "./test/context";
 export * from "./test/creator";
-export * from "./test/simple";
 export * from "./test/tester";
 export * from "./type";

package/dist/index.js

@@ -18,11 +18,9 @@ __exportStar(require("./case"), exports);
 __exportStar(require("./compare"), exports);
 __exportStar(require("./helper"), exports);
 __exportStar(require("./plugin"), exports);
-__exportStar(require("./processor"), exports);
 __exportStar(require("./reporter"), exports);
 __exportStar(require("./runner"), exports);
 __exportStar(require("./test/context"), exports);
 __exportStar(require("./test/creator"), exports);
-__exportStar(require("./test/simple"), exports);
 __exportStar(require("./test/tester"), exports);
 __exportStar(require("./type"), exports);

package/dist/runner/index.d.ts

@@ -1,7 +1,2 @@
-export * from "./basic";
-export * from "./cache";
-export * from "./hot";
-export * from "./multiple";
-export * from "./runner/node";
-export * from "./type";
-export * from "./watch";
+export * from "./node";
+export * from "./web";

package/dist/runner/index.js

@@ -14,10 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./basic"), exports);
-__exportStar(require("./cache"), exports);
-__exportStar(require("./hot"), exports);
-__exportStar(require("./multiple"), exports);
-__exportStar(require("./runner/node"), exports);
-__exportStar(require("./type"), exports);
-__exportStar(require("./watch"), exports);
+__exportStar(require("./node"), exports);
+__exportStar(require("./web"), exports);

package/dist/runner/{runner/node → node}/index.d.ts

@@ -1,5 +1,4 @@
-import type { ECompilerType, ITestEnv, ITestRunner, TCompilerOptions, TCompilerStatsCompilation, TTestConfig } from "../../../type";
-import { type IGlobalContext, type IModuleScope, type TModuleObject, type TRunnerFile, type TRunnerRequirer } from "../../type";
+import { type ECompilerType, type IGlobalContext, type IModuleScope, type ITestEnv, type ITestRunner, type TCompilerOptions, type TCompilerStatsCompilation, type TModuleObject, type TRunnerFile, type TRunnerRequirer, type TTestConfig } from "../../type";
 declare global {
     var printLogger: boolean;
 }

package/dist/runner/{runner/node → node}/index.js

@@ -41,8 +41,8 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_url_1 = require("node:url");
 const node_vm_1 = __importStar(require("node:vm"));
-const asModule_1 = __importDefault(require("../../../helper/legacy/asModule"));
-const urlToRelativePath_1 = __importDefault(require("../../../helper/legacy/urlToRelativePath"));
+const asModule_1 = __importDefault(require("../../helper/legacy/asModule"));
+const urlToRelativePath_1 = __importDefault(require("../../helper/legacy/urlToRelativePath"));
 const type_1 = require("../../type");
 const isRelativePath = (p) => /^\.\.?\//.test(p);
 const getSubPath = (p) => {

package/dist/runner/{runner/web → web}/fake.d.ts

@@ -1,5 +1,4 @@
-import type { ECompilerType } from "../../../type";
-import { type TRunnerFile, type TRunnerRequirer } from "../../type";
+import { type ECompilerType, type TRunnerFile, type TRunnerRequirer } from "../../type";
 import { type INodeRunnerOptions, NodeRunner } from "../node";
 export declare class FakeDocumentWebRunner<T extends ECompilerType = ECompilerType.Rspack> extends NodeRunner<T> {
     protected _webOptions: INodeRunnerOptions<T>;

package/dist/runner/{runner/web → web}/fake.js

@@ -41,13 +41,13 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_url_1 = require("node:url");
 const node_vm_1 = __importStar(require("node:vm"));
-const helper_1 = require("../../../helper");
-const asModule_1 = __importDefault(require("../../../helper/legacy/asModule"));
-const createFakeWorker_1 = __importDefault(require("../../../helper/legacy/createFakeWorker"));
-const currentScript_1 = __importDefault(require("../../../helper/legacy/currentScript"));
-const EventSourceForNode_1 = __importDefault(require("../../../helper/legacy/EventSourceForNode"));
-const FakeDocument_1 = __importDefault(require("../../../helper/legacy/FakeDocument"));
-const urlToRelativePath_1 = __importDefault(require("../../../helper/legacy/urlToRelativePath"));
+const helper_1 = require("../../helper");
+const asModule_1 = __importDefault(require("../../helper/legacy/asModule"));
+const createFakeWorker_1 = __importDefault(require("../../helper/legacy/createFakeWorker"));
+const currentScript_1 = __importDefault(require("../../helper/legacy/currentScript"));
+const EventSourceForNode_1 = __importDefault(require("../../helper/legacy/EventSourceForNode"));
+const FakeDocument_1 = __importDefault(require("../../helper/legacy/FakeDocument"));
+const urlToRelativePath_1 = __importDefault(require("../../helper/legacy/urlToRelativePath"));
 const type_1 = require("../../type");
 const node_1 = require("../node");
 class FakeDocumentWebRunner extends node_1.NodeRunner {

package/dist/runner/{runner/web → web}/index.d.ts

@@ -1,4 +1,4 @@
-import { type ECompilerType, EDocumentType, type ITestRunner } from "../../../type";
+import { type ECompilerType, EDocumentType, type ITestRunner } from "../../type";
 import type { INodeRunnerOptions, NodeRunner } from "../node";
 export interface IWebRunnerOptions<T extends ECompilerType = ECompilerType.Rspack> extends INodeRunnerOptions<T> {
     dom: EDocumentType;
@@ -9,6 +9,6 @@ export declare class WebRunner<T extends ECompilerType = ECompilerType.Rspack> i
     private implement;
     constructor(_webOptions: IWebRunnerOptions<T>);
     run(file: string): Promise<unknown>;
-    getRequire(): import("../..").TRunnerRequirer;
+    getRequire(): import("../../type").TRunnerRequirer;
     getGlobal(name: string): unknown;
 }

package/dist/runner/{runner/web → web}/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebRunner = void 0;
-const type_1 = require("../../../type");
+const type_1 = require("../../type");
 const fake_1 = require("./fake");
 const jsdom_1 = require("./jsdom");
 class WebRunner {

package/dist/runner/{runner/web → web}/jsdom.d.ts

@@ -1,5 +1,4 @@
-import type { ECompilerType } from "../../../type";
-import type { TRunnerFile, TRunnerRequirer } from "../../type";
+import type { ECompilerType, TRunnerFile, TRunnerRequirer } from "../../type";
 import { type INodeRunnerOptions, NodeRunner } from "../node";
 export declare class JSDOMWebRunner<T extends ECompilerType = ECompilerType.Rspack> extends NodeRunner<T> {
     protected _webOptions: INodeRunnerOptions<T>;

package/dist/runner/{runner/web → web}/jsdom.js

@@ -7,10 +7,10 @@ exports.JSDOMWebRunner = void 0;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const jsdom_1 = require("jsdom");
-const helper_1 = require("../../../helper");
-const createFakeWorker_1 = __importDefault(require("../../../helper/legacy/createFakeWorker"));
-const EventSourceForNode_1 = __importDefault(require("../../../helper/legacy/EventSourceForNode"));
-const urlToRelativePath_1 = __importDefault(require("../../../helper/legacy/urlToRelativePath"));
+const helper_1 = require("../../helper");
+const createFakeWorker_1 = __importDefault(require("../../helper/legacy/createFakeWorker"));
+const EventSourceForNode_1 = __importDefault(require("../../helper/legacy/EventSourceForNode"));
+const urlToRelativePath_1 = __importDefault(require("../../helper/legacy/urlToRelativePath"));
 const node_1 = require("../node");
 // Compatibility code to suppress iconv-lite warnings
 require("iconv-lite").skipDecodeWarning = true;

package/dist/test/context.d.ts

@@ -1,4 +1,4 @@
-import type { ECompilerType, ITestCompilerManager, ITestContext, ITesterConfig, ITestRunner, TRunnerFactory, TTestConfig } from "../type";
+import { ECompilerType, type ITestCompilerManager, type ITestContext, type ITestEnv, type ITesterConfig, type ITestRunner, type TTestConfig } from "../type";
 export type TTestContextOptions = Omit<ITesterConfig, "name" | "steps">;
 export declare class TestContext implements ITestContext {
     private config;
@@ -6,15 +6,12 @@ export declare class TestContext implements ITestContext {
     protected compilers: Map<string, ITestCompilerManager<ECompilerType>>;
     protected store: Map<string, Record<string, unknown>>;
     protected runners: Map<string, ITestRunner>;
-    protected runnerFactory: TRunnerFactory<ECompilerType> | null;
     constructor(config: TTestContextOptions);
     getSource(sub?: string): string;
     getDist(sub?: string): string;
     getTemp(sub?: string): string | null;
     getCompiler<T extends ECompilerType>(name: string, type: T | void): ITestCompilerManager<T>;
-    getRunnerFactory<T extends ECompilerType>(name: string): TRunnerFactory<T> | null;
-    getRunner(key: string): ITestRunner | null;
-    setRunner(key: string, runner: ITestRunner): void;
+    getRunner(name: string, file: string, env: ITestEnv): ITestRunner;
     getTestConfig<T extends ECompilerType>(): TTestConfig<T>;
     setValue<T>(name: string, key: string, value: T): void;
     getValue<T>(name: string, key: string): T | void;
@@ -23,4 +20,5 @@ export declare class TestContext implements ITestContext {
     getNames(): string[];
     getError(name?: string): Error[];
     clearError(name?: string): void;
+    closeCompiler(name: string): Promise<void>;
 }

package/dist/test/context.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TestContext = void 0;
 const node_path_1 = __importDefault(require("node:path"));
 const compiler_1 = require("../compiler");
+const type_1 = require("../type");
 class TestContext {
     constructor(config) {
         this.config = config;
@@ -13,7 +14,6 @@ class TestContext {
         this.compilers = new Map();
         this.store = new Map();
         this.runners = new Map();
-        this.runnerFactory = null;
     }
     getSource(sub) {
         if (sub) {
@@ -46,18 +46,18 @@ class TestContext {
         }
         return compiler;
     }
-    getRunnerFactory(name) {
-        if (!this.runnerFactory &&
-            typeof this.config.runnerFactory === "function") {
-            this.runnerFactory = new this.config.runnerFactory(name, this);
+    getRunner(name, file, env) {
+        if (!this.config.runnerCreator) {
+            throw new Error("TestContext: Runner creator not found");
         }
-        return this.runnerFactory;
-    }
-    getRunner(key) {
-        return this.runners.get(key) || null;
-    }
-    setRunner(key, runner) {
-        this.runners.set(key, runner);
+        const runnerKey = this.config.runnerCreator.key(this, name, file);
+        let runner = this.runners.get(runnerKey);
+        if (runner) {
+            return runner;
+        }
+        runner = this.config.runnerCreator.runner(this, name, file, env);
+        this.runners.set(runnerKey, runner);
+        return runner;
     }
     getTestConfig() {
         return this.config.testConfig || {};
@@ -104,5 +104,15 @@ class TestContext {
             this.errors.clear();
         }
     }
+    async closeCompiler(name) {
+        const rspackCompiler = this.getCompiler(name, type_1.ECompilerType.Rspack);
+        if (rspackCompiler) {
+            await rspackCompiler.close();
+        }
+        const webpackCompiler = this.getCompiler(name, type_1.ECompilerType.Webpack);
+        if (webpackCompiler) {
+            await webpackCompiler.close();
+        }
+    }
 }
 exports.TestContext = TestContext;