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

package/dist/app/extend/application.js

@@ -1,385 +1,9 @@
-import { request } from "../../lib/supertest.js";
-import { getMockAgent, restoreMockAgent } from "../../lib/mock_agent.js";
-import { createMockHttpClient } from "../../lib/mock_httpclient.js";
-import { Application } from "egg";
-import assert from "node:assert";
-import { mock, restore } from "mm";
-import { debuglog } from "node:util";
-import fs from "node:fs";
-import http, { IncomingMessage } from "node:http";
-import mergeDescriptors from "merge-descriptors";
-import { isAsyncFunction, isObject } from "is-type-of";
-import { Logger, Transport } from "egg-logger";
+import "../../mock_http_server-De0r07gr.js";
+import "../../utils-MhP_Krx1.js";
+import "../../supertest-Cg412Los.js";
+import "../../mock_agent-CxT7Q0_N.js";
+import "../../mock_httpclient-B6UVI7GS.js";
+import "../../types-CPNMyF89.js";
+import { ApplicationUnittest } from "../../application-LrKwuOKn.js";
 
-//#region src/app/extend/application.ts
-const debug = debuglog("egg/mock/app/extend/application");
-const ORIGIN_TYPES = Symbol("@eggjs/mock originTypes");
-const BACKGROUND_TASKS = Symbol("Application#backgroundTasks");
-const REUSED_CTX = Symbol("Context#reusedInSuite");
-var ApplicationUnittest = class extends Application {
-	_mockHttpClient;
-	/**
-	* mock Context
-	* @function App#mockContext
-	* @param {Object} data - ctx data
-	* @param {Object} [options] - mock ctx options
-	* @example
-	* ```js
-	* const ctx = app.mockContext({
-	*   user: {
-	*     name: 'Jason'
-	*   }
-	* });
-	* console.log(ctx.user.name); // Jason
-	*
-	* // controller
-	* module.exports = function*() {
-	*   this.body = this.user.name;
-	* };
-	* ```
-	*/
-	mockContext(data, options) {
-		data = data ?? {};
-		function mockRequest(req$1) {
-			for (const key in data?.headers) {
-				mock(req$1.headers, key, data.headers[key]);
-				mock(req$1.headers, key.toLowerCase(), data.headers[key]);
-			}
-		}
-		const mockCtxStorage = this.options.mockCtxStorage ?? true;
-		options = Object.assign({ mockCtxStorage }, options);
-		if ("_customMockContext" in this && typeof this._customMockContext === "function") this._customMockContext(data);
-		for (const key in data) mock(this.context, key, data[key]);
-		const req = this.mockRequest(data);
-		const res = new http.ServerResponse(req);
-		if (options.reuseCtxStorage !== false) {
-			if (this.currentContext && !this.currentContext[REUSED_CTX]) {
-				mockRequest(this.currentContext.request.req);
-				this.currentContext[REUSED_CTX] = true;
-				return this.currentContext;
-			}
-		}
-		const ctx = this.createContext(req, res);
-		if (options.mockCtxStorage) mock(this.ctxStorage, "getStore", () => ctx);
-		return ctx;
-	}
-	async mockContextScope(fn, data) {
-		const ctx = this.mockContext(data, {
-			mockCtxStorage: false,
-			reuseCtxStorage: false
-		});
-		return await this.ctxStorage.run(ctx, async () => {
-			return await fn(ctx);
-		});
-	}
-	/**
-	* mock cookie session
-	* @function App#mockSession
-	* @param {Object} data - session object
-	*/
-	mockSession(data) {
-		if (!data) return this;
-		if (isObject(data) && !("save" in data)) Object.defineProperty(data, "save", {
-			value: () => {},
-			enumerable: false
-		});
-		mock(this.context, "session", data);
-		return this;
-	}
-	/**
-	* Mock service
-	* @function App#mockService
-	* @param {String} service - name
-	* @param {String} methodName - method
-	* @param {Object|Function|Error} fn - mock you data
-	*/
-	mockService(service, methodName, fn) {
-		if (typeof service === "string") {
-			const splits = service.split(".");
-			service = this.serviceClasses;
-			for (const key of splits) service = service[key];
-			service = service.prototype || service;
-		}
-		this._mockFn(service, methodName, fn);
-		return this;
-	}
-	/**
-	* mock service that return error
-	* @function App#mockServiceError
-	* @param {String} service - name
-	* @param {String} methodName - method
-	* @param {Error} [err] - error information
-	*/
-	mockServiceError(service, methodName, err) {
-		if (typeof err === "string") err = new Error(err);
-		if (!err) err = /* @__PURE__ */ new Error(`mock ${methodName} error`);
-		this.mockService(service, methodName, err);
-		return this;
-	}
-	_mockFn(obj, name, data) {
-		const origin = obj[name];
-		assert(typeof origin === "function", `property ${name} in original object must be function`);
-		if (!obj[ORIGIN_TYPES]) obj[ORIGIN_TYPES] = {};
-		let type = obj[ORIGIN_TYPES][name];
-		if (!type) type = obj[ORIGIN_TYPES][name] = isAsyncFunction(origin) ? "async" : "sync";
-		if (typeof data === "function") {
-			const fn = data;
-			if (type === "async" && !isAsyncFunction(fn)) {
-				mock(obj, name, function(...args) {
-					return new Promise((resolve) => {
-						resolve(fn.apply(this, args));
-					});
-				});
-				return;
-			}
-			mock(obj, name, fn);
-			return;
-		}
-		if (type === "async") {
-			mock(obj, name, () => {
-				return new Promise((resolve, reject) => {
-					if (data instanceof Error) return reject(data);
-					resolve(data);
-				});
-			});
-			return;
-		}
-		mock(obj, name, () => {
-			if (data instanceof Error) throw data;
-			return data;
-		});
-	}
-	/**
-	* mock request
-	* @function App#mockRequest
-	* @param {Request} req - mock request
-	*/
-	mockRequest(req) {
-		req = { ...req };
-		const headers = req.headers ?? {};
-		for (const key in req.headers) headers[key.toLowerCase()] = req.headers[key];
-		if (!headers["x-forwarded-for"]) headers["x-forwarded-for"] = "127.0.0.1";
-		headers["x-mock-request-from"] = "@eggjs/mock";
-		req.headers = headers;
-		mergeDescriptors(req, {
-			query: {},
-			querystring: "",
-			host: "127.0.0.1",
-			hostname: "127.0.0.1",
-			protocol: "http",
-			secure: "false",
-			method: "GET",
-			url: "/",
-			path: "/",
-			socket: {
-				remoteAddress: "127.0.0.1",
-				remotePort: 7001
-			}
-		});
-		return req;
-	}
-	/**
-	* mock cookies
-	* @function App#mockCookies
-	*/
-	mockCookies(cookies) {
-		if (!cookies) return this;
-		const createContext = this.createContext;
-		mock(this, "createContext", function(req, res) {
-			const ctx = createContext.call(this, req, res);
-			const getCookie = ctx.cookies.get;
-			mock(ctx.cookies, "get", function(key, opts) {
-				if (cookies[key]) return cookies[key];
-				return getCookie.call(this, key, opts);
-			});
-			return ctx;
-		});
-		return this;
-	}
-	/**
-	* mock header
-	* @function App#mockHeaders
-	*/
-	mockHeaders(headers) {
-		if (!headers) return this;
-		const getHeader = this.request.get;
-		mock(this.request, "get", function(field) {
-			const value = findHeaders(headers, field);
-			if (value) return value;
-			return getHeader.call(this, field);
-		});
-		return this;
-	}
-	/**
-	* mock csrf
-	* @function App#mockCsrf
-	* @since 1.11
-	*/
-	mockCsrf() {
-		mock(this.context, "assertCSRF", () => {});
-		mock(this.context, "assertCsrf", () => {});
-		return this;
-	}
-	/**
-	* mock httpclient
-	* @alias mockHttpClient
-	* @function App#mockHttpclient
-	*/
-	mockHttpclient(mockUrl, mockMethod, mockResult) {
-		return this.mockHttpClient(mockUrl, mockMethod, mockResult);
-	}
-	/**
-	* mock httpclient
-	* @function App#mockHttpClient
-	*/
-	mockHttpClient(mockUrl, mockMethod, mockResult) {
-		if (!this._mockHttpClient) this._mockHttpClient = createMockHttpClient(this);
-		this._mockHttpClient(mockUrl, mockMethod, mockResult);
-		return this;
-	}
-	/**
-	* @deprecated Please use app.mockHttpClient instead of app.mockUrllib
-	*/
-	mockUrllib(mockUrl, mockMethod, mockResult) {
-		this.deprecate("[@eggjs/mock] Please use app.mockHttpClient instead of app.mockUrllib");
-		return this.mockHttpClient(mockUrl, mockMethod, mockResult);
-	}
-	/**
-	* get mock httpclient agent
-	* @function App#mockHttpclientAgent
-	*/
-	mockAgent() {
-		return getMockAgent(this);
-	}
-	async mockAgentRestore() {
-		await restoreMockAgent();
-	}
-	/**
-	* @see mm#restore
-	* @function App#mockRestore
-	*/
-	async mockRestore() {
-		await this.mockAgentRestore();
-		restore();
-	}
-	/**
-	* @see mm
-	* @function App#mm
-	*/
-	get mm() {
-		return mock;
-	}
-	/**
-	* override loadAgent
-	* @function App#loadAgent
-	*/
-	loadAgent() {}
-	/**
-	* mock serverEnv
-	* @function App#mockEnv
-	* @param {String} env - serverEnv
-	*/
-	mockEnv(env) {
-		mock(this.config, "env", env);
-		mock(this.config, "serverEnv", env);
-		debug("mock env: %o", env);
-		return this;
-	}
-	/**
-	* http request helper
-	* @function App#httpRequest
-	* @return {SupertestRequest} req - supertest request
-	* @see https://github.com/visionmedia/supertest
-	*/
-	httpRequest() {
-		return request(this);
-	}
-	/**
-	* collection logger message, then can be use on `expectLog()`
-	* @param {String|Logger} [logger] - logger instance, default is `app.logger`
-	* @function App#mockLog
-	*/
-	mockLog(logger) {
-		logger = logger ?? this.logger;
-		if (typeof logger === "string") logger = this.getLogger(logger);
-		if ("_mockLogs" in logger && logger._mockLogs) return;
-		const transport = new Transport(logger.options);
-		const log = logger.log;
-		const mockLogs = [];
-		mock(logger, "_mockLogs", mockLogs);
-		mock(logger, "log", (level, args, meta) => {
-			const message = transport.log(level, args, meta);
-			mockLogs.push(message);
-			log.apply(logger, [
-				level,
-				args,
-				meta
-			]);
-		});
-	}
-	__checkExpectLog(expectOrNot, str, logger) {
-		logger = logger || this.logger;
-		if (typeof logger === "string") logger = this.getLogger(logger);
-		const filepath = logger.options.file;
-		let content;
-		if ("_mockLogs" in logger && logger._mockLogs) content = logger._mockLogs.join("\n");
-		else content = fs.readFileSync(filepath, "utf8");
-		let match;
-		let type;
-		if (str instanceof RegExp) {
-			match = str.test(content);
-			type = "RegExp";
-		} else {
-			match = content.includes(String(str));
-			type = "String";
-		}
-		if (expectOrNot) assert(match, `Can't find ${type}:"${str}" in ${filepath}, log content: ...${content.substring(content.length - 500)}`);
-		else assert(!match, `Find ${type}:"${str}" in ${filepath}, log content: ...${content.substring(content.length - 500)}`);
-	}
-	/**
-	* expect str/regexp in the logger, if your server disk is slow, please call `mockLog()` first.
-	* @param {String|RegExp} str - test str or regexp
-	* @param {String|Logger} [logger] - logger instance, default is `ctx.logger`
-	* @function App#expectLog
-	*/
-	expectLog(str, logger) {
-		this.__checkExpectLog(true, str, logger);
-	}
-	/**
-	* not expect str/regexp in the logger, if your server disk is slow, please call `mockLog()` first.
-	* @param {String|RegExp} str - test str or regexp
-	* @param {String|Logger} [logger] - logger instance, default is `ctx.logger`
-	* @function App#notExpectLog
-	*/
-	notExpectLog(str, logger) {
-		this.__checkExpectLog(false, str, logger);
-	}
-	async backgroundTasksFinished() {
-		const tasks = this._backgroundTasks;
-		debug("waiting %d background tasks", tasks.length);
-		if (tasks.length === 0) return;
-		this._backgroundTasks = [];
-		await Promise.all(tasks);
-		debug("finished %d background tasks", tasks.length);
-		if (this._backgroundTasks.length) {
-			debug("new background tasks created: %s", this._backgroundTasks.length);
-			await this.backgroundTasksFinished();
-		}
-	}
-	get _backgroundTasks() {
-		if (!this[BACKGROUND_TASKS]) this[BACKGROUND_TASKS] = [];
-		return this[BACKGROUND_TASKS];
-	}
-	set _backgroundTasks(tasks) {
-		this[BACKGROUND_TASKS] = tasks;
-	}
-};
-function findHeaders(headers, key) {
-	if (!headers || !key) return null;
-	key = key.toLowerCase();
-	for (const headerKey in headers) if (key === headerKey.toLowerCase()) return headers[headerKey];
-	return null;
-}
-
-//#endregion
 export { ApplicationUnittest as default };

package/dist/app-6Bn3F5Uw.js

@@ -0,0 +1,252 @@
+import { createServer } from "./mock_http_server-De0r07gr.js";
+import { getProperty, getSourceDirname, rimraf, sleep } from "./utils-MhP_Krx1.js";
+import { formatOptions } from "./format_options-LRnReKde.js";
+import { context } from "./context-BIduDy1M.js";
+import { setCustomLoader } from "./mock_custom_loader-f_tHRojG.js";
+import { strict } from "node:assert";
+import path from "node:path";
+import { debuglog } from "node:util";
+import os from "node:os";
+import { importModule } from "@eggjs/utils";
+import { Base } from "sdk-base";
+import { detectPort } from "detect-port";
+
+//#region src/lib/app.ts
+const debug = debuglog("egg/mock/lib/app");
+const apps = /* @__PURE__ */ new Map();
+const APP_INIT = Symbol("appInit");
+const MESSENGER = Symbol("messenger");
+const MOCK_APP_METHOD = [
+	"ready",
+	"closed",
+	"isClosed",
+	"close",
+	"_agent",
+	"_app",
+	"on",
+	"once",
+	"then"
+];
+var MockApplicationWorker = class extends Base {
+	_agent;
+	_app;
+	baseDir;
+	[APP_INIT] = false;
+	_initOnListeners;
+	_initOnceListeners;
+	constructor(options) {
+		super({
+			initMethod: "_init",
+			...options
+		});
+		this.baseDir = options.baseDir;
+		this._initOnListeners = /* @__PURE__ */ new Set();
+		this._initOnceListeners = /* @__PURE__ */ new Set();
+	}
+	async _init() {
+		if (this.options.beforeInit) {
+			await this.options.beforeInit(this);
+			this.options.beforeInit = void 0;
+		}
+		if (this.options.clean !== false) {
+			const logDir = path.join(this.options.baseDir, "logs");
+			try {
+				if (os.platform() === "win32") await sleep(1e3);
+				await rimraf(logDir);
+			} catch (err) {
+				console.error(`remove log dir ${logDir} failed: ${err.stack}`);
+			}
+			const runDir = path.join(this.options.baseDir, "run");
+			try {
+				if (os.platform() === "win32") await sleep(1e3);
+				await rimraf(runDir);
+			} catch (err) {
+				console.error(`remove run dir ${runDir} failed: ${err.stack}`);
+			}
+		}
+		this.options.clusterPort = await detectPort();
+		debug("[init] options: %o", this.options);
+		const egg = await importModule(this.options.framework);
+		strict(egg.Agent, `should export Agent class from framework ${this.options.framework}`);
+		const Agent = egg.Agent;
+		const agent = this._agent = new Agent({ ...this.options });
+		debug("agent instantiate");
+		await agent.ready();
+		debug("agent ready");
+		const app = this._app = new (bindMessenger(egg.Application, agent))({ ...this.options });
+		app.agent = agent;
+		Reflect.set(agent, "app", app);
+		Object.assign(app.context, context);
+		debug("app instantiate");
+		this[APP_INIT] = true;
+		debug("this[APP_INIT] = true");
+		this.#bindEvent();
+		debug("http server instantiate");
+		createServer(app);
+		await app.ready();
+		setCustomLoader(app);
+		const msg = {
+			action: "egg-ready",
+			data: this.options
+		};
+		app.messenger.onMessage(msg);
+		agent.messenger.onMessage(msg);
+		debug("app ready");
+	}
+	#bindEvent() {
+		debug("bind cache events to app");
+		for (const args of this._initOnListeners) {
+			debug("on(%s), use cache and pass to app", args);
+			this._app.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._app.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._app.on(args[0], args[1]);
+		} else {
+			debug("on(%s), cache it because app 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 app", args);
+			this._app.once(args[0], args[1]);
+		} else {
+			debug("once(%s), cache it because app has not init", args);
+			this._initOnceListeners.add(args);
+			super.on(args[0], args[1]);
+		}
+		return this;
+	}
+	/**
+	* close app
+	*/
+	async _close() {
+		const baseDir = this.baseDir;
+		if (this._app) await this._app.close();
+		else await sleep(200);
+		if (this._agent) await this._agent.close();
+		apps.delete(baseDir);
+		debug("delete app cache %s, remain %s", baseDir, [...apps.keys()]);
+		if (os.platform() === "win32") await sleep(1e3);
+	}
+	/**
+	* @deprecated please use isClosed instead, keep compatible with old version
+	*/
+	get closed() {
+		return this.isClosed;
+	}
+};
+function createApp(createOptions) {
+	const options = formatOptions({
+		...createOptions,
+		mode: "all-in-one-process"
+	});
+	debug("[createApp] options: %o", options);
+	if (options.cache && apps.has(options.baseDir)) {
+		const app = apps.get(options.baseDir);
+		if (app && !app.isClosed) {
+			debug("use cache app %s", options.baseDir);
+			return app;
+		}
+		apps.delete(options.baseDir);
+	}
+	const appWorker = new MockApplicationWorker(options);
+	const proxyApp = new Proxy(appWorker, {
+		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._app[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._app[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._app, 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._app[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._app, prop);
+		},
+		getPrototypeOf(target) {
+			if (!target[APP_INIT]) throw new Error("can't getPrototypeOf before ready");
+			debug("proxy handler.getPrototypeOf %s");
+			return Object.getPrototypeOf(target._app);
+		}
+	});
+	apps.set(options.baseDir, proxyApp);
+	return proxyApp;
+}
+function bindMessenger(ApplicationClass, agent) {
+	const agentMessenger = agent.messenger;
+	return class MessengerApplication extends ApplicationClass {
+		[MESSENGER];
+		constructor(options) {
+			super(options);
+			this.messenger.sendRandom = (action, data) => {
+				this.messenger.sendToAgent(action, data);
+			};
+			agentMessenger.on("egg-ready", () => {
+				agentMessenger.sendRandom = (action, data) => {
+					agentMessenger.sendToApp(action, data);
+					return agentMessenger;
+				};
+			});
+			agentMessenger.send = new Proxy(agentMessenger.send, { apply: this._sendMessage.bind(this) });
+		}
+		_sendMessage(_target, _thisArg, [action, data, to]) {
+			const appMessenger = this.messenger;
+			setImmediate(() => {
+				if (to === "app") appMessenger.onMessage({
+					action,
+					data
+				});
+				else agentMessenger.onMessage({
+					action,
+					data
+				});
+			});
+		}
+		get messenger() {
+			return this[MESSENGER];
+		}
+		set messenger(m) {
+			m.send = new Proxy(m.send, { apply: this._sendMessage.bind(this) });
+			this[MESSENGER] = m;
+		}
+		get [Symbol.for("egg#eggPath")]() {
+			return path.join(getSourceDirname(), "lib/tmp");
+		}
+	};
+}
+
+//#endregion
+export { createApp };