@eggjs/mock 6.0.6 → 6.1.0-beta.10

package/dist/bootstrap.js

@@ -0,0 +1,14 @@
+import { getEggOptions } from "./lib/utils.js";
+import { getBootstrapApp, setupApp } from "./lib/app_handler.js";
+import src_default, { mm as proxyMock } from "./index.js";
+import { strict as assert } from "node:assert";
+import path from "node:path";
+import { readJSONSync } from "utility";
+
+//#region src/bootstrap.ts
+const options = getEggOptions();
+if (readJSONSync(path.join(options.baseDir || process.cwd(), "package.json")).eggPlugin) throw new Error("DO NOT USE bootstrap to test plugin");
+const app = setupApp();
+
+//#endregion
+export { app, assert, getBootstrapApp, src_default as mm, proxyMock as mock };

package/dist/index.d.ts

@@ -0,0 +1,81 @@
+import { MockHttpClientMethod, MockResponseCallbackOptions, MockResultFunction, MockResultOptions, ResultObject } from "./lib/mock_httpclient.js";
+import { MockAgent, MockApplicationOptions, MockClusterApplicationOptions, MockClusterOptions, MockOption, MockOptions } from "./lib/types.js";
+import ApplicationUnittest from "./app/extend/application.js";
+import { MockClusterApplication, createCluster } from "./lib/cluster.js";
+import { createApp } from "./lib/app.js";
+import { restore as restore$1 } from "./lib/restore.js";
+import { setGetAppCallback } from "./lib/app_handler.js";
+import * as mm0 from "mm";
+import { mock } from "mm";
+
+//#region src/index.d.ts
+declare const mock$1: {
+  restore: typeof restore$1;
+  /**
+   * 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 mm0.isMocked;
+  mock: typeof mock;
+  mm: typeof mock;
+  datas: typeof mm0.datas;
+  mockDatas: typeof mm0.datas;
+  data: typeof mm0.data;
+  mockData: typeof mm0.data;
+  dataWithAsyncDispose: typeof mm0.dataWithAsyncDispose;
+  empty: typeof mm0.empty;
+  mockEmpty: typeof mm0.empty;
+  error: typeof mm0.error;
+  mockError: typeof mm0.error;
+  spy: typeof mm0.spy;
+  errorOnce: typeof mm0.errorOnce;
+  syncError: typeof mm0.syncError;
+  syncEmpty: typeof mm0.syncEmpty;
+  syncData: typeof mm0.syncData;
+  http: {
+    request: (url: mm0.RequestURL, data: mm0.ResponseData, headers?: Record<string, any>, delay?: number) => void;
+    requestError: (url: mm0.RequestURL, reqError?: mm0.MockError, resError?: mm0.MockError, delay?: number) => void;
+  };
+  https: {
+    request: (url: mm0.RequestURL, data: mm0.ResponseData, headers?: Record<string, any>, delay?: number) => void;
+    requestError: (url: mm0.RequestURL, reqError?: mm0.MockError, resError?: mm0.MockError, delay?: number) => void;
+  };
+  spawn: typeof mm0.spawn;
+  classMethod: typeof mm0.classMethod;
+};
+declare const proxyMock: ((target: any, property: PropertyKey, value?: any) => void) & typeof mock$1;
+//#endregion
+export { MockAgent, type ApplicationUnittest as MockApplication, MockApplicationOptions, type MockClusterApplication, MockClusterApplicationOptions, MockClusterOptions, MockHttpClientMethod, MockOption, MockOptions, MockResponseCallbackOptions, MockResultFunction, MockResultOptions, ResultObject, createApp, createCluster, proxyMock as default, proxyMock as mm, proxyMock as mock, setGetAppCallback };

package/dist/index.js

@@ -0,0 +1,47 @@
+import { createCluster } from "./lib/cluster.js";
+import { createApp } from "./lib/app.js";
+import { restore as restore$1 } from "./lib/restore.js";
+import { setGetAppCallback } from "./lib/app_handler.js";
+import mm$1, { mock } from "mm";
+
+//#region src/index.ts
+const mock$1 = {
+	...mm$1,
+	restore: restore$1,
+	app: createApp,
+	cluster: createCluster,
+	env(env) {
+		mock(process.env, "EGG_MOCK_SERVER_ENV", env);
+		mock(process.env, "EGG_SERVER_ENV", env);
+	},
+	consoleLevel(level) {
+		level = (level || "").toUpperCase();
+		mock(process.env, "EGG_LOG", level);
+	},
+	home(homePath) {
+		if (homePath) mock(process.env, "EGG_HOME", homePath);
+	},
+	setGetAppCallback
+};
+const proxyMock = new Proxy(mock, {
+	apply(target, _, args) {
+		return target(args[0], args[1], args[2]);
+	},
+	get(_target, property, receiver) {
+		return Reflect.get(mock$1, property, receiver);
+	}
+});
+var src_default = proxyMock;
+process.setMaxListeners(100);
+process.once("SIGQUIT", () => {
+	process.exit(0);
+});
+process.once("SIGTERM", () => {
+	process.exit(0);
+});
+process.once("SIGINT", () => {
+	process.exit(0);
+});
+
+//#endregion
+export { createApp, createCluster, src_default as default, proxyMock as mm, proxyMock as mock, setGetAppCallback };

package/dist/inject_mocha.d.ts

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

package/dist/inject_mocha.js

@@ -0,0 +1,35 @@
+import { __require, __toESM } from "./_virtual/rolldown_runtime.js";
+import { injectContext } from "./lib/inject_context.js";
+import { require_mocha } from "./node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/index.js";
+import { debuglog } from "node:util";
+import { getRequire } from "@eggjs/utils";
+
+//#region src/inject_mocha.ts
+var import_mocha = /* @__PURE__ */ __toESM(require_mocha(), 1);
+const debug = debuglog("egg/mock/inject_mocha");
+/**
+* Find active node mocha instances.
+*/
+function findNodeJSMocha() {
+	let children;
+	if (typeof __require === "function") children = __require.cache || {};
+	else {
+		children = getRequire().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;
+	});
+}
+const modules = findNodeJSMocha();
+debug("modules length: %s", modules.length);
+for (const module of modules) {
+	if (!module) continue;
+	injectContext(module);
+}
+
+//#endregion
+export {  };

package/dist/lib/agent_handler.d.ts

@@ -0,0 +1,7 @@
+import { MockAgent } from "./parallel/agent.js";
+
+//#region src/lib/agent_handler.d.ts
+declare function setupAgent(): Promise<MockAgent>;
+declare function closeAgent(): Promise<void>;
+//#endregion
+export { closeAgent, setupAgent };

package/dist/lib/agent_handler.js

@@ -0,0 +1,26 @@
+import { getEggOptions } from "./utils.js";
+import { createAgent } from "./parallel/agent.js";
+import { debuglog } from "node:util";
+
+//#region src/lib/agent_handler.ts
+const debug = debuglog("egg/mock/lib/agent_handler");
+let agent;
+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;
+}
+async function closeAgent() {
+	debug("setupAgent call, agent: %s", !!agent);
+	if (agent) await agent.close();
+}
+
+//#endregion
+export { closeAgent, setupAgent };

package/dist/lib/app.d.ts

@@ -0,0 +1,7 @@
+import { MockOptions } from "./types.js";
+import ApplicationUnittest from "../app/extend/application.js";
+
+//#region src/lib/app.d.ts
+declare function createApp(createOptions?: MockOptions): ApplicationUnittest;
+//#endregion
+export { createApp };

package/dist/lib/app.js

@@ -0,0 +1,251 @@
+import { createServer } from "./mock_http_server.js";
+import { getProperty, getSourceDirname, rimraf, sleep } from "./utils.js";
+import { formatOptions } from "./format_options.js";
+import { context } from "./context.js";
+import { setCustomLoader } from "./mock_custom_loader.js";
+import "../app/extend/application.js";
+import "../app/extend/agent.js";
+import { strict } from "node:assert";
+import path from "node:path";
+import { debuglog } from "node:util";
+import os from "node:os";
+import { importModule } from "@eggjs/utils";
+import { Base } from "sdk-base";
+import { detectPort } from "detect-port";
+
+//#region src/lib/app.ts
+const debug = debuglog("egg/mock/lib/app");
+const apps = /* @__PURE__ */ new Map();
+const APP_INIT = Symbol("appInit");
+const MESSENGER = Symbol("messenger");
+const MOCK_APP_METHOD = [
+	"ready",
+	"closed",
+	"isClosed",
+	"close",
+	"_agent",
+	"_app",
+	"on",
+	"once",
+	"then"
+];
+var MockApplicationWorker = class extends Base {
+	_agent;
+	_app;
+	baseDir;
+	[APP_INIT] = false;
+	_initOnListeners;
+	_initOnceListeners;
+	constructor(options) {
+		super({
+			initMethod: "_init",
+			...options
+		});
+		this.baseDir = options.baseDir;
+		this._initOnListeners = /* @__PURE__ */ new Set();
+		this._initOnceListeners = /* @__PURE__ */ new Set();
+	}
+	async _init() {
+		if (this.options.beforeInit) {
+			await this.options.beforeInit(this);
+			this.options.beforeInit = void 0;
+		}
+		if (this.options.clean !== false) {
+			const logDir = path.join(this.options.baseDir, "logs");
+			try {
+				if (os.platform() === "win32") await sleep(1e3);
+				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(1e3);
+				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);
+		strict(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 app = this._app = new (bindMessenger(egg.Application, agent))({ ...this.options });
+		app.agent = agent;
+		Reflect.set(agent, "app", app);
+		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();
+		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);
+			super.on(args[0], args[1]);
+		}
+		return this;
+	}
+	/**
+	* close app
+	*/
+	async _close() {
+		const baseDir = this.baseDir;
+		if (this._app) await this._app.close();
+		else 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(1e3);
+	}
+	/**
+	* @deprecated please use isClosed instead, keep compatible with old version
+	*/
+	get closed() {
+		return this.isClosed;
+	}
+};
+function createApp(createOptions) {
+	const options = formatOptions(createOptions);
+	debug("[createApp] options: %o", options);
+	if (options.cache && apps.has(options.baseDir)) {
+		const app = apps.get(options.baseDir);
+		if (app && !app.isClosed) {
+			debug("use cache app %s", options.baseDir);
+			return app;
+		}
+		apps.delete(options.baseDir);
+	}
+	const appWorker = new MockApplicationWorker(options);
+	const proxyApp = new Proxy(appWorker, {
+		get(target, prop) {
+			if (MOCK_APP_METHOD.includes(prop)) return getProperty(target, prop);
+			if (!target[APP_INIT]) throw new Error(`can't get ${prop} before 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) {
+			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) {
+			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);
+			this.messenger.sendRandom = (action, data) => {
+				this.messenger.sendToAgent(action, data);
+			};
+			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");
+		}
+	};
+}
+
+//#endregion
+export { createApp };

package/dist/lib/app_handler.d.ts

@@ -0,0 +1,9 @@
+import ApplicationUnittest from "../app/extend/application.js";
+
+//#region src/lib/app_handler.d.ts
+declare function setupApp(): ApplicationUnittest;
+declare function setGetAppCallback(cb: (suite: unknown, test?: unknown) => any): void;
+declare function getApp(suite?: unknown, test?: unknown): Promise<any>;
+declare function getBootstrapApp(): ApplicationUnittest;
+//#endregion
+export { getApp, getBootstrapApp, setGetAppCallback, setupApp };

package/dist/lib/app_handler.js

@@ -0,0 +1,56 @@
+import { getEggOptions } from "./utils.js";
+import "../app/extend/application.js";
+import { createApp as createApp$1 } from "./app.js";
+import { restore } from "./restore.js";
+import { createApp } from "./parallel/app.js";
+import { setupAgent } from "./agent_handler.js";
+import { debuglog } from "node:util";
+
+//#region src/lib/app_handler.ts
+const debug = debuglog("egg/mock/lib/app_handler");
+globalThis.__eggMockAppInstance = null;
+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) {
+		app = createApp({
+			...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$1(options);
+		if (typeof beforeAll === "function") beforeAll(() => app.ready());
+		if (typeof afterEach === "function") {
+			afterEach(() => app.backgroundTasksFinished());
+			afterEach(restore);
+		}
+	}
+	globalThis.__eggMockAppInstance = app;
+	return app;
+}
+let getAppCallback;
+function setGetAppCallback(cb) {
+	getAppCallback = cb;
+}
+async function getApp(suite, test) {
+	if (getAppCallback) return getAppCallback(suite, test);
+	const app = globalThis.__eggMockAppInstance;
+	if (app) await app.ready();
+	return app;
+}
+function getBootstrapApp() {
+	return globalThis.__eggMockAppInstance;
+}
+
+//#endregion
+export { getApp, getBootstrapApp, setGetAppCallback, setupApp };

package/dist/lib/cluster.d.ts

@@ -0,0 +1,126 @@
+import { EggTestRequest } from "./supertest.js";
+import { MockClusterApplicationOptions, MockClusterOptions } from "./types.js";
+import ApplicationUnittest from "../app/extend/application.js";
+import { Coffee } from "coffee";
+
+//#region src/lib/cluster.d.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);
+ *   });
+ * });
+ */
+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(): EggTestRequest;
+  _callFunctionOnAppWorker(method: string, args?: any[], property?: any, needResult?: boolean): any;
+}
+type MockClusterApplication = ClusterApplication & ApplicationUnittest;
+declare function createCluster(initOptions?: MockClusterOptions): MockClusterApplication;
+declare function restore(): Promise<void>;
+//#endregion
+export { ClusterApplication, MockClusterApplication, createCluster, restore };