@eggjs/mock 7.0.0-beta.20 → 7.0.0-beta.21

package/dist/lib/agent_handler.js

@@ -1,9 +1,24 @@
-import "../utils-MhP_Krx1.js";
-import "../format_options-LRnReKde.js";
-import "../context-BIduDy1M.js";
-import "../mock_custom_loader-f_tHRojG.js";
-import "../util-BpppqTXv.js";
-import "../agent-BKYkjoCx.js";
-import { closeAgent, setupAgent } from "../agent_handler-DeUtoRVT.js";
-
-export { closeAgent, setupAgent };
+import { debuglog } from 'node:util';
+import { createAgent, MockAgent } from "./parallel/agent.js";
+import { getEggOptions } from "./utils.js";
+const debug = debuglog('egg/mock/lib/agent_handler');
+let agent;
+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();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWdlbnRfaGFuZGxlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9saWIvYWdlbnRfaGFuZGxlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sV0FBVyxDQUFDO0FBRXJDLE9BQU8sRUFBRSxXQUFXLEVBQUUsU0FBUyxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDN0QsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUUzQyxNQUFNLEtBQUssR0FBRyxRQUFRLENBQUMsNEJBQTRCLENBQUMsQ0FBQztBQUVyRCxJQUFJLEtBQWdCLENBQUM7QUFFckIsTUFBTSxDQUFDLEtBQUssVUFBVSxVQUFVO0lBQzlCLEtBQUssQ0FDSCx1RkFBdUYsRUFDdkYsT0FBTyxDQUFDLEdBQUcsQ0FBQyxxQkFBcUIsRUFDakMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxVQUFVLEVBQ3RCLENBQUMsQ0FBQyxLQUFLLENBQ1IsQ0FBQztJQUNGLElBQUksS0FBSyxFQUFFLENBQUM7UUFDVixNQUFNLEtBQUssQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUNwQixPQUFPLEtBQUssQ0FBQztJQUNmLENBQUM7SUFDRCxJQUFJLE9BQU8sQ0FBQyxHQUFHLENBQUMscUJBQXFCLElBQUksT0FBTyxDQUFDLEdBQUcsQ0FBQyxVQUFVLEVBQUUsQ0FBQztRQUNoRSxLQUFLLEdBQUcsV0FBVyxDQUFDLGFBQWEsRUFBRSxDQUFDLENBQUM7UUFDckMsTUFBTSxLQUFLLENBQUMsS0FBSyxFQUFFLENBQUM7SUFDdEIsQ0FBQztJQUNELE9BQU8sS0FBSyxDQUFDO0FBQ2YsQ0FBQztBQUVELE1BQU0sQ0FBQyxLQUFLLFVBQVUsVUFBVTtJQUM5QixLQUFLLENBQUMsNEJBQTRCLEVBQUUsQ0FBQyxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQzdDLElBQUksS0FBSyxFQUFFLENBQUM7UUFDVixNQUFNLEtBQUssQ0FBQyxLQUFLLEVBQUUsQ0FBQztJQUN0QixDQUFDO0FBQ0gsQ0FBQyJ9

package/dist/lib/app.d.ts

@@ -1,6 +1,3 @@
-import "../mock_httpclient-1EgQkMxi.js";
-import "../supertest-BIds28yL.js";
-import "../types-CjZ-JeCo.js";
-import "../application-BPpvw5dg.js";
-import { createApp } from "../app-l47a-gqT.js";
-export { createApp };
+import type { MockOptions } from './types.ts';
+import ApplicationUnittest from '../app/extend/application.ts';
+export declare function createApp(createOptions?: MockOptions): ApplicationUnittest;

package/dist/lib/app.js

@@ -1,14 +1,291 @@
-import "../mock_http_server-De0r07gr.js";
-import "../utils-MhP_Krx1.js";
-import "../supertest-Cg412Los.js";
-import "../format_options-LRnReKde.js";
-import "../context-BIduDy1M.js";
-import "../mock_custom_loader-f_tHRojG.js";
-import "../mock_agent-CxT7Q0_N.js";
-import "../mock_httpclient-B6UVI7GS.js";
-import "../types-CPNMyF89.js";
-import "../application-LrKwuOKn.js";
-import "../agent-DZ_fHoxJ.js";
-import { createApp } from "../app-6Bn3F5Uw.js";
-
-export { createApp };
+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";
+import ApplicationUnittest from "../app/extend/application.js";
+import AgentUnittest from "../app/extend/agent.js";
+const debug = debuglog('egg/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'];
+class MockApplicationWorker 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('[init] options: %o', this.options);
+        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,
+        mode: 'all-in-one-process',
+    });
+    debug('[createApp] options: %o', options);
+    if (options.cache && apps.has(options.baseDir)) {
+        const app = apps.get(options.baseDir);
+        // return cache when it hasn't been killed
+        if (app && !app.isClosed) {
+            debug('use cache app %s', options.baseDir);
+            return app;
+        }
+        // delete the cache when it's closed
+        apps.delete(options.baseDir);
+    }
+    const appWorker = new MockApplicationWorker(options);
+    const proxyApp = new Proxy(appWorker, {
+        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, proxyApp);
+    return proxyApp;
+}
+function bindMessenger(ApplicationClass, agent) {
+    const agentMessenger = agent.messenger;
+    return class MessengerApplication extends ApplicationClass {
+        [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/lib/app_handler.d.ts

@@ -1,6 +1,5 @@
-import "../mock_httpclient-1EgQkMxi.js";
-import "../supertest-BIds28yL.js";
-import "../types-CjZ-JeCo.js";
-import "../application-BPpvw5dg.js";
-import { getApp, getBootstrapApp, setGetAppCallback, setupApp } from "../app_handler-Gp5J9X-v.js";
-export { getApp, getBootstrapApp, setGetAppCallback, setupApp };
+import ApplicationUnittest from '../app/extend/application.ts';
+export declare function setupApp(): ApplicationUnittest;
+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(): ApplicationUnittest;

package/dist/lib/app_handler.js

@@ -1,21 +1,69 @@
-import "../mock_http_server-De0r07gr.js";
-import "../utils-MhP_Krx1.js";
-import "../supertest-Cg412Los.js";
-import "../format_options-LRnReKde.js";
-import "../cluster-CA_hr9eV.js";
-import "../context-BIduDy1M.js";
-import "../mock_custom_loader-f_tHRojG.js";
-import "../mock_agent-CxT7Q0_N.js";
-import "../mock_httpclient-B6UVI7GS.js";
-import "../types-CPNMyF89.js";
-import "../application-LrKwuOKn.js";
-import "../agent-DZ_fHoxJ.js";
-import "../app-6Bn3F5Uw.js";
-import "../restore-CVQYXquh.js";
-import "../util-BpppqTXv.js";
-import "../app-CoypamK1.js";
-import "../agent-BKYkjoCx.js";
-import "../agent_handler-DeUtoRVT.js";
-import { getApp, getBootstrapApp, setGetAppCallback, setupApp } from "../app_handler-CkiK6fyC.js";
-
-export { getApp, getBootstrapApp, setGetAppCallback, setupApp };
+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";
+import ApplicationUnittest from "../app/extend/application.js";
+const debug = debuglog('egg/mock/lib/app_handler');
+globalThis.__eggMockAppInstance = null;
+export function setupApp() {
+    let app = globalThis.__eggMockAppInstance;
+    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());
+        }
+        // @ts-ignore mocha tsd
+        if (typeof afterEach === 'function') {
+            // mocha and jest
+            // @ts-ignore mocha tsd
+            afterEach(() => app.backgroundTasksFinished());
+            // @ts-ignore mocha tsd
+            afterEach(restore);
+        }
+    }
+    globalThis.__eggMockAppInstance = app;
+    return app;
+}
+let getAppCallback;
+export function setGetAppCallback(cb) {
+    getAppCallback = cb;
+}
+export async function getApp(suite, test) {
+    if (getAppCallback) {
+        return getAppCallback(suite, test);
+    }
+    const app = globalThis.__eggMockAppInstance;
+    if (app) {
+        await app.ready();
+    }
+    return app;
+}
+export function getBootstrapApp() {
+    return globalThis.__eggMockAppInstance;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cluster.d.ts

@@ -1,6 +1,121 @@
-import "../mock_httpclient-1EgQkMxi.js";
-import "../supertest-BIds28yL.js";
-import "../types-CjZ-JeCo.js";
-import "../application-BPpvw5dg.js";
-import { ClusterApplication, MockClusterApplication, createCluster, restore } from "../cluster-RTfUwmUd.js";
-export { ClusterApplication, MockClusterApplication, createCluster, restore };
+import { Coffee } from 'coffee';
+import type { MockClusterOptions, MockClusterApplicationOptions } from './types.ts';
+import type ApplicationUnittest from '../app/extend/application.ts';
+declare global {
+    var eggMockMasterPort: number;
+}
+/**
+ * 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;
+    private _address;
+    /**
+     * @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;
+        address: string | undefined;
+    };
+    /**
+     * 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.ts").EggTestRequest;
+    _callFunctionOnAppWorker(method: string, args?: any[], property?: any, needResult?: boolean): any;
+}
+export type MockClusterApplication = ClusterApplication & ApplicationUnittest;
+export declare function createCluster(initOptions?: MockClusterOptions): MockClusterApplication;
+export declare function restore(): Promise<void>;