@eggjs/mock 6.0.0-beta.3

package/src/lib/restore.ts

@@ -0,0 +1,14 @@
+import { debuglog } from 'node:util';
+import { restore as mmRestore } from 'mm';
+import { restoreMockAgent } from './mock_agent.js';
+import { restore as clusterRestore } from './cluster.js';
+
+const debug = debuglog('@eggjs/mock/lib/restore');
+
+export async function restore() {
+  // keep mm.restore execute in the current event loop
+  mmRestore();
+  await clusterRestore();
+  await restoreMockAgent();
+  debug('restore all');
+}

package/src/lib/start-cluster.ts

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert';
+import { debuglog } from 'node:util';
+import { importModule } from '@eggjs/utils';
+import { isAsyncFunction } from 'is-type-of';
+
+const debug = debuglog('@eggjs/mock/lib/start-cluster');
+
+// if (process.env.EGG_BIN_PREREQUIRE) {
+//   require('./prerequire');
+// }
+
+async function main() {
+  const options = JSON.parse(process.argv[2]);
+  debug('startCluster with options: %o', options);
+  const { startCluster } = await importModule(options.framework);
+  assert(isAsyncFunction(startCluster),
+    `framework(${options.framework}) should export startCluster as an async function`);
+  await startCluster(options);
+}
+
+main();

package/src/lib/supertest.ts

@@ -0,0 +1,45 @@
+import path from 'node:path';
+import { readJSONSync } from 'utility';
+import { Request, Test } from '@eggjs/supertest';
+import { createServer } from './mock_http_server.js';
+import { getSourceDirname } from './utils.js';
+
+// patch from https://github.com/visionmedia/supertest/blob/199506d8dbfe0bb1434fc07c38cdcd1ab4c7c926/index.js#L19
+
+let pkgVersion = '';
+
+/**
+ * Test against the given `app`,
+ * returning a new `Test`.
+ */
+export class EggTestRequest extends Request {
+  #app: any;
+
+  constructor(app: any) {
+    super(createServer(app));
+    this.#app = app;
+  }
+
+  protected _testRequest(method: string, url: string): Test {
+    // support pathFor(url)
+    if (url[0] !== '/') {
+      const realUrl = this.#app.router.pathFor(url);
+      if (!realUrl) {
+        throw new Error(`Can\'t find router:${url}, please check your \'app/router.js\'`);
+      }
+      url = realUrl;
+    }
+    const test = super._testRequest(method, url);
+    if (!pkgVersion) {
+      const pkgFile = path.join(getSourceDirname(), '../package.json');
+      const pkg = readJSONSync(pkgFile);
+      pkgVersion = pkg.version;
+    }
+    test.set('User-Agent', `@eggjs/mock/${pkgVersion} Node.js/${process.version}`);
+    return test;
+  }
+}
+
+export function request(app: any) {
+  return new EggTestRequest(app);
+}

package/src/lib/types.ts

@@ -0,0 +1,72 @@
+export interface MockOptions {
+  /**
+   * The directory of the application
+   */
+  baseDir?: string;
+
+  /**
+   * Custom you plugins
+   */
+  plugins?: any;
+
+  /**
+   * The directory of the egg framework
+   *
+   * Set to `true` to use the current directory as framework directory
+   */
+  framework?: string | boolean;
+
+  /**
+   * current test on plugin
+   */
+  plugin?: boolean;
+
+  /**
+   * @deprecated please use framework instead
+   */
+  customEgg?: string | boolean;
+
+  /**
+   * Cache application based on baseDir
+   */
+  cache?: boolean;
+
+  /**
+   * Switch on process coverage, but it'll be slower
+   */
+  coverage?: boolean;
+
+  /**
+   * Remove $baseDir/logs and $baseDir/run before start, default is `true`
+   */
+  clean?: boolean;
+
+  /**
+   * default options.mockCtxStorage value on each mockContext
+   */
+  mockCtxStorage?: boolean;
+
+  beforeInit?: (app: any) => Promise<void>;
+}
+
+export interface MockClusterOptions extends MockOptions {
+  workers?: number | string;
+  cache?: boolean;
+  port?: number;
+  /**
+   * opt pass to coffee, such as { execArgv: ['--debug'] }
+   */
+  opt?: object;
+}
+
+export interface MockApplicationOptions extends MockOptions {
+  baseDir: string;
+  framework: string;
+  clusterPort?: number;
+}
+
+export interface MockClusterApplicationOptions extends MockClusterOptions {
+  baseDir: string;
+  framework: string;
+  port: number;
+}

package/src/lib/utils.ts

@@ -0,0 +1,82 @@
+import { rm } from 'node:fs/promises';
+import { rmSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { scheduler } from 'node:timers/promises';
+
+export function getSourceDirname() {
+  if (typeof __dirname !== 'undefined') {
+    return path.dirname(__dirname);
+  }
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  return path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+}
+
+export async function sleep(delay: number) {
+  await scheduler.wait(delay);
+}
+
+export async function rimraf(filepath: string) {
+  await rm(filepath, { force: true, recursive: true });
+}
+
+export function rimrafSync(filepath: string) {
+  rmSync(filepath, { force: true, recursive: true });
+}
+
+export function getProperty(target: any, prop: PropertyKey) {
+  const member = target[prop];
+  if (typeof member === 'function') {
+    return member.bind(target);
+  }
+  return member;
+}
+
+export function getEggOptions() {
+  const options = {
+    baseDir: process.env.EGG_BASE_DIR ?? process.cwd(),
+    framework: process.env.EGG_FRAMEWORK,
+  };
+  return options;
+}
+
+// const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+// /**
+//  * Merge the property descriptors of `src` into `dest`
+//  *
+//  * @param {object} dest Object to add descriptors to
+//  * @param {object} src Object to clone descriptors from
+//  * @param {boolean} [redefine=true] Redefine `dest` properties with `src` properties
+//  * @return {object} Reference to dest
+//  * @public
+//  */
+
+// function merge(dest, src, redefine) {
+//   if (!dest) {
+//     throw new TypeError('argument dest is required');
+//   }
+
+//   if (!src) {
+//     throw new TypeError('argument src is required');
+//   }
+
+//   if (redefine === undefined) {
+//     // Default to true
+//     redefine = true;
+//   }
+
+//   Object.getOwnPropertyNames(src).forEach(function forEachOwnPropertyName(name) {
+//     if (!redefine && hasOwnProperty.call(dest, name)) {
+//       // Skip descriptor
+//       return;
+//     }
+
+//     // Copy descriptor
+//     const descriptor = Object.getOwnPropertyDescriptor(src, name);
+//     Object.defineProperty(dest, name, descriptor);
+//   });
+
+//   return dest;
+// }

package/src/register.ts

@@ -0,0 +1,80 @@
+import { debuglog } from 'node:util';
+import { createRequire } from 'node:module';
+import { mock } from './index.js';
+import { setupAgent, closeAgent } from './lib/agent_handler.js';
+import { getApp } from './lib/app_handler.js';
+import { injectContext } from './lib/inject_context.js';
+
+const debug = debuglog('@eggjs/mock/register');
+
+export async function mochaGlobalSetup() {
+  debug('mochaGlobalSetup, agent.setupAgent() start');
+  await setupAgent();
+  debug('mochaGlobalSetup, agent.setupAgent() end');
+}
+
+export async function mochaGlobalTeardown() {
+  debug('mochaGlobalTeardown, agent.closeAgent() start');
+  await closeAgent();
+  debug('mochaGlobalTeardown, agent.closeAgent() end');
+}
+
+export const mochaHooks = {
+  async beforeAll() {
+    const app = await getApp();
+    debug('mochaHooks.beforeAll call, _app: %s', app);
+    if (app) {
+      await app.ready();
+    }
+  },
+  async afterEach() {
+    const app = await getApp();
+    debug('mochaHooks.afterEach call, _app: %s', app);
+    if (app) {
+      await app.backgroundTasksFinished();
+    }
+    await mock.restore();
+  },
+  async afterAll() {
+    // skip auto app close on parallel
+    if (process.env.ENABLE_MOCHA_PARALLEL) return;
+    const app = await getApp();
+    debug('mochaHooks.afterAll call, _app: %s', app);
+    if (app) {
+      await app.close();
+    }
+  },
+};
+
+/**
+ * Find active node mocha instances.
+ */
+function findNodeJSMocha() {
+  let children: any;
+  if (typeof require === 'function') {
+    children = require.cache || {};
+  } else {
+    // FIXME: not work on ESM
+    children = createRequire(process.cwd()).cache || {};
+    debug('createRequire on esm');
+  }
+
+  return Object.keys(children)
+    .filter(function(child) {
+      const val = children[child].exports;
+      return typeof val === 'function' && val.name === 'Mocha';
+    })
+    .map(function(child) {
+      return children[child].exports;
+    });
+}
+
+import 'mocha';
+
+const modules = findNodeJSMocha();
+// console.error('modules length: %s', modules.length);
+
+for (const module of modules) {
+  if (!module) continue;
+  injectContext(module);
+}