@eggjs/mock 6.0.6 → 6.1.0-beta.10

package/dist/node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/mocharc.js

@@ -0,0 +1,24 @@
+import { __commonJS } from "../../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/mocharc.json
+var require_mocharc = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/mocharc.json": ((exports, module) => {
+	module.exports = {
+		"diff": true,
+		"extension": [
+			"js",
+			"cjs",
+			"mjs"
+		],
+		"package": "./package.json",
+		"reporter": "spec",
+		"slow": 75,
+		"timeout": 2e3,
+		"ui": "bdd",
+		"watch-ignore": ["node_modules", ".git"]
+	};
+}) });
+
+//#endregion
+export default require_mocharc();
+
+export { require_mocharc };

package/dist/node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/nodejs/buffered-worker-pool.js

@@ -0,0 +1,152 @@
+import { __commonJS, __require } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require_src } from "../../../../../debug@4.4.3_supports-color@8.1.1/node_modules/debug/src/index.js";
+import { require_errors } from "../errors.js";
+import { require_serialize_javascript } from "../../../../../serialize-javascript@6.0.2/node_modules/serialize-javascript/index.js";
+import { require_src as require_src$1 } from "../../../../../workerpool@9.3.4/node_modules/workerpool/src/index.js";
+import { require_serializer } from "./serializer.js";
+
+//#region ../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/nodejs/buffered-worker-pool.js
+var require_buffered_worker_pool = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/nodejs/buffered-worker-pool.js": ((exports) => {
+	/**
+	* @typedef {import('workerpool').WorkerPoolOptions} WorkerPoolOptions
+	* @typedef {import('../types.d.ts').MochaOptions} MochaOptions
+	* @typedef {import('../types.d.ts').SerializedWorkerResult} SerializedWorkerResult
+	*/
+	const serializeJavascript = require_serialize_javascript();
+	const workerpool = require_src$1();
+	const { deserialize } = require_serializer();
+	const debug = require_src()("mocha:parallel:buffered-worker-pool");
+	const { createInvalidArgumentTypeError } = require_errors();
+	const WORKER_PATH = __require.resolve("./worker.js");
+	/**
+	* A mapping of Mocha `Options` objects to serialized values.
+	*
+	* This is helpful because we tend to same the same options over and over
+	* over IPC.
+	* @type {WeakMap<MochaOptions,string>}
+	*/
+	let optionsCache = /* @__PURE__ */ new WeakMap();
+	/**
+	* These options are passed into the [workerpool](https://npm.im/workerpool) module.
+	* @type {Partial<WorkerPoolOptions>}
+	*/
+	const WORKER_POOL_DEFAULT_OPTS = {
+		workerType: "process",
+		forkOpts: { execArgv: process.execArgv },
+		maxWorkers: workerpool.cpus - 1
+	};
+	/**
+	* A wrapper around a third-party worker pool implementation.
+	* @private
+	*/
+	var BufferedWorkerPool = class BufferedWorkerPool {
+		/**
+		* Creates an underlying worker pool instance; determines max worker count
+		* @param {Partial<WorkerPoolOptions>} [opts] - Options
+		*/
+		constructor(opts = {}) {
+			const maxWorkers = Math.max(1, typeof opts.maxWorkers === "undefined" ? WORKER_POOL_DEFAULT_OPTS.maxWorkers : opts.maxWorkers);
+			/* istanbul ignore next */
+			if (workerpool.cpus < 2) debug("not enough CPU cores available to run multiple jobs; avoid --parallel on this machine");
+			else if (maxWorkers >= workerpool.cpus) debug("%d concurrent job(s) requested, but only %d core(s) available", maxWorkers, workerpool.cpus);
+			/* istanbul ignore next */
+			debug("run(): starting worker pool of max size %d, using node args: %s", maxWorkers, process.execArgv.join(" "));
+			let counter = 0;
+			const onCreateWorker = ({ forkOpts }) => {
+				return { forkOpts: {
+					...forkOpts,
+					env: {
+						...process.env,
+						MOCHA_WORKER_ID: counter++
+					}
+				} };
+			};
+			this.options = {
+				...WORKER_POOL_DEFAULT_OPTS,
+				...opts,
+				maxWorkers,
+				onCreateWorker
+			};
+			this._pool = workerpool.pool(WORKER_PATH, this.options);
+		}
+		/**
+		* Terminates all workers in the pool.
+		* @param {boolean} [force] - Whether to force-kill workers. By default, lets workers finish their current task before termination.
+		* @private
+		* @returns {Promise<void>}
+		*/
+		async terminate(force = false) {
+			/* istanbul ignore next */
+			debug("terminate(): terminating with force = %s", force);
+			return this._pool.terminate(force);
+		}
+		/**
+		* Adds a test file run to the worker pool queue for execution by a worker process.
+		*
+		* Handles serialization/deserialization.
+		*
+		* @param {string} filepath - Filepath of test
+		* @param {MochaOptions} [options] - Options for Mocha instance
+		* @private
+		* @returns {Promise<SerializedWorkerResult>}
+		*/
+		async run(filepath, options = {}) {
+			if (!filepath || typeof filepath !== "string") throw createInvalidArgumentTypeError("Expected a non-empty filepath", "filepath", "string");
+			const serializedOptions = BufferedWorkerPool.serializeOptions(options);
+			const result = await this._pool.exec("run", [filepath, serializedOptions]);
+			return deserialize(result);
+		}
+		/**
+		* Returns stats about the state of the worker processes in the pool.
+		*
+		* Used for debugging.
+		*
+		* @private
+		*/
+		stats() {
+			return this._pool.stats();
+		}
+		/**
+		* Instantiates a {@link WorkerPool}.
+		* @private
+		*/
+		static create(...args) {
+			return new BufferedWorkerPool(...args);
+		}
+		/**
+		* Given Mocha options object `opts`, serialize into a format suitable for
+		* transmission over IPC.
+		*
+		* @param {MochaOptions} [opts] - Mocha options
+		* @private
+		* @returns {string} Serialized options
+		*/
+		static serializeOptions(opts = {}) {
+			if (!optionsCache.has(opts)) {
+				const serialized = serializeJavascript(opts, {
+					unsafe: true,
+					ignoreFunction: true
+				});
+				optionsCache.set(opts, serialized);
+				/* istanbul ignore next */
+				debug("serializeOptions(): serialized options %O to: %s", opts, serialized);
+			}
+			return optionsCache.get(opts);
+		}
+		/**
+		* Resets internal cache of serialized options objects.
+		*
+		* For testing/debugging
+		* @private
+		*/
+		static resetOptionsCache() {
+			optionsCache = /* @__PURE__ */ new WeakMap();
+		}
+	};
+	exports.BufferedWorkerPool = BufferedWorkerPool;
+}) });
+
+//#endregion
+export default require_buffered_worker_pool();
+
+export { require_buffered_worker_pool };

package/dist/node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/nodejs/esm-utils.js

@@ -0,0 +1,74 @@
+import { __commonJS, __require } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require_src } from "../../../../../debug@4.4.3_supports-color@8.1.1/node_modules/debug/src/index.js";
+
+//#region ../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/nodejs/esm-utils.js
+var require_esm_utils = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/nodejs/esm-utils.js": ((exports) => {
+	const path = __require("node:path");
+	const url = __require("node:url");
+	const debug = require_src()("mocha:esm-utils");
+	const forward = (x) => x;
+	const formattedImport = async (file, esmDecorator = forward) => {
+		if (path.isAbsolute(file)) try {
+			return await exports.doImport(esmDecorator(url.pathToFileURL(file)));
+		} catch (err) {
+			if (err instanceof SyntaxError && err.message && err.stack && !err.stack.includes(file)) {
+				const newErrorWithFilename = new SyntaxError(err.message);
+				newErrorWithFilename.stack = err.stack.replace(/^SyntaxError/, `SyntaxError[ @${file} ]`);
+				throw newErrorWithFilename;
+			}
+			throw err;
+		}
+		return exports.doImport(esmDecorator(file));
+	};
+	exports.doImport = async (file) => import(file);
+	const tryImportAndRequire = async (file, esmDecorator) => {
+		if (path.extname(file) === ".mjs") return formattedImport(file, esmDecorator);
+		try {
+			return dealWithExports(await formattedImport(file, esmDecorator));
+		} catch (err) {
+			if (err.code === "ERR_MODULE_NOT_FOUND" || err.code === "ERR_UNKNOWN_FILE_EXTENSION" || err.code === "ERR_UNSUPPORTED_DIR_IMPORT") try {
+				return __require(file);
+			} catch (requireErr) {
+				if (requireErr.code === "ERR_REQUIRE_ESM" || requireErr instanceof SyntaxError && requireErr.toString().includes("Cannot use import statement outside a module")) throw err;
+				else throw requireErr;
+			}
+			else throw err;
+		}
+	};
+	const requireModule = async (file, esmDecorator) => {
+		if (path.extname(file) === ".mjs") return formattedImport(file, esmDecorator);
+		try {
+			return __require(file);
+		} catch (requireErr) {
+			debug("requireModule caught err: %O", requireErr.message);
+			try {
+				return dealWithExports(await formattedImport(file, esmDecorator));
+			} catch (importErr) {
+				if (importErr.code === "ERR_INTERNAL_ASSERTION") throw requireErr;
+				throw importErr;
+			}
+		}
+	};
+	debug("assigning requireOrImport, require_module === %O", process.features.require_module);
+	if (process.features.require_module) exports.requireOrImport = requireModule;
+	else exports.requireOrImport = tryImportAndRequire;
+	function dealWithExports(module) {
+		if (module.default) return module.default;
+		else return {
+			...module,
+			default: void 0
+		};
+	}
+	exports.loadFilesAsync = async (files, preLoadFunc, postLoadFunc, esmDecorator) => {
+		for (const file of files) {
+			preLoadFunc(file);
+			const result = await exports.requireOrImport(path.resolve(file), esmDecorator);
+			postLoadFunc(file, result);
+		}
+	};
+}) });
+
+//#endregion
+export default require_esm_utils();
+
+export { require_esm_utils };

package/dist/node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/nodejs/file-unloader.js

@@ -0,0 +1,22 @@
+import { __commonJS, __require } from "../../../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/nodejs/file-unloader.js
+var require_file_unloader = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/nodejs/file-unloader.js": ((exports) => {
+	/**
+	* This module should not be in the browser bundle, so it's here.
+	* @private
+	* @module
+	*/
+	/**
+	* Deletes a file from the `require` cache.
+	* @param {string} file - File
+	*/
+	exports.unloadFile = (file) => {
+		delete __require.cache[__require.resolve(file)];
+	};
+}) });
+
+//#endregion
+export default require_file_unloader();
+
+export { require_file_unloader };

package/dist/node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/nodejs/parallel-buffered-runner.js

@@ -0,0 +1,329 @@
+import { __commonJS, __require } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require_utils } from "../utils.js";
+import { require_src } from "../../../../../debug@4.4.3_supports-color@8.1.1/node_modules/debug/src/index.js";
+import { require_errors } from "../errors.js";
+import { require_runner } from "../runner.js";
+import { require_buffered_worker_pool } from "./buffered-worker-pool.js";
+
+//#region ../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/nodejs/parallel-buffered-runner.js
+var require_parallel_buffered_runner = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/nodejs/parallel-buffered-runner.js": ((exports, module) => {
+	/**
+	* @typedef {import('../types.d.ts').FileRunner} FileRunner
+	* @typedef {import('../types.d.ts').RunnerOptions} RunnerOptions
+	* @typedef {import('../types.d.ts').SerializedWorkerResult} SerializedWorkerResult
+	* @typedef {import('../types.d.ts').SigIntListener} SigIntListener
+	*/
+	const Runner = require_runner();
+	const { EVENT_RUN_BEGIN, EVENT_RUN_END } = Runner.constants;
+	const debug = require_src()("mocha:parallel:parallel-buffered-runner");
+	const { BufferedWorkerPool } = require_buffered_worker_pool();
+	const { setInterval, clearInterval } = global;
+	const { createMap, constants } = require_utils();
+	const { MOCHA_ID_PROP_NAME } = constants;
+	const { createFatalError } = require_errors();
+	const DEFAULT_WORKER_REPORTER = __require.resolve("./reporters/parallel-buffered");
+	/**
+	* List of options to _not_ serialize for transmission to workers
+	*/
+	const DENY_OPTIONS = [
+		"globalSetup",
+		"globalTeardown",
+		"parallel",
+		"p",
+		"jobs",
+		"j"
+	];
+	/**
+	* Outputs a debug statement with worker stats
+	* @param {BufferedWorkerPool} pool - Worker pool
+	*/
+	/* istanbul ignore next */
+	const debugStats = (pool) => {
+		const { totalWorkers, busyWorkers, idleWorkers, pendingTasks } = pool.stats();
+		debug("%d/%d busy workers; %d idle; %d tasks queued", busyWorkers, totalWorkers, idleWorkers, pendingTasks);
+	};
+	/**
+	* The interval at which we will display stats for worker processes in debug mode
+	*/
+	const DEBUG_STATS_INTERVAL = 5e3;
+	const ABORTED = "ABORTED";
+	const IDLE = "IDLE";
+	const ABORTING = "ABORTING";
+	const RUNNING = "RUNNING";
+	const BAILING = "BAILING";
+	const BAILED = "BAILED";
+	const COMPLETE = "COMPLETE";
+	const states = createMap({
+		[IDLE]: new Set([RUNNING, ABORTING]),
+		[RUNNING]: new Set([
+			COMPLETE,
+			BAILING,
+			ABORTING
+		]),
+		[COMPLETE]: /* @__PURE__ */ new Set(),
+		[ABORTED]: /* @__PURE__ */ new Set(),
+		[ABORTING]: new Set([ABORTED]),
+		[BAILING]: new Set([BAILED, ABORTING]),
+		[BAILED]: new Set([COMPLETE, ABORTING])
+	});
+	/**
+	* This `Runner` delegates tests runs to worker threads.  Does not execute any
+	* {@link Runnable}s by itself!
+	* @public
+	*/
+	var ParallelBufferedRunner = class extends Runner {
+		constructor(...args) {
+			super(...args);
+			let state = IDLE;
+			Object.defineProperty(this, "_state", {
+				get() {
+					return state;
+				},
+				set(newState) {
+					if (states[state].has(newState)) state = newState;
+					else throw new Error(`invalid state transition: ${state} => ${newState}`);
+				}
+			});
+			this._workerReporter = DEFAULT_WORKER_REPORTER;
+			this._linkPartialObjects = false;
+			this._linkedObjectMap = /* @__PURE__ */ new Map();
+			this.once(Runner.constants.EVENT_RUN_END, () => {
+				this._state = COMPLETE;
+			});
+		}
+		/**
+		* Returns a mapping function to enqueue a file in the worker pool and return results of its execution.
+		* @param {BufferedWorkerPool} pool - Worker pool
+		* @param {RunnerOptions} options - Mocha options
+		* @returns {FileRunner} Mapping function
+		* @private
+		*/
+		_createFileRunner(pool, options) {
+			/**
+			* Emits event and sets `BAILING` state, if necessary.
+			* @param {Object} event - Event having `eventName`, maybe `data` and maybe `error`
+			* @param {number} failureCount - Failure count
+			*/
+			const emitEvent = (event, failureCount) => {
+				this.emit(event.eventName, event.data, event.error);
+				if (this._state !== BAILING && event.data && event.data._bail && (failureCount || event.error)) {
+					debug("run(): nonzero failure count & found bail flag");
+					this._state = BAILING;
+				}
+			};
+			/**
+			* Given an event, recursively find any objects in its data that have ID's, and create object references to already-seen objects.
+			* @param {Object} event - Event having `eventName`, maybe `data` and maybe `error`
+			*/
+			const linkEvent = (event) => {
+				const stack = [{
+					parent: event,
+					prop: "data"
+				}];
+				while (stack.length) {
+					const { parent, prop } = stack.pop();
+					const obj = parent[prop];
+					let newObj;
+					if (obj && typeof obj === "object") if (obj[MOCHA_ID_PROP_NAME]) {
+						const id = obj[MOCHA_ID_PROP_NAME];
+						newObj = this._linkedObjectMap.has(id) ? Object.assign(this._linkedObjectMap.get(id), obj) : obj;
+						this._linkedObjectMap.set(id, newObj);
+						parent[prop] = newObj;
+					} else throw createFatalError("Object missing ID received in event data", obj);
+					Object.keys(newObj).forEach((key) => {
+						const value = obj[key];
+						if (value && typeof value === "object" && value[MOCHA_ID_PROP_NAME]) stack.push({
+							obj: value,
+							parent: newObj,
+							prop: key
+						});
+					});
+				}
+			};
+			return async (file) => {
+				debug("run(): enqueueing test file %s", file);
+				try {
+					const { failureCount, events } = await pool.run(file, options);
+					if (this._state === BAILED) return;
+					debug("run(): completed run of file %s; %d failures / %d events", file, failureCount, events.length);
+					this.failures += failureCount;
+					let event = events.shift();
+					if (this._linkPartialObjects) while (event) {
+						linkEvent(event);
+						emitEvent(event, failureCount);
+						event = events.shift();
+					}
+					else while (event) {
+						emitEvent(event, failureCount);
+						event = events.shift();
+					}
+					if (this._state === BAILING) {
+						debug("run(): terminating pool due to \"bail\" flag");
+						this._state = BAILED;
+						await pool.terminate();
+					}
+				} catch (err) {
+					if (this._state === BAILED || this._state === ABORTING) debug("run(): worker pool terminated with intent; skipping file %s", file);
+					else {
+						debug("run(): encountered uncaught exception: %O", err);
+						if (this.allowUncaught) {
+							this._state = ABORTING;
+							await pool.terminate(true);
+						}
+						throw err;
+					}
+				} finally {
+					debug("run(): done running file %s", file);
+				}
+			};
+		}
+		/**
+		* Listen on `Process.SIGINT`; terminate pool if caught.
+		* Returns the listener for later call to `process.removeListener()`.
+		* @param {BufferedWorkerPool} pool - Worker pool
+		* @returns {SigIntListener} Listener
+		* @private
+		*/
+		_bindSigIntListener(pool) {
+			const sigIntListener = async () => {
+				debug("run(): caught a SIGINT");
+				this._state = ABORTING;
+				try {
+					debug("run(): force-terminating worker pool");
+					await pool.terminate(true);
+				} catch (err) {
+					console.error(`Error while attempting to force-terminate worker pool: ${err}`);
+					process.exitCode = 1;
+				} finally {
+					process.nextTick(() => {
+						debug("run(): imminent death");
+						this._state = ABORTED;
+						process.kill(process.pid, "SIGINT");
+					});
+				}
+			};
+			process.once("SIGINT", sigIntListener);
+			return sigIntListener;
+		}
+		/**
+		* Runs Mocha tests by creating a thread pool, then delegating work to the
+		* worker threads.
+		*
+		* Each worker receives one file, and as workers become available, they take a
+		* file from the queue and run it. The worker thread execution is treated like
+		* an RPC--it returns a `Promise` containing serialized information about the
+		* run.  The information is processed as it's received, and emitted to a
+		* {@link Reporter}, which is likely listening for these events.
+		*
+		* @param {Function} callback - Called with an exit code corresponding to
+		* number of test failures.
+		* @param {RunnerOptions} [opts] - options
+		*/
+		run(callback, { files, options = {} } = {}) {
+			/**
+			* Listener on `Process.SIGINT` which tries to cleanly terminate the worker pool.
+			*/
+			let sigIntListener;
+			options = {
+				...options,
+				reporter: this._workerReporter
+			};
+			(async () => {
+				/**
+				* This is an interval that outputs stats about the worker pool every so often
+				*/
+				let debugInterval;
+				/**
+				* @type {BufferedWorkerPool}
+				*/
+				let pool;
+				try {
+					pool = BufferedWorkerPool.create({ maxWorkers: options.jobs });
+					sigIntListener = this._bindSigIntListener(pool);
+					/* istanbul ignore next */
+					debugInterval = setInterval(() => debugStats(pool), DEBUG_STATS_INTERVAL).unref();
+					this.started = true;
+					this._state = RUNNING;
+					this.emit(EVENT_RUN_BEGIN);
+					options = { ...options };
+					DENY_OPTIONS.forEach((opt) => {
+						delete options[opt];
+					});
+					const results = await Promise.allSettled(files.map(this._createFileRunner(pool, options)));
+					await pool.terminate();
+					results.filter(({ status }) => status === "rejected").forEach(({ reason }) => {
+						if (this.allowUncaught) throw reason;
+						this.uncaught(reason);
+					});
+					if (this._state === ABORTING) return;
+					this.emit(EVENT_RUN_END);
+					debug("run(): completing with failure count %d", this.failures);
+					callback(this.failures);
+				} catch (err) {
+					process.nextTick(() => {
+						debug("run(): re-throwing uncaught exception");
+						throw err;
+					});
+				} finally {
+					clearInterval(debugInterval);
+					process.removeListener("SIGINT", sigIntListener);
+				}
+			})();
+			return this;
+		}
+		/**
+		* Toggle partial object linking behavior; used for building object references from
+		* unique ID's.
+		* @param {boolean} [value] - If `true`, enable partial object linking, otherwise disable
+		* @returns {Runner}
+		* @chainable
+		* @public
+		* @example
+		* // this reporter needs proper object references when run in parallel mode
+		* class MyReporter() {
+		*   constructor(runner) {
+		*     runner.linkPartialObjects(true)
+		*       .on(EVENT_SUITE_BEGIN, suite => {
+		*         // this Suite may be the same object...
+		*       })
+		*       .on(EVENT_TEST_BEGIN, test => {
+		*         // ...as the `test.parent` property
+		*       });
+		*   }
+		* }
+		*/
+		linkPartialObjects(value) {
+			this._linkPartialObjects = Boolean(value);
+			return super.linkPartialObjects(value);
+		}
+		/**
+		* If this class is the `Runner` in use, then this is going to return `true`.
+		*
+		* For use by reporters.
+		* @returns {true}
+		* @public
+		*/
+		isParallelMode() {
+			return true;
+		}
+		/**
+		* Configures an alternate reporter for worker processes to use. Subclasses
+		* using worker processes should implement this.
+		* @public
+		* @param {string} path - Absolute path to alternate reporter for worker processes to use
+		* @returns {Runner}
+		* @throws When in serial mode
+		* @chainable
+		*/
+		workerReporter(reporter) {
+			this._workerReporter = reporter;
+			return this;
+		}
+	};
+	module.exports = ParallelBufferedRunner;
+}) });
+
+//#endregion
+export default require_parallel_buffered_runner();
+
+export { require_parallel_buffered_runner };