mocha 11.7.4 → 11.7.6

package/lib/mocha.js

@@ -1,4 +1,4 @@
-'use strict';
+"use strict";
 
 /*!
  * mocha
@@ -6,24 +6,24 @@
  * MIT Licensed
  */
 
-var escapeRe = require('escape-string-regexp');
-var path = require('node:path');
-var builtinReporters = require('./reporters');
-var utils = require('./utils');
-var mocharc = require('./mocharc.json');
-var Suite = require('./suite');
-var esmUtils = require('./nodejs/esm-utils');
-var createStatsCollector = require('./stats-collector');
+var escapeRe = require("escape-string-regexp");
+var path = require("node:path");
+var builtinReporters = require("./reporters");
+var utils = require("./utils");
+var mocharc = require("./mocharc.json");
+var Suite = require("./suite");
+var esmUtils = require("./nodejs/esm-utils");
+var createStatsCollector = require("./stats-collector");
 const {
   createInvalidReporterError,
   createInvalidInterfaceError,
   createMochaInstanceAlreadyDisposedError,
   createMochaInstanceAlreadyRunningError,
-  createUnsupportedError
-} = require('./errors');
-const {EVENT_FILE_PRE_REQUIRE, EVENT_FILE_POST_REQUIRE, EVENT_FILE_REQUIRE} =
+  createUnsupportedError,
+} = require("./errors");
+const { EVENT_FILE_PRE_REQUIRE, EVENT_FILE_POST_REQUIRE, EVENT_FILE_REQUIRE } =
   Suite.constants;
-var debug = require('debug')('mocha:mocha');
+var debug = require("debug")("mocha:mocha");
 
 /**
  * @typedef {import('./types.d.ts').DoneCB} DoneCB
@@ -45,32 +45,32 @@ var mochaStates = utils.defineConstants({
    * Initial state of the mocha instance
    * @private
    */
-  INIT: 'init',
+  INIT: "init",
   /**
    * Mocha instance is running tests
    * @private
    */
-  RUNNING: 'running',
+  RUNNING: "running",
   /**
    * Mocha instance is done running tests and references to test functions and hooks are cleaned.
    * You can reset this state by unloading the test files.
    * @private
    */
-  REFERENCES_CLEANED: 'referencesCleaned',
+  REFERENCES_CLEANED: "referencesCleaned",
   /**
    * Mocha instance is disposed and can no longer be used.
    * @private
    */
-  DISPOSED: 'disposed'
+  DISPOSED: "disposed",
 });
 
 /**
  * To require local UIs and reporters when running in node.
  */
 
-if (!utils.isBrowser() && typeof module.paths !== 'undefined') {
+if (!utils.isBrowser() && typeof module.paths !== "undefined") {
   var cwd = utils.cwd();
-  module.paths.push(cwd, path.join(cwd, 'node_modules'));
+  module.paths.push(cwd, path.join(cwd, "node_modules"));
 }
 
 /**
@@ -79,34 +79,34 @@ if (!utils.isBrowser() && typeof module.paths !== 'undefined') {
  */
 
 exports.utils = utils;
-exports.interfaces = require('./interfaces');
+exports.interfaces = require("./interfaces");
 /**
  * @public
  * @memberof Mocha
  */
 exports.reporters = builtinReporters;
-exports.Runnable = require('./runnable');
-exports.Context = require('./context');
+exports.Runnable = require("./runnable");
+exports.Context = require("./context");
 /**
  *
  * @memberof Mocha
  */
-exports.Runner = require('./runner');
+exports.Runner = require("./runner");
 exports.Suite = Suite;
-exports.Hook = require('./hook');
-exports.Test = require('./test');
+exports.Hook = require("./hook");
+exports.Test = require("./test");
 
 let currentContext;
 exports.afterEach = function (...args) {
   return (currentContext.afterEach || currentContext.teardown).apply(
     this,
-    args
+    args,
   );
 };
 exports.after = function (...args) {
   return (currentContext.after || currentContext.suiteTeardown).apply(
     this,
-    args
+    args,
   );
 };
 exports.beforeEach = function (...args) {
@@ -121,13 +121,13 @@ exports.describe = function (...args) {
 exports.describe.only = function (...args) {
   return (currentContext.describe || currentContext.suite).only.apply(
     this,
-    args
+    args,
   );
 };
 exports.describe.skip = function (...args) {
   return (currentContext.describe || currentContext.suite).skip.apply(
     this,
-    args
+    args,
   );
 };
 exports.it = function (...args) {
@@ -159,11 +159,11 @@ exports.run = function (...args) {
  * @param {MochaOptions} [options] - Settings object.
  */
 function Mocha(options = {}) {
-  options = {...mocharc, ...options};
+  options = { ...mocharc, ...options };
   this.files = [];
   this.options = options;
   // root suite
-  this.suite = new exports.Suite('', new exports.Context(), true);
+  this.suite = new exports.Suite("", new exports.Context(), true);
   this._cleanReferencesAfterRun = true;
   this._state = mochaStates.INIT;
 
@@ -172,38 +172,38 @@ function Mocha(options = {}) {
     .ui(options.ui)
     .reporter(
       options.reporter,
-      options['reporter-option'] ||
+      options["reporter-option"] ||
         options.reporterOption ||
-        options.reporterOptions // for backwards compatibility
+        options.reporterOptions, // for backwards compatibility
     )
     .slow(options.slow)
     .global(options.global);
 
   // this guard exists because Suite#timeout does not consider `undefined` to be valid input
-  if (typeof options.timeout !== 'undefined') {
+  if (typeof options.timeout !== "undefined") {
     this.timeout(options.timeout === false ? 0 : options.timeout);
   }
 
-  if ('retries' in options) {
+  if ("retries" in options) {
     this.retries(options.retries);
   }
 
   [
-    'allowUncaught',
-    'asyncOnly',
-    'bail',
-    'checkLeaks',
-    'color',
-    'delay',
-    'diff',
-    'dryRun',
-    'passOnFailingTestSuite',
-    'failZero',
-    'forbidOnly',
-    'forbidPending',
-    'fullTrace',
-    'inlineDiffs',
-    'invert'
+    "allowUncaught",
+    "asyncOnly",
+    "bail",
+    "checkLeaks",
+    "color",
+    "delay",
+    "diff",
+    "dryRun",
+    "passOnFailingTestSuite",
+    "failZero",
+    "forbidOnly",
+    "forbidPending",
+    "fullTrace",
+    "inlineDiffs",
+    "invert",
   ].forEach(function (opt) {
     if (options[opt]) {
       this[opt]();
@@ -246,9 +246,9 @@ function Mocha(options = {}) {
 
   if (
     options.parallel &&
-    (typeof options.jobs === 'undefined' || options.jobs > 1)
+    (typeof options.jobs === "undefined" || options.jobs > 1)
   ) {
-    debug('attempting to enable parallel mode');
+    debug("attempting to enable parallel mode");
     this.parallelMode(true);
   }
 }
@@ -302,10 +302,10 @@ Mocha.prototype.addFile = function (file) {
  * mocha.reporter('xunit', { output: '/path/to/testspec.xunit.xml' });
  */
 Mocha.prototype.reporter = function (reporterName, reporterOptions) {
-  if (typeof reporterName === 'function') {
+  if (typeof reporterName === "function") {
     this._reporter = reporterName;
   } else {
-    reporterName = reporterName || 'spec';
+    reporterName = reporterName || "spec";
     var reporter;
     // Try to load a built-in reporter.
     if (builtinReporters[reporterName]) {
@@ -350,10 +350,10 @@ Mocha.prototype.reporter = function (reporterName, reporterOptions) {
  */
 Mocha.prototype.ui = function (ui) {
   var bindInterface;
-  if (typeof ui === 'function') {
+  if (typeof ui === "function") {
     bindInterface = ui;
   } else {
-    ui = ui || 'bdd';
+    ui = ui || "bdd";
     bindInterface = exports.interfaces[ui];
     if (!bindInterface) {
       try {
@@ -421,7 +421,7 @@ Mocha.prototype.loadFiles = function (fn) {
  *   .then(() => mocha.run(failures => process.exitCode = failures ? 1 : 0))
  *   .catch(() => process.exitCode = 1);
  */
-Mocha.prototype.loadFilesAsync = function ({esmDecorator} = {}) {
+Mocha.prototype.loadFilesAsync = function ({ esmDecorator } = {}) {
   var self = this;
   var suite = this.suite;
   this.lazyLoadFiles(true);
@@ -435,7 +435,7 @@ Mocha.prototype.loadFilesAsync = function ({esmDecorator} = {}) {
       suite.emit(EVENT_FILE_REQUIRE, resultModule, file, self);
       suite.emit(EVENT_FILE_POST_REQUIRE, global, file, self);
     },
-    esmDecorator
+    esmDecorator,
   );
 };
 
@@ -450,10 +450,10 @@ Mocha.prototype.loadFilesAsync = function ({esmDecorator} = {}) {
 Mocha.unloadFile = function (file) {
   if (utils.isBrowser()) {
     throw createUnsupportedError(
-      'unloadFile() is only supported in a Node.js environment'
+      "unloadFile() is only supported in a Node.js environment",
     );
   }
-  return require('./nodejs/file-unloader').unloadFile(file);
+  return require("./nodejs/file-unloader").unloadFile(file);
 };
 
 /**
@@ -474,9 +474,9 @@ Mocha.unloadFile = function (file) {
 Mocha.prototype.unloadFiles = function () {
   if (this._state === mochaStates.DISPOSED) {
     throw createMochaInstanceAlreadyDisposedError(
-      'Mocha instance is already disposed, it cannot be used again.',
+      "Mocha instance is already disposed, it cannot be used again.",
       this._cleanReferencesAfterRun,
-      this
+      this,
     );
   }
 
@@ -606,7 +606,7 @@ Mocha.prototype.cleanReferencesAfterRun = function (cleanReferencesAfterRun) {
 Mocha.prototype.dispose = function () {
   if (this._state === mochaStates.RUNNING) {
     throw createMochaInstanceAlreadyRunningError(
-      'Cannot dispose while the mocha instance is still running tests.'
+      "Cannot dispose while the mocha instance is still running tests.",
     );
   }
   this.unloadFiles();
@@ -861,7 +861,7 @@ Mocha.prototype.failZero = function (failZero) {
  * @return {Mocha} this
  * @chainable
  */
-Mocha.prototype.passOnFailingTestSuite = function(passOnFailingTestSuite) {
+Mocha.prototype.passOnFailingTestSuite = function (passOnFailingTestSuite) {
   this.options.passOnFailingTestSuite = passOnFailingTestSuite === true;
   return this;
 };
@@ -901,8 +901,8 @@ Mocha.prototype.forbidPending = function (forbidPending) {
 Mocha.prototype._guardRunningStateTransition = function () {
   if (this._state === mochaStates.RUNNING) {
     throw createMochaInstanceAlreadyRunningError(
-      'Mocha instance is currently running tests, cannot start a next test run until this one is done',
-      this
+      "Mocha instance is currently running tests, cannot start a next test run until this one is done",
+      this,
     );
   }
   if (
@@ -910,9 +910,9 @@ Mocha.prototype._guardRunningStateTransition = function () {
     this._state === mochaStates.REFERENCES_CLEANED
   ) {
     throw createMochaInstanceAlreadyDisposedError(
-      'Mocha instance is already disposed, cannot start a new test run. Please create a new mocha instance. Be sure to set disable `cleanReferencesAfterRun` when you want to reuse the same mocha instance for multiple test runs.',
+      "Mocha instance is already disposed, cannot start a new test run. Please create a new mocha instance. Be sure to set disable `cleanReferencesAfterRun` when you want to reuse the same mocha instance for multiple test runs.",
       this._cleanReferencesAfterRun,
-      this
+      this,
     );
   }
 };
@@ -924,11 +924,11 @@ Mocha.prototype._guardRunningStateTransition = function () {
  * @type string
  * @readonly
  */
-Object.defineProperty(Mocha.prototype, 'version', {
-  value: require('../package.json').version,
+Object.defineProperty(Mocha.prototype, "version", {
+  value: require("../package.json").version,
   configurable: false,
   enumerable: true,
-  writable: false
+  writable: false,
 });
 
 /**
@@ -966,7 +966,7 @@ Mocha.prototype.run = function (fn) {
     cleanReferencesAfterRun: this._cleanReferencesAfterRun,
     delay: options.delay,
     dryRun: options.dryRun,
-    failZero: options.failZero
+    failZero: options.failZero,
   });
   createStatsCollector(runner);
   var reporter = new this._reporter(runner, options);
@@ -988,30 +988,30 @@ Mocha.prototype.run = function (fn) {
   exports.reporters.Base.inlineDiffs = options.inlineDiffs;
   exports.reporters.Base.hideDiff = !options.diff;
 
-  const done = failures => {
+  const done = (failures) => {
     this._previousRunner = runner;
     this._state = this._cleanReferencesAfterRun
       ? mochaStates.REFERENCES_CLEANED
       : mochaStates.INIT;
     fn = fn || utils.noop;
-    if (typeof reporter.done === 'function') {
+    if (typeof reporter.done === "function") {
       reporter.done(failures, fn);
     } else {
       fn(failures);
     }
   };
 
-  const runAsync = async runner => {
+  const runAsync = async (runner) => {
     const context =
       this.options.enableGlobalSetup && this.hasGlobalSetupFixtures()
         ? await this.runGlobalSetup(runner)
         : {};
     const failureCount = await runner.runAsync({
       files: this.files,
-      options
+      options,
     });
     if (this.options.enableGlobalTeardown && this.hasGlobalTeardownFixtures()) {
-      await this.runGlobalTeardown(runner, {context});
+      await this.runGlobalTeardown(runner, { context });
     }
     return failureCount;
   };
@@ -1035,22 +1035,22 @@ Mocha.prototype.rootHooks = function rootHooks({
   beforeAll = [],
   beforeEach = [],
   afterAll = [],
-  afterEach = []
+  afterEach = [],
 } = {}) {
   beforeAll = utils.castArray(beforeAll);
   beforeEach = utils.castArray(beforeEach);
   afterAll = utils.castArray(afterAll);
   afterEach = utils.castArray(afterEach);
-  beforeAll.forEach(hook => {
+  beforeAll.forEach((hook) => {
     this.suite.beforeAll(hook);
   });
-  beforeEach.forEach(hook => {
+  beforeEach.forEach((hook) => {
     this.suite.beforeEach(hook);
   });
-  afterAll.forEach(hook => {
+  afterAll.forEach((hook) => {
     this.suite.afterAll(hook);
   });
-  afterEach.forEach(hook => {
+  afterEach.forEach((hook) => {
     this.suite.afterEach(hook);
   });
   return this;
@@ -1073,7 +1073,7 @@ Mocha.prototype.rootHooks = function rootHooks({
  */
 Mocha.prototype.parallelMode = function parallelMode(enable = true) {
   if (utils.isBrowser()) {
-    throw createUnsupportedError('parallel mode is only supported in Node.js');
+    throw createUnsupportedError("parallel mode is only supported in Node.js");
   }
   const parallel = Boolean(enable);
   if (
@@ -1085,14 +1085,14 @@ Mocha.prototype.parallelMode = function parallelMode(enable = true) {
   }
   if (this._state !== mochaStates.INIT) {
     throw createUnsupportedError(
-      'cannot change parallel mode after having called run()'
+      "cannot change parallel mode after having called run()",
     );
   }
   this.options.parallel = parallel;
 
   // swap Runner class
   this._runnerClass = parallel
-    ? require('./nodejs/parallel-buffered-runner')
+    ? require("./nodejs/parallel-buffered-runner")
     : exports.Runner;
 
   // lazyLoadFiles may have been set `true` otherwise (for ESM loading),
@@ -1112,7 +1112,7 @@ Mocha.prototype.parallelMode = function parallelMode(enable = true) {
  */
 Mocha.prototype.lazyLoadFiles = function lazyLoadFiles(enable) {
   this._lazyLoadFiles = enable === true;
-  debug('set lazy load to %s', enable);
+  debug("set lazy load to %s", enable);
   return this;
 };
 
@@ -1128,7 +1128,7 @@ Mocha.prototype.lazyLoadFiles = function lazyLoadFiles(enable) {
 Mocha.prototype.globalSetup = function globalSetup(setupFns = []) {
   setupFns = utils.castArray(setupFns);
   this.options.globalSetup = setupFns;
-  debug('configured %d global setup functions', setupFns.length);
+  debug("configured %d global setup functions", setupFns.length);
   return this;
 };
 
@@ -1144,7 +1144,7 @@ Mocha.prototype.globalSetup = function globalSetup(setupFns = []) {
 Mocha.prototype.globalTeardown = function globalTeardown(teardownFns = []) {
   teardownFns = utils.castArray(teardownFns);
   this.options.globalTeardown = teardownFns;
-  debug('configured %d global teardown functions', teardownFns.length);
+  debug("configured %d global teardown functions", teardownFns.length);
   return this;
 };
 
@@ -1159,11 +1159,11 @@ Mocha.prototype.globalTeardown = function globalTeardown(teardownFns = []) {
  * @returns {Promise<object>} Context object
  */
 Mocha.prototype.runGlobalSetup = async function runGlobalSetup(context = {}) {
-  const {globalSetup} = this.options;
+  const { globalSetup } = this.options;
   if (globalSetup && globalSetup.length) {
-    debug('run(): global setup starting');
+    debug("run(): global setup starting");
     await this._runGlobalFixtures(globalSetup, context);
-    debug('run(): global setup complete');
+    debug("run(): global setup complete");
   }
   return context;
 };
@@ -1179,14 +1179,14 @@ Mocha.prototype.runGlobalSetup = async function runGlobalSetup(context = {}) {
  * @returns {Promise<object>} Context object
  */
 Mocha.prototype.runGlobalTeardown = async function runGlobalTeardown(
-  context = {}
+  context = {},
 ) {
-  const {globalTeardown} = this.options;
+  const { globalTeardown } = this.options;
   if (globalTeardown && globalTeardown.length) {
-    debug('run(): global teardown starting');
+    debug("run(): global teardown starting");
     await this._runGlobalFixtures(globalTeardown, context);
   }
-  debug('run(): global teardown complete');
+  debug("run(): global teardown complete");
   return context;
 };
 
@@ -1199,7 +1199,7 @@ Mocha.prototype.runGlobalTeardown = async function runGlobalTeardown(
  */
 Mocha.prototype._runGlobalFixtures = async function _runGlobalFixtures(
   fixtureFns = [],
-  context = {}
+  context = {},
 ) {
   for await (const fixtureFn of fixtureFns) {
     await fixtureFn.call(context);
@@ -1229,7 +1229,7 @@ Mocha.prototype.enableGlobalSetup = function enableGlobalSetup(enabled = true) {
  * @returns {Mocha}
  */
 Mocha.prototype.enableGlobalTeardown = function enableGlobalTeardown(
-  enabled = true
+  enabled = true,
 ) {
   this.options.enableGlobalTeardown = Boolean(enabled);
   return this;

package/lib/nodejs/buffered-worker-pool.js

@@ -5,7 +5,7 @@
  * @module buffered-worker-pool
  */
 
-'use strict';
+"use strict";
 
 /**
  * @typedef {import('workerpool').WorkerPoolOptions} WorkerPoolOptions
@@ -13,13 +13,13 @@
  * @typedef {import('../types.d.ts').SerializedWorkerResult} SerializedWorkerResult
  */
 
-const serializeJavascript = require('serialize-javascript');
-const workerpool = require('workerpool');
-const {deserialize} = require('./serializer');
-const debug = require('debug')('mocha:parallel:buffered-worker-pool');
-const {createInvalidArgumentTypeError} = require('../errors');
+const serializeJavascript = require("serialize-javascript");
+const workerpool = require("workerpool");
+const { deserialize } = require("./serializer");
+const debug = require("debug")("mocha:parallel:buffered-worker-pool");
+const { createInvalidArgumentTypeError } = require("../errors");
 
-const WORKER_PATH = require.resolve('./worker.js');
+const WORKER_PATH = require.resolve("./worker.js");
 
 /**
  * A mapping of Mocha `Options` objects to serialized values.
@@ -36,11 +36,11 @@ let optionsCache = new WeakMap();
  */
 const WORKER_POOL_DEFAULT_OPTS = {
   // use child processes, not worker threads!
-  workerType: 'process',
+  workerType: "process",
   // ensure the same flags sent to `node` for this `mocha` invocation are passed
   // along to children
-  forkOpts: {execArgv: process.execArgv},
-  maxWorkers: workerpool.cpus - 1
+  forkOpts: { execArgv: process.execArgv },
+  maxWorkers: workerpool.cpus - 1,
 };
 
 /**
@@ -55,40 +55,40 @@ class BufferedWorkerPool {
   constructor(opts = {}) {
     const maxWorkers = Math.max(
       1,
-      typeof opts.maxWorkers === 'undefined'
+      typeof opts.maxWorkers === "undefined"
         ? WORKER_POOL_DEFAULT_OPTS.maxWorkers
-        : opts.maxWorkers
+        : opts.maxWorkers,
     );
 
     /* istanbul ignore next */
     if (workerpool.cpus < 2) {
       // TODO: decide whether we should warn
       debug(
-        'not enough CPU cores available to run multiple jobs; avoid --parallel on this machine'
+        "not enough CPU cores available to run multiple jobs; avoid --parallel on this machine",
       );
     } else if (maxWorkers >= workerpool.cpus) {
       // TODO: decide whether we should warn
       debug(
-        '%d concurrent job(s) requested, but only %d core(s) available',
+        "%d concurrent job(s) requested, but only %d core(s) available",
         maxWorkers,
-        workerpool.cpus
+        workerpool.cpus,
       );
     }
     /* istanbul ignore next */
     debug(
-      'run(): starting worker pool of max size %d, using node args: %s',
+      "run(): starting worker pool of max size %d, using node args: %s",
       maxWorkers,
-      process.execArgv.join(' ')
+      process.execArgv.join(" "),
     );
 
     let counter = 0;
-    const onCreateWorker = ({forkOpts}) => {
+    const onCreateWorker = ({ forkOpts }) => {
       return {
         forkOpts: {
           ...forkOpts,
           // adds an incremental id to all workers, which can be useful to allocate resources for each process
-          env: {...process.env, MOCHA_WORKER_ID: counter++}
-        }
+          env: { ...process.env, MOCHA_WORKER_ID: counter++ },
+        },
       };
     };
 
@@ -96,7 +96,7 @@ class BufferedWorkerPool {
       ...WORKER_POOL_DEFAULT_OPTS,
       ...opts,
       maxWorkers,
-      onCreateWorker
+      onCreateWorker,
     };
     this._pool = workerpool.pool(WORKER_PATH, this.options);
   }
@@ -109,7 +109,7 @@ class BufferedWorkerPool {
    */
   async terminate(force = false) {
     /* istanbul ignore next */
-    debug('terminate(): terminating with force = %s', force);
+    debug("terminate(): terminating with force = %s", force);
     return this._pool.terminate(force);
   }
 
@@ -124,15 +124,15 @@ class BufferedWorkerPool {
    * @returns {Promise<SerializedWorkerResult>}
    */
   async run(filepath, options = {}) {
-    if (!filepath || typeof filepath !== 'string') {
+    if (!filepath || typeof filepath !== "string") {
       throw createInvalidArgumentTypeError(
-        'Expected a non-empty filepath',
-        'filepath',
-        'string'
+        "Expected a non-empty filepath",
+        "filepath",
+        "string",
       );
     }
     const serializedOptions = BufferedWorkerPool.serializeOptions(options);
-    const result = await this._pool.exec('run', [filepath, serializedOptions]);
+    const result = await this._pool.exec("run", [filepath, serializedOptions]);
     return deserialize(result);
   }
 
@@ -167,14 +167,14 @@ class BufferedWorkerPool {
     if (!optionsCache.has(opts)) {
       const serialized = serializeJavascript(opts, {
         unsafe: true, // this means we don't care about XSS
-        ignoreFunction: true // do not serialize functions
+        ignoreFunction: true, // do not serialize functions
       });
       optionsCache.set(opts, serialized);
       /* istanbul ignore next */
       debug(
-        'serializeOptions(): serialized options %O to: %s',
+        "serializeOptions(): serialized options %O to: %s",
         opts,
-        serialized
+        serialized,
       );
     }
     return optionsCache.get(opts);