@eggjs/mock 6.0.7 → 6.1.0-beta.2

package/dist/lib/mock_httpclient.js

@@ -0,0 +1,110 @@
+import { getMockAgent } from "./mock_agent.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/lib/parallel/agent.d.ts

@@ -0,0 +1,24 @@
+import { MockApplicationOptions, MockOptions } from "../types.js";
+import { APP_INIT } from "./util.js";
+import { EggCore } from "@eggjs/core";
+import { Base } from "sdk-base";
+
+//#region src/lib/parallel/agent.d.ts
+declare class MockAgent extends Base {
+  #private;
+  options: MockApplicationOptions;
+  baseDir: string;
+  [APP_INIT]: boolean;
+  _instance: EggCore;
+  constructor(options: MockApplicationOptions);
+  _init(): Promise<void>;
+  on(...args: any[]): this;
+  once(...args: any[]): this;
+  /**
+   * close agent
+   */
+  _close(): Promise<void>;
+}
+declare function createAgent(options: MockOptions): MockAgent;
+//#endregion
+export { MockAgent, createAgent };

package/dist/lib/parallel/agent.js

@@ -0,0 +1,111 @@
+import { rimraf, sleep } from "../utils.js";
+import { formatOptions } from "../format_options.js";
+import { context } from "../context.js";
+import { setCustomLoader } from "../mock_custom_loader.js";
+import { APP_INIT } from "./util.js";
+import path from "node:path";
+import { debuglog } from "node:util";
+import { importModule } from "@eggjs/utils";
+import { Base } from "sdk-base";
+import { detectPort } from "detect-port";
+
+//#region src/lib/parallel/agent.ts
+const debug = debuglog("egg/mock/lib/parallel/agent");
+var MockAgent = class extends Base {
+	baseDir;
+	[APP_INIT] = false;
+	#initOnListeners = /* @__PURE__ */ new Set();
+	#initOnceListeners = /* @__PURE__ */ new Set();
+	_instance;
+	constructor(options) {
+		super({ initMethod: "_init" });
+		this.options = options;
+		this.baseDir = this.options.baseDir;
+	}
+	async _init() {
+		if (this.options.beforeInit) {
+			await this.options.beforeInit(this);
+			delete this.options.beforeInit;
+		}
+		if (this.options.clean !== false) {
+			const logDir = path.join(this.options.baseDir, "logs");
+			try {
+				await rimraf(logDir);
+			} catch (err) {
+				console.error(`remove log dir ${logDir} failed: ${err.stack}`);
+			}
+			const runDir = path.join(this.options.baseDir, "run");
+			try {
+				await rimraf(runDir);
+			} catch (err) {
+				console.error(`remove run dir ${runDir} failed: ${err.stack}`);
+			}
+		}
+		this.options.clusterPort = await detectPort();
+		process.env.CLUSTER_PORT = String(this.options.clusterPort);
+		debug("get clusterPort %s", this.options.clusterPort);
+		const { Agent } = await importModule(this.options.framework);
+		const agent = this._instance = new Agent({ ...this.options });
+		Object.assign(agent.context, context);
+		setCustomLoader(agent);
+		debug("agent instantiate");
+		this[APP_INIT] = true;
+		debug("this[APP_INIT] = true");
+		this.#bindEvents();
+		await agent.ready();
+		const msg = {
+			action: "egg-ready",
+			data: this.options
+		};
+		agent.messenger.onMessage(msg);
+		debug("agent ready");
+	}
+	#bindEvents() {
+		debug("bind cache events to agent");
+		for (const args of this.#initOnListeners) {
+			debug("on(%s), use cache and pass to agent", args);
+			this._instance.on(args[0], args[1]);
+			this.removeListener(args[0], args[1]);
+		}
+		for (const args of this.#initOnceListeners) {
+			debug("once(%s), use cache and pass to agent", args);
+			this._instance.once(args[0], args[1]);
+			this.removeListener(args[0], args[1]);
+		}
+	}
+	on(...args) {
+		if (this[APP_INIT]) {
+			debug("on(%s), pass to agent", args);
+			this._instance.on(args[0], args[1]);
+		} else {
+			debug("on(%s), cache it because agent has not init", args);
+			this.#initOnListeners.add(args);
+			super.on(args[0], args[1]);
+		}
+		return this;
+	}
+	once(...args) {
+		if (this[APP_INIT]) {
+			debug("once(%s), pass to agent", args);
+			this._instance.once(args[0], args[1]);
+		} else {
+			debug("once(%s), cache it because agent has not init", args);
+			this.#initOnceListeners.add(args);
+			super.on(args[0], args[1]);
+		}
+		return this;
+	}
+	/**
+	* close agent
+	*/
+	async _close() {
+		if (this._instance) await this._instance.close();
+		else await sleep(200);
+	}
+};
+function createAgent(options) {
+	return new MockAgent(formatOptions(options));
+}
+
+//#endregion
+export { MockAgent, createAgent };

package/dist/lib/parallel/app.d.ts

@@ -0,0 +1,24 @@
+import { MockApplicationOptions, MockOptions } from "../types.js";
+import { APP_INIT } from "./util.js";
+import { EggCore } from "@eggjs/core";
+import { Base } from "sdk-base";
+
+//#region src/lib/parallel/app.d.ts
+declare class MockParallelApplication extends Base {
+  #private;
+  options: MockApplicationOptions;
+  baseDir: string;
+  [APP_INIT]: boolean;
+  _instance: EggCore;
+  constructor(options: MockApplicationOptions);
+  _init(): Promise<void>;
+  on(...args: any[]): this;
+  once(...args: any[]): this;
+  /**
+   * close app
+   */
+  _close(): Promise<void>;
+}
+declare function createApp(initOptions: MockOptions): any;
+//#endregion
+export { MockParallelApplication, createApp };

package/dist/lib/parallel/app.js

@@ -0,0 +1,98 @@
+import { createServer } from "../mock_http_server.js";
+import { sleep } from "../utils.js";
+import { formatOptions } from "../format_options.js";
+import { context } from "../context.js";
+import { setCustomLoader } from "../mock_custom_loader.js";
+import { APP_INIT, proxyApp } from "./util.js";
+import { debuglog } from "node:util";
+import { importModule } from "@eggjs/utils";
+import { Base } from "sdk-base";
+
+//#region src/lib/parallel/app.ts
+const debug = debuglog("egg/mock/lib/parallel/app");
+var MockParallelApplication = class extends Base {
+	baseDir;
+	[APP_INIT] = false;
+	#initOnListeners = /* @__PURE__ */ new Set();
+	#initOnceListeners = /* @__PURE__ */ new Set();
+	_instance;
+	constructor(options) {
+		super({ initMethod: "_init" });
+		this.options = options;
+		this.baseDir = options.baseDir;
+	}
+	async _init() {
+		if (this.options.beforeInit) {
+			await this.options.beforeInit(this);
+			delete this.options.beforeInit;
+		}
+		if (!this.options.clusterPort) this.options.clusterPort = parseInt(process.env.CLUSTER_PORT);
+		if (!this.options.clusterPort) throw new Error("cannot get env.CLUSTER_PORT, parallel run fail");
+		debug("get clusterPort %s", this.options.clusterPort);
+		const { Application } = await importModule(this.options.framework);
+		const app = this._instance = new Application({ ...this.options });
+		Object.assign(app.context, context);
+		setCustomLoader(app);
+		debug("app instantiate");
+		this[APP_INIT] = true;
+		debug("this[APP_INIT] = true");
+		this.#bindEvents();
+		debug("http server instantiate");
+		createServer(app);
+		await app.ready();
+		const msg = {
+			action: "egg-ready",
+			data: this.options
+		};
+		app.messenger.onMessage(msg);
+		debug("app ready");
+	}
+	#bindEvents() {
+		for (const args of this.#initOnListeners) {
+			debug("on(%s), use cache and pass to app", args);
+			this._instance.on(args[0], args[1]);
+			this.removeListener(args[0], args[1]);
+		}
+		for (const args of this.#initOnceListeners) {
+			debug("once(%s), use cache and pass to app", args);
+			this._instance.once(args[0], args[1]);
+			this.removeListener(args[0], args[1]);
+		}
+	}
+	on(...args) {
+		if (this[APP_INIT]) {
+			debug("on(%s), pass to app", args);
+			this._instance.on(args[0], args[1]);
+		} else {
+			debug("on(%s), cache it because app has not init", args);
+			if (this.#initOnListeners) this.#initOnListeners.add(args);
+			super.on(args[0], args[1]);
+		}
+		return this;
+	}
+	once(...args) {
+		if (this[APP_INIT]) {
+			debug("once(%s), pass to app", args);
+			this._instance.once(args[0], args[1]);
+		} else {
+			debug("once(%s), cache it because app has not init", args);
+			if (this.#initOnceListeners) this.#initOnceListeners.add(args);
+			super.on(args[0], args[1]);
+		}
+		return this;
+	}
+	/**
+	* close app
+	*/
+	async _close() {
+		if (this._instance) await this._instance.close();
+		else await sleep(200);
+	}
+};
+function createApp(initOptions) {
+	const app = new MockParallelApplication(formatOptions(initOptions));
+	return proxyApp(app);
+}
+
+//#endregion
+export { MockParallelApplication, createApp };

package/dist/lib/parallel/util.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/lib/parallel/util.js

@@ -0,0 +1,59 @@
+import { getProperty } from "../utils.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/lib/prerequire.d.ts

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

package/dist/lib/prerequire.js

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

package/dist/lib/request_call_function.d.ts

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

package/dist/lib/request_call_function.js

@@ -0,0 +1,37 @@
+import httpClient from "urllib";
+
+//#region src/lib/request_call_function.ts
+const { port, method, args, property, needResult } = JSON.parse(process.argv[2]);
+const url = `http://127.0.0.1:${port}/__egg_mock_call_function`;
+httpClient.request(url, {
+	method: "POST",
+	data: {
+		method,
+		args,
+		property,
+		needResult
+	},
+	contentType: "json",
+	dataType: "json"
+}).then(({ data }) => {
+	if (!data.success) {
+		if (data.error) console.error(data.error);
+		else if (data.message) {
+			const err = new Error(data.message);
+			err.stack = data.stack;
+			console.error(err);
+		}
+		process.exit(2);
+	}
+	if (data.result) console.log("%j", data.result);
+	process.exit(0);
+}).catch((err) => {
+	if (method === "mockRestore" && err.message.includes("ECONNREFUSED")) process.exit(0);
+	console.error("POST %s error, method: %s, args: %j", url, method, args);
+	console.error(err.stack);
+	if (method === "mockRestore") process.exit(0);
+	else process.exit(1);
+});
+
+//#endregion
+export {  };

package/dist/lib/restore.d.ts

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

package/dist/lib/restore.js

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

package/dist/{commonjs/lib → lib}/start-cluster.d.ts

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-export {};
+export {};

package/dist/lib/start-cluster.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import assert from "node:assert";
+import { debuglog } from "node:util";
+import { importModule } from "@eggjs/utils";
+import { isAsyncFunction } from "is-type-of";
+
+//#region src/lib/start-cluster.ts
+const debug = debuglog("egg/mock/lib/start-cluster");
+async function main() {
+	const options = JSON.parse(process.argv[2]);
+	debug("startCluster with options: %o", options);
+	const { startCluster } = await importModule(options.framework);
+	assert(isAsyncFunction(startCluster), `framework(${options.framework}) should export startCluster as an async function`);
+	await startCluster(options);
+}
+main();
+
+//#endregion
+export {  };

package/dist/lib/supertest.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/lib/supertest.js

@@ -0,0 +1,39 @@
+import { createServer } from "./mock_http_server.js";
+import { getSourceDirname } from "./utils.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/lib/tmp/empty.d.ts

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

package/dist/lib/tmp/empty.js

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