@eggjs/mock 7.0.0-beta.18 → 7.0.0-beta.20

package/dist/cluster-RTfUwmUd.d.ts

@@ -0,0 +1,126 @@
+import { EggTestRequest } from "./supertest-BIds28yL.js";
+import { MockClusterApplicationOptions, MockClusterOptions } from "./types-CjZ-JeCo.js";
+import { ApplicationUnittest } from "./application-BPpvw5dg.js";
+import { Coffee } from "coffee";
+
+//#region src/lib/cluster.d.ts
+declare global {
+  var eggMockMasterPort: number;
+}
+/**
+ * A cluster version of egg.Application, you can test with supertest
+ * @example
+ * ```js
+ * const mm = require('mm');
+ * const request = require('supertest');
+ *
+ * describe('ClusterApplication', () => {
+ *   let app;
+ *   before(function (done) {
+ *     app = mm.cluster({ baseDir });
+ *     app.ready(done);
+ *   });
+ *
+ *   after(function () {
+ *     app.close();
+ *   });
+ *
+ *   it('should 200', function (done) {
+ *     request(app.callback())
+ *     .get('/')
+ *     .expect(200, done);
+ *   });
+ * });
+ */
+declare class ClusterApplication extends Coffee {
+  [key: string | symbol]: any;
+  options: MockClusterApplicationOptions;
+  port: number;
+  baseDir: string;
+  closed: boolean;
+  private _address;
+  /**
+   * @class
+   * @param {Object} options
+   * - {String} baseDir - The directory of the application
+   * - {Object} plugins - Custom you plugins
+   * - {String} framework - The directory of the egg framework
+   * - {Boolean} [cache=true] - Cache application based on baseDir
+   * - {Boolean} [coverage=true] - Switch on process coverage, but it'll be slower
+   * - {Boolean} [clean=true] - Remove $baseDir/logs
+   * - {Object}  [opt] - opt pass to coffee, such as { execArgv: ['--debug'] }
+   * ```
+   */
+  constructor(options: MockClusterApplicationOptions);
+  /**
+   * the process that forked
+   * @member {ChildProcess}
+   */
+  get process(): any;
+  /**
+   * Compatible API for supertest
+   */
+  callback(): this;
+  /**
+   * Compatible API for supertest
+   * @member {String} url
+   * @private
+   */
+  get url(): string;
+  /**
+   * Compatible API for supertest
+   */
+  address(): {
+    port: number;
+    address: string | undefined;
+  };
+  /**
+   * Compatible API for supertest
+   */
+  listen(): this;
+  /**
+   * kill the process
+   */
+  close(): Promise<void>;
+  get isClosed(): boolean;
+  get router(): {
+    pathFor(url: string): any;
+  };
+  /**
+   * get app[property] value in app worker
+   */
+  getAppInstanceProperty(property: string): any;
+  /**
+   * collection logger message, then can be use on `expectLog()`
+   * it's different from `app.expectLog()`, only support string params.
+   *
+   * @param {String} [logger] - logger instance name, default is `logger`
+   * @function ClusterApplication#expectLog
+   */
+  mockLog(logger?: string): void;
+  /**
+   * expect str in the logger
+   * it's different from `app.expectLog()`, only support string params.
+   *
+   * @param {String} str - test str
+   * @param {String} [logger] - logger instance name, default is `logger`
+   * @function ClusterApplication#expectLog
+   */
+  expectLog(str: string, logger?: string): void;
+  /**
+   * not expect str in the logger
+   * it's different from `app.notExpectLog()`, only support string params.
+   *
+   * @param {String} str - test str
+   * @param {String} [logger] - logger instance name, default is `logger`
+   * @function ClusterApplication#notExpectLog
+   */
+  notExpectLog(str: string, logger?: string): void;
+  httpRequest(): EggTestRequest;
+  _callFunctionOnAppWorker(method: string, args?: any[], property?: any, needResult?: boolean): any;
+}
+type MockClusterApplication = ClusterApplication & ApplicationUnittest;
+declare function createCluster(initOptions?: MockClusterOptions): MockClusterApplication;
+declare function restore(): Promise<void>;
+//#endregion
+export { ClusterApplication, MockClusterApplication, createCluster, restore };

package/dist/context-BIduDy1M.js

@@ -0,0 +1,10 @@
+//#region src/lib/context.ts
+const context = { runInBackground(scope) {
+	const taskName = scope._name || scope.name;
+	if (taskName) scope._name = taskName;
+	const promise = this._runInBackground(scope);
+	this.app._backgroundTasks.push(promise);
+} };
+
+//#endregion
+export { context };

package/dist/format_options-LRnReKde.js

@@ -0,0 +1,65 @@
+import { getSourceDirname } from "./utils-MhP_Krx1.js";
+import path from "node:path";
+import { readJSONSync } from "utility";
+import { isMocked, mm } from "mm";
+import { debuglog } from "node:util";
+import { getFrameworkPath } from "@eggjs/utils";
+
+//#region src/lib/format_options.ts
+const debug = debuglog("egg/mock/lib/format_options");
+/**
+* format the options
+*/
+function formatOptions(initOptions) {
+	const options = {
+		baseDir: process.cwd(),
+		cache: true,
+		coverage: true,
+		clean: true,
+		...initOptions
+	};
+	if (!path.isAbsolute(options.baseDir)) options.baseDir = path.join(process.cwd(), "test/fixtures", options.baseDir);
+	let framework = initOptions?.framework ?? initOptions?.customEgg;
+	if (framework === true) {
+		framework = process.cwd();
+		options.plugin = false;
+	} else {
+		if (!framework) framework = "";
+		framework = getFrameworkPath({
+			framework,
+			baseDir: options.baseDir
+		});
+	}
+	options.framework = options.customEgg = framework;
+	const plugins = options.plugins = options.plugins || {};
+	let pluginPath = path.join(getSourceDirname(), "..");
+	if (pluginPath.endsWith("/dist") || pluginPath.endsWith("\\dist")) pluginPath = path.join(pluginPath, "..");
+	plugins["egg-mock"] = {
+		enable: true,
+		path: pluginPath
+	};
+	if (options.plugin !== false) {
+		const pluginPath$1 = process.cwd();
+		const pkgPath = path.join(pluginPath$1, "package.json");
+		const pluginName = getPluginName(pkgPath);
+		if (options.plugin && !pluginName) throw new Error(`should set "eggPlugin" property in ${pkgPath}`);
+		if (pluginName) plugins[pluginName] = {
+			enable: true,
+			path: pluginPath$1
+		};
+	}
+	const env = process.env.EGG_SERVER_ENV;
+	if (!isMocked(process.env, "HOME") && (env === "default" || env === "test" || env === "prod")) mm(process.env, "HOME", options.baseDir);
+	if (process.env.EGG_MOCK_SERVER_ENV) options.cache = false;
+	debug("[formatOptions] options: %j", options);
+	return options;
+}
+function getPluginName(pkgPath) {
+	try {
+		const pkg = readJSONSync(pkgPath);
+		if (pkg.eggPlugin?.name) return pkg.eggPlugin.name;
+	} catch {}
+}
+
+//#endregion
+export { formatOptions };

package/dist/index-BtBMDZg8.d.ts

@@ -0,0 +1,78 @@
+import { createCluster } from "./cluster-RTfUwmUd.js";
+import { createApp } from "./app-l47a-gqT.js";
+import { restore as restore$1 } from "./restore-BL0cE0KG.js";
+import { setGetAppCallback } from "./app_handler-Gp5J9X-v.js";
+import * as mm0 from "mm";
+import { mock } from "mm";
+
+//#region src/index.d.ts
+declare const mock$1: {
+  restore: typeof restore$1;
+  /**
+   * Create a egg mocked application
+   * @function mm#app
+   * @param {Object} [options]
+   * - {String} baseDir - The directory of the application
+   * - {Object} plugins - Custom you plugins
+   * - {String} framework - The directory of the egg framework
+   * - {Boolean} [true] cache - Cache application based on baseDir
+   * - {Boolean} [true] coverage - Switch on process coverage, but it'll be slower
+   * - {Boolean} [true] clean - Remove $baseDir/logs
+   * @return {App} return {@link Application}
+   * @example
+   * ```js
+   * const app = mm.app();
+   * ```
+   */
+  app: typeof createApp;
+  /**
+   * Create a egg mocked cluster application
+   * @function mm#cluster
+   * @see ClusterApplication
+   */
+  cluster: typeof createCluster;
+  /**
+   * mock the serverEnv of Egg
+   * @member {Function} mm#env
+   * @param {String} env - contain default, test, prod, local, unittest
+   * @see https://github.com/eggjs/egg-core/blob/master/lib/loader/egg_loader.js#L78
+   */
+  env(env: string): void;
+  /**
+   * mock console level
+   * @param {String} level - logger level
+   */
+  consoleLevel(level: string): void;
+  home(homePath?: string): void;
+  setGetAppCallback: typeof setGetAppCallback;
+  isMocked: typeof mm0.isMocked;
+  mock: typeof mock;
+  mm: typeof mock;
+  datas: typeof mm0.datas;
+  mockDatas: typeof mm0.datas;
+  data: typeof mm0.data;
+  mockData: typeof mm0.data;
+  dataWithAsyncDispose: typeof mm0.dataWithAsyncDispose;
+  empty: typeof mm0.empty;
+  mockEmpty: typeof mm0.empty;
+  error: typeof mm0.error;
+  mockError: typeof mm0.error;
+  spy: typeof mm0.spy;
+  errorOnce: typeof mm0.errorOnce;
+  syncError: typeof mm0.syncError;
+  syncEmpty: typeof mm0.syncEmpty;
+  syncData: typeof mm0.syncData;
+  http: {
+    request: (url: mm0.RequestURL, data: mm0.ResponseData, headers?: Record<string, any>, delay?: number) => void;
+    requestError: (url: mm0.RequestURL, reqError?: mm0.MockError, resError?: mm0.MockError, delay?: number) => void;
+  };
+  https: {
+    request: (url: mm0.RequestURL, data: mm0.ResponseData, headers?: Record<string, any>, delay?: number) => void;
+    requestError: (url: mm0.RequestURL, reqError?: mm0.MockError, resError?: mm0.MockError, delay?: number) => void;
+  };
+  spawn: typeof mm0.spawn;
+  classMethod: typeof mm0.classMethod;
+};
+declare const proxyMock: ((target: any, property: PropertyKey, value?: any) => void) & typeof mock$1;
+//#endregion
+export { proxyMock };

package/dist/index.d.ts

@@ -1,81 +1,10 @@
-import { MockHttpClientMethod, MockResponseCallbackOptions, MockResultFunction, MockResultOptions, ResultObject } from "./lib/mock_httpclient.js";
-import { MockAgent, MockApplicationOptions, MockClusterApplicationOptions, MockClusterOptions, MockOption, MockOptions } from "./lib/types.js";
-import ApplicationUnittest from "./app/extend/application.js";
-import { MockClusterApplication, createCluster } from "./lib/cluster.js";
-import { createApp } from "./lib/app.js";
-import { restore as restore$1 } from "./lib/restore.js";
-import { setGetAppCallback } from "./lib/app_handler.js";
-import * as mm0 from "mm";
-import { mock } from "mm";
-
-//#region src/index.d.ts
-declare const mock$1: {
-  restore: typeof restore$1;
-  /**
-   * Create a egg mocked application
-   * @function mm#app
-   * @param {Object} [options]
-   * - {String} baseDir - The directory of the application
-   * - {Object} plugins - Custom you plugins
-   * - {String} framework - The directory of the egg framework
-   * - {Boolean} [true] cache - Cache application based on baseDir
-   * - {Boolean} [true] coverage - Switch on process coverage, but it'll be slower
-   * - {Boolean} [true] clean - Remove $baseDir/logs
-   * @return {App} return {@link Application}
-   * @example
-   * ```js
-   * const app = mm.app();
-   * ```
-   */
-  app: typeof createApp;
-  /**
-   * Create a egg mocked cluster application
-   * @function mm#cluster
-   * @see ClusterApplication
-   */
-  cluster: typeof createCluster;
-  /**
-   * mock the serverEnv of Egg
-   * @member {Function} mm#env
-   * @param {String} env - contain default, test, prod, local, unittest
-   * @see https://github.com/eggjs/egg-core/blob/master/lib/loader/egg_loader.js#L78
-   */
-  env(env: string): void;
-  /**
-   * mock console level
-   * @param {String} level - logger level
-   */
-  consoleLevel(level: string): void;
-  home(homePath?: string): void;
-  setGetAppCallback: typeof setGetAppCallback;
-  isMocked: typeof mm0.isMocked;
-  mock: typeof mock;
-  mm: typeof mock;
-  datas: typeof mm0.datas;
-  mockDatas: typeof mm0.datas;
-  data: typeof mm0.data;
-  mockData: typeof mm0.data;
-  dataWithAsyncDispose: typeof mm0.dataWithAsyncDispose;
-  empty: typeof mm0.empty;
-  mockEmpty: typeof mm0.empty;
-  error: typeof mm0.error;
-  mockError: typeof mm0.error;
-  spy: typeof mm0.spy;
-  errorOnce: typeof mm0.errorOnce;
-  syncError: typeof mm0.syncError;
-  syncEmpty: typeof mm0.syncEmpty;
-  syncData: typeof mm0.syncData;
-  http: {
-    request: (url: mm0.RequestURL, data: mm0.ResponseData, headers?: Record<string, any>, delay?: number) => void;
-    requestError: (url: mm0.RequestURL, reqError?: mm0.MockError, resError?: mm0.MockError, delay?: number) => void;
-  };
-  https: {
-    request: (url: mm0.RequestURL, data: mm0.ResponseData, headers?: Record<string, any>, delay?: number) => void;
-    requestError: (url: mm0.RequestURL, reqError?: mm0.MockError, resError?: mm0.MockError, delay?: number) => void;
-  };
-  spawn: typeof mm0.spawn;
-  classMethod: typeof mm0.classMethod;
-};
-declare const proxyMock: ((target: any, property: PropertyKey, value?: any) => void) & typeof mock$1;
-//#endregion
-export { MockAgent, type ApplicationUnittest as MockApplication, MockApplicationOptions, type MockClusterApplication, MockClusterApplicationOptions, MockClusterOptions, MockHttpClientMethod, MockOption, MockOptions, MockResponseCallbackOptions, MockResultFunction, MockResultOptions, ResultObject, createApp, createCluster, proxyMock as default, proxyMock as mm, proxyMock as mock, setGetAppCallback };
+import { MockHttpClientMethod, MockResponseCallbackOptions, MockResultFunction, MockResultOptions, ResultObject } from "./mock_httpclient-1EgQkMxi.js";
+import "./supertest-BIds28yL.js";
+import { MockAgent, MockApplicationOptions, MockClusterApplicationOptions, MockClusterOptions, MockOption, MockOptions } from "./types-CjZ-JeCo.js";
+import { ApplicationUnittest } from "./application-BPpvw5dg.js";
+import { MockClusterApplication, createCluster } from "./cluster-RTfUwmUd.js";
+import { createApp } from "./app-l47a-gqT.js";
+import "./restore-BL0cE0KG.js";
+import { setGetAppCallback } from "./app_handler-Gp5J9X-v.js";
+import { proxyMock } from "./index-BtBMDZg8.js";
+export { MockAgent, ApplicationUnittest as MockApplication, MockApplicationOptions, MockClusterApplication, MockClusterApplicationOptions, MockClusterOptions, MockHttpClientMethod, MockOption, MockOptions, MockResponseCallbackOptions, MockResultFunction, MockResultOptions, ResultObject, createApp, createCluster, proxyMock as default, proxyMock as mm, proxyMock as mock, setGetAppCallback };

package/dist/index.js

@@ -1,47 +1,22 @@
-import { createCluster } from "./lib/cluster.js";
-import { createApp } from "./lib/app.js";
-import { restore as restore$1 } from "./lib/restore.js";
-import { setGetAppCallback } from "./lib/app_handler.js";
-import mm$1, { mock } from "mm";
+import "./mock_http_server-De0r07gr.js";
+import "./utils-MhP_Krx1.js";
+import "./supertest-Cg412Los.js";
+import "./format_options-LRnReKde.js";
+import { createCluster } from "./cluster-CA_hr9eV.js";
+import "./context-BIduDy1M.js";
+import "./mock_custom_loader-f_tHRojG.js";
+import "./mock_agent-CxT7Q0_N.js";
+import "./mock_httpclient-B6UVI7GS.js";
+import "./types-CPNMyF89.js";
+import "./application-LrKwuOKn.js";
+import "./agent-DZ_fHoxJ.js";
+import { createApp } from "./app-6Bn3F5Uw.js";
+import "./restore-CVQYXquh.js";
+import "./util-BpppqTXv.js";
+import "./app-CoypamK1.js";
+import "./agent-BKYkjoCx.js";
+import "./agent_handler-DeUtoRVT.js";
+import { setGetAppCallback } from "./app_handler-CkiK6fyC.js";
+import { proxyMock, src_default } from "./src-D22EjdGo.js";
 
-//#region src/index.ts
-const mock$1 = {
-	...mm$1,
-	restore: restore$1,
-	app: createApp,
-	cluster: createCluster,
-	env(env) {
-		mock(process.env, "EGG_MOCK_SERVER_ENV", env);
-		mock(process.env, "EGG_SERVER_ENV", env);
-	},
-	consoleLevel(level) {
-		level = (level || "").toUpperCase();
-		mock(process.env, "EGG_LOG", level);
-	},
-	home(homePath) {
-		if (homePath) mock(process.env, "EGG_HOME", homePath);
-	},
-	setGetAppCallback
-};
-const proxyMock = new Proxy(mock, {
-	apply(target, _, args) {
-		return target(args[0], args[1], args[2]);
-	},
-	get(_target, property, receiver) {
-		return Reflect.get(mock$1, property, receiver);
-	}
-});
-var src_default = proxyMock;
-process.setMaxListeners(100);
-process.once("SIGQUIT", () => {
-	process.exit(0);
-});
-process.once("SIGTERM", () => {
-	process.exit(0);
-});
-process.once("SIGINT", () => {
-	process.exit(0);
-});
-
-//#endregion
 export { createApp, createCluster, src_default as default, proxyMock as mm, proxyMock as mock, setGetAppCallback };

package/dist/inject_context-BxpcF-ds.js

@@ -0,0 +1,106 @@
+import { getApp } from "./app_handler-CkiK6fyC.js";
+import assert from "node:assert";
+import { debuglog } from "node:util";
+
+//#region src/lib/inject_context.ts
+const debug = debuglog("egg/mock/lib/inject_context");
+const MOCHA_SUITE_APP = Symbol.for("mocha#suite#app");
+/**
+* Monkey patch the mocha instance with egg context.
+*
+* @param {Function} mocha - the module of mocha
+*/
+function injectContext(mocha) {
+	if (mocha._injectContextLoaded) {
+		debug("mocha already injected context, skip it");
+		return;
+	}
+	const { Runner } = mocha;
+	const runSuite = Runner.prototype.runSuite;
+	const runTests = Runner.prototype.runTests;
+	function getTestTitle(suite, test) {
+		const suiteTitle = suite.root ? "root suite" : suite.title;
+		if (!test) return `"${suiteTitle}"`;
+		return `"${suiteTitle} - ${test.title}"`;
+	}
+	Runner.prototype.runSuite = async function(suite, fn) {
+		debug("run suite: %s", suite.title);
+		let app;
+		const self = this;
+		try {
+			app = await getApp(suite);
+			debug("get app: %s", !!app);
+			await app.ready();
+		} catch {
+			app = null;
+		}
+		if (!app) return runSuite.call(self, suite, fn);
+		let errSuite;
+		try {
+			suite.ctx[MOCHA_SUITE_APP] = app;
+			await (app.mockModuleContextScope || app.mockContextScope).call(app, async function() {
+				await new Promise((resolve) => {
+					runSuite.call(self, suite, (aErrSuite) => {
+						errSuite = aErrSuite;
+						resolve();
+					});
+				});
+			});
+		} catch (err) {
+			suite.beforeAll("egg-mock-mock-ctx-failed", async () => {
+				throw err;
+			});
+			return runSuite.call(self, suite, (aErrSuite) => {
+				return fn(aErrSuite);
+			});
+		}
+		return fn(errSuite);
+	};
+	Runner.prototype.runTests = async function(suite, fn) {
+		const tests = suite.tests.slice();
+		if (!tests.length) return runTests.call(this, suite, fn);
+		const app = suite.ctx[MOCHA_SUITE_APP];
+		const self = this;
+		if (!app) return runTests.call(self, suite, fn);
+		function done(errSuite) {
+			suite.tests = tests;
+			return fn(errSuite);
+		}
+		async function next(i) {
+			const test = tests[i];
+			if (!test) return done();
+			suite.tests = [test];
+			let app$1;
+			try {
+				app$1 = await getApp(suite, test);
+				assert(app$1, `not found app for test ${getTestTitle(suite, test)}`);
+				await app$1.ready();
+			} catch (err) {
+				self.fail(test, err);
+				return next(i + 1);
+			}
+			try {
+				await (app$1.mockModuleContextScope || app$1.mockContextScope).call(app$1, async function() {
+					return await new Promise((resolve) => {
+						runTests.call(self, suite, () => {
+							return resolve();
+						});
+					});
+				});
+			} catch (err) {
+				self.fail(test, err);
+				return next(i + 1);
+			}
+			return next(i + 1);
+		}
+		next(0).catch((err) => {
+			self.fail(suite, err);
+			done(suite);
+		});
+	};
+	mocha._injectContextLoaded = true;
+	debug("inject context success");
+}
+
+//#endregion
+export { injectContext };

package/dist/inject_mocha-BVf8v6El.js

@@ -0,0 +1,38 @@
+import { injectContext } from "./inject_context-BxpcF-ds.js";
+import { createRequire } from "node:module";
+import { debuglog } from "node:util";
+import { getRequire } from "@eggjs/utils";
+import "mocha";
+
+//#region rolldown:runtime
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region src/inject_mocha.ts
+const debug = debuglog("egg/mock/inject_mocha");
+/**
+* Find active node mocha instances.
+*/
+function findNodeJSMocha() {
+	let children;
+	if (typeof __require === "function") children = __require.cache || {};
+	else {
+		children = getRequire().cache || {};
+		debug("createRequire on esm");
+	}
+	return Object.keys(children).filter(function(child) {
+		const val = children[child].exports;
+		return typeof val === "function" && val.name === "Mocha";
+	}).map(function(child) {
+		return children[child].exports;
+	});
+}
+const modules = findNodeJSMocha();
+debug("modules length: %s", modules.length);
+for (const module of modules) {
+	if (!module) continue;
+	injectContext(module);
+}
+
+//#endregion
+export {  };

package/dist/inject_mocha-Daf1Aj8M.d.ts

@@ -0,0 +1 @@
+import "mocha";

package/dist/inject_mocha.d.ts

@@ -1 +1 @@
-import "mocha";
+import "./inject_mocha-Daf1Aj8M.js";

package/dist/inject_mocha.js

@@ -1,34 +1,23 @@
-import { __require } from "./_virtual/rolldown_runtime.js";
-import { injectContext } from "./lib/inject_context.js";
-import { debuglog } from "node:util";
-import { getRequire } from "@eggjs/utils";
-import "mocha";
+import "./inject_mocha-BVf8v6El.js";
+import "./mock_http_server-De0r07gr.js";
+import "./utils-MhP_Krx1.js";
+import "./supertest-Cg412Los.js";
+import "./format_options-LRnReKde.js";
+import "./cluster-CA_hr9eV.js";
+import "./context-BIduDy1M.js";
+import "./mock_custom_loader-f_tHRojG.js";
+import "./mock_agent-CxT7Q0_N.js";
+import "./mock_httpclient-B6UVI7GS.js";
+import "./types-CPNMyF89.js";
+import "./application-LrKwuOKn.js";
+import "./agent-DZ_fHoxJ.js";
+import "./app-6Bn3F5Uw.js";
+import "./restore-CVQYXquh.js";
+import "./util-BpppqTXv.js";
+import "./app-CoypamK1.js";
+import "./agent-BKYkjoCx.js";
+import "./agent_handler-DeUtoRVT.js";
+import "./app_handler-CkiK6fyC.js";
+import "./inject_context-BxpcF-ds.js";
 
-//#region src/inject_mocha.ts
-const debug = debuglog("egg/mock/inject_mocha");
-/**
-* Find active node mocha instances.
-*/
-function findNodeJSMocha() {
-	let children;
-	if (typeof __require === "function") children = __require.cache || {};
-	else {
-		children = getRequire().cache || {};
-		debug("createRequire on esm");
-	}
-	return Object.keys(children).filter(function(child) {
-		const val = children[child].exports;
-		return typeof val === "function" && val.name === "Mocha";
-	}).map(function(child) {
-		return children[child].exports;
-	});
-}
-const modules = findNodeJSMocha();
-debug("modules length: %s", modules.length);
-for (const module of modules) {
-	if (!module) continue;
-	injectContext(module);
-}
-
-//#endregion
 export {  };

package/dist/lib/agent_handler.d.ts

@@ -1,4 +1,7 @@
-import { MockAgent } from "./parallel/agent.js";
+import "../mock_httpclient-1EgQkMxi.js";
+import "../types-CjZ-JeCo.js";
+import "../util-1xYBaaoh.js";
+import { MockAgent } from "../agent-CHCe8tnW.js";
 
 //#region src/lib/agent_handler.d.ts
 declare function setupAgent(): Promise<MockAgent>;