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

package/dist/application-LrKwuOKn.js

@@ -0,0 +1,385 @@
+import { request } from "./supertest-Cg412Los.js";
+import { getMockAgent, restoreMockAgent } from "./mock_agent-CxT7Q0_N.js";
+import { createMockHttpClient } from "./mock_httpclient-B6UVI7GS.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";
+
+//#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 };

package/dist/bootstrap.d.ts

@@ -1,6 +1,12 @@
-import ApplicationUnittest from "./app/extend/application.js";
-import { getBootstrapApp } from "./lib/app_handler.js";
-import proxyMock from "./index.js";
+import "./mock_httpclient-1EgQkMxi.js";
+import "./supertest-BIds28yL.js";
+import "./types-CjZ-JeCo.js";
+import { ApplicationUnittest } from "./application-BPpvw5dg.js";
+import "./cluster-RTfUwmUd.js";
+import "./app-l47a-gqT.js";
+import "./restore-BL0cE0KG.js";
+import { getBootstrapApp } from "./app_handler-Gp5J9X-v.js";
+import { proxyMock } from "./index-BtBMDZg8.js";
 import { strict as assert } from "node:assert";
 
 //#region src/bootstrap.d.ts

package/dist/bootstrap.js

@@ -1,6 +1,23 @@
-import { getEggOptions } from "./lib/utils.js";
-import { getBootstrapApp, setupApp } from "./lib/app_handler.js";
-import src_default, { mm as proxyMock } from "./index.js";
+import "./mock_http_server-De0r07gr.js";
+import { getEggOptions } from "./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 { getBootstrapApp, setupApp } from "./app_handler-CkiK6fyC.js";
+import { proxyMock, src_default } from "./src-D22EjdGo.js";
 import { strict as assert } from "node:assert";
 import path from "node:path";
 import { readJSONSync } from "utility";

package/dist/cluster-CA_hr9eV.js

@@ -0,0 +1,283 @@
+import { rimrafSync, sleep } from "./utils-MhP_Krx1.js";
+import { request } from "./supertest-Cg412Los.js";
+import { formatOptions } from "./format_options-LRnReKde.js";
+import path from "node:path";
+import { debuglog } from "node:util";
+import os from "node:os";
+import childProcess from "node:child_process";
+import { once } from "node:events";
+import { existsSync } from "node:fs";
+import { Coffee } from "coffee";
+import { Ready } from "get-ready";
+
+//#region src/lib/cluster.ts
+const debug = debuglog("egg/mock/lib/cluster");
+const clusters = /* @__PURE__ */ new Map();
+globalThis.eggMockMasterPort = 17e3 + process.pid % 1e3;
+let serverBin = path.join(import.meta.dirname, "start-cluster.js");
+if (!existsSync(serverBin)) serverBin = path.join(import.meta.dirname, "start-cluster.ts");
+let requestCallFunctionFile = path.join(import.meta.dirname, "request_call_function.js");
+if (!existsSync(requestCallFunctionFile)) requestCallFunctionFile = path.join(import.meta.dirname, "request_call_function.ts");
+/**
+* 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);
+*   });
+* });
+*/
+var ClusterApplication = class extends Coffee {
+	options;
+	port;
+	baseDir;
+	closed;
+	_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) {
+		const opt = options.opt;
+		delete options.opt;
+		options.port = options.port ?? ++globalThis.eggMockMasterPort;
+		if (!options.workers) options.workers = 1;
+		const args = [JSON.stringify(options)];
+		debug("fork %s, args: %s, opt: %j", serverBin, args.join(" "), opt);
+		super({
+			method: "fork",
+			cmd: serverBin,
+			args,
+			opt
+		});
+		Ready.mixin(this);
+		this.port = options.port;
+		this.baseDir = options.baseDir;
+		this.debug(process.env.DEBUG ? 0 : 2);
+		if (options.coverage === false) this.coverage(false);
+		process.nextTick(() => {
+			this.proc.on("message", (msg) => {
+				switch (msg && msg.action ? msg.action : msg) {
+					case "egg-ready":
+						debug("on message egg-ready %o", msg);
+						this._address = msg.data.address;
+						this.emit("close", 0);
+						break;
+					case "app-worker-died":
+					case "agent-worker-died":
+						this.emit("close", 1);
+						break;
+					default: break;
+				}
+			});
+		});
+		this.end(() => this.ready(true));
+	}
+	/**
+	* the process that forked
+	* @member {ChildProcess}
+	*/
+	get process() {
+		return this.proc;
+	}
+	/**
+	* Compatible API for supertest
+	*/
+	callback() {
+		return this;
+	}
+	/**
+	* Compatible API for supertest
+	* @member {String} url
+	* @private
+	*/
+	get url() {
+		if (this._address) return this._address;
+		return "http://127.0.0.1:" + this.port;
+	}
+	/**
+	* Compatible API for supertest
+	*/
+	address() {
+		return {
+			port: this.port,
+			address: this._address
+		};
+	}
+	/**
+	* Compatible API for supertest
+	*/
+	listen() {
+		return this;
+	}
+	/**
+	* kill the process
+	*/
+	async close() {
+		this.closed = true;
+		const proc = this.proc;
+		const baseDir = this.baseDir;
+		if (proc?.connected) {
+			proc.kill("SIGTERM");
+			await once(proc, "exit");
+		}
+		clusters.delete(baseDir);
+		debug("delete cluster cache %s, remain %s", baseDir, [...clusters.keys()]);
+		if (os.platform() === "win32") await sleep(1e3);
+	}
+	get isClosed() {
+		return this.closed;
+	}
+	get router() {
+		const self = this;
+		return { pathFor(url) {
+			return self._callFunctionOnAppWorker("pathFor", [url], "router", true);
+		} };
+	}
+	/**
+	* get app[property] value in app worker
+	*/
+	getAppInstanceProperty(property) {
+		return this._callFunctionOnAppWorker("__getter__", [], property, true);
+	}
+	/**
+	* 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) {
+		logger = logger ?? "logger";
+		this._callFunctionOnAppWorker("mockLog", [logger], null, true);
+	}
+	/**
+	* 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, logger) {
+		logger = logger ?? "logger";
+		this._callFunctionOnAppWorker("expectLog", [str, logger], null, true);
+	}
+	/**
+	* 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, logger) {
+		logger = logger ?? "logger";
+		this._callFunctionOnAppWorker("notExpectLog", [str, logger], null, true);
+	}
+	httpRequest() {
+		return request(this);
+	}
+	_callFunctionOnAppWorker(method, args = [], property = void 0, needResult = false) {
+		for (let i = 0; i < args.length; i++) {
+			const arg = args[i];
+			if (typeof arg === "function") args[i] = {
+				__egg_mock_type: "function",
+				value: arg.toString()
+			};
+			else if (arg instanceof Error) {
+				const errObject = {
+					__egg_mock_type: "error",
+					name: arg.name,
+					message: arg.message,
+					stack: arg.stack
+				};
+				for (const key in arg) if (key !== "name" && key !== "message" && key !== "stack") errObject[key] = arg[key];
+				args[i] = errObject;
+			}
+		}
+		const data = {
+			port: this.port,
+			method,
+			args,
+			property,
+			needResult
+		};
+		const child = childProcess.spawnSync(process.execPath, [requestCallFunctionFile, JSON.stringify(data)], { stdio: "pipe" });
+		let result;
+		if (child.stdout && child.stdout.length > 0) if (needResult) result = JSON.parse(child.stdout.toString());
+		else console.error(child.stdout.toString());
+		if (child.status !== 0) throw new Error(child.stderr.toString());
+		if (child.error) throw child.error;
+		return result;
+	}
+};
+function createCluster(initOptions) {
+	const options = formatOptions(initOptions);
+	if (options.cache && clusters.has(options.baseDir)) {
+		const clusterApp$1 = clusters.get(options.baseDir);
+		if (!clusterApp$1.isClosed) return clusterApp$1;
+		clusters.delete(options.baseDir);
+	}
+	if (options.clean !== false) {
+		const logDir = path.join(options.baseDir, "logs");
+		try {
+			rimrafSync(logDir);
+		} catch (err) {
+			console.error(`remove log dir ${logDir} failed: ${err.stack}`);
+		}
+		const runDir = path.join(options.baseDir, "run");
+		try {
+			rimrafSync(runDir);
+		} catch (err) {
+			console.error(`remove run dir ${runDir} failed: ${err.stack}`);
+		}
+	}
+	let clusterApp = new ClusterApplication(options);
+	clusterApp = new Proxy(clusterApp, { get(target, prop) {
+		debug("proxy handler.get %s", prop);
+		const method = prop;
+		if (typeof method === "string" && /^mock\w+$/.test(method) && target[method] === void 0) return function mockProxy(...args) {
+			return target._callFunctionOnAppWorker(method, args, null, true);
+		};
+		return target[prop];
+	} });
+	clusters.set(options.baseDir, clusterApp);
+	return clusterApp;
+}
+async function restore() {
+	for (const clusterApp of clusters.values()) await clusterApp.mockRestore();
+}
+process.on("exit", () => {
+	for (const clusterApp of clusters.values()) {
+		debug("on exit close clusterApp, port: %s", clusterApp.port);
+		clusterApp.close();
+	}
+});
+
+//#endregion
+export { ClusterApplication, createCluster, restore };