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

package/dist/app-CoypamK1.js

@@ -0,0 +1,99 @@
+import { createServer } from "./mock_http_server-De0r07gr.js";
+import { 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 { APP_INIT, proxyApp } from "./util-BpppqTXv.js";
+import { Application } from "egg";
+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: Application$1 } = await importModule(this.options.framework);
+		const app = this._instance = new Application$1({ ...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/app-l47a-gqT.d.ts

@@ -0,0 +1,7 @@
+import { MockOptions } from "./types-CjZ-JeCo.js";
+import { ApplicationUnittest } from "./application-BPpvw5dg.js";
+
+//#region src/lib/app.d.ts
+declare function createApp(createOptions?: MockOptions): ApplicationUnittest;
+//#endregion
+export { createApp };

package/dist/app_handler-CkiK6fyC.js

@@ -0,0 +1,55 @@
+import { getEggOptions } from "./utils-MhP_Krx1.js";
+import { createApp as createApp$1 } from "./app-6Bn3F5Uw.js";
+import { restore } from "./restore-CVQYXquh.js";
+import { createApp } from "./app-CoypamK1.js";
+import { setupAgent } from "./agent_handler-DeUtoRVT.js";
+import { debuglog } from "node:util";
+
+//#region src/lib/app_handler.ts
+const debug = debuglog("egg/mock/lib/app_handler");
+globalThis.__eggMockAppInstance = null;
+function setupApp() {
+	let app = globalThis.__eggMockAppInstance;
+	if (app) {
+		debug("return exists app");
+		return app;
+	}
+	const options = getEggOptions();
+	debug("env.ENABLE_MOCHA_PARALLEL: %s, process.env.AUTO_AGENT: %s", process.env.ENABLE_MOCHA_PARALLEL, process.env.AUTO_AGENT);
+	if (process.env.ENABLE_MOCHA_PARALLEL && process.env.AUTO_AGENT) {
+		app = createApp({
+			...options,
+			beforeInit: async (parallelApp) => {
+				const agent = await setupAgent();
+				parallelApp.options.clusterPort = agent.options.clusterPort;
+				debug("mockParallelApp beforeInit get clusterPort: %s", parallelApp.options.clusterPort);
+			}
+		});
+		debug("mockParallelApp app: %s", !!app);
+	} else {
+		app = createApp$1(options);
+		if (typeof beforeAll === "function") beforeAll(() => app.ready());
+		if (typeof afterEach === "function") {
+			afterEach(() => app.backgroundTasksFinished());
+			afterEach(restore);
+		}
+	}
+	globalThis.__eggMockAppInstance = app;
+	return app;
+}
+let getAppCallback;
+function setGetAppCallback(cb) {
+	getAppCallback = cb;
+}
+async function getApp(suite, test) {
+	if (getAppCallback) return getAppCallback(suite, test);
+	const app = globalThis.__eggMockAppInstance;
+	if (app) await app.ready();
+	return app;
+}
+function getBootstrapApp() {
+	return globalThis.__eggMockAppInstance;
+}
+
+//#endregion
+export { getApp, getBootstrapApp, setGetAppCallback, setupApp };

package/dist/app_handler-Gp5J9X-v.d.ts

@@ -0,0 +1,9 @@
+import { ApplicationUnittest } from "./application-BPpvw5dg.js";
+
+//#region src/lib/app_handler.d.ts
+declare function setupApp(): ApplicationUnittest;
+declare function setGetAppCallback(cb: (suite: unknown, test?: unknown) => any): void;
+declare function getApp(suite?: unknown, test?: unknown): Promise<any>;
+declare function getBootstrapApp(): ApplicationUnittest;
+//#endregion
+export { getApp, getBootstrapApp, setGetAppCallback, setupApp };

package/dist/application-BPpvw5dg.d.ts

@@ -0,0 +1,175 @@
+import { MockHttpClientMethod, MockResultFunction, MockResultOptions } from "./mock_httpclient-1EgQkMxi.js";
+import { EggTestRequest } from "./supertest-BIds28yL.js";
+import { MockOptions } from "./types-CjZ-JeCo.js";
+import { Application, Context } from "egg";
+import { mock } from "mm";
+import { IncomingMessage } from "node:http";
+import { Logger } from "egg-logger";
+import { MockAgent } 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 Context {
+  service: any;
+}
+declare abstract class ApplicationUnittest extends Application {
+  [key: string]: any;
+  options: MockOptions & Application['options'];
+  _mockHttpClient?: MockHttpClientMethod;
+  agent: NonNullable<Application['agent']>;
+  /**
+   * 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(): MockAgent;
+  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 { ApplicationUnittest, MockContext, MockContextData, MockContextOptions };