@eggjs/mock 6.0.0-beta.3

package/src/index.d.ts

@@ -0,0 +1,193 @@
+// import { Application, Context, EggLogger } from 'egg';
+// import { MockMate } from 'mm';
+// import { Test } from 'supertest';
+// import { MockAgent } from 'urllib';
+// import { Suite } from 'mocha';
+
+// export { MockAgent };
+
+// export interface EggTest extends Test {
+//   unexpectHeader(name: string, b?: Function): EggTest;
+//   expectHeader(name: string, b?: Function): EggTest;
+// }
+
+// export type Methods = 'get' | 'post' | 'delete' | 'del' | 'put' | 'head' | 'options' | 'patch' | 'trace' | 'connect';
+
+// export interface BaseMockApplication<T, C> extends Application {
+//   ready(): Promise<void>;
+//   close(): Promise<void>;
+//   callback(): any;
+
+//   /**
+//    * mock Context
+//    */
+//   mockContext(data?: any, options?: any): C;
+
+//   /**
+//    * mock Context
+//    */
+//   mockContextScope<R>(fn: (ctx: C) => Promise<R>, data?: any): Promise<R>;
+
+//   /**
+//    * mock cookie session
+//    */
+//   mockSession(data: any): T;
+
+//   mockCookies(cookies: any): T;
+
+//   mockHeaders(headers: any): T;
+
+//   /**
+//    * Mock service
+//    */
+//   mockService(service: string, methodName: string, fn: any): T;
+
+//   /**
+//    * mock service that return error
+//    */
+//   mockServiceError(service: string, methodName: string, err?: Error): T;
+
+//   mockHttpclient(mockUrl: string | RegExp, mockMethod: string | string[], mockResult: MockHttpClientResult): Application;
+
+//   mockHttpclient(mockUrl: string | RegExp, mockResult: MockHttpClientResult): Application;
+
+//   mockAgent(): MockAgent;
+//   mockAgentRestore(): Promise<void>;
+//   mockRestore(): Promise<void>;
+
+//   /**
+//    * mock csrf
+//    */
+//   mockCsrf(): T;
+
+//   /**
+//    * http request helper
+//    */
+//   httpRequest(): {
+//     [key in Methods]: (url: string) => EggTest;
+//   } & {
+//     [key: string]: (url: string) => EggTest;
+//   };
+
+//   /**
+//    * mock logger
+//    */
+//   mockLog(logger?: EggLogger | string): void;
+//   expectLog(expected: string | RegExp, logger?: EggLogger | string): void;
+//   notExpectLog(expected: string | RegExp, logger?: EggLogger | string): void;
+
+//   /**
+//    * background task
+//    */
+//   backgroundTasksFinished(): Promise<void>;
+// }
+
+// export interface ResultObject {
+//   data?: string | object | Buffer;
+//   status?: number;
+//   headers?: any;
+//   delay?: number;
+//   persist?: boolean;
+//   repeats?: number;
+// }
+
+// export type ResultFunction = (url?: string, opts?: any) => ResultObject | string | void;
+
+// export type MockHttpClientResult = ResultObject | ResultFunction | string;
+
+// export interface MockOption {
+//   /**
+//    * The directory of the application
+//    */
+//   baseDir?: string;
+
+//   /**
+//    * Custom you plugins
+//    */
+//   plugins?: any;
+
+//   /**
+//    * The directory of the egg framework
+//    */
+//   framework?: string;
+
+//   /**
+//    * Cache application based on baseDir
+//    */
+//   cache?: boolean;
+
+//   /**
+//    * Swtich on process coverage, but it'll be slower
+//    */
+//   coverage?: boolean;
+
+//   /**
+//    * Remove $baseDir/logs
+//    */
+//   clean?: boolean;
+
+//   /**
+//    * default options.mockCtxStorage value on each mockContext
+//    */
+//   mockCtxStorage?: boolean;
+// }
+
+// export interface MockClusterOption extends MockOption {
+//   workers?: number | string;
+//   cache?: boolean;
+//   /**
+//    * opt for egg-bin
+//    */
+//   opt?: object;
+// }
+
+// export type EnvType = 'default' | 'test' | 'prod' | 'local' | 'unittest' | string & {};
+// export type LogLevel = 'DEBUG' | 'INFO' | 'WARN' | 'ERROR' | 'NONE';
+
+// export interface MockApplication extends BaseMockApplication<Application, Context> {
+//   [key: string]: any;
+// }
+
+// export interface EggMock extends MockMate {
+//   /**
+//    * Create a egg mocked application
+//    */
+//   app: (option?: MockOption) => MockApplication;
+
+//   /**
+//    * Create a mock cluster server, but you can't use API in application, you should test using supertest
+//    */
+//   cluster: (option?: MockClusterOption) => MockApplication;
+
+//   /**
+//    * mock the serverEnv of Egg
+//    */
+//   env: (env: EnvType) => void;
+
+//   /**
+//    * mock console level
+//    */
+//   consoleLevel: (level: LogLevel) => void;
+
+//   /**
+//    * set EGG_HOME path
+//    */
+//   home: (homePath: string) => void;
+
+//   /**
+//    * restore mock
+//    */
+//   restore: () => any;
+
+//   /**
+//    * If you use mm.app instead of egg-mock/bootstrap to bootstrap app.
+//    * Should manually call setGetAppCallback,
+//    * then egg-mock will inject ctx for each test case
+//    * @param cb
+//    */
+//   setGetAppCallback: (cb: (suite: Suite) => Promise<MockApplication>) => void;
+// }
+
+// declare const mm: EggMock;
+// export { mm };
+// export default mm;

package/src/index.test-d.ts

@@ -0,0 +1,47 @@
+// import { expectType } from 'tsd';
+// import { Application, Context } from 'egg';
+// import { MockApplication, MockAgent, ResultObject } from '.';
+// import { app, mock, mm } from './bootstrap';
+
+// expectType<MockApplication>(app);
+// expectType<Context>(app.currentContext);
+// expectType<Context | undefined>(app.ctxStorage.getStore());
+// expectType<MockApplication>(mock.app());
+// expectType<MockApplication>(mm.app());
+
+// expectType<MockAgent>(mm.app().mockAgent());
+
+// expectType<Application>(mm.app().mockHttpclient('url', 'post', { data: 'ok' }));
+// expectType<Application>(mm.app().mockHttpclient('url', 'post', 'data'));
+// expectType<Application>(mm.app().mockHttpclient('url', {
+//   data: 'mock response',
+//   repeats: 1,
+// }));
+// expectType<Application>(mm.app().mockHttpclient('url', () => {}));
+// expectType<Application>(mm.app().mockHttpclient('url', 'post', () => {}));
+// expectType<Application>(mm.app().mockHttpclient('url', 'get', {
+//   data: 'mock response',
+//   repeats: 1,
+// }));
+
+// expectType<void>(app.mockLog());
+// expectType<void>(app.mockLog('logger'));
+// expectType<void>(app.mockLog(app.logger));
+// expectType<void>(app.expectLog('foo string'));
+// expectType<void>(app.expectLog('foo string', 'coreLogger'));
+// expectType<void>(app.expectLog('foo string', app.coreLogger));
+// expectType<void>(app.expectLog(/foo string/));
+// expectType<void>(app.expectLog(/foo string/, 'coreLogger'));
+// expectType<void>(app.expectLog(/foo string/, app.coreLogger));
+// expectType<void>(mm.env('default'));
+// expectType<void>(mm.env('devserver'));
+
+// expectType<Promise<void>>(app.mockAgentRestore());
+// expectType<Promise<void>>(app.mockRestore());
+// expectType<Promise<void>>(app.mockContextScope(async () => {}));
+// expectType<Promise<void>>(app.mockContextScope(async ctx => {}));
+
+// expectType<Promise<void>>(app.backgroundTasksFinished());
+
+// const result: ResultObject = {};
+// expectType<number>(result.status!);

package/src/index.ts

@@ -0,0 +1,110 @@
+import mm from 'mm';
+import { mock as _mock } from 'mm';
+import { createCluster } from './lib/cluster.js';
+import { createApp } from './lib/app.js';
+// import { getMockAgent } from './lib/mock_agent.js';
+import { restore } from './lib/restore.js';
+import { setGetAppCallback } from './lib/app_handler.js';
+import ApplicationUnittest from './app/extend/application.js';
+
+// egg-bin will set this flag to require files for instrument
+// if (process.env.EGG_BIN_PREREQUIRE) {
+//   require('./lib/prerequire');
+// }
+
+// inherit & extends mm
+const mock = {
+  ...mm,
+  restore,
+
+  /**
+   * Create a egg mocked application
+   * @function mm#app
+   * @param {Object} [options]
+   * - {String} baseDir - The directory of the application
+   * - {Object} plugins - Custom you plugins
+   * - {String} framework - The directory of the egg framework
+   * - {Boolean} [true] cache - Cache application based on baseDir
+   * - {Boolean} [true] coverage - Switch on process coverage, but it'll be slower
+   * - {Boolean} [true] clean - Remove $baseDir/logs
+   * @return {App} return {@link Application}
+   * @example
+   * ```js
+   * const app = mm.app();
+   * ```
+   */
+  app: createApp,
+
+  /**
+   * Create a egg mocked cluster application
+   * @function mm#cluster
+   * @see ClusterApplication
+   */
+  cluster: createCluster,
+
+  /**
+   * mock the serverEnv of Egg
+   * @member {Function} mm#env
+   * @param {String} env - contain default, test, prod, local, unittest
+   * @see https://github.com/eggjs/egg-core/blob/master/lib/loader/egg_loader.js#L78
+   */
+  env(env: string) {
+    _mock(process.env, 'EGG_MOCK_SERVER_ENV', env);
+    _mock(process.env, 'EGG_SERVER_ENV', env);
+  },
+
+  /**
+   * mock console level
+   * @param {String} level - logger level
+   */
+  consoleLevel(level: string) {
+    level = (level || '').toUpperCase();
+    _mock(process.env, 'EGG_LOG', level);
+  },
+
+  home(homePath?: string) {
+    if (homePath) {
+      _mock(process.env, 'EGG_HOME', homePath);
+    }
+  },
+
+  setGetAppCallback,
+};
+
+// import mm from '@eggjs/mock';
+const proxyMock = new Proxy(_mock, {
+  apply(target, _, args) {
+    return target(args[0], args[1], args[2]);
+  },
+  get(_target, property, receiver) {
+    // import mm from '@eggjs/mock';
+    // mm.isMocked(foo, 'bar')
+    return Reflect.get(mock, property, receiver);
+  },
+}) as unknown as ((target: any, property: PropertyKey, value?: any) => void) & typeof mock;
+
+export default proxyMock;
+
+export {
+  proxyMock as mock,
+  // alias to mm
+  proxyMock as mm,
+  ApplicationUnittest as MockApplication,
+  setGetAppCallback,
+  createApp,
+  createCluster,
+};
+
+process.setMaxListeners(100);
+
+process.once('SIGQUIT', () => {
+  process.exit(0);
+});
+
+process.once('SIGTERM', () => {
+  process.exit(0);
+});
+
+process.once('SIGINT', () => {
+  process.exit(0);
+});

package/src/lib/agent_handler.ts

@@ -0,0 +1,28 @@
+import { debuglog } from 'node:util';
+import { createAgent, MockAgent } from './parallel/agent.js';
+import { getEggOptions } from './utils.js';
+
+const debug = debuglog('@eggjs/mock/lib/agent_handler');
+
+let agent: MockAgent;
+
+export async function setupAgent() {
+  debug('setupAgent call, env.ENABLE_MOCHA_PARALLEL: %s, process.env.AUTO_AGENT: %s, agent: %s',
+    process.env.ENABLE_MOCHA_PARALLEL, process.env.AUTO_AGENT, !!agent);
+  if (agent) {
+    await agent.ready();
+    return agent;
+  }
+  if (process.env.ENABLE_MOCHA_PARALLEL && process.env.AUTO_AGENT) {
+    agent = createAgent(getEggOptions());
+    await agent.ready();
+  }
+  return agent;
+}
+
+export async function closeAgent() {
+  debug('setupAgent call, agent: %s', !!agent);
+  if (agent) {
+    await agent.close();
+  }
+}

package/src/lib/app.ts

@@ -0,0 +1,313 @@
+import { debuglog } from 'node:util';
+import { strict as assert } from 'node:assert';
+import os from 'node:os';
+import path from 'node:path';
+import { Base } from 'sdk-base';
+import { detectPort } from 'detect-port';
+import type { Agent, Application } from 'egg';
+import { importModule } from '@eggjs/utils';
+import { sleep, rimraf, getProperty, getSourceDirname } from './utils.js';
+import { formatOptions } from './format_options.js';
+import { context } from './context.js';
+import { setCustomLoader } from './mock_custom_loader.js';
+import { createServer } from './mock_http_server.js';
+import type { MockOptions, MockApplicationOptions } from './types.js';
+
+const debug = debuglog('@eggjs/mock/lib/app');
+
+const apps = new Map();
+const APP_INIT = Symbol('appInit');
+const MESSENGER = Symbol('messenger');
+const MOCK_APP_METHOD = [
+  'ready',
+  'closed',
+  'isClosed',
+  'close',
+  '_agent',
+  '_app',
+  'on',
+  'once',
+  'then',
+];
+
+export class MockApplication extends Base {
+  _agent: Agent;
+  _app: Application;
+  declare options: MockApplicationOptions;
+  baseDir: string;
+  [APP_INIT] = false;
+  _initOnListeners: Set<any[]>;
+  _initOnceListeners: Set<any[]>;
+
+  constructor(options: MockApplicationOptions) {
+    super({
+      initMethod: '_init',
+      ...options,
+    });
+    this.baseDir = options.baseDir;
+    this._initOnListeners = new Set();
+    this._initOnceListeners = new Set();
+  }
+
+  async _init() {
+    if (this.options.beforeInit) {
+      await this.options.beforeInit(this);
+      // init once
+      this.options.beforeInit = undefined;
+    }
+    if (this.options.clean !== false) {
+      const logDir = path.join(this.options.baseDir, 'logs');
+      try {
+        if (os.platform() === 'win32') {
+          await sleep(1000);
+        }
+        await rimraf(logDir);
+      } catch (err: any) {
+        console.error(`remove log dir ${logDir} failed: ${err.stack}`);
+      }
+      const runDir = path.join(this.options.baseDir, 'run');
+      try {
+        if (os.platform() === 'win32') {
+          await sleep(1000);
+        }
+        await rimraf(runDir);
+      } catch (err: any) {
+        console.error(`remove run dir ${runDir} failed: ${err.stack}`);
+      }
+    }
+
+    this.options.clusterPort = await detectPort();
+    debug('get clusterPort %s', this.options.clusterPort);
+    const egg = await importModule(this.options.framework);
+    assert(egg.Agent, `should export Agent class from framework ${this.options.framework}`);
+
+    const Agent = egg.Agent;
+    const agent = this._agent = new Agent({ ...this.options }) as Agent;
+    debug('agent instantiate');
+    await agent.ready();
+    debug('agent ready');
+
+    const ApplicationClass = bindMessenger(egg.Application, agent);
+    const app = this._app = new ApplicationClass({ ...this.options }) as unknown as Application;
+
+    // https://github.com/eggjs/egg/blob/8bb7c7e7d59d6aeca4b2ed1eb580368dcb731a4d/lib/egg.js#L125
+    // egg single mode mount this at start(), so egg-mock should impel it.
+    app.agent = agent;
+    Reflect.set(agent, 'app', app);
+
+    // egg-mock plugin need to override egg context
+    Object.assign(app.context, context);
+
+    debug('app instantiate');
+    this[APP_INIT] = true;
+    debug('this[APP_INIT] = true');
+    this.#bindEvent();
+    debug('http server instantiate');
+    createServer(app);
+    await app.ready();
+    // work for config ready
+    setCustomLoader(app);
+
+    const msg = {
+      action: 'egg-ready',
+      data: this.options,
+    };
+    app.messenger.onMessage(msg);
+    agent.messenger.onMessage(msg);
+    debug('app ready');
+  }
+
+  #bindEvent() {
+    debug('bind cache events to app');
+    for (const args of this._initOnListeners) {
+      debug('on(%s), use cache and pass to app', args);
+      this._app.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._app.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._app.on(args[0], args[1]);
+    } else {
+      debug('on(%s), cache it because app 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 app', args);
+      this._app.once(args[0], args[1]);
+    } else {
+      debug('once(%s), cache it because app has not init', args);
+      this._initOnceListeners.add(args);
+      // maybe some edge case bug here
+      super.on(args[0], args[1]);
+    }
+    return this;
+  }
+
+  /**
+   * close app
+   */
+  async _close() {
+    const baseDir = this.baseDir;
+    if (this._app) {
+      await this._app.close();
+    } else {
+      // when app init throws an exception, must wait for app quit gracefully
+      await sleep(200);
+    }
+
+    if (this._agent) {
+      await this._agent.close();
+    }
+
+    apps.delete(baseDir);
+    debug('delete app cache %s, remain %s', baseDir, [ ...apps.keys() ]);
+
+    if (os.platform() === 'win32') {
+      await sleep(1000);
+    }
+  }
+
+  /**
+   * @deprecated please use isClosed instead, keep compatible with old version
+   */
+  get closed() {
+    return this.isClosed;
+  }
+}
+
+export function createApp(createOptions?: MockOptions) {
+  const options = formatOptions(createOptions);
+  if (options.cache && apps.has(options.baseDir)) {
+    const app = apps.get(options.baseDir);
+    // return cache when it hasn't been killed
+    if (!app.isClosed) {
+      debug('use cache app %s', options.baseDir);
+      return app;
+    }
+    // delete the cache when it's closed
+    apps.delete(options.baseDir);
+  }
+
+  let app = new MockApplication(options);
+  app = new Proxy(app, {
+    get(target: any, prop: string) {
+      // don't delegate properties on MockApplication
+      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._app[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._app[prop] = value;
+      return true;
+    },
+    defineProperty(target, prop: string, descriptor) {
+      // can't define properties on MockApplication
+      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._app, prop, descriptor);
+      return true;
+    },
+    deleteProperty(target, prop: string) {
+      // can't delete properties on MockApplication
+      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._app[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._app, prop);
+    },
+    getPrototypeOf(target) {
+      if (!target[APP_INIT]) {
+        throw new Error('can\'t getPrototypeOf before ready');
+      }
+      debug('proxy handler.getPrototypeOf %s');
+      return Object.getPrototypeOf(target._app);
+    },
+  });
+
+  apps.set(options.baseDir, app);
+  return app;
+}
+
+function bindMessenger(Application: any, agent: Agent) {
+  const agentMessenger = agent.messenger;
+  return class MessengerApplication extends Application {
+    [MESSENGER]: any;
+
+    constructor(options: any) {
+      super(options);
+
+      // enable app to send to a random agent
+      this.messenger.sendRandom = (action: string, data: unknown) => {
+        this.messenger.sendToAgent(action, data);
+      };
+      // enable agent to send to a random app
+      agentMessenger.on('egg-ready', () => {
+        agentMessenger.sendRandom = (action: string, data: unknown) => {
+          agentMessenger.sendToApp(action, data);
+          return agentMessenger;
+        };
+      });
+
+      agentMessenger.send = new Proxy(agentMessenger.send, {
+        apply: this._sendMessage.bind(this),
+      });
+    }
+    _sendMessage(_target: any, _thisArg: unknown, [ action, data, to ]: [ string, unknown | undefined, string]) {
+      const appMessenger = this.messenger;
+      setImmediate(() => {
+        if (to === 'app') {
+          appMessenger.onMessage({ action, data });
+        } else {
+          agentMessenger.onMessage({ action, data });
+        }
+      });
+    }
+    get messenger() {
+      return this[MESSENGER];
+    }
+    set messenger(m) {
+      m.send = new Proxy(m.send, {
+        apply: this._sendMessage.bind(this),
+      });
+      this[MESSENGER] = m;
+    }
+
+    get [Symbol.for('egg#eggPath')]() {
+      return path.join(getSourceDirname(), 'lib/tmp');
+    }
+  };
+}