@eggjs/mock 6.0.6 → 6.1.0-beta.10

package/dist/node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/stats-collector.js

@@ -0,0 +1,72 @@
+import { __commonJS } from "../../../../../../_virtual/rolldown_runtime.js";
+import { require_runner } from "./runner.js";
+
+//#region ../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/stats-collector.js
+var require_stats_collector = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/stats-collector.js": ((exports, module) => {
+	/**
+	* @typedef {import('./types.d.ts').StatsCollector} StatsCollector
+	* @typedef {import('./runner.js')} Runner
+	*/
+	/**
+	* Provides a factory function for a {@link StatsCollector} object.
+	* @module
+	*/
+	var constants = require_runner().constants;
+	var EVENT_TEST_PASS = constants.EVENT_TEST_PASS;
+	var EVENT_TEST_FAIL = constants.EVENT_TEST_FAIL;
+	var EVENT_SUITE_BEGIN = constants.EVENT_SUITE_BEGIN;
+	var EVENT_RUN_BEGIN = constants.EVENT_RUN_BEGIN;
+	var EVENT_TEST_PENDING = constants.EVENT_TEST_PENDING;
+	var EVENT_RUN_END = constants.EVENT_RUN_END;
+	var EVENT_TEST_END = constants.EVENT_TEST_END;
+	var Date = global.Date;
+	/**
+	* Provides stats such as test duration, number of tests passed / failed etc., by listening for events emitted by `runner`.
+	*
+	* @private
+	* @param {Runner} runner - Runner instance
+	* @throws {TypeError} If falsy `runner`
+	*/
+	function createStatsCollector(runner) {
+		/**
+		* @type {StatsCollector}
+		*/
+		var stats = {
+			suites: 0,
+			tests: 0,
+			passes: 0,
+			pending: 0,
+			failures: 0
+		};
+		if (!runner) throw new TypeError("Missing runner argument");
+		runner.stats = stats;
+		runner.once(EVENT_RUN_BEGIN, function() {
+			stats.start = new Date();
+		});
+		runner.on(EVENT_SUITE_BEGIN, function(suite) {
+			suite.root || stats.suites++;
+		});
+		runner.on(EVENT_TEST_PASS, function() {
+			stats.passes++;
+		});
+		runner.on(EVENT_TEST_FAIL, function() {
+			stats.failures++;
+		});
+		runner.on(EVENT_TEST_PENDING, function() {
+			stats.pending++;
+		});
+		runner.on(EVENT_TEST_END, function() {
+			stats.tests++;
+		});
+		runner.once(EVENT_RUN_END, function() {
+			stats.end = new Date();
+			stats.duration = stats.end - stats.start;
+		});
+	}
+	module.exports = createStatsCollector;
+}) });
+
+//#endregion
+export default require_stats_collector();
+
+export { require_stats_collector };

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

@@ -0,0 +1,517 @@
+import { __commonJS, __require } from "../../../../../../_virtual/rolldown_runtime.js";
+import { require_ms } from "../../../../ms@2.1.3/node_modules/ms/index.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_hook } from "./hook.js";
+
+//#region ../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/suite.js
+var require_suite = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/suite.js": ((exports, module) => {
+	/**
+	* @typedef {import('./test.js')} Test
+	*/
+	/**
+	* Module dependencies.
+	* @private
+	*/
+	const { EventEmitter } = __require("node:events");
+	const Hook = require_hook();
+	var { assignNewMochaID, clamp, constants: utilsConstants, defineConstants, getMochaID, inherits, isString } = require_utils();
+	const debug = require_src()("mocha:suite");
+	const milliseconds = require_ms();
+	const errors = require_errors();
+	const { MOCHA_ID_PROP_NAME } = utilsConstants;
+	/**
+	* Expose `Suite`.
+	*/
+	exports = module.exports = Suite;
+	/**
+	* Create a new `Suite` with the given `title` and parent `Suite`.
+	*
+	* @public
+	* @param {Suite} parent - Parent suite (required!)
+	* @param {string} title - Title
+	* @return {Suite}
+	*/
+	Suite.create = function(parent, title) {
+		var suite = new Suite(title, parent.ctx);
+		suite.parent = parent;
+		title = suite.fullTitle();
+		parent.addSuite(suite);
+		return suite;
+	};
+	/**
+	* Constructs a new `Suite` instance with the given `title`, `ctx`, and `isRoot`.
+	*
+	* @public
+	* @class
+	* @extends EventEmitter
+	* @see {@link https://nodejs.org/api/events.html#events_class_eventemitter|EventEmitter}
+	* @param {string} title - Suite title.
+	* @param {Context} parentContext - Parent context instance.
+	* @param {boolean} [isRoot=false] - Whether this is the root suite.
+	*/
+	function Suite(title, parentContext, isRoot) {
+		if (!isString(title)) throw errors.createInvalidArgumentTypeError("Suite argument \"title\" must be a string. Received type \"" + typeof title + "\"", "title", "string");
+		this.title = title;
+		function Context() {}
+		Context.prototype = parentContext;
+		this.ctx = new Context();
+		this.suites = [];
+		this.tests = [];
+		this.root = isRoot === true;
+		this.pending = false;
+		this._retries = -1;
+		this._beforeEach = [];
+		this._beforeAll = [];
+		this._afterEach = [];
+		this._afterAll = [];
+		this._timeout = 2e3;
+		this._slow = 75;
+		this._bail = false;
+		this._onlyTests = [];
+		this._onlySuites = [];
+		assignNewMochaID(this);
+		Object.defineProperty(this, "id", { get() {
+			return getMochaID(this);
+		} });
+		this.reset();
+	}
+	/**
+	* Inherit from `EventEmitter.prototype`.
+	*/
+	inherits(Suite, EventEmitter);
+	/**
+	* Resets the state initially or for a next run.
+	*/
+	Suite.prototype.reset = function() {
+		this.delayed = false;
+		function doReset(thingToReset) {
+			thingToReset.reset();
+		}
+		this.suites.forEach(doReset);
+		this.tests.forEach(doReset);
+		this._beforeEach.forEach(doReset);
+		this._afterEach.forEach(doReset);
+		this._beforeAll.forEach(doReset);
+		this._afterAll.forEach(doReset);
+	};
+	/**
+	* Return a clone of this `Suite`.
+	*
+	* @private
+	* @return {Suite}
+	*/
+	Suite.prototype.clone = function() {
+		var suite = new Suite(this.title);
+		debug("clone");
+		suite.ctx = this.ctx;
+		suite.root = this.root;
+		suite.timeout(this.timeout());
+		suite.retries(this.retries());
+		suite.slow(this.slow());
+		suite.bail(this.bail());
+		return suite;
+	};
+	/**
+	* Set or get timeout `ms` or short-hand such as "2s".
+	*
+	* @private
+	* @todo Do not attempt to set value if `ms` is undefined
+	* @param {number|string} ms
+	* @return {Suite|number} for chaining
+	*/
+	Suite.prototype.timeout = function(ms) {
+		if (!arguments.length) return this._timeout;
+		if (typeof ms === "string") ms = milliseconds(ms);
+		var range = [0, Math.pow(2, 31) - 1];
+		ms = clamp(ms, range);
+		debug("timeout %d", ms);
+		this._timeout = parseInt(ms, 10);
+		return this;
+	};
+	/**
+	* Set or get number of times to retry a failed test.
+	*
+	* @private
+	* @param {number|string} n
+	* @return {Suite|number} for chaining
+	*/
+	Suite.prototype.retries = function(n) {
+		if (!arguments.length) return this._retries;
+		debug("retries %d", n);
+		this._retries = parseInt(n, 10) || 0;
+		return this;
+	};
+	/**
+	* Set or get slow `ms` or short-hand such as "2s".
+	*
+	* @private
+	* @param {number|string} ms
+	* @return {Suite|number} for chaining
+	*/
+	Suite.prototype.slow = function(ms) {
+		if (!arguments.length) return this._slow;
+		if (typeof ms === "string") ms = milliseconds(ms);
+		debug("slow %d", ms);
+		this._slow = ms;
+		return this;
+	};
+	/**
+	* Set or get whether to bail after first error.
+	*
+	* @private
+	* @param {boolean} bail
+	* @return {Suite|number} for chaining
+	*/
+	Suite.prototype.bail = function(bail) {
+		if (!arguments.length) return this._bail;
+		debug("bail %s", bail);
+		this._bail = bail;
+		return this;
+	};
+	/**
+	* Check if this suite or its parent suite is marked as pending.
+	*
+	* @private
+	*/
+	Suite.prototype.isPending = function() {
+		return this.pending || this.parent && this.parent.isPending();
+	};
+	/**
+	* Generic hook-creator.
+	* @private
+	* @param {string} title - Title of hook
+	* @param {Function} fn - Hook callback
+	* @returns {Hook} A new hook
+	*/
+	Suite.prototype._createHook = function(title, fn) {
+		var hook = new Hook(title, fn);
+		hook.parent = this;
+		hook.timeout(this.timeout());
+		hook.retries(this.retries());
+		hook.slow(this.slow());
+		hook.ctx = this.ctx;
+		hook.file = this.file;
+		return hook;
+	};
+	/**
+	* Run `fn(test[, done])` before running tests.
+	*
+	* @private
+	* @param {string} title
+	* @param {Function} fn
+	* @return {Suite} for chaining
+	*/
+	Suite.prototype.beforeAll = function(title, fn) {
+		if (this.isPending()) return this;
+		if (typeof title === "function") {
+			fn = title;
+			title = fn.name;
+		}
+		title = "\"before all\" hook" + (title ? ": " + title : "");
+		var hook = this._createHook(title, fn);
+		this._beforeAll.push(hook);
+		this.emit(constants.EVENT_SUITE_ADD_HOOK_BEFORE_ALL, hook);
+		return hook;
+	};
+	/**
+	* Run `fn(test[, done])` after running tests.
+	*
+	* @private
+	* @param {string} title
+	* @param {Function} fn
+	* @return {Suite} for chaining
+	*/
+	Suite.prototype.afterAll = function(title, fn) {
+		if (this.isPending()) return this;
+		if (typeof title === "function") {
+			fn = title;
+			title = fn.name;
+		}
+		title = "\"after all\" hook" + (title ? ": " + title : "");
+		var hook = this._createHook(title, fn);
+		this._afterAll.push(hook);
+		this.emit(constants.EVENT_SUITE_ADD_HOOK_AFTER_ALL, hook);
+		return hook;
+	};
+	/**
+	* Run `fn(test[, done])` before each test case.
+	*
+	* @private
+	* @param {string} title
+	* @param {Function} fn
+	* @return {Suite} for chaining
+	*/
+	Suite.prototype.beforeEach = function(title, fn) {
+		if (this.isPending()) return this;
+		if (typeof title === "function") {
+			fn = title;
+			title = fn.name;
+		}
+		title = "\"before each\" hook" + (title ? ": " + title : "");
+		var hook = this._createHook(title, fn);
+		this._beforeEach.push(hook);
+		this.emit(constants.EVENT_SUITE_ADD_HOOK_BEFORE_EACH, hook);
+		return hook;
+	};
+	/**
+	* Run `fn(test[, done])` after each test case.
+	*
+	* @private
+	* @param {string} title
+	* @param {Function} fn
+	* @return {Suite} for chaining
+	*/
+	Suite.prototype.afterEach = function(title, fn) {
+		if (this.isPending()) return this;
+		if (typeof title === "function") {
+			fn = title;
+			title = fn.name;
+		}
+		title = "\"after each\" hook" + (title ? ": " + title : "");
+		var hook = this._createHook(title, fn);
+		this._afterEach.push(hook);
+		this.emit(constants.EVENT_SUITE_ADD_HOOK_AFTER_EACH, hook);
+		return hook;
+	};
+	/**
+	* Add a test `suite`.
+	*
+	* @private
+	* @param {Suite} suite
+	* @return {Suite} for chaining
+	*/
+	Suite.prototype.addSuite = function(suite) {
+		suite.parent = this;
+		suite.root = false;
+		suite.timeout(this.timeout());
+		suite.retries(this.retries());
+		suite.slow(this.slow());
+		suite.bail(this.bail());
+		this.suites.push(suite);
+		this.emit(constants.EVENT_SUITE_ADD_SUITE, suite);
+		return this;
+	};
+	/**
+	* Add a `test` to this suite.
+	*
+	* @private
+	* @param {Test} test
+	* @return {Suite} for chaining
+	*/
+	Suite.prototype.addTest = function(test) {
+		test.parent = this;
+		test.timeout(this.timeout());
+		test.retries(this.retries());
+		test.slow(this.slow());
+		test.ctx = this.ctx;
+		this.tests.push(test);
+		this.emit(constants.EVENT_SUITE_ADD_TEST, test);
+		return this;
+	};
+	/**
+	* Return the full title generated by recursively concatenating the parent's
+	* full title.
+	*
+	* @memberof Suite
+	* @public
+	* @return {string}
+	*/
+	Suite.prototype.fullTitle = function() {
+		return this.titlePath().join(" ");
+	};
+	/**
+	* Return the title path generated by recursively concatenating the parent's
+	* title path.
+	*
+	* @memberof Suite
+	* @public
+	* @return {string[]}
+	*/
+	Suite.prototype.titlePath = function() {
+		var result = [];
+		if (this.parent) result = result.concat(this.parent.titlePath());
+		if (!this.root) result.push(this.title);
+		return result;
+	};
+	/**
+	* Return the total number of tests.
+	*
+	* @memberof Suite
+	* @public
+	* @return {number}
+	*/
+	Suite.prototype.total = function() {
+		return this.suites.reduce(function(sum, suite) {
+			return sum + suite.total();
+		}, 0) + this.tests.length;
+	};
+	/**
+	* Iterates through each suite recursively to find all tests. Applies a
+	* function in the format `fn(test)`.
+	*
+	* @private
+	* @param {Function} fn
+	* @return {Suite}
+	*/
+	Suite.prototype.eachTest = function(fn) {
+		this.tests.forEach(fn);
+		this.suites.forEach(function(suite) {
+			suite.eachTest(fn);
+		});
+		return this;
+	};
+	/**
+	* This will run the root suite if we happen to be running in delayed mode.
+	* @private
+	*/
+	Suite.prototype.run = function run() {
+		if (this.root) this.emit(constants.EVENT_ROOT_SUITE_RUN);
+	};
+	/**
+	* Determines whether a suite has an `only` test or suite as a descendant.
+	*
+	* @private
+	* @returns {Boolean}
+	*/
+	Suite.prototype.hasOnly = function hasOnly() {
+		return this._onlyTests.length > 0 || this._onlySuites.length > 0 || this.suites.some(function(suite) {
+			return suite.hasOnly();
+		});
+	};
+	/**
+	* Filter suites based on `isOnly` logic.
+	*
+	* @private
+	* @returns {Boolean}
+	*/
+	Suite.prototype.filterOnly = function filterOnly() {
+		if (this._onlyTests.length) {
+			this.tests = this._onlyTests;
+			this.suites = [];
+		} else {
+			this.tests = [];
+			this._onlySuites.forEach(function(onlySuite) {
+				if (onlySuite.hasOnly()) onlySuite.filterOnly();
+			});
+			var onlySuites = this._onlySuites;
+			this.suites = this.suites.filter(function(childSuite) {
+				return onlySuites.indexOf(childSuite) !== -1 || childSuite.filterOnly();
+			});
+		}
+		return this.tests.length > 0 || this.suites.length > 0;
+	};
+	/**
+	* Adds a suite to the list of subsuites marked `only`.
+	*
+	* @private
+	* @param {Suite} suite
+	*/
+	Suite.prototype.appendOnlySuite = function(suite) {
+		this._onlySuites.push(suite);
+	};
+	/**
+	* Marks a suite to be `only`.
+	*
+	* @private
+	*/
+	Suite.prototype.markOnly = function() {
+		this.parent && this.parent.appendOnlySuite(this);
+	};
+	/**
+	* Adds a test to the list of tests marked `only`.
+	*
+	* @private
+	* @param {Test} test
+	*/
+	Suite.prototype.appendOnlyTest = function(test) {
+		this._onlyTests.push(test);
+	};
+	/**
+	* Returns the array of hooks by hook name; see `HOOK_TYPE_*` constants.
+	* @private
+	*/
+	Suite.prototype.getHooks = function getHooks(name) {
+		return this["_" + name];
+	};
+	/**
+	* cleans all references from this suite and all child suites.
+	*/
+	Suite.prototype.dispose = function() {
+		this.suites.forEach(function(suite) {
+			suite.dispose();
+		});
+		this.cleanReferences();
+	};
+	/**
+	* Cleans up the references to all the deferred functions
+	* (before/after/beforeEach/afterEach) and tests of a Suite.
+	* These must be deleted otherwise a memory leak can happen,
+	* as those functions may reference variables from closures,
+	* thus those variables can never be garbage collected as long
+	* as the deferred functions exist.
+	*
+	* @private
+	*/
+	Suite.prototype.cleanReferences = function cleanReferences() {
+		function cleanArrReferences(arr) {
+			for (var i$1 = 0; i$1 < arr.length; i$1++) delete arr[i$1].fn;
+		}
+		if (Array.isArray(this._beforeAll)) cleanArrReferences(this._beforeAll);
+		if (Array.isArray(this._beforeEach)) cleanArrReferences(this._beforeEach);
+		if (Array.isArray(this._afterAll)) cleanArrReferences(this._afterAll);
+		if (Array.isArray(this._afterEach)) cleanArrReferences(this._afterEach);
+		for (var i = 0; i < this.tests.length; i++) delete this.tests[i].fn;
+	};
+	/**
+	* Returns an object suitable for IPC.
+	* Functions are represented by keys beginning with `$$`.
+	* @private
+	* @returns {Object}
+	*/
+	Suite.prototype.serialize = function serialize() {
+		return {
+			_bail: this._bail,
+			$$fullTitle: this.fullTitle(),
+			$$isPending: Boolean(this.isPending()),
+			root: this.root,
+			title: this.title,
+			[MOCHA_ID_PROP_NAME]: this.id,
+			parent: this.parent ? { [MOCHA_ID_PROP_NAME]: this.parent.id } : null
+		};
+	};
+	var constants = defineConstants(
+		/**
+		* {@link Suite}-related constants.
+		* @public
+		* @memberof Suite
+		* @alias constants
+		* @readonly
+		* @static
+		* @enum {string}
+		*/
+		{
+			EVENT_FILE_POST_REQUIRE: "post-require",
+			EVENT_FILE_PRE_REQUIRE: "pre-require",
+			EVENT_FILE_REQUIRE: "require",
+			EVENT_ROOT_SUITE_RUN: "run",
+			HOOK_TYPE_AFTER_ALL: "afterAll",
+			HOOK_TYPE_AFTER_EACH: "afterEach",
+			HOOK_TYPE_BEFORE_ALL: "beforeAll",
+			HOOK_TYPE_BEFORE_EACH: "beforeEach",
+			EVENT_SUITE_ADD_SUITE: "suite",
+			EVENT_SUITE_ADD_HOOK_AFTER_ALL: "afterAll",
+			EVENT_SUITE_ADD_HOOK_AFTER_EACH: "afterEach",
+			EVENT_SUITE_ADD_HOOK_BEFORE_ALL: "beforeAll",
+			EVENT_SUITE_ADD_HOOK_BEFORE_EACH: "beforeEach",
+			EVENT_SUITE_ADD_TEST: "test"
+		}
+	);
+	Suite.constants = constants;
+}) });
+
+//#endregion
+export default require_suite();
+
+export { require_suite };

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

@@ -0,0 +1,105 @@
+import { __commonJS } from "../../../../../../_virtual/rolldown_runtime.js";
+import { require_utils } from "./utils.js";
+import { require_errors } from "./errors.js";
+import { require_runnable } from "./runnable.js";
+
+//#region ../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/test.js
+var require_test = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/test.js": ((exports, module) => {
+	var Runnable = require_runnable();
+	var utils = require_utils();
+	var createInvalidArgumentTypeError = require_errors().createInvalidArgumentTypeError;
+	var isString = utils.isString;
+	const { MOCHA_ID_PROP_NAME } = utils.constants;
+	module.exports = Test;
+	/**
+	* Initialize a new `Test` with the given `title` and callback `fn`.
+	*
+	* @public
+	* @class
+	* @extends Runnable
+	* @param {String} title - Test title (required)
+	* @param {Function} [fn] - Test callback.  If omitted, the Test is considered "pending"
+	*/
+	function Test(title, fn) {
+		if (!isString(title)) throw createInvalidArgumentTypeError("Test argument \"title\" should be a string. Received type \"" + typeof title + "\"", "title", "string");
+		this.type = "test";
+		Runnable.call(this, title, fn);
+		this.reset();
+	}
+	/**
+	* Inherit from `Runnable.prototype`.
+	*/
+	utils.inherits(Test, Runnable);
+	/**
+	* Resets the state initially or for a next run.
+	*/
+	Test.prototype.reset = function() {
+		Runnable.prototype.reset.call(this);
+		this.pending = !this.fn;
+		delete this.state;
+	};
+	/**
+	* Set or get retried test
+	*
+	* @private
+	*/
+	Test.prototype.retriedTest = function(n) {
+		if (!arguments.length) return this._retriedTest;
+		this._retriedTest = n;
+	};
+	/**
+	* Add test to the list of tests marked `only`.
+	*
+	* @private
+	*/
+	Test.prototype.markOnly = function() {
+		this.parent.appendOnlyTest(this);
+	};
+	Test.prototype.clone = function() {
+		var test = new Test(this.title, this.fn);
+		test.timeout(this.timeout());
+		test.slow(this.slow());
+		test.retries(this.retries());
+		test.currentRetry(this.currentRetry());
+		test.retriedTest(this.retriedTest() || this);
+		test.globals(this.globals());
+		test.parent = this.parent;
+		test.file = this.file;
+		test.ctx = this.ctx;
+		return test;
+	};
+	/**
+	* Returns an minimal object suitable for transmission over IPC.
+	* Functions are represented by keys beginning with `$$`.
+	* @private
+	* @returns {Object}
+	*/
+	Test.prototype.serialize = function serialize() {
+		return {
+			$$currentRetry: this._currentRetry,
+			$$fullTitle: this.fullTitle(),
+			$$isPending: Boolean(this.pending),
+			$$retriedTest: this._retriedTest || null,
+			$$slow: this._slow,
+			$$titlePath: this.titlePath(),
+			body: this.body,
+			duration: this.duration,
+			err: this.err,
+			parent: {
+				$$fullTitle: this.parent.fullTitle(),
+				[MOCHA_ID_PROP_NAME]: this.parent.id
+			},
+			speed: this.speed,
+			state: this.state,
+			title: this.title,
+			type: this.type,
+			file: this.file,
+			[MOCHA_ID_PROP_NAME]: this.id
+		};
+	};
+}) });
+
+//#endregion
+export default require_test();
+
+export { require_test };