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

package/dist/mock_agent-CxT7Q0_N.js

@@ -0,0 +1,45 @@
+import { debuglog } from "node:util";
+import { Dispatcher, HttpClient, MockAgent, getGlobalDispatcher, setGlobalDispatcher } from "urllib";
+
+//#region src/lib/mock_agent.ts
+const debug = debuglog("egg/mock/lib/mock_agent");
+globalThis.__mockAgent = null;
+globalThis.__httpClientDispatchers = /* @__PURE__ */ new Map();
+function getMockAgent(app) {
+	debug("getMockAgent");
+	if (!globalThis.__globalDispatcher) {
+		globalThis.__globalDispatcher = getGlobalDispatcher();
+		debug("create global dispatcher");
+	}
+	if (app?.httpClient && !globalThis.__httpClientDispatchers.has(app.httpClient)) {
+		globalThis.__httpClientDispatchers.set(app.httpClient, app.httpClient.getDispatcher());
+		debug("add new httpClient, size: %d", globalThis.__httpClientDispatchers.size);
+	}
+	if (!globalThis.__mockAgent) {
+		globalThis.__mockAgent = new MockAgent();
+		setGlobalDispatcher(globalThis.__mockAgent);
+		if (typeof app?.httpClient?.setDispatcher === "function") app.httpClient.setDispatcher(globalThis.__mockAgent);
+		debug("create new mockAgent");
+	}
+	return globalThis.__mockAgent;
+}
+async function restoreMockAgent() {
+	debug("restoreMockAgent start");
+	if (globalThis.__globalDispatcher) {
+		setGlobalDispatcher(globalThis.__globalDispatcher);
+		debug("restore global dispatcher");
+	}
+	debug("restore httpClient, size: %d", globalThis.__httpClientDispatchers.size);
+	for (const [httpClient$1, dispatcher] of globalThis.__httpClientDispatchers) httpClient$1.setDispatcher(dispatcher);
+	globalThis.__httpClientDispatchers.clear();
+	if (globalThis.__mockAgent) {
+		const agent = globalThis.__mockAgent;
+		globalThis.__mockAgent = null;
+		await agent.close();
+		debug("close mockAgent");
+	}
+	debug("restoreMockAgent end");
+}
+
+//#endregion
+export { getMockAgent, restoreMockAgent };

package/dist/mock_custom_loader-f_tHRojG.js

@@ -0,0 +1,35 @@
+import { debuglog } from "node:util";
+
+//#region src/lib/mock_custom_loader.ts
+const debug = debuglog("egg/mock/lib/mock_custom_loader");
+function setCustomLoader(app) {
+	const customLoader = app.config.customLoader;
+	if (!customLoader) return;
+	for (const field of Object.keys(customLoader)) {
+		const loaderConfig = Object.assign({}, customLoader[field]);
+		loaderConfig.field = field;
+		addMethod(loaderConfig);
+	}
+	function addMethod(loaderConfig) {
+		const field = loaderConfig.field;
+		const appMethodName = "mock" + field.replace(/^[a-z]/i, (s) => s.toUpperCase());
+		if (app[appMethodName]) {
+			app.coreLogger.warn("Can't override app.%s", appMethodName);
+			return;
+		}
+		debug("[addMethod] %s => %j", appMethodName, loaderConfig);
+		app[appMethodName] = function(service, methodName, fn) {
+			if (typeof service === "string") {
+				const arr = service.split(".");
+				service = loaderConfig.inject === "ctx" ? this[field + "Classes"] : this[field];
+				for (const key of arr) service = service[key];
+				service = service.prototype || service;
+			}
+			this._mockFn(service, methodName, fn);
+			return this;
+		};
+	}
+}
+
+//#endregion
+export { setCustomLoader };

package/dist/mock_http_server-De0r07gr.js

@@ -0,0 +1,17 @@
+import http, { Server } from "node:http";
+
+//#region src/lib/mock_http_server.ts
+const SERVER = Symbol("http_server");
+function createServer(app) {
+	let server = app[SERVER] || app.callback();
+	if (typeof server === "function") {
+		server = http.createServer(server);
+		app[SERVER] = server;
+		if (!app.server) app.server = server;
+		app.emit("server", server);
+	}
+	return server;
+}
+
+//#endregion
+export { createServer };

package/dist/mock_httpclient-1EgQkMxi.d.ts

@@ -0,0 +1,40 @@
+import { BodyInit, Dispatcher, Headers } from "urllib";
+
+//#region src/lib/mock_httpclient.d.ts
+interface MockResultOptions {
+  data: string | Buffer | Record<string, any>;
+  /**
+   * http status
+   */
+  status?: number;
+  /**
+   * response header
+   */
+  headers?: Record<string, string>;
+  /**
+   * delay the associated reply by a set amount in ms
+   */
+  delay?: number;
+  /**
+   * any matching request will always reply with the defined response indefinitely
+   */
+  persist?: boolean;
+  /**
+   * any matching request will reply with the defined response a fixed amount of times
+   */
+  repeats?: number;
+}
+type ResultObject = MockResultOptions;
+interface MockResponseCallbackOptions {
+  path: string;
+  method: string;
+  headers?: Headers | Record<string, string>;
+  origin?: string;
+  body?: BodyInit | Dispatcher.DispatchOptions['body'] | null;
+  maxRedirections?: number;
+}
+type MockResultFunction = (url: string, options: MockResponseCallbackOptions) => MockResultOptions | string;
+declare function createMockHttpClient(app: any): (mockUrl: string | RegExp, mockMethod: string | string[] | MockResultOptions | MockResultFunction, mockResult?: MockResultOptions | MockResultFunction | string) => void;
+type MockHttpClientMethod = ReturnType<typeof createMockHttpClient>;
+//#endregion
+export { MockHttpClientMethod, MockResponseCallbackOptions, MockResultFunction, MockResultOptions, ResultObject, createMockHttpClient };

package/dist/mock_httpclient-B6UVI7GS.js

@@ -0,0 +1,110 @@
+import { getMockAgent } from "./mock_agent-CxT7Q0_N.js";
+import { mm } from "mm";
+import { extend } from "@eggjs/extend2";
+
+//#region src/lib/mock_httpclient.ts
+function normalizeResult(result) {
+	if (typeof result === "string") result = { data: result };
+	if (!result.status) result.status = 200;
+	result.data = result.data || "";
+	if (Buffer.isBuffer(result.data)) {} else if (typeof result.data === "object") result.data = Buffer.from(JSON.stringify(result.data));
+	else if (typeof result.data === "string") result.data = Buffer.from(result.data);
+	else throw new Error("`mockResult.data` must be buffer, string or json");
+	result.headers = result.headers ?? {};
+	return result;
+}
+const MOCK_CONFIGS = Symbol("MOCK_CONFIGS");
+const MOCK_CONFIG_INDEX = Symbol("MOCK_CONFIG_INDEX");
+function createMockHttpClient(app) {
+	/**
+	* mock httpclient
+	* @function mockHttpclient
+	* @param {String} mockUrl - url
+	* @param {String|Array} mockMethod - http method, default is '*'
+	* @param {Object|Function} mockResult - you data
+	*   - data - buffer / string / json
+	*   - status - http status
+	*   - headers - response header
+	*   - delay - delay the associated reply by a set amount in ms.
+	*   - persist - any matching request will always reply with the defined response indefinitely, default is true
+	*   - repeats - number, any matching request will reply with the defined response a fixed amount of times
+	*/
+	return function mockHttpClient(mockUrl, mockMethod, mockResult) {
+		let mockMethods = mockMethod;
+		if (!mockResult) {
+			mockResult = mockMethod;
+			mockMethods = ["*"];
+		}
+		if (!Array.isArray(mockMethods)) mockMethods = [mockMethods];
+		mockMethods = mockMethods.map((method) => (method || "GET").toUpperCase());
+		let mockConfigs = app[MOCK_CONFIGS];
+		if (!mockConfigs) {
+			mockConfigs = [];
+			mm(app, MOCK_CONFIGS, mockConfigs);
+		}
+		let mockConfigIndex = -1;
+		let origin = mockUrl;
+		let originMethod;
+		const pathname = mockUrl;
+		let pathMethod;
+		if (typeof mockUrl === "string") {
+			const urlObject = new URL(mockUrl);
+			origin = urlObject.origin;
+			const originalPathname = urlObject.pathname;
+			pathMethod = (path) => {
+				if (path === originalPathname) return true;
+				if (path.includes("?")) return path.startsWith(originalPathname);
+				return false;
+			};
+		} else if (mockUrl instanceof RegExp) {
+			let requestOrigin = "";
+			originMethod = (value) => {
+				requestOrigin = value;
+				return true;
+			};
+			pathMethod = (path) => {
+				for (const config of mockConfigs) if (config.mockUrl.test(`${requestOrigin}${path}`)) {
+					mm(app, MOCK_CONFIG_INDEX, config.mockConfigIndex);
+					return true;
+				}
+				return false;
+			};
+			mockConfigIndex = mockConfigs.length;
+			mockConfigs.push({
+				mockUrl,
+				mockResult,
+				mockConfigIndex
+			});
+		}
+		const mockPool = originMethod ? getMockAgent(app).get(originMethod) : getMockAgent(app).get(originMethod ?? origin);
+		let persist = true;
+		if (typeof mockResult === "object" && typeof mockResult.persist === "boolean") persist = mockResult.persist;
+		mockMethods.forEach(function(method) {
+			const mockScope = mockPool.intercept({
+				path: pathMethod ?? pathname,
+				method: method === "*" ? () => true : method
+			}).reply((options) => {
+				const requestUrl = `${options.origin}${options.path}`;
+				let mockRequestResult;
+				if (mockConfigIndex >= 0) {
+					mockResult = mockConfigs[app[MOCK_CONFIG_INDEX]].mockResult;
+					mockRequestResult = typeof mockResult === "function" ? mockResult(requestUrl, options) : mockResult;
+				} else mockRequestResult = typeof mockResult === "function" ? mockResult(requestUrl, options) : mockResult;
+				const result = extend(true, {}, normalizeResult(mockRequestResult));
+				return {
+					statusCode: result.status,
+					data: result.data,
+					responseOptions: { headers: result.headers }
+				};
+			});
+			if (typeof mockResult === "object") {
+				if (mockResult.delay && mockResult.delay > 0) mockScope.delay(mockResult.delay);
+			}
+			if (persist) mockScope.persist();
+			else if (typeof mockResult === "object" && mockResult.repeats && mockResult.repeats > 0) mockScope.times(mockResult.repeats);
+		});
+	};
+}
+
+//#endregion
+export { createMockHttpClient };

package/dist/register.d.ts

@@ -1,3 +1,5 @@
+import "./inject_mocha-Daf1Aj8M.js";
+
 //#region src/register.d.ts
 declare function mochaGlobalSetup(): Promise<void>;
 declare function mochaGlobalTeardown(): Promise<void>;

package/dist/register.js

@@ -1,7 +1,25 @@
-import { closeAgent, setupAgent } from "./lib/agent_handler.js";
-import { getApp } from "./lib/app_handler.js";
-import { mm as proxyMock } from "./index.js";
-import "./inject_mocha.js";
+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 { closeAgent, setupAgent } from "./agent_handler-DeUtoRVT.js";
+import { getApp } from "./app_handler-CkiK6fyC.js";
+import { proxyMock } from "./src-D22EjdGo.js";
+import "./inject_context-BxpcF-ds.js";
 import { debuglog } from "node:util";
 
 //#region src/register.ts

package/dist/restore-BL0cE0KG.d.ts

@@ -0,0 +1,4 @@
+//#region src/lib/restore.d.ts
+declare function restore(): Promise<void>;
+//#endregion
+export { restore };

package/dist/restore-CVQYXquh.js

@@ -0,0 +1,16 @@
+import { restore as restore$1 } from "./cluster-CA_hr9eV.js";
+import { restoreMockAgent } from "./mock_agent-CxT7Q0_N.js";
+import { restore } from "mm";
+import { debuglog } from "node:util";
+
+//#region src/lib/restore.ts
+const debug = debuglog("egg/mock/lib/restore");
+async function restore$2() {
+	restore();
+	await restore$1();
+	await restoreMockAgent();
+	debug("restore all");
+}
+
+//#endregion
+export { restore$2 as restore };

package/dist/src-D22EjdGo.js

@@ -0,0 +1,47 @@
+import { createCluster } from "./cluster-CA_hr9eV.js";
+import { createApp } from "./app-6Bn3F5Uw.js";
+import { restore as restore$1 } from "./restore-CVQYXquh.js";
+import { setGetAppCallback } from "./app_handler-CkiK6fyC.js";
+import mm$1, { mock } from "mm";
+
+//#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 { proxyMock, src_default };

package/dist/supertest-BIds28yL.d.ts

@@ -0,0 +1,16 @@
+import { Request, Test } from "@eggjs/supertest";
+
+//#region src/lib/supertest.d.ts
+
+/**
+ * Test against the given `app`,
+ * returning a new `Test`.
+ */
+declare class EggTestRequest extends Request {
+  #private;
+  constructor(app: any);
+  protected _testRequest(method: string, url: string): Test;
+}
+declare function request(app: any): EggTestRequest;
+//#endregion
+export { EggTestRequest, request };

package/dist/supertest-Cg412Los.js

@@ -0,0 +1,39 @@
+import { createServer } from "./mock_http_server-De0r07gr.js";
+import { getSourceDirname } from "./utils-MhP_Krx1.js";
+import path from "node:path";
+import { readJSONSync } from "utility";
+import { Request, Test } from "@eggjs/supertest";
+
+//#region src/lib/supertest.ts
+let pkgVersion = "";
+/**
+* Test against the given `app`,
+* returning a new `Test`.
+*/
+var EggTestRequest = class extends Request {
+	#app;
+	constructor(app) {
+		super(createServer(app));
+		this.#app = app;
+	}
+	_testRequest(method, url) {
+		if (url[0] !== "/") {
+			const realUrl = this.#app.router.pathFor(url);
+			if (!realUrl) throw new Error(`Can't find router:${url}, please check your 'app/router.js'`);
+			url = realUrl;
+		}
+		const test = super._testRequest(method, url);
+		if (!pkgVersion) {
+			const pkgFile = path.join(getSourceDirname(), "../package.json");
+			pkgVersion = readJSONSync(pkgFile).version;
+		}
+		test.set("User-Agent", `@eggjs/mock/${pkgVersion} Node.js/${process.version}`);
+		return test;
+	}
+};
+function request(app) {
+	return new EggTestRequest(app);
+}
+
+//#endregion
+export { EggTestRequest, request };

package/dist/types-CPNMyF89.js

@@ -0,0 +1 @@
+export {  };

package/dist/types-CjZ-JeCo.d.ts

@@ -0,0 +1,75 @@
+import { MockAgent as MockAgent$1 } from "urllib";
+
+//#region src/lib/types.d.ts
+interface MockOptions {
+  /**
+   * The mode of the application
+   */
+  mode?: 'all-in-one-process' | 'cluster' | 'single';
+  /**
+   * The directory of the application
+   */
+  baseDir?: string;
+  /**
+   * Custom you plugins
+   */
+  plugins?: any;
+  /**
+   * The directory of the egg framework
+   *
+   * Set to `true` to use the current directory as framework directory
+   */
+  framework?: string | boolean;
+  /**
+   * current test on plugin
+   */
+  plugin?: boolean;
+  /**
+   * @deprecated please use `framework` instead
+   */
+  customEgg?: string | boolean;
+  /**
+   * Cache application based on baseDir
+   */
+  cache?: boolean;
+  /**
+   * Switch on process coverage, but it'll be slower
+   */
+  coverage?: boolean;
+  /**
+   * Remove $baseDir/logs and $baseDir/run before start, default is `true`
+   */
+  clean?: boolean;
+  /**
+   * default options.mockCtxStorage value on each mockContext
+   */
+  mockCtxStorage?: boolean;
+  beforeInit?: (app: any) => Promise<void>;
+}
+interface MockClusterOptions extends MockOptions {
+  workers?: number | string;
+  cache?: boolean;
+  port?: number;
+  /**
+   * opt pass to coffee, such as { execArgv: ['--debug'] }
+   */
+  opt?: object;
+  startMode?: 'process' | 'worker_threads';
+}
+/**
+ * @deprecated please use MockOptions instead
+ * keep this for compatible
+ */
+type MockOption = MockOptions;
+interface MockApplicationOptions extends MockOptions {
+  baseDir: string;
+  framework: string;
+  clusterPort?: number;
+}
+interface MockClusterApplicationOptions extends MockClusterOptions {
+  baseDir: string;
+  framework: string;
+  port: number;
+}
+//#endregion
+export { type MockAgent$1 as MockAgent, MockApplicationOptions, MockClusterApplicationOptions, MockClusterOptions, MockOption, MockOptions };

package/dist/util-1xYBaaoh.d.ts

@@ -0,0 +1,6 @@
+//#region src/lib/parallel/util.d.ts
+declare const MOCK_APP_METHOD: string[];
+declare const APP_INIT: unique symbol;
+declare function proxyApp(app: any): any;
+//#endregion
+export { APP_INIT, MOCK_APP_METHOD, proxyApp };

package/dist/util-BpppqTXv.js

@@ -0,0 +1,59 @@
+import { getProperty } from "./utils-MhP_Krx1.js";
+import { debuglog } from "node:util";
+
+//#region src/lib/parallel/util.ts
+const debug = debuglog("egg/mock/lib/parallel/util");
+const MOCK_APP_METHOD = [
+	"ready",
+	"isClosed",
+	"closed",
+	"close",
+	"on",
+	"once"
+];
+const APP_INIT = Symbol("appInit");
+function proxyApp(app) {
+	return new Proxy(app, {
+		get(target, prop) {
+			if (MOCK_APP_METHOD.includes(prop)) return getProperty(target, prop);
+			if (!target[APP_INIT]) throw new Error(`can't get ${prop} before ready`);
+			debug("proxy handler.get %s", prop);
+			return target._instance[prop];
+		},
+		set(target, prop, value) {
+			if (MOCK_APP_METHOD.includes(prop)) return true;
+			if (!target[APP_INIT]) throw new Error(`can't set ${prop} before ready`);
+			debug("proxy handler.set %s", prop);
+			target._instance[prop] = value;
+			return true;
+		},
+		defineProperty(target, prop, descriptor) {
+			if (MOCK_APP_METHOD.includes(prop)) return true;
+			if (!target[APP_INIT]) throw new Error(`can't defineProperty ${prop} before ready`);
+			debug("proxy handler.defineProperty %s", prop);
+			Object.defineProperty(target._instance, prop, descriptor);
+			return true;
+		},
+		deleteProperty(target, prop) {
+			if (MOCK_APP_METHOD.includes(prop)) return true;
+			if (!target[APP_INIT]) throw new Error(`can't delete ${prop} before ready`);
+			debug("proxy handler.deleteProperty %s", prop);
+			delete target._instance[prop];
+			return true;
+		},
+		getOwnPropertyDescriptor(target, prop) {
+			if (MOCK_APP_METHOD.includes(prop)) return Object.getOwnPropertyDescriptor(target, prop);
+			if (!target[APP_INIT]) throw new Error(`can't getOwnPropertyDescriptor ${prop} before ready`);
+			debug("proxy handler.getOwnPropertyDescriptor %s", prop);
+			return Object.getOwnPropertyDescriptor(target._instance, prop);
+		},
+		getPrototypeOf(target) {
+			if (!target[APP_INIT]) throw new Error("can't getPrototypeOf before ready");
+			debug("proxy handler.getPrototypeOf %s");
+			return Object.getPrototypeOf(target._instance);
+		}
+	});
+}
+
+//#endregion
+export { APP_INIT, MOCK_APP_METHOD, proxyApp };

package/dist/utils-MhP_Krx1.js

@@ -0,0 +1,40 @@
+import path from "node:path";
+import { rmSync } from "node:fs";
+import { rm } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { scheduler } from "node:timers/promises";
+
+//#region src/lib/utils.ts
+function getSourceDirname() {
+	if (typeof __dirname !== "undefined") return path.dirname(__dirname);
+	return path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+}
+async function sleep(delay) {
+	await scheduler.wait(delay);
+}
+async function rimraf(filepath) {
+	await rm(filepath, {
+		force: true,
+		recursive: true
+	});
+}
+function rimrafSync(filepath) {
+	rmSync(filepath, {
+		force: true,
+		recursive: true
+	});
+}
+function getProperty(target, prop) {
+	const member = target[prop];
+	if (typeof member === "function") return member.bind(target);
+	return member;
+}
+function getEggOptions() {
+	return {
+		baseDir: process.env.EGG_BASE_DIR ?? process.cwd(),
+		framework: process.env.EGG_FRAMEWORK
+	};
+}
+
+//#endregion
+export { getEggOptions, getProperty, getSourceDirname, rimraf, rimrafSync, sleep };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eggjs/mock",
-  "version": "7.0.0-beta.19",
+  "version": "7.0.0-beta.20",
   "publishConfig": {
     "access": "public"
   },
@@ -70,19 +70,18 @@
     "detect-port": "^2.1.0",
     "egg-logger": "^3.5.0",
     "get-ready": "^3.1.0",
-    "globby": "^11.0.2",
     "is-type-of": "^2.2.0",
     "merge-descriptors": "^2.0.0",
     "mm": "^4.0.2",
     "sdk-base": "^5.0.1",
     "urllib": "^4.8.2",
     "utility": "^2.5.0",
-    "@eggjs/supertest": "9.0.0-beta.19",
-    "@eggjs/extend2": "5.0.0-beta.19",
-    "@eggjs/utils": "5.0.0-beta.19"
+    "@eggjs/supertest": "9.0.0-beta.20",
+    "@eggjs/utils": "5.0.0-beta.20",
+    "@eggjs/extend2": "5.0.0-beta.20"
   },
   "peerDependencies": {
-    "egg": "4.1.0-beta.19"
+    "egg": "4.1.0-beta.20"
   },
   "devDependencies": {
     "@eggjs/tegg": "^3.2.2",
@@ -93,7 +92,7 @@
     "egg-errors": "^2.3.2",
     "tsdown": "^0.15.4",
     "typescript": "^5.9.3",
-    "@eggjs/tracer": "4.0.0-beta.19"
+    "@eggjs/tracer": "4.0.0-beta.20"
   },
   "scripts": {
     "build": "tsdown",

package/dist/_virtual/rolldown_runtime.js

@@ -1,7 +0,0 @@
-import { createRequire } from "node:module";
-
-//#region rolldown:runtime
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-//#endregion
-export { __require };