@eggjs/mock 6.0.0-beta.3

package/src/lib/mock_agent.ts

@@ -0,0 +1,57 @@
+import { debuglog } from 'node:util';
+import {
+  MockAgent, setGlobalDispatcher, getGlobalDispatcher, Dispatcher,
+  HttpClient,
+} from 'urllib';
+
+const debug = debuglog('@eggjs/mock/lib/mock_agent');
+
+declare namespace globalThis {
+  let __mockAgent: MockAgent | null;
+  let __globalDispatcher: Dispatcher;
+  let __httpClientDispatchers: Map<HttpClient, Dispatcher>;
+}
+
+globalThis.__mockAgent = null;
+globalThis.__httpClientDispatchers = new Map<HttpClient, Dispatcher>();
+
+export function getMockAgent(app?: { httpClient?: HttpClient }) {
+  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;
+}
+
+export 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, dispatcher ] of globalThis.__httpClientDispatchers) {
+    httpClient.setDispatcher(dispatcher);
+  }
+  globalThis.__httpClientDispatchers.clear();
+  if (globalThis.__mockAgent) {
+    const agent = globalThis.__mockAgent;
+    globalThis.__mockAgent = null;
+    await agent.close();
+    debug('close mockAgent');
+  }
+  debug('restoreMockAgent end');
+}

package/src/lib/mock_custom_loader.ts

@@ -0,0 +1,36 @@
+import { debuglog } from 'node:util';
+
+const debug = debuglog('@eggjs/mock/lib/mock_custom_loader');
+
+export function setCustomLoader(app: any) {
+  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: any) {
+    const field = loaderConfig.field as string;
+    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: any, methodName: string, fn: any) {
+      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;
+    };
+  }
+}

package/src/lib/mock_http_server.ts

@@ -0,0 +1,19 @@
+import http, { Server } from 'node:http';
+
+const SERVER = Symbol('http_server');
+
+export function createServer(app: any): Server {
+  let server = app[SERVER] || app.callback();
+  if (typeof server === 'function') {
+    server = http.createServer(server);
+    // cache server, avoid create many times
+    app[SERVER] = server;
+    if (!app.server) {
+      app.server = server;
+    }
+    // emit server event just like egg-cluster does
+    // https://github.com/eggjs/egg-cluster/blob/master/lib/app_worker.js#L52
+    app.emit('server', server);
+  }
+  return server;
+}

package/src/lib/mock_httpclient.ts

@@ -0,0 +1,181 @@
+import { mm } from 'mm';
+import { extend } from 'extend2';
+import type { Dispatcher, Headers, BodyInit } from 'urllib';
+import { getMockAgent } from './mock_agent.js';
+
+export 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;
+}
+
+export interface MockResponseCallbackOptions {
+  path: string;
+  method: string;
+  headers?: Headers | Record<string, string>;
+  origin?: string;
+  body?: BodyInit | Dispatcher.DispatchOptions['body'] | null;
+  maxRedirections?: number;
+}
+
+export type MockResultFunction =
+  (url: string, options: MockResponseCallbackOptions) => MockResultOptions | string;
+
+function normalizeResult(result: string | MockResultOptions) {
+  if (typeof result === 'string') {
+    result = { data: result };
+  }
+
+  if (!result.status) {
+    result.status = 200;
+  }
+
+  result.data = result.data || '';
+  if (Buffer.isBuffer(result.data)) {
+    // do nothing
+  } else if (typeof result.data === 'object') {
+    // json
+    result.data = Buffer.from(JSON.stringify(result.data));
+  } else if (typeof result.data === 'string') {
+    // string
+    result.data = Buffer.from(result.data);
+  } else {
+    throw new Error('`mockResult.data` must be buffer, string or json');
+  }
+  result.headers = result.headers ?? {};
+  return result;
+}
+
+const MOCK_CONFIGS = Symbol('MOCK_CONFIGS');
+const MOCK_CONFIG_INDEX = Symbol('MOCK_CONFIG_INDEX');
+
+export function createMockHttpClient(app: any) {
+  /**
+   * mock httpclient
+   * @function mockHttpclient
+   * @param {String} mockUrl - url
+   * @param {String|Array} mockMethod - http method, default is '*'
+   * @param {Object|Function} mockResult - you data
+   *   - data - buffer / string / json
+   *   - status - http status
+   *   - headers - response header
+   *   - delay - delay the associated reply by a set amount in ms.
+   *   - persist - any matching request will always reply with the defined response indefinitely, default is true
+   *   - repeats - number, any matching request will reply with the defined response a fixed amount of times
+   */
+  return function mockHttpClient(mockUrl: string | RegExp, mockMethod: string | string[] | MockResultOptions | MockResultFunction, mockResult?: MockResultOptions | MockResultFunction | string) {
+    let mockMethods = mockMethod as string[];
+    if (!mockResult) {
+      // app.mockHttpclient(mockUrl, mockResult)
+      mockResult = mockMethod as MockResultOptions;
+      mockMethods = [ '*' ];
+    }
+    if (!Array.isArray(mockMethods)) {
+      mockMethods = [ mockMethods ];
+    }
+    mockMethods = mockMethods.map(method => (method || 'GET').toUpperCase());
+
+    // use MockAgent on undici
+    let mockConfigs = app[MOCK_CONFIGS];
+    if (!mockConfigs) {
+      mockConfigs = [];
+      mm(app, MOCK_CONFIGS, mockConfigs);
+    }
+
+    let mockConfigIndex = -1;
+    let origin = mockUrl;
+    let originMethod: ((value: string) => boolean) | undefined;
+    const pathname = mockUrl;
+    let pathMethod: (path: string) => boolean;
+    if (typeof mockUrl === 'string') {
+      const urlObject = new URL(mockUrl);
+      origin = urlObject.origin;
+      const originalPathname = urlObject.pathname;
+      pathMethod = path => {
+        if (path === originalPathname) return true;
+        // should match /foo?a=1 including query
+        if (path.includes('?')) return path.startsWith(originalPathname);
+        return false;
+      };
+    } else if (mockUrl instanceof RegExp) {
+      let requestOrigin = '';
+      originMethod = value => {
+        requestOrigin = value;
+        return true;
+      };
+      pathMethod = path => {
+        for (const config of mockConfigs) {
+          if (config.mockUrl.test(`${requestOrigin}${path}`)) {
+            mm(app, MOCK_CONFIG_INDEX, config.mockConfigIndex);
+            return true;
+          }
+        }
+        return false;
+      };
+      mockConfigIndex = mockConfigs.length;
+      mockConfigs.push({ mockUrl, mockResult, mockConfigIndex });
+    }
+    const mockPool = originMethod
+      ? getMockAgent(app).get(originMethod)
+      : getMockAgent(app).get(originMethod ?? origin as string);
+    // persist default is true
+    let persist = true;
+    if (typeof mockResult === 'object' && typeof mockResult.persist === 'boolean') {
+      persist = mockResult.persist;
+    }
+    mockMethods.forEach(function(method) {
+      const mockScope = mockPool.intercept({
+        path: pathMethod ?? pathname,
+        method: method === '*' ? () => true : method,
+      }).reply(options => {
+        // not support mockResult as an async function
+        const requestUrl = `${options.origin}${options.path}`;
+        let mockRequestResult;
+        if (mockConfigIndex >= 0) {
+          mockResult = mockConfigs[app[MOCK_CONFIG_INDEX]].mockResult;
+          mockRequestResult = typeof mockResult === 'function' ? mockResult(requestUrl, options) : mockResult;
+        } else {
+          mockRequestResult = typeof mockResult === 'function' ? mockResult(requestUrl, options) : mockResult;
+        }
+        const result = extend(true, {}, normalizeResult(mockRequestResult!));
+        return {
+          statusCode: result.status,
+          data: result.data,
+          responseOptions: {
+            headers: result.headers,
+          },
+        };
+      });
+      if (typeof mockResult === 'object') {
+        if (mockResult.delay && mockResult.delay > 0) {
+          mockScope.delay(mockResult.delay);
+        }
+      }
+      if (persist) {
+        mockScope.persist();
+      } else if (typeof mockResult === 'object' && mockResult.repeats && mockResult.repeats > 0) {
+        mockScope.times(mockResult.repeats);
+      }
+    });
+  };
+}
+
+export type MockHttpClientMethod = ReturnType<typeof createMockHttpClient>;

package/src/lib/parallel/agent.ts

@@ -0,0 +1,128 @@
+import { debuglog } from 'node:util';
+import path from 'node:path';
+import { Base } from 'sdk-base';
+import { detectPort } from 'detect-port';
+import { importModule } from '@eggjs/utils';
+import type { EggCore } from '@eggjs/core';
+import { context } from '../context.js';
+import { formatOptions } from '../format_options.js';
+import { MockOptions, MockApplicationOptions } from '../types.js';
+import { sleep, rimraf } from '../utils.js';
+import { setCustomLoader } from '../mock_custom_loader.js';
+import { APP_INIT } from './util.js';
+
+const debug = debuglog('@eggjs/mock/lib/parallel/agent');
+
+export class MockAgent extends Base {
+  declare options: MockApplicationOptions;
+  baseDir: string;
+  [APP_INIT] = false;
+  #initOnListeners = new Set<any[]>();
+  #initOnceListeners = new Set<any[]>();
+  _instance: EggCore;
+
+  constructor(options: MockApplicationOptions) {
+    super({ initMethod: '_init' });
+    this.options = options;
+    this.baseDir = this.options.baseDir;
+  }
+
+  async _init() {
+    if (this.options.beforeInit) {
+      await this.options.beforeInit(this);
+      delete this.options.beforeInit;
+    }
+    if (this.options.clean !== false) {
+      const logDir = path.join(this.options.baseDir, 'logs');
+      try {
+        await rimraf(logDir);
+      } catch (err: any) {
+        console.error(`remove log dir ${logDir} failed: ${err.stack}`);
+      }
+      const runDir = path.join(this.options.baseDir, 'run');
+      try {
+        await rimraf(runDir);
+      } catch (err: any) {
+        console.error(`remove run dir ${runDir} failed: ${err.stack}`);
+      }
+    }
+
+    this.options.clusterPort = await detectPort();
+    process.env.CLUSTER_PORT = String(this.options.clusterPort);
+    debug('get clusterPort %s', this.options.clusterPort);
+    const { Agent }: { Agent: typeof EggCore } = await importModule(this.options.framework);
+
+    const agent = this._instance = new Agent({ ...this.options });
+
+    // egg-mock plugin need to override egg context
+    Object.assign(agent.context, context);
+    setCustomLoader(agent);
+
+    debug('agent instantiate');
+    this[APP_INIT] = true;
+    debug('this[APP_INIT] = true');
+    this.#bindEvents();
+    await agent.ready();
+
+    const msg = {
+      action: 'egg-ready',
+      data: this.options,
+    };
+    (agent as any).messenger.onMessage(msg);
+    debug('agent ready');
+  }
+
+  #bindEvents() {
+    debug('bind cache events to agent');
+    for (const args of this.#initOnListeners) {
+      debug('on(%s), use cache and pass to agent', 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 agent', args);
+      this._instance.once(args[0], args[1]);
+      this.removeListener(args[0], args[1]);
+    }
+  }
+
+  on(...args: any[]) {
+    if (this[APP_INIT]) {
+      debug('on(%s), pass to agent', args);
+      this._instance.on(args[0], args[1]);
+    } else {
+      debug('on(%s), cache it because agent has not init', args);
+      this.#initOnListeners.add(args);
+      super.on(args[0], args[1]);
+    }
+    return this;
+  }
+
+  once(...args: any[]) {
+    if (this[APP_INIT]) {
+      debug('once(%s), pass to agent', args);
+      this._instance.once(args[0], args[1]);
+    } else {
+      debug('once(%s), cache it because agent has not init', args);
+      this.#initOnceListeners.add(args);
+      super.on(args[0], args[1]);
+    }
+    return this;
+  }
+
+  /**
+   * close agent
+   */
+  async _close() {
+    if (this._instance) {
+      await this._instance.close();
+    } else {
+      // when agent init throws an exception, must wait for agent quit gracefully
+      await sleep(200);
+    }
+  }
+}
+
+export function createAgent(options: MockOptions) {
+  return new MockAgent(formatOptions(options));
+}

package/src/lib/parallel/app.ts

@@ -0,0 +1,123 @@
+import { debuglog } from 'node:util';
+import { Base } from 'sdk-base';
+import { importModule } from '@eggjs/utils';
+import type { EggCore } from '@eggjs/core';
+import { context } from '../context.js';
+import { formatOptions } from '../format_options.js';
+import { MockOptions, MockApplicationOptions } from '../types.js';
+import { sleep } from '../utils.js';
+import { setCustomLoader } from '../mock_custom_loader.js';
+import { createServer } from '../mock_http_server.js';
+import { proxyApp, APP_INIT } from './util.js';
+
+const debug = debuglog('@eggjs/mock/lib/parallel/app');
+
+export class MockParallelApplication extends Base {
+  declare options: MockApplicationOptions;
+  baseDir: string;
+  [APP_INIT] = false;
+  #initOnListeners = new Set<any[]>();
+  #initOnceListeners = new Set<any[]>();
+  _instance: EggCore;
+
+  constructor(options: MockApplicationOptions) {
+    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: typeof EggCore } = await importModule(this.options.framework);
+
+    const app = this._instance = new Application({ ...this.options });
+
+    // egg-mock plugin need to override egg context
+    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 as any).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: any[]) {
+    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: any[]) {
+    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 {
+      // when app init throws an exception, must wait for app quit gracefully
+      await sleep(200);
+    }
+  }
+}
+
+export function createApp(initOptions: MockOptions) {
+  const app = new MockParallelApplication(formatOptions(initOptions));
+  return proxyApp(app);
+}

package/src/lib/parallel/util.ts

@@ -0,0 +1,66 @@
+import { debuglog } from 'node:util';
+import { getProperty } from '../utils.js';
+
+const debug = debuglog('@eggjs/mock/lib/parallel/util');
+
+export const MOCK_APP_METHOD = [
+  'ready',
+  'isClosed',
+  'closed',
+  'close',
+  'on',
+  'once',
+];
+
+export const APP_INIT = Symbol('appInit');
+
+export function proxyApp(app: any) {
+  const proxyApp = new Proxy(app, {
+    get(target, prop: string) {
+      // don't delegate properties on MockAgent
+      if (MOCK_APP_METHOD.includes(prop)) {
+        return getProperty(target, prop);
+      }
+      if (!target[APP_INIT]) throw new Error(`can't get ${prop} before ready`);
+      // it's asynchronous when agent and app are loading,
+      // so should get the properties after loader ready
+      debug('proxy handler.get %s', prop);
+      return target._instance[prop];
+    },
+    set(target, prop: string, 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._instance[prop] = value;
+      return true;
+    },
+    defineProperty(target, prop: string, descriptor) {
+      // can't define properties on MockAgent
+      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._instance, prop, descriptor);
+      return true;
+    },
+    deleteProperty(target, prop: string) {
+      // can't delete properties on MockAgent
+      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._instance[prop];
+      return true;
+    },
+    getOwnPropertyDescriptor(target, prop: string) {
+      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._instance, prop);
+    },
+    getPrototypeOf(target) {
+      if (!target[APP_INIT]) throw new Error('can\'t getPrototypeOf before ready');
+      debug('proxy handler.getPrototypeOf %s');
+      return Object.getPrototypeOf(target._instance);
+    },
+  });
+  return proxyApp;
+}

package/src/lib/prerequire.ts

@@ -0,0 +1,25 @@
+// const debug = require('util').debuglog('egg-mock/prerequire');
+// const path = require('path');
+// const { existsSync } = require('fs');
+// const globby = require('globby');
+
+// const cwd = process.cwd();
+// const dirs = [];
+// if (existsSync(path.join(cwd, 'app'))) {
+//   dirs.push('app/**/*.js');
+// }
+// // avoid Error: ENOENT: no such file or directory, scandir
+// if (existsSync(path.join(cwd, 'config'))) {
+//   dirs.push('config/**/*.js');
+// }
+// const files = globby.sync(dirs, { cwd });
+
+// for (const file of files) {
+//   const filepath = path.join(cwd, file);
+//   try {
+//     debug('%s prerequire %s', process.pid, filepath);
+//     require(filepath);
+//   } catch (err) {
+//     debug('prerequire error %s', err.message);
+//   }
+// }

package/src/lib/request_call_function.ts

@@ -0,0 +1,49 @@
+import httpClient from 'urllib';
+
+const { port, method, args, property, needResult } = JSON.parse(process.argv[2]);
+const url = `http://127.0.0.1:${port}/__egg_mock_call_function`;
+
+httpClient.request(url, {
+  method: 'POST',
+  data: {
+    method,
+    args,
+    property,
+    needResult,
+  },
+  contentType: 'json',
+  dataType: 'json',
+}).then(({ data }) => {
+  if (!data.success) {
+    // console.log('POST %s error, method: %s, args: %j, result data: %j',
+    //   url, method, args, data);
+    if (data.error) {
+      console.error(data.error);
+    } else if (data.message) {
+      const err = new Error(data.message);
+      err.stack = data.stack;
+      console.error(err);
+    }
+    process.exit(2);
+  }
+
+  if (data.result) {
+    console.log('%j', data.result);
+  }
+  process.exit(0);
+}).catch(err => {
+  // ignore ECONNREFUSED error on mockRestore
+  if (method === 'mockRestore' && err.message.includes('ECONNREFUSED')) {
+    process.exit(0);
+  }
+
+  console.error('POST %s error, method: %s, args: %j', url, method, args);
+  console.error(err.stack);
+
+  // ignore all error on mockRestore
+  if (method === 'mockRestore') {
+    process.exit(0);
+  } else {
+    process.exit(1);
+  }
+});