@eggjs/mock 6.0.0-beta.3

package/dist/esm/lib/app.js

@@ -0,0 +1,295 @@
+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 { 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';
+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;
+    _app;
+    baseDir;
+    [APP_INIT] = false;
+    _initOnListeners;
+    _initOnceListeners;
+    constructor(options) {
+        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) {
+                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) {
+                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 });
+        debug('agent instantiate');
+        await agent.ready();
+        debug('agent ready');
+        const ApplicationClass = bindMessenger(egg.Application, agent);
+        const app = this._app = new ApplicationClass({ ...this.options });
+        // 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) {
+        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) {
+        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) {
+    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, prop) {
+            // 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, 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, 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) {
+            // 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) {
+            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, agent) {
+    const agentMessenger = agent.messenger;
+    return class MessengerApplication extends Application {
+        [MESSENGER];
+        constructor(options) {
+            super(options);
+            // enable app to send to a random agent
+            this.messenger.sendRandom = (action, data) => {
+                this.messenger.sendToAgent(action, data);
+            };
+            // enable agent to send to a random app
+            agentMessenger.on('egg-ready', () => {
+                agentMessenger.sendRandom = (action, data) => {
+                    agentMessenger.sendToApp(action, data);
+                    return agentMessenger;
+                };
+            });
+            agentMessenger.send = new Proxy(agentMessenger.send, {
+                apply: this._sendMessage.bind(this),
+            });
+        }
+        _sendMessage(_target, _thisArg, [action, data, to]) {
+            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');
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app.js","sourceRoot":"","sources":["../../../src/lib/app.ts"],"names":[],"mappings":"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"}

package/dist/esm/lib/app_handler.d.ts

@@ -0,0 +1,5 @@
+import Application from '../app/extend/application.js';
+export declare function setupApp(): Application | undefined;
+export declare function setGetAppCallback(cb: (suite: unknown, test?: unknown) => any): void;
+export declare function getApp(suite?: unknown, test?: unknown): Promise<any>;
+export declare function getBootstrapApp(): Application;

package/dist/esm/lib/app_handler.js

@@ -0,0 +1,61 @@
+import { debuglog } from 'node:util';
+import { createApp as createParallelApp } from './parallel/app.js';
+import { setupAgent } from './agent_handler.js';
+import { createApp } from './app.js';
+import { restore } from './restore.js';
+import { getEggOptions } from './utils.js';
+const debug = debuglog('@eggjs/mock/lib/app_handler');
+let app;
+export function setupApp() {
+    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) {
+        // setup agent first
+        app = createParallelApp({
+            ...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(options);
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        if (typeof beforeAll === 'function') {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            // jest
+            beforeAll(() => app.ready());
+        }
+        if (typeof afterEach === 'function') {
+            // mocha and jest
+            afterEach(() => app.backgroundTasksFinished());
+            afterEach(restore);
+        }
+    }
+}
+let getAppCallback;
+export function setGetAppCallback(cb) {
+    getAppCallback = cb;
+}
+export async function getApp(suite, test) {
+    if (getAppCallback) {
+        return getAppCallback(suite, test);
+    }
+    if (app) {
+        await app.ready();
+    }
+    return app;
+}
+export function getBootstrapApp() {
+    return app;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/cluster.d.ts

@@ -0,0 +1,114 @@
+import { Coffee } from 'coffee';
+import type { MockClusterOptions, MockClusterApplicationOptions } from './types.js';
+/**
+ * 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 declare 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);
+    /**
+     * the process that forked
+     * @member {ChildProcess}
+     */
+    get process(): any;
+    /**
+     * Compatible API for supertest
+     */
+    callback(): this;
+    /**
+     * Compatible API for supertest
+     * @member {String} url
+     * @private
+     */
+    get url(): string;
+    /**
+     * Compatible API for supertest
+     */
+    address(): {
+        port: number;
+    };
+    /**
+     * Compatible API for supertest
+     */
+    listen(): this;
+    /**
+     * kill the process
+     */
+    close(): Promise<void>;
+    get isClosed(): boolean;
+    get router(): {
+        pathFor(url: string): any;
+    };
+    /**
+     * get app[property] value in app worker
+     */
+    getAppInstanceProperty(property: string): any;
+    /**
+     * 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): void;
+    /**
+     * 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): void;
+    /**
+     * 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): void;
+    httpRequest(): import("./supertest.js").EggTestRequest;
+    _callFunctionOnAppWorker(method: string, args?: any[], property?: any, needResult?: boolean): any;
+}
+export declare function createCluster(initOptions?: MockClusterOptions): any;
+export declare function restore(): Promise<void>;