@eggjs/mock 6.0.7 → 6.1.0-beta.2

package/dist/app/extend/application.d.ts

@@ -0,0 +1,176 @@
+import { MockHttpClientMethod, MockResultFunction, MockResultOptions } from "../../lib/mock_httpclient.js";
+import { EggTestRequest } from "../../lib/supertest.js";
+import { MockOptions } from "../../lib/types.js";
+import { Context, EggCore, EggCoreOptions } from "@eggjs/core";
+import { mock } from "mm";
+import { IncomingMessage } from "node:http";
+import { Logger } from "egg-logger";
+import * as urllib1 from "urllib";
+import { HttpClient } from "urllib";
+
+//#region src/app/extend/application.d.ts
+interface MockContextOptions {
+  /**
+   * mock ctxStorage or not, default is `true`
+   */
+  mockCtxStorage?: boolean;
+  /**
+   * reuse ctxStorage or not, default is `true`
+   */
+  reuseCtxStorage?: boolean;
+}
+interface MockContextData {
+  headers?: Record<string, string | string[]>;
+  [key: string]: any;
+}
+interface MockContext extends EggContext, Context {
+  service: any;
+}
+declare abstract class ApplicationUnittest extends EggCore {
+  [key: string]: any;
+  options: MockOptions & EggCoreOptions;
+  _mockHttpClient?: MockHttpClientMethod;
+  httpclient: HttpClient;
+  /**
+   * 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?: MockContextData, options?: MockContextOptions): MockContext;
+  mockContextScope(fn: (ctx?: MockContext) => Promise<any>, data?: MockContextData): Promise<any>;
+  /**
+   * mock cookie session
+   * @function App#mockSession
+   * @param {Object} data - session object
+   */
+  mockSession(data: any): this;
+  /**
+   * Mock service
+   * @function App#mockService
+   * @param {String} service - name
+   * @param {String} methodName - method
+   * @param {Object|Function|Error} fn - mock you data
+   */
+  mockService(service: string | any, methodName: string, fn: any): this;
+  /**
+   * mock service that return error
+   * @function App#mockServiceError
+   * @param {String} service - name
+   * @param {String} methodName - method
+   * @param {Error} [err] - error information
+   */
+  mockServiceError(service: string | any, methodName: string, err?: string | Error): this;
+  _mockFn(obj: any, name: string, data: any): void;
+  /**
+   * mock request
+   * @function App#mockRequest
+   * @param {Request} req - mock request
+   */
+  mockRequest(req: MockContextData): IncomingMessage;
+  /**
+   * mock cookies
+   * @function App#mockCookies
+   */
+  mockCookies(cookies: Record<string, string | string[]>): this;
+  /**
+   * mock header
+   * @function App#mockHeaders
+   */
+  mockHeaders(headers: Record<string, string | string[]>): this;
+  /**
+   * mock csrf
+   * @function App#mockCsrf
+   * @since 1.11
+   */
+  mockCsrf(): this;
+  /**
+   * mock httpclient
+   * @alias mockHttpClient
+   * @function App#mockHttpclient
+   */
+  mockHttpclient(mockUrl: string | RegExp, mockMethod: string | string[] | MockResultOptions | MockResultFunction, mockResult?: MockResultOptions | MockResultFunction | string): this;
+  /**
+   * mock httpclient
+   * @function App#mockHttpClient
+   */
+  mockHttpClient(mockUrl: string | RegExp, mockMethod: string | string[] | MockResultOptions | MockResultFunction, mockResult?: MockResultOptions | MockResultFunction | string): this;
+  /**
+   * @deprecated Please use app.mockHttpClient instead of app.mockUrllib
+   */
+  mockUrllib(mockUrl: string | RegExp, mockMethod: string | string[] | MockResultOptions | MockResultFunction, mockResult?: MockResultOptions | MockResultFunction | string): this;
+  /**
+   * get mock httpclient agent
+   * @function App#mockHttpclientAgent
+   */
+  mockAgent(): urllib1.MockAgent<urllib1.MockAgent.Options>;
+  mockAgentRestore(): Promise<void>;
+  /**
+   * @see mm#restore
+   * @function App#mockRestore
+   */
+  mockRestore(): Promise<void>;
+  /**
+   * @see mm
+   * @function App#mm
+   */
+  get mm(): typeof mock;
+  /**
+   * override loadAgent
+   * @function App#loadAgent
+   */
+  loadAgent(): void;
+  /**
+   * mock serverEnv
+   * @function App#mockEnv
+   * @param {String} env - serverEnv
+   */
+  mockEnv(env: string): this;
+  /**
+   * http request helper
+   * @function App#httpRequest
+   * @return {SupertestRequest} req - supertest request
+   * @see https://github.com/visionmedia/supertest
+   */
+  httpRequest(): EggTestRequest;
+  /**
+   * collection logger message, then can be use on `expectLog()`
+   * @param {String|Logger} [logger] - logger instance, default is `app.logger`
+   * @function App#mockLog
+   */
+  mockLog(logger?: string | Logger): void;
+  __checkExpectLog(expectOrNot: boolean, str: string | RegExp, logger?: string | Logger): void;
+  /**
+   * 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: string | RegExp, logger?: string | Logger): void;
+  /**
+   * 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: string | RegExp, logger?: string | Logger): void;
+  backgroundTasksFinished(): Promise<void>;
+  get _backgroundTasks(): Promise<any>[];
+  set _backgroundTasks(tasks: Promise<any>[]);
+}
+//#endregion
+export { MockContext, MockContextData, MockContextOptions, ApplicationUnittest as default };

package/dist/app/extend/application.js

@@ -0,0 +1,385 @@
+import { request } from "../../lib/supertest.js";
+import { getMockAgent, restoreMockAgent } from "../../lib/mock_agent.js";
+import { createMockHttpClient } from "../../lib/mock_httpclient.js";
+import { EggCore } from "@eggjs/core";
+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 EggCore {
+	_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/middleware/cluster_app_mock.d.ts

@@ -0,0 +1,6 @@
+import { Context, Next } from "@eggjs/core";
+
+//#region src/app/middleware/cluster_app_mock.d.ts
+declare const _default: () => (ctx: Context, next: Next) => Promise<void>;
+//#endregion
+export { _default as default };

package/dist/app/middleware/cluster_app_mock.js

@@ -0,0 +1,97 @@
+import { Context } from "@eggjs/core";
+import { debuglog } from "node:util";
+
+//#region src/app/middleware/cluster_app_mock.ts
+const debug = debuglog("egg/mock/app/middleware/cluster_app_mock");
+var cluster_app_mock_default = () => {
+	return async function clusterAppMock(ctx, next) {
+		if (ctx.originalUrl !== "/__egg_mock_call_function") return next();
+		const body = ctx.request.body;
+		debug("%s %s, body: %j", ctx.method, ctx.url, body);
+		const { method, property, args, needResult } = body;
+		if (!method) {
+			ctx.status = 422;
+			ctx.body = {
+				success: false,
+				error: "Missing method"
+			};
+			return;
+		}
+		if (args && !Array.isArray(args)) {
+			ctx.status = 422;
+			ctx.body = {
+				success: false,
+				error: "args should be an Array instance"
+			};
+			return;
+		}
+		if (property) {
+			if (method === "__getter__") {
+				if (!ctx.app[property]) {
+					debug("property %s not exists on app", property);
+					ctx.status = 422;
+					ctx.body = {
+						success: false,
+						error: `property "${property}" not exists on app`
+					};
+					return;
+				}
+				ctx.body = {
+					success: true,
+					result: ctx.app[property]
+				};
+				return;
+			}
+			if (!ctx.app[property] || typeof ctx.app[property][method] !== "function") {
+				debug("property %s.%s not exists on app", property, method);
+				ctx.status = 422;
+				ctx.body = {
+					success: false,
+					error: `method "${method}" not exists on app.${property}`
+				};
+				return;
+			}
+		} else if (typeof ctx.app[method] !== "function") {
+			debug("method %s not exists on app", method);
+			ctx.status = 422;
+			ctx.body = {
+				success: false,
+				error: `method "${method}" not exists on app`
+			};
+			return;
+		}
+		debug("call %s with %j", method, args);
+		for (let i = 0; i < args.length; i++) {
+			const arg = args[i];
+			if (arg && typeof arg === "object") {
+				if (arg.__egg_mock_type === "function") args[i] = eval(`(function() { return ${arg.value} })()`);
+				else if (arg.__egg_mock_type === "error") {
+					const err = new Error(arg.message);
+					err.name = arg.name;
+					err.stack = arg.stack;
+					for (const key in arg) if (key !== "name" && key !== "message" && key !== "stack" && key !== "__egg_mock_type") err[key] = arg[key];
+					args[i] = err;
+				}
+			}
+		}
+		const target = property ? ctx.app[property] : ctx.app;
+		const fn = target[method];
+		try {
+			Promise.resolve(fn.call(target, ...args)).then((result) => {
+				ctx.body = needResult ? {
+					success: true,
+					result
+				} : { success: true };
+			});
+		} catch (err) {
+			ctx.status = 500;
+			ctx.body = {
+				success: false,
+				error: err.message
+			};
+		}
+	};
+};
+
+//#endregion
+export { cluster_app_mock_default as default };

package/dist/app.d.ts

@@ -0,0 +1,10 @@
+import { EggCore, ILifecycleBoot } from "@eggjs/core";
+
+//#region src/app.d.ts
+declare class Boot implements ILifecycleBoot {
+  #private;
+  constructor(app: EggCore);
+  configWillLoad(): void;
+}
+//#endregion
+export { Boot as default };

package/dist/app.js

@@ -0,0 +1,17 @@
+import { EggCore } from "@eggjs/core";
+
+//#region src/app.ts
+var Boot = class {
+	#app;
+	constructor(app) {
+		this.#app = app;
+	}
+	configWillLoad() {
+		const index = this.#app.config.coreMiddleware.indexOf("securities");
+		if (index >= 0) this.#app.config.coreMiddleware.splice(index, 0, "clusterAppMock");
+		else this.#app.config.coreMiddleware.push("clusterAppMock");
+	}
+};
+
+//#endregion
+export { Boot as default };

package/dist/bootstrap.d.ts

@@ -0,0 +1,9 @@
+import ApplicationUnittest from "./app/extend/application.js";
+import { getBootstrapApp } from "./lib/app_handler.js";
+import proxyMock from "./index.js";
+import { strict as assert } from "node:assert";
+
+//#region src/bootstrap.d.ts
+declare const app: ApplicationUnittest;
+//#endregion
+export { ApplicationUnittest as MockApplication, app, assert, getBootstrapApp, proxyMock as mm, proxyMock as mock };