@eggjs/mock 6.0.0-beta.3

package/dist/esm/app/middleware/cluster_app_mock.js

@@ -0,0 +1,98 @@
+import { debuglog } from 'node:util';
+const debug = debuglog('@eggjs/mock/app/middleware/cluster_app_mock');
+export default () => {
+    return async function clusterAppMock(ctx, next) {
+        // use originalUrl to make sure other middlewares can't change request url
+        if (ctx.originalUrl !== '/__egg_mock_call_function') {
+            return next();
+        }
+        debug('%s %s, body: %j', ctx.method, ctx.url, ctx.request.body);
+        const { method, property, args, needResult } = ctx.request.body;
+        if (!method) {
+            ctx.status = 422;
+            ctx.body = {
+                success: false,
+                error: 'Missing method',
+            };
+            return;
+        }
+        if (args && !Array.isArray(args)) {
+            ctx.status = 422;
+            ctx.body = {
+                success: false,
+                error: 'args should be an Array instance',
+            };
+            return;
+        }
+        if (property) {
+            // method: '__getter__' and property: 'config'
+            if (method === '__getter__') {
+                if (!ctx.app[property]) {
+                    debug('property %s not exists on app', property);
+                    ctx.status = 422;
+                    ctx.body = {
+                        success: false,
+                        error: `property "${property}" not exists on app`,
+                    };
+                    return;
+                }
+                ctx.body = { success: true, result: ctx.app[property] };
+                return;
+            }
+            if (!ctx.app[property] || typeof ctx.app[property][method] !== 'function') {
+                debug('property %s.%s not exists on app', property, method);
+                ctx.status = 422;
+                ctx.body = {
+                    success: false,
+                    error: `method "${method}" not exists on app.${property}`,
+                };
+                return;
+            }
+        }
+        else {
+            if (typeof ctx.app[method] !== 'function') {
+                debug('method %s not exists on app', method);
+                ctx.status = 422;
+                ctx.body = {
+                    success: false,
+                    error: `method "${method}" not exists on app`,
+                };
+                return;
+            }
+        }
+        debug('call %s with %j', method, args);
+        for (let i = 0; i < args.length; i++) {
+            const arg = args[i];
+            if (arg && typeof arg === 'object') {
+                // convert __egg_mock_type back to function
+                if (arg.__egg_mock_type === 'function') {
+                    // eslint-disable-next-line
+                    args[i] = eval(`(function() { return ${arg.value} })()`);
+                }
+                else if (arg.__egg_mock_type === 'error') {
+                    const err = new Error(arg.message);
+                    err.name = arg.name;
+                    err.stack = arg.stack;
+                    for (const key in arg) {
+                        if (key !== 'name' && key !== 'message' && key !== 'stack' && key !== '__egg_mock_type') {
+                            err[key] = arg[key];
+                        }
+                    }
+                    args[i] = err;
+                }
+            }
+        }
+        const target = property ? ctx.app[property] : ctx.app;
+        const fn = target[method];
+        try {
+            Promise.resolve(fn.call(target, ...args)).then(result => {
+                ctx.body = needResult ? { success: true, result } : { success: true };
+            });
+        }
+        catch (err) {
+            ctx.status = 500;
+            ctx.body = { success: false, error: err.message };
+        }
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/app.d.ts

@@ -0,0 +1,6 @@
+import { ILifecycleBoot, EggCore } from '@eggjs/core';
+export default class Boot implements ILifecycleBoot {
+    #private;
+    constructor(app: EggCore);
+    configWillLoad(): void;
+}

package/dist/esm/app.js

@@ -0,0 +1,17 @@
+export default class Boot {
+    #app;
+    constructor(app) {
+        this.#app = app;
+    }
+    configWillLoad() {
+        // make sure clusterAppMock position before securities
+        const index = this.#app.config.coreMiddleware.indexOf('securities');
+        if (index >= 0) {
+            this.#app.config.coreMiddleware.splice(index, 0, 'clusterAppMock');
+        }
+        else {
+            this.#app.config.coreMiddleware.push('clusterAppMock');
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2FwcC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLENBQUMsT0FBTyxPQUFPLElBQUk7SUFDdkIsSUFBSSxDQUFVO0lBQ2QsWUFBWSxHQUFZO1FBQ3RCLElBQUksQ0FBQyxJQUFJLEdBQUcsR0FBRyxDQUFDO0lBQ2xCLENBQUM7SUFFRCxjQUFjO1FBQ1osc0RBQXNEO1FBQ3RELE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLGNBQWMsQ0FBQyxPQUFPLENBQUMsWUFBWSxDQUFDLENBQUM7UUFDcEUsSUFBSSxLQUFLLElBQUksQ0FBQyxFQUFFLENBQUM7WUFDZixJQUFJLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxjQUFjLENBQUMsTUFBTSxDQUFDLEtBQUssRUFBRSxDQUFDLEVBQUUsZ0JBQWdCLENBQUMsQ0FBQztRQUNyRSxDQUFDO2FBQU0sQ0FBQztZQUNOLElBQUksQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLGNBQWMsQ0FBQyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztRQUN6RCxDQUFDO0lBQ0gsQ0FBQztDQUNGIn0=

package/dist/esm/bootstrap.d.ts

@@ -0,0 +1,4 @@
+import { strict as assert } from 'node:assert';
+import mm, { mock } from './index.js';
+declare const app: import("./index.js").MockApplication;
+export { assert, app, mm, mock, };

package/dist/esm/bootstrap.js

@@ -0,0 +1,16 @@
+import { strict as assert } from 'node:assert';
+import path from 'node:path';
+import { readJSONSync } from 'utility';
+import mm, { mock } from './index.js';
+import { getBootstrapApp, setupApp } from './lib/app_handler.js';
+import { getEggOptions } from './lib/utils.js';
+const options = getEggOptions();
+// throw error when an egg plugin test is using bootstrap
+const pkgInfo = readJSONSync(path.join(options.baseDir || process.cwd(), 'package.json'));
+if (pkgInfo.eggPlugin) {
+    throw new Error('DO NOT USE bootstrap to test plugin');
+}
+setupApp();
+const app = getBootstrapApp();
+export { assert, app, mm, mock, };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYm9vdHN0cmFwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2Jvb3RzdHJhcC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxJQUFJLE1BQU0sRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUMvQyxPQUFPLElBQUksTUFBTSxXQUFXLENBQUM7QUFDN0IsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUN2QyxPQUFPLEVBQUUsRUFBRSxFQUFFLElBQUksRUFBRSxNQUFNLFlBQVksQ0FBQztBQUN0QyxPQUFPLEVBQUUsZUFBZSxFQUFFLFFBQVEsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ2pFLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUUvQyxNQUFNLE9BQU8sR0FBRyxhQUFhLEVBQUUsQ0FBQztBQUVoQyx5REFBeUQ7QUFDekQsTUFBTSxPQUFPLEdBQUcsWUFBWSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLE9BQU8sSUFBSSxPQUFPLENBQUMsR0FBRyxFQUFFLEVBQUUsY0FBYyxDQUFDLENBQUMsQ0FBQztBQUMxRixJQUFJLE9BQU8sQ0FBQyxTQUFTLEVBQUUsQ0FBQztJQUN0QixNQUFNLElBQUksS0FBSyxDQUFDLHFDQUFxQyxDQUFDLENBQUM7QUFDekQsQ0FBQztBQUVELFFBQVEsRUFBRSxDQUFDO0FBRVgsTUFBTSxHQUFHLEdBQUcsZUFBZSxFQUFFLENBQUM7QUFFOUIsT0FBTyxFQUNMLE1BQU0sRUFDTixHQUFHLEVBQ0gsRUFBRSxFQUNGLElBQUksR0FDTCxDQUFDIn0=

package/dist/esm/index.d.ts

@@ -0,0 +1,76 @@
+import { mock as _mock } from 'mm';
+import { createCluster } from './lib/cluster.js';
+import { createApp } from './lib/app.js';
+import { restore } from './lib/restore.js';
+import { setGetAppCallback } from './lib/app_handler.js';
+import ApplicationUnittest from './app/extend/application.js';
+declare const mock: {
+    restore: typeof 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: typeof createApp;
+    /**
+     * Create a egg mocked cluster application
+     * @function mm#cluster
+     * @see ClusterApplication
+     */
+    cluster: typeof 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): void;
+    /**
+     * mock console level
+     * @param {String} level - logger level
+     */
+    consoleLevel(level: string): void;
+    home(homePath?: string): void;
+    setGetAppCallback: typeof setGetAppCallback;
+    isMocked: typeof import("mm").isMocked;
+    mock: typeof _mock;
+    mm: typeof _mock;
+    datas: typeof import("mm").datas;
+    mockDatas: typeof import("mm").datas;
+    data: typeof import("mm").data;
+    mockData: typeof import("mm").data;
+    dataWithAsyncDispose: typeof import("mm").dataWithAsyncDispose;
+    empty: typeof import("mm").empty;
+    mockEmpty: typeof import("mm").empty;
+    error: typeof import("mm").error;
+    mockError: typeof import("mm").error;
+    spy: typeof import("mm").spy;
+    errorOnce: typeof import("mm").errorOnce;
+    syncError: typeof import("mm").syncError;
+    syncEmpty: typeof import("mm").syncEmpty;
+    syncData: typeof import("mm").syncData;
+    http: {
+        request: (url: import("mm").RequestURL, data: import("mm").ResponseData, headers?: Record<string, any>, delay?: number) => void;
+        requestError: (url: import("mm").RequestURL, reqError?: import("mm").MockError, resError?: import("mm").MockError, delay?: number) => void;
+    };
+    https: {
+        request: (url: import("mm").RequestURL, data: import("mm").ResponseData, headers?: Record<string, any>, delay?: number) => void;
+        requestError: (url: import("mm").RequestURL, reqError?: import("mm").MockError, resError?: import("mm").MockError, delay?: number) => void;
+    };
+    spawn: typeof import("mm").spawn;
+    classMethod: typeof import("mm").classMethod;
+};
+declare const proxyMock: ((target: any, property: PropertyKey, value?: any) => void) & typeof mock;
+export default proxyMock;
+export { proxyMock as mock, proxyMock as mm, ApplicationUnittest as MockApplication, setGetAppCallback, createApp, createCluster, };

package/dist/esm/index.js

@@ -0,0 +1,90 @@
+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) {
+        _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) {
+        level = (level || '').toUpperCase();
+        _mock(process.env, 'EGG_LOG', level);
+    },
+    home(homePath) {
+        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);
+    },
+});
+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);
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/index.test-d.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/index.test-d.js

@@ -0,0 +1,42 @@
+// import { expectType } from 'tsd';
+// import { Application, Context } from 'egg';
+// import { MockApplication, MockAgent, ResultObject } from '.';
+// import { app, mock, mm } from './bootstrap';
+export {};
+// 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!);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXgudGVzdC1kLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2luZGV4LnRlc3QtZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxvQ0FBb0M7QUFDcEMsOENBQThDO0FBQzlDLGdFQUFnRTtBQUNoRSwrQ0FBK0M7O0FBRS9DLG9DQUFvQztBQUNwQywyQ0FBMkM7QUFDM0MsOERBQThEO0FBQzlELDJDQUEyQztBQUMzQyx5Q0FBeUM7QUFFekMsK0NBQStDO0FBRS9DLG1GQUFtRjtBQUNuRiwyRUFBMkU7QUFDM0UsMkRBQTJEO0FBQzNELDJCQUEyQjtBQUMzQixnQkFBZ0I7QUFDaEIsT0FBTztBQUNQLHFFQUFxRTtBQUNyRSw2RUFBNkU7QUFDN0Usa0VBQWtFO0FBQ2xFLDJCQUEyQjtBQUMzQixnQkFBZ0I7QUFDaEIsT0FBTztBQUVQLG1DQUFtQztBQUNuQywyQ0FBMkM7QUFDM0MsNkNBQTZDO0FBQzdDLGlEQUFpRDtBQUNqRCwrREFBK0Q7QUFDL0QsaUVBQWlFO0FBQ2pFLGlEQUFpRDtBQUNqRCwrREFBK0Q7QUFDL0QsaUVBQWlFO0FBQ2pFLHVDQUF1QztBQUN2Qyx5Q0FBeUM7QUFFekMscURBQXFEO0FBQ3JELGdEQUFnRDtBQUNoRCxtRUFBbUU7QUFDbkUsb0VBQW9FO0FBRXBFLDREQUE0RDtBQUU1RCxtQ0FBbUM7QUFDbkMsc0NBQXNDIn0=

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

@@ -0,0 +1,3 @@
+import { MockAgent } from './parallel/agent.js';
+export declare function setupAgent(): Promise<MockAgent>;
+export declare function closeAgent(): Promise<void>;

package/dist/esm/lib/agent_handler.js

@@ -0,0 +1,24 @@
+import { debuglog } from 'node:util';
+import { createAgent } from './parallel/agent.js';
+import { getEggOptions } from './utils.js';
+const debug = debuglog('@eggjs/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWdlbnRfaGFuZGxlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saWIvYWdlbnRfaGFuZGxlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sV0FBVyxDQUFDO0FBQ3JDLE9BQU8sRUFBRSxXQUFXLEVBQWEsTUFBTSxxQkFBcUIsQ0FBQztBQUM3RCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sWUFBWSxDQUFDO0FBRTNDLE1BQU0sS0FBSyxHQUFHLFFBQVEsQ0FBQywrQkFBK0IsQ0FBQyxDQUFDO0FBRXhELElBQUksS0FBZ0IsQ0FBQztBQUVyQixNQUFNLENBQUMsS0FBSyxVQUFVLFVBQVU7SUFDOUIsS0FBSyxDQUFDLHVGQUF1RixFQUMzRixPQUFPLENBQUMsR0FBRyxDQUFDLHFCQUFxQixFQUFFLE9BQU8sQ0FBQyxHQUFHLENBQUMsVUFBVSxFQUFFLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUN0RSxJQUFJLEtBQUssRUFBRSxDQUFDO1FBQ1YsTUFBTSxLQUFLLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDcEIsT0FBTyxLQUFLLENBQUM7SUFDZixDQUFDO0lBQ0QsSUFBSSxPQUFPLENBQUMsR0FBRyxDQUFDLHFCQUFxQixJQUFJLE9BQU8sQ0FBQyxHQUFHLENBQUMsVUFBVSxFQUFFLENBQUM7UUFDaEUsS0FBSyxHQUFHLFdBQVcsQ0FBQyxhQUFhLEVBQUUsQ0FBQyxDQUFDO1FBQ3JDLE1BQU0sS0FBSyxDQUFDLEtBQUssRUFBRSxDQUFDO0lBQ3RCLENBQUM7SUFDRCxPQUFPLEtBQUssQ0FBQztBQUNmLENBQUM7QUFFRCxNQUFNLENBQUMsS0FBSyxVQUFVLFVBQVU7SUFDOUIsS0FBSyxDQUFDLDRCQUE0QixFQUFFLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUM3QyxJQUFJLEtBQUssRUFBRSxDQUFDO1FBQ1YsTUFBTSxLQUFLLENBQUMsS0FBSyxFQUFFLENBQUM7SUFDdEIsQ0FBQztBQUNILENBQUMifQ==

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

@@ -0,0 +1,28 @@
+import { Base } from 'sdk-base';
+import type { Agent, Application } from 'egg';
+import type { MockOptions, MockApplicationOptions } from './types.js';
+declare const APP_INIT: unique symbol;
+export declare class MockApplication extends Base {
+    #private;
+    _agent: Agent;
+    _app: Application;
+    options: MockApplicationOptions;
+    baseDir: string;
+    [APP_INIT]: boolean;
+    _initOnListeners: Set<any[]>;
+    _initOnceListeners: Set<any[]>;
+    constructor(options: MockApplicationOptions);
+    _init(): Promise<void>;
+    on(...args: any[]): this;
+    once(...args: any[]): this;
+    /**
+     * close app
+     */
+    _close(): Promise<void>;
+    /**
+     * @deprecated please use isClosed instead, keep compatible with old version
+     */
+    get closed(): boolean;
+}
+export declare function createApp(createOptions?: MockOptions): any;
+export {};