@eggjs/mock 6.0.6 → 6.1.0-beta.10

package/src/lib/cluster.ts

@@ -1,363 +0,0 @@
-import { debuglog } from 'node:util';
-import path from 'node:path';
-import os from 'node:os';
-import childProcess from 'node:child_process';
-import { once } from 'node:events';
-import { Coffee } from 'coffee';
-import { Ready } from 'get-ready';
-import { request as supertestRequest } from './supertest.js';
-import { sleep, rimrafSync, getSourceDirname } from './utils.js';
-import { formatOptions } from './format_options.js';
-import type { MockClusterOptions, MockClusterApplicationOptions } from './types.js';
-
-const debug = debuglog('@eggjs/mock/lib/cluster');
-
-const clusters = new Map();
-const serverBin = path.join(getSourceDirname(), 'lib/start-cluster.js');
-const requestCallFunctionFile = path.join(getSourceDirname(), 'lib/request_call_function.js');
-let masterPort = 17000;
-
-/**
- * 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);
- *   });
- * });
- */
-export class ClusterApplication extends Coffee {
-  [key: string | symbol]: any;
-  options: MockClusterApplicationOptions;
-  port: number;
-  baseDir: string;
-  closed: boolean;
-
-  /**
-   * @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: MockClusterApplicationOptions) {
-    const opt = options.opt;
-    delete options.opt;
-
-    // incremental port
-    options.port = options.port ?? ++masterPort;
-    // Set 1 worker when test
-    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;
-
-    // print stdout and stderr when DEBUG, otherwise stderr.
-    this.debug(process.env.DEBUG ? 0 : 2);
-
-    // disable coverage
-    if (options.coverage === false) {
-      this.coverage(false);
-    }
-
-    process.nextTick(() => {
-      this.proc.on('message', (msg: any) => {
-        // 'egg-ready' and { action: 'egg-ready' }
-        const action = msg && msg.action ? msg.action : msg;
-        switch (action) {
-          case 'egg-ready':
-            this.emit('close', 0);
-            break;
-          case 'app-worker-died':
-          case 'agent-worker-died':
-            this.emit('close', 1);
-            break;
-          default:
-            // ignore it
-            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() {
-    return 'http://127.0.0.1:' + this.port;
-  }
-
-  /**
-   * Compatible API for supertest
-   */
-  address() {
-    return {
-      port: this.port,
-    };
-  }
-
-  /**
-   * 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(1000);
-    }
-  }
-
-  get isClosed() {
-    return this.closed;
-  }
-
-  // mock app.router.pathFor(name) api
-  get router() {
-    const self = this;
-    return {
-      pathFor(url: string) {
-        return self._callFunctionOnAppWorker('pathFor', [ url ], 'router', true);
-      },
-    };
-  }
-
-  /**
-   * get app[property] value in app worker
-   */
-  getAppInstanceProperty(property: string) {
-    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?: string) {
-    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: string, logger?: string) {
-    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: string, logger?: string) {
-    logger = logger ?? 'logger';
-    this._callFunctionOnAppWorker('notExpectLog', [ str, logger ], null, true);
-  }
-
-  httpRequest() {
-    return supertestRequest(this);
-  }
-
-  _callFunctionOnAppWorker(method: string, args: any[] = [], property: any = undefined, 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: any = {
-          __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 as any)[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',
-    });
-    // if (child.stderr && child.stderr.length > 0) {
-    //   console.error(child.stderr.toString());
-    // }
-    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;
-  }
-}
-
-export function createCluster(initOptions?: MockClusterOptions) {
-  const options = formatOptions(initOptions) as MockClusterApplicationOptions;
-  if (options.cache && clusters.has(options.baseDir)) {
-    const clusterApp = clusters.get(options.baseDir);
-    // return cache when it hasn't been killed
-    if (!clusterApp.isClosed) {
-      return clusterApp;
-    }
-
-    // delete the cache when it's closed
-    clusters.delete(options.baseDir);
-  }
-
-  if (options.clean !== false) {
-    const logDir = path.join(options.baseDir, 'logs');
-    try {
-      rimrafSync(logDir);
-    } catch (err: any) {
-      console.error(`remove log dir ${logDir} failed: ${err.stack}`);
-    }
-    const runDir = path.join(options.baseDir, 'run');
-    try {
-      rimrafSync(runDir);
-    } catch (err: any) {
-      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);
-      // proxy mockXXX function to app worker
-      const method = prop;
-      if (typeof method === 'string' && /^mock\w+$/.test(method) && target[method] === undefined) {
-        return function mockProxy(...args: any[]) {
-          return target._callFunctionOnAppWorker(method, args, null, true);
-        };
-      }
-      return target[prop];
-    },
-  });
-
-  clusters.set(options.baseDir, clusterApp);
-  return clusterApp;
-}
-
-// export to let mm.restore() worked
-export async function restore() {
-  for (const clusterApp of clusters.values()) {
-    // will proxy to app.mockRestore()
-    await clusterApp.mockRestore();
-  }
-}
-
-// ensure to close App process on test exit.
-process.on('exit', () => {
-  for (const clusterApp of clusters.values()) {
-    debug('on exit close clusterApp, port: %s', clusterApp.port);
-    clusterApp.close();
-  }
-});

package/src/lib/context.ts

@@ -1,14 +0,0 @@
-import { utils } from '@eggjs/core';
-
-export const context = {
-  runInBackground(scope: any) {
-    /* 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);
-  },
-} as any;

package/src/lib/format_options.ts

@@ -1,103 +0,0 @@
-import { debuglog } from 'node:util';
-import path from 'node:path';
-import { mm, isMocked } from 'mm';
-import { getFrameworkPath } from '@eggjs/utils';
-import { readJSONSync } from 'utility';
-import { MockOptions, MockApplicationOptions } from './types.js';
-import { getSourceDirname } from './utils.js';
-
-const debug = debuglog('@eggjs/mock/lib/format_options');
-
-/**
- * format the options
- */
-export function formatOptions(initOptions?: MockOptions) {
-  const options = {
-    baseDir: process.cwd(),
-    cache: true,
-    coverage: true,
-    clean: true,
-    ...initOptions,
-  } as MockApplicationOptions;
-
-  // relative path to test/fixtures
-  // ```js
-  // formatOptions({ baseDir: 'app' }); // baseDir => $PWD/test/fixtures/app
-  // ```
-  if (!path.isAbsolute(options.baseDir)) {
-    options.baseDir = path.join(process.cwd(), 'test/fixtures', options.baseDir);
-  }
-
-  let framework = initOptions?.framework ?? initOptions?.customEgg;
-  // test for framework
-  if (framework === true) {
-    framework = process.cwd();
-    // disable plugin test when framework test
-    options.plugin = false;
-  } else {
-    if (!framework) {
-      framework = '';
-    }
-    // it will throw when framework is not found
-    framework = getFrameworkPath({ framework, baseDir: options.baseDir });
-  }
-  options.framework = options.customEgg = framework;
-
-  const plugins = options.plugins = options.plugins || {};
-
-  // add self as a plugin
-  let pluginPath = path.join(getSourceDirname(), '..');
-  // for dist directory
-  // convert `/eggjs/mock/dist` to `/eggjs/mock`
-  if (pluginPath.endsWith('/dist') || pluginPath.endsWith('\\dist')) {
-    pluginPath = path.join(pluginPath, '..');
-  }
-  plugins['egg-mock'] = {
-    enable: true,
-    path: pluginPath,
-  };
-
-  // test for plugin
-  if (options.plugin !== false) {
-    // add self to plugin list
-    const pluginPath = process.cwd();
-    const pkgPath = path.join(pluginPath, '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,
-      };
-    }
-  }
-
-  // mock HOME as baseDir, but ignore if it has been mocked
-  const env = process.env.EGG_SERVER_ENV;
-  if (!isMocked(process.env, 'HOME') &&
-    (env === 'default' || env === 'test' || env === 'prod')) {
-    mm(process.env, 'HOME', options.baseDir);
-  }
-
-  // disable cache after call mm.env(),
-  // otherwise it will use cache and won't load again.
-  if (process.env.EGG_MOCK_SERVER_ENV) {
-    options.cache = false;
-  }
-
-  debug('format options: %j', options);
-  return options;
-}
-
-function getPluginName(pkgPath: string): string | undefined {
-  try {
-    const pkg = readJSONSync(pkgPath);
-    if (pkg.eggPlugin?.name) {
-      return pkg.eggPlugin.name;
-    }
-  } catch (_) {
-    // ignore
-  }
-}

package/src/lib/inject_context.ts

@@ -1,134 +0,0 @@
-import { debuglog } from 'node:util';
-import assert from 'node:assert';
-import { getApp } from './app_handler.js';
-
-const MOCHA_SUITE_APP = Symbol.for('mocha#suite#app');
-
-const debug = debuglog('@eggjs/mock/lib/inject_context');
-
-/**
- * Monkey patch the mocha instance with egg context.
- *
- * @param {Function} mocha - the module of mocha
- */
-export function injectContext(mocha: any) {
-  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: any, test: any) {
-    const suiteTitle = suite.root ? 'root suite' : suite.title;
-    if (!test) {
-      return `"${suiteTitle}"`;
-    }
-    return `"${suiteTitle} - ${test.title}"`;
-  }
-
-  // Inject ctx for before/after.
-  Runner.prototype.runSuite = async function(suite: any, fn: any) {
-    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.ready 时报错，不使用失败的 app
-      app = null;
-    }
-    if (!app) {
-      // app 不存在，直接跳过，在 beforeEach 的 hook 中会报错
-      // 确保不打乱 mocha 的顺序，防止 mocha 内部状态错误
-      return runSuite.call(self, suite, fn);
-    }
-    let errSuite;
-    try {
-      suite.ctx[MOCHA_SUITE_APP] = app;
-      const mockContextFun = app.mockModuleContextScope || app.mockContextScope;
-      await mockContextFun.call(app, async function() {
-        await new Promise<void>(resolve => {
-          runSuite.call(self, suite, (aErrSuite: Error) => {
-            errSuite = aErrSuite;
-            resolve();
-          });
-        });
-      });
-    } catch (err) {
-      // mockContext 失败后动态注册一个 beforeAll hook
-      // 快速失败，直接阻塞后续用例
-      suite.beforeAll('egg-mock-mock-ctx-failed', async () => {
-        throw err;
-      });
-      return runSuite.call(self, suite, (aErrSuite: Error) => {
-        return fn(aErrSuite);
-      });
-    }
-    return fn(errSuite);
-  };
-
-  // Inject ctx for beforeEach/it/afterEach.
-  // And ctx with before/after is not same as beforeEach/it/afterEach.
-  Runner.prototype.runTests = async function(suite: any, fn: any) {
-    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?: Error) {
-      suite.tests = tests;
-      return fn(errSuite);
-    }
-
-    async function next(i: number) {
-      const test = tests[i];
-      if (!test) {
-        return done();
-      }
-      suite.tests = [ test ];
-
-      let app;
-      try {
-        app = await getApp(suite, test);
-        assert(app, `not found app for test ${getTestTitle(suite, test)}`);
-        await app.ready();
-      } catch (err) {
-        self.fail(test, err);
-        return next(i + 1);
-      }
-
-      try {
-        const mockContextFun = app.mockModuleContextScope || app.mockContextScope;
-        await mockContextFun.call(app, async function() {
-          return await new Promise<void>(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');
-}

package/src/lib/mock_agent.ts

@@ -1,57 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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;
-    };
-  }
-}