@rspack/test-tools 1.5.5 → 1.5.7

package/dist/runner/node/index.js

@@ -0,0 +1,396 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeRunner = void 0;
+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 type_1 = require("../../type");
+const isRelativePath = (p) => /^\.\.?\//.test(p);
+const getSubPath = (p) => {
+    const lastSlash = p.lastIndexOf("/");
+    let firstSlash = p.indexOf("/");
+    if (lastSlash !== -1 && firstSlash !== lastSlash) {
+        if (firstSlash !== -1) {
+            let next = p.indexOf("/", firstSlash + 1);
+            let dir = p.slice(firstSlash + 1, next);
+            while (dir === ".") {
+                firstSlash = next;
+                next = p.indexOf("/", firstSlash + 1);
+                dir = p.slice(firstSlash + 1, next);
+            }
+        }
+        return p.slice(firstSlash + 1, lastSlash + 1);
+    }
+    return "";
+};
+const cached = new Map();
+class NodeRunner {
+    constructor(_options) {
+        this._options = _options;
+        this.requireCache = Object.create(null);
+        this.globalContext = null;
+        this.baseModuleScope = null;
+        this.requirers = new Map();
+    }
+    run(file) {
+        if (!this.globalContext) {
+            this.globalContext = this.createGlobalContext();
+        }
+        this.baseModuleScope = this.createBaseModuleScope();
+        if (typeof this._options.testConfig.moduleScope === "function") {
+            this._options.testConfig.moduleScope(this.baseModuleScope, this._options.stats, this._options.compilerOptions);
+        }
+        this.createRunner();
+        const res = this.getRequire()(this._options.dist, file.startsWith("./") || file.startsWith("https://test.cases/")
+            ? file
+            : `./${file}`);
+        if (typeof res === "object" && "then" in res) {
+            return res;
+        }
+        return Promise.resolve(res);
+    }
+    getRequire() {
+        const entryRequire = this.requirers.get("entry");
+        return (currentDirectory, modulePath, context = {}) => {
+            const p = Array.isArray(modulePath)
+                ? modulePath
+                : modulePath.split("?")[0];
+            return entryRequire(currentDirectory, p, context);
+        };
+    }
+    getGlobal(name) {
+        return (this.globalContext || {})[name];
+    }
+    createGlobalContext() {
+        return {
+            console: {
+                log: (...args) => {
+                    if (printLogger) {
+                        console.log(...args);
+                    }
+                },
+                warn: (...args) => {
+                    if (printLogger) {
+                        console.warn(...args);
+                    }
+                },
+                error: (...args) => {
+                    console.error(...args);
+                },
+                info: (...args) => {
+                    if (printLogger) {
+                        console.info(...args);
+                    }
+                },
+                debug: (...args) => {
+                    if (printLogger) {
+                        console.info(...args);
+                    }
+                },
+                trace: (...args) => {
+                    if (printLogger) {
+                        console.info(...args);
+                    }
+                },
+                assert: (...args) => {
+                    console.assert(...args);
+                },
+                clear: () => {
+                    console.clear();
+                }
+            },
+            setTimeout: ((cb, ms, ...args) => {
+                const timeout = setTimeout(cb, ms, ...args);
+                timeout.unref();
+                return timeout;
+            }),
+            clearTimeout: clearTimeout
+        };
+    }
+    createBaseModuleScope() {
+        const baseModuleScope = {
+            console: this.globalContext.console,
+            setTimeout: this.globalContext.setTimeout,
+            clearTimeout: this.globalContext.clearTimeout,
+            nsObj: (m) => {
+                Object.defineProperty(m, Symbol.toStringTag, {
+                    value: "Module"
+                });
+                return m;
+            },
+            process,
+            URL,
+            Blob,
+            Symbol,
+            Buffer,
+            setImmediate,
+            __MODE__: this._options.compilerOptions.mode,
+            __SNAPSHOT__: node_path_1.default.join(this._options.source, "__snapshot__"),
+            ...this._options.env
+        };
+        return baseModuleScope;
+    }
+    createModuleScope(requireFn, m, file) {
+        const requirer = requireFn.bind(null, node_path_1.default.dirname(file.path));
+        requirer.webpackTestSuiteRequire = true;
+        return {
+            ...this.baseModuleScope,
+            require: requirer,
+            module: m,
+            exports: m.exports,
+            __dirname: node_path_1.default.dirname(file.path),
+            __filename: file.path,
+            _globalAssign: {
+                expect: this._options.env.expect
+            }
+        };
+    }
+    getFile(modulePath, currentDirectory) {
+        const cacheKey = `${currentDirectory}|${modulePath}`;
+        if (this._options.cachable && cached.has(cacheKey)) {
+            return cached.get(cacheKey);
+        }
+        let res = null;
+        if (Array.isArray(modulePath)) {
+            res = {
+                path: node_path_1.default.join(currentDirectory, ".array-require.js"),
+                content: `module.exports = (${modulePath
+                    .map(arg => {
+                    return `require(${JSON.stringify(`./${arg}`)})`;
+                })
+                    .join(", ")});`,
+                subPath: ""
+            };
+        }
+        else if (modulePath.startsWith("https://test.cases/")) {
+            const relativePath = (0, urlToRelativePath_1.default)(modulePath);
+            const absPath = node_path_1.default.join(currentDirectory, relativePath);
+            res = {
+                path: absPath,
+                content: node_fs_1.default.readFileSync(absPath, "utf-8"),
+                subPath: ""
+            };
+        }
+        else if (isRelativePath(modulePath)) {
+            const p = node_path_1.default.join(currentDirectory, modulePath);
+            res = {
+                path: p,
+                content: node_fs_1.default.readFileSync(p, "utf-8"),
+                subPath: getSubPath(modulePath)
+            };
+        }
+        else if (node_path_1.default.isAbsolute(modulePath)) {
+            res = {
+                path: modulePath,
+                content: node_fs_1.default.readFileSync(modulePath, "utf-8"),
+                subPath: "absolute_path"
+            };
+        }
+        if (this._options.cachable && res) {
+            cached.set(cacheKey, res);
+        }
+        return res;
+    }
+    preExecute(code, file) { }
+    postExecute(m, file) { }
+    createRunner() {
+        this.requirers.set("cjs", this.createCjsRequirer());
+        this.requirers.set("esm", this.createEsmRequirer());
+        this.requirers.set("miss", this.createMissRequirer());
+        this.requirers.set("json", this.createJsonRequirer());
+        this.requirers.set("entry", (currentDirectory, modulePath, context) => {
+            const file = this.getFile(modulePath, currentDirectory);
+            if (!file) {
+                return this.requirers.get("miss")(currentDirectory, modulePath);
+            }
+            if (file.path.endsWith(".json")) {
+                return this.requirers.get("json")(currentDirectory, modulePath, {
+                    ...context,
+                    file
+                });
+            }
+            if (file.path.endsWith(".mjs") &&
+                this._options.compilerOptions.experiments?.outputModule) {
+                return this.requirers.get("esm")(currentDirectory, modulePath, {
+                    ...context,
+                    file
+                });
+            }
+            return this.requirers.get("cjs")(currentDirectory, modulePath, {
+                ...context,
+                file
+            });
+        });
+    }
+    createMissRequirer() {
+        return (currentDirectory, modulePath, context = {}) => {
+            const modulePathStr = modulePath;
+            const modules = this._options.testConfig.modules;
+            if (modules && modulePathStr in modules) {
+                return modules[modulePathStr];
+            }
+            return require(modulePathStr.startsWith("node:")
+                ? modulePathStr.slice(5)
+                : modulePathStr);
+        };
+    }
+    createJsonRequirer() {
+        return (currentDirectory, modulePath, context = {}) => {
+            if (Array.isArray(modulePath)) {
+                throw new Error("Array module path is not supported in hot cases");
+            }
+            const file = context.file || this.getFile(modulePath, currentDirectory);
+            if (!file) {
+                return this.requirers.get("miss")(currentDirectory, modulePath);
+            }
+            return JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(this._options.dist, modulePath), "utf-8"));
+        };
+    }
+    createCjsRequirer() {
+        return (currentDirectory, modulePath, context = {}) => {
+            if (modulePath === "@rspack/test-tools") {
+                return require("@rspack/test-tools");
+            }
+            const file = context.file || this.getFile(modulePath, currentDirectory);
+            if (!file) {
+                return this.requirers.get("miss")(currentDirectory, modulePath);
+            }
+            if (file.path in this.requireCache) {
+                return this.requireCache[file.path].exports;
+            }
+            const m = {
+                exports: {},
+                webpackTestSuiteModule: true
+            };
+            this.requireCache[file.path] = m;
+            if (!this._options.runInNewContext) {
+                file.content = `Object.assign(global, _globalAssign);\n ${file.content}`;
+            }
+            const currentModuleScope = this.createModuleScope(this.getRequire(), m, file);
+            if (this._options.testConfig.moduleScope) {
+                this._options.testConfig.moduleScope(currentModuleScope, this._options.stats, this._options.compilerOptions);
+            }
+            if (file.content.includes("__STATS__") && this._options.stats) {
+                currentModuleScope.__STATS__ = this._options.stats();
+            }
+            if (file.content.includes("__STATS_I__")) {
+                const statsIndex = this._options.stats?.()?.__index__;
+                if (typeof statsIndex === "number") {
+                    currentModuleScope.__STATS_I__ = statsIndex;
+                }
+            }
+            const args = Object.keys(currentModuleScope);
+            const argValues = args.map(arg => currentModuleScope[arg]);
+            const code = `(function(${args.join(", ")}) {
+        ${file.content}
+      })`;
+            this.preExecute(code, file);
+            const fn = this._options.runInNewContext
+                ? node_vm_1.default.runInNewContext(code, this.globalContext, file.path)
+                : node_vm_1.default.runInThisContext(code, file.path);
+            fn.call(this._options.testConfig.nonEsmThis
+                ? this._options.testConfig.nonEsmThis(modulePath)
+                : m.exports, ...argValues);
+            this.postExecute(m, file);
+            return m.exports;
+        };
+    }
+    createEsmRequirer() {
+        const esmContext = node_vm_1.default.createContext(this.baseModuleScope, {
+            name: "context for esm"
+        });
+        const esmCache = new Map();
+        const esmIdentifier = this._options.name;
+        return (currentDirectory, modulePath, context = {}) => {
+            if (!node_vm_1.SourceTextModule) {
+                throw new Error("Running this test requires '--experimental-vm-modules'.\nRun with 'node --experimental-vm-modules node_modules/jest-cli/bin/jest'.");
+            }
+            const _require = this.getRequire();
+            const file = context.file || this.getFile(modulePath, currentDirectory);
+            if (!file) {
+                return this.requirers.get("miss")(currentDirectory, modulePath);
+            }
+            if (file.content.includes("__STATS__")) {
+                esmContext.__STATS__ = this._options.stats?.();
+            }
+            let esm = esmCache.get(file.path);
+            if (!esm) {
+                esm = new node_vm_1.SourceTextModule(file.content, {
+                    identifier: `${esmIdentifier}-${file.path}`,
+                    // no attribute
+                    url: `${(0, node_url_1.pathToFileURL)(file.path).href}?${esmIdentifier}`,
+                    context: esmContext,
+                    initializeImportMeta: (meta, _) => {
+                        meta.url = (0, node_url_1.pathToFileURL)(file.path).href;
+                    },
+                    importModuleDynamically: async (specifier, module) => {
+                        const result = await _require(node_path_1.default.dirname(file.path), specifier, {
+                            esmMode: type_1.EEsmMode.Evaluated
+                        });
+                        return await (0, asModule_1.default)(result, module.context);
+                    }
+                });
+                esmCache.set(file.path, esm);
+            }
+            if (context.esmMode === type_1.EEsmMode.Unlinked)
+                return esm;
+            return (async () => {
+                await esm.link(async (specifier, referencingModule) => {
+                    return await (0, asModule_1.default)(await _require(node_path_1.default.dirname(referencingModule.identifier
+                        ? referencingModule.identifier.slice(esmIdentifier.length + 1)
+                        : (0, node_url_1.fileURLToPath)(referencingModule.url)), specifier, {
+                        esmMode: type_1.EEsmMode.Unlinked
+                    }), referencingModule.context, true);
+                });
+                if (esm.instantiate)
+                    esm.instantiate();
+                await esm.evaluate();
+                if (context.esmMode === type_1.EEsmMode.Evaluated) {
+                    return esm;
+                }
+                const ns = esm.namespace;
+                return ns.default && ns.default instanceof Promise ? ns.default : ns;
+            })();
+        };
+    }
+}
+exports.NodeRunner = NodeRunner;

package/dist/runner/web/fake.d.ts

@@ -0,0 +1,15 @@
+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>;
+    private document;
+    private oldCurrentScript;
+    constructor(_webOptions: INodeRunnerOptions<T>);
+    run(file: string): Promise<unknown>;
+    protected createGlobalContext(): import("../../type").IGlobalContext;
+    protected createModuleScope(requireFn: TRunnerRequirer, m: any, file: TRunnerFile): import("../../type").IModuleScope;
+    protected createBaseModuleScope(): import("../../type").IModuleScope;
+    protected preExecute(_: string, file: TRunnerFile): void;
+    protected postExecute(_: Object, file: TRunnerFile): void;
+    protected createEsmRequirer(): TRunnerRequirer;
+}

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

@@ -41,16 +41,16 @@ 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 cjs_1 = require("../cjs");
-class FakeDocumentWebRunner extends cjs_1.CommonJsRunner {
+const node_1 = require("../node");
+class FakeDocumentWebRunner extends node_1.NodeRunner {
     constructor(_webOptions) {
         super(_webOptions);
         this._webOptions = _webOptions;
@@ -141,24 +141,6 @@ class FakeDocumentWebRunner extends cjs_1.CommonJsRunner {
         moduleScope.__dirname = this._options.dist;
         return moduleScope;
     }
-    createRunner() {
-        super.createRunner();
-        this.requirers.set("cjs", this.getRequire());
-        this.requirers.set("mjs", this.createESMRequirer());
-        this.requirers.set("json", this.createJsonRequirer());
-        this.requirers.set("entry", (_, modulePath, context) => {
-            if (Array.isArray(modulePath)) {
-                throw new Error("Array module path is not supported in web runner");
-            }
-            if (modulePath.endsWith(".json")) {
-                return this.requirers.get("json")(this._options.dist, modulePath, context);
-            }
-            else if (modulePath.endsWith(".mjs")) {
-                return this.requirers.get("mjs")(this._options.dist, modulePath, context);
-            }
-            return this.requirers.get("cjs")(this._options.dist, modulePath, context);
-        });
-    }
     preExecute(_, file) {
         this.oldCurrentScript = this.document.currentScript;
         this.document.currentScript = new currentScript_1.default(file.subPath);
@@ -169,7 +151,7 @@ class FakeDocumentWebRunner extends cjs_1.CommonJsRunner {
         this.document.currentScript = this.oldCurrentScript;
         this.oldCurrentScript = null;
     }
-    createESMRequirer() {
+    createEsmRequirer() {
         const esmContext = node_vm_1.default.createContext({
             ...this.baseModuleScope,
             ...this.globalContext

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

@@ -1,15 +1,14 @@
 import { type ECompilerType, EDocumentType, type ITestRunner } from "../../type";
-import type { IBasicRunnerOptions } from "./basic";
-import type { CommonJsRunner } from "./cjs";
-export interface IWebRunnerOptions<T extends ECompilerType = ECompilerType.Rspack> extends IBasicRunnerOptions<T> {
+import type { INodeRunnerOptions, NodeRunner } from "../node";
+export interface IWebRunnerOptions<T extends ECompilerType = ECompilerType.Rspack> extends INodeRunnerOptions<T> {
     dom: EDocumentType;
 }
 export declare class WebRunner<T extends ECompilerType = ECompilerType.Rspack> implements ITestRunner {
     protected _webOptions: IWebRunnerOptions<T>;
-    protected originMethods: Partial<CommonJsRunner>;
+    protected originMethods: Partial<NodeRunner<T>>;
     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.js → web/index.js}

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebRunner = void 0;
 const type_1 = require("../../type");
-const fake_1 = require("./web/fake");
-const jsdom_1 = require("./web/jsdom");
+const fake_1 = require("./fake");
+const jsdom_1 = require("./jsdom");
 class WebRunner {
     constructor(_webOptions) {
         this._webOptions = _webOptions;

package/dist/runner/web/jsdom.d.ts

@@ -0,0 +1,24 @@
+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>;
+    private dom;
+    constructor(_webOptions: INodeRunnerOptions<T>);
+    run(file: string): Promise<unknown>;
+    getGlobal(name: string): unknown;
+    protected createResourceLoader(): {
+        fetch(url: string, _: {
+            element: HTMLScriptElement;
+        }): any;
+    };
+    protected createBaseModuleScope(): import("../../type").IModuleScope;
+    protected getModuleContent(file: TRunnerFile): [
+        Record<string, unknown>,
+        {
+            exports: Record<string, unknown>;
+        },
+        string
+    ];
+    protected createJSDOMRequirer(): TRunnerRequirer;
+    protected createRunner(): void;
+}

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

@@ -7,14 +7,14 @@ 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 cjs_1 = require("../cjs");
+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;
-class JSDOMWebRunner extends cjs_1.CommonJsRunner {
+class JSDOMWebRunner extends node_1.NodeRunner {
     constructor(_webOptions) {
         super(_webOptions);
         this._webOptions = _webOptions;
@@ -87,7 +87,7 @@ class JSDOMWebRunner extends cjs_1.CommonJsRunner {
                     if (!file) {
                         throw new Error(`File not found: ${filePath}`);
                     }
-                    const [_m, code] = that.getModuleContent(file);
+                    const [_scope, _m, code] = that.getModuleContent(file);
                     finalCode = code;
                 }
                 else {
@@ -167,6 +167,7 @@ class JSDOMWebRunner extends cjs_1.CommonJsRunner {
             .join(", ");
         this.dom.window[scopeKey] = currentModuleScope;
         return [
+            this.dom.window[scopeKey],
             m,
             `
 			// hijack document.currentScript for auto public path
@@ -202,7 +203,16 @@ class JSDOMWebRunner extends cjs_1.CommonJsRunner {
             if (file.path in this.requireCache) {
                 return this.requireCache[file.path].exports;
             }
-            const [m, code] = this.getModuleContent(file);
+            const [scope, m, code] = this.getModuleContent(file);
+            if (code.includes("__STATS__")) {
+                scope.__STATS__ = this._options.stats?.();
+            }
+            if (code.includes("__STATS_I__")) {
+                const statsIndex = this._options.stats?.()?.__index__;
+                if (typeof statsIndex === "number") {
+                    scope.__STATS_I__ = statsIndex;
+                }
+            }
             this.preExecute(code, file);
             this.dom.window.eval(code);
             this.postExecute(m, file);

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;