@eggjs/mock 6.0.6 → 6.1.0-beta.2

package/dist/lib/cluster.js

@@ -0,0 +1,283 @@
+import { rimrafSync, sleep } from "./utils.js";
+import { request } from "./supertest.js";
+import { formatOptions } from "./format_options.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 };

package/dist/lib/context.d.ts

@@ -0,0 +1,4 @@
+//#region src/lib/context.d.ts
+declare const context: any;
+//#endregion
+export { context };

package/dist/lib/context.js

@@ -0,0 +1,13 @@
+import { utils } from "@eggjs/core";
+
+//#region src/lib/context.ts
+const context = { runInBackground(scope) {
+	/* istanbul ignore next */
+	const taskName = scope._name || scope.name || utils.getCalleeFromStack(true);
+	if (taskName) scope._name = taskName;
+	const promise = this._runInBackground(scope);
+	this.app._backgroundTasks.push(promise);
+} };
+
+//#endregion
+export { context };

package/dist/lib/format_options.d.ts

@@ -0,0 +1,10 @@
+import { MockApplicationOptions, MockOptions } from "./types.js";
+
+//#region src/lib/format_options.d.ts
+
+/**
+ * format the options
+ */
+declare function formatOptions(initOptions?: MockOptions): MockApplicationOptions;
+//#endregion
+export { formatOptions };

package/dist/lib/format_options.js

@@ -0,0 +1,65 @@
+import { getSourceDirname } from "./utils.js";
+import path from "node:path";
+import { readJSONSync } from "utility";
+import { isMocked, mm } from "mm";
+import { debuglog } from "node:util";
+import { getFrameworkPath } from "@eggjs/utils";
+
+//#region src/lib/format_options.ts
+const debug = debuglog("egg/mock/lib/format_options");
+/**
+* format the options
+*/
+function formatOptions(initOptions) {
+	const options = {
+		baseDir: process.cwd(),
+		cache: true,
+		coverage: true,
+		clean: true,
+		...initOptions
+	};
+	if (!path.isAbsolute(options.baseDir)) options.baseDir = path.join(process.cwd(), "test/fixtures", options.baseDir);
+	let framework = initOptions?.framework ?? initOptions?.customEgg;
+	if (framework === true) {
+		framework = process.cwd();
+		options.plugin = false;
+	} else {
+		if (!framework) framework = "";
+		framework = getFrameworkPath({
+			framework,
+			baseDir: options.baseDir
+		});
+	}
+	options.framework = options.customEgg = framework;
+	const plugins = options.plugins = options.plugins || {};
+	let pluginPath = path.join(getSourceDirname(), "..");
+	if (pluginPath.endsWith("/dist") || pluginPath.endsWith("\\dist")) pluginPath = path.join(pluginPath, "..");
+	plugins["egg-mock"] = {
+		enable: true,
+		path: pluginPath
+	};
+	if (options.plugin !== false) {
+		const pluginPath$1 = process.cwd();
+		const pkgPath = path.join(pluginPath$1, "package.json");
+		const pluginName = getPluginName(pkgPath);
+		if (options.plugin && !pluginName) throw new Error(`should set "eggPlugin" property in ${pkgPath}`);
+		if (pluginName) plugins[pluginName] = {
+			enable: true,
+			path: pluginPath$1
+		};
+	}
+	const env = process.env.EGG_SERVER_ENV;
+	if (!isMocked(process.env, "HOME") && (env === "default" || env === "test" || env === "prod")) mm(process.env, "HOME", options.baseDir);
+	if (process.env.EGG_MOCK_SERVER_ENV) options.cache = false;
+	debug("[formatOptions] options: %j", options);
+	return options;
+}
+function getPluginName(pkgPath) {
+	try {
+		const pkg = readJSONSync(pkgPath);
+		if (pkg.eggPlugin?.name) return pkg.eggPlugin.name;
+	} catch {}
+}
+
+//#endregion
+export { formatOptions };

package/dist/lib/inject_context.d.ts

@@ -0,0 +1,9 @@
+//#region src/lib/inject_context.d.ts
+/**
+ * Monkey patch the mocha instance with egg context.
+ *
+ * @param {Function} mocha - the module of mocha
+ */
+declare function injectContext(mocha: any): void;
+//#endregion
+export { injectContext };

package/dist/lib/inject_context.js

@@ -0,0 +1,106 @@
+import { getApp } from "./app_handler.js";
+import assert from "node:assert";
+import { debuglog } from "node:util";
+
+//#region src/lib/inject_context.ts
+const debug = debuglog("egg/mock/lib/inject_context");
+const MOCHA_SUITE_APP = Symbol.for("mocha#suite#app");
+/**
+* Monkey patch the mocha instance with egg context.
+*
+* @param {Function} mocha - the module of mocha
+*/
+function injectContext(mocha) {
+	if (mocha._injectContextLoaded) {
+		debug("mocha already injected context, skip it");
+		return;
+	}
+	const { Runner } = mocha;
+	const runSuite = Runner.prototype.runSuite;
+	const runTests = Runner.prototype.runTests;
+	function getTestTitle(suite, test) {
+		const suiteTitle = suite.root ? "root suite" : suite.title;
+		if (!test) return `"${suiteTitle}"`;
+		return `"${suiteTitle} - ${test.title}"`;
+	}
+	Runner.prototype.runSuite = async function(suite, fn) {
+		debug("run suite: %s", suite.title);
+		let app;
+		const self = this;
+		try {
+			app = await getApp(suite);
+			debug("get app: %s", !!app);
+			await app.ready();
+		} catch {
+			app = null;
+		}
+		if (!app) return runSuite.call(self, suite, fn);
+		let errSuite;
+		try {
+			suite.ctx[MOCHA_SUITE_APP] = app;
+			await (app.mockModuleContextScope || app.mockContextScope).call(app, async function() {
+				await new Promise((resolve) => {
+					runSuite.call(self, suite, (aErrSuite) => {
+						errSuite = aErrSuite;
+						resolve();
+					});
+				});
+			});
+		} catch (err) {
+			suite.beforeAll("egg-mock-mock-ctx-failed", async () => {
+				throw err;
+			});
+			return runSuite.call(self, suite, (aErrSuite) => {
+				return fn(aErrSuite);
+			});
+		}
+		return fn(errSuite);
+	};
+	Runner.prototype.runTests = async function(suite, fn) {
+		const tests = suite.tests.slice();
+		if (!tests.length) return runTests.call(this, suite, fn);
+		const app = suite.ctx[MOCHA_SUITE_APP];
+		const self = this;
+		if (!app) return runTests.call(self, suite, fn);
+		function done(errSuite) {
+			suite.tests = tests;
+			return fn(errSuite);
+		}
+		async function next(i) {
+			const test = tests[i];
+			if (!test) return done();
+			suite.tests = [test];
+			let app$1;
+			try {
+				app$1 = await getApp(suite, test);
+				assert(app$1, `not found app for test ${getTestTitle(suite, test)}`);
+				await app$1.ready();
+			} catch (err) {
+				self.fail(test, err);
+				return next(i + 1);
+			}
+			try {
+				await (app$1.mockModuleContextScope || app$1.mockContextScope).call(app$1, async function() {
+					return await new Promise((resolve) => {
+						runTests.call(self, suite, () => {
+							return resolve();
+						});
+					});
+				});
+			} catch (err) {
+				self.fail(test, err);
+				return next(i + 1);
+			}
+			return next(i + 1);
+		}
+		next(0).catch((err) => {
+			self.fail(suite, err);
+			done(suite);
+		});
+	};
+	mocha._injectContextLoaded = true;
+	debug("inject context success");
+}
+
+//#endregion
+export { injectContext };

package/dist/lib/mock_agent.d.ts

@@ -0,0 +1,9 @@
+import { HttpClient, MockAgent } from "urllib";
+
+//#region src/lib/mock_agent.d.ts
+declare function getMockAgent(app?: {
+  httpClient?: HttpClient;
+}): MockAgent<MockAgent.Options>;
+declare function restoreMockAgent(): Promise<void>;
+//#endregion
+export { getMockAgent, restoreMockAgent };

package/dist/lib/mock_agent.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/lib/mock_custom_loader.d.ts

@@ -0,0 +1,4 @@
+//#region src/lib/mock_custom_loader.d.ts
+declare function setCustomLoader(app: any): void;
+//#endregion
+export { setCustomLoader };

package/dist/lib/mock_custom_loader.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/lib/mock_http_server.d.ts

@@ -0,0 +1,6 @@
+import { Server } from "node:http";
+
+//#region src/lib/mock_http_server.d.ts
+declare function createServer(app: any): Server;
+//#endregion
+export { createServer };

package/dist/lib/mock_http_server.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/lib/mock_httpclient.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 };