mocha 11.7.4 → 11.7.6

package/lib/nodejs/esm-utils.js

@@ -1,8 +1,8 @@
-const path = require('node:path');
-const url = require('node:url');
-const debug = require('debug')('mocha:esm-utils');
+const path = require("node:path");
+const url = require("node:url");
+const debug = require("debug")("mocha:esm-utils");
 
-const forward = x => x;
+const forward = (x) => x;
 
 const formattedImport = async (file, esmDecorator = forward) => {
   if (path.isAbsolute(file)) {
@@ -23,7 +23,7 @@ const formattedImport = async (file, esmDecorator = forward) => {
         const newErrorWithFilename = new SyntaxError(err.message);
         newErrorWithFilename.stack = err.stack.replace(
           /^SyntaxError/,
-          `SyntaxError[ @${file} ]`
+          `SyntaxError[ @${file} ]`,
         );
         throw newErrorWithFilename;
       }
@@ -33,23 +33,23 @@ const formattedImport = async (file, esmDecorator = forward) => {
   return exports.doImport(esmDecorator(file));
 };
 
-exports.doImport = async file => import(file);
+exports.doImport = async (file) => import(file);
 
 // When require(esm) is not available, we need to use `import()` to load ESM modules.
 // In this case, CJS modules are loaded using `import()` as well. When Node.js' builtin
 // TypeScript support is enabled, `.ts` files are also loaded using `import()`, and
 // compilers based on `require.extensions` are omitted.
 const tryImportAndRequire = async (file, esmDecorator) => {
-  if (path.extname(file) === '.mjs') {
+  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'
+      err.code === "ERR_MODULE_NOT_FOUND" ||
+      err.code === "ERR_UNKNOWN_FILE_EXTENSION" ||
+      err.code === "ERR_UNSUPPORTED_DIR_IMPORT"
     ) {
       try {
         // Importing a file usually works, but the resolution of `import` is the ESM
@@ -58,11 +58,11 @@ const tryImportAndRequire = async (file, esmDecorator) => {
         return require(file);
       } catch (requireErr) {
         if (
-          requireErr.code === 'ERR_REQUIRE_ESM' ||
+          requireErr.code === "ERR_REQUIRE_ESM" ||
           (requireErr instanceof SyntaxError &&
             requireErr
               .toString()
-              .includes('Cannot use import statement outside a module'))
+              .includes("Cannot use import statement outside a module"))
         ) {
           // ERR_REQUIRE_ESM happens when the test file is a JS file, but via type:module is actually ESM,
           // AND has an import to a file that doesn't exist.
@@ -91,13 +91,13 @@ const tryImportAndRequire = async (file, esmDecorator) => {
 // and `require.cache` effective, while allowing us to load ESM modules
 // and CJS modules in the same way.
 const requireModule = async (file, esmDecorator) => {
-  if (path.extname(file) === '.mjs') {
+  if (path.extname(file) === ".mjs") {
     return formattedImport(file, esmDecorator);
   }
   try {
     return require(file);
   } catch (requireErr) {
-    debug('requireModule caught err: %O', requireErr.message);
+    debug("requireModule caught err: %O", requireErr.message);
     try {
       return dealWithExports(await formattedImport(file, esmDecorator));
     } catch (importErr) {
@@ -106,8 +106,8 @@ const requireModule = async (file, esmDecorator) => {
       // What we actually care about is the original require() error.
       // See: https://github.com/mochajs/mocha/issues/5393
       if (
-        /\.(cts|mts|ts)$/.test(file) ||
-        importErr.code === 'ERR_UNKNOWN_FILE_EXTENSION'
+        /\.(cts|mts|ts)$/.test(file) &&
+        importErr.code === "ERR_UNKNOWN_FILE_EXTENSION"
       ) {
         throw requireErr;
       }
@@ -115,7 +115,7 @@ const requireModule = async (file, esmDecorator) => {
       // Similarly, for an exports/imports mismatch such as a missing 'default',
       // the require() error will be more informative for users.
       // See: https://github.com/mochajs/mocha/issues/5411
-      if (importErr.code === 'ERR_INTERNAL_ASSERTION') {
+      if (importErr.code === "ERR_INTERNAL_ASSERTION") {
         throw requireErr;
       }
 
@@ -126,7 +126,10 @@ const requireModule = async (file, esmDecorator) => {
 
 // We only assign this `requireOrImport` function once based on Node version
 // We check for file extensions in `requireModule` and `tryImportAndRequire`
-debug('assigning requireOrImport, require_module === %O', process.features.require_module);
+debug(
+  "assigning requireOrImport, require_module === %O",
+  process.features.require_module,
+);
 if (process.features.require_module) {
   exports.requireOrImport = requireModule;
 } else {
@@ -137,7 +140,7 @@ function dealWithExports(module) {
   if (module.default) {
     return module.default;
   } else {
-    return {...module, default: undefined};
+    return { ...module, default: undefined };
   }
 }
 
@@ -145,13 +148,13 @@ exports.loadFilesAsync = async (
   files,
   preLoadFunc,
   postLoadFunc,
-  esmDecorator
+  esmDecorator,
 ) => {
   for (const file of files) {
     preLoadFunc(file);
     const result = await exports.requireOrImport(
       path.resolve(file),
-      esmDecorator
+      esmDecorator,
     );
     postLoadFunc(file, result);
   }

package/lib/nodejs/file-unloader.js

@@ -1,4 +1,4 @@
-'use strict';
+"use strict";
 
 /**
  * This module should not be in the browser bundle, so it's here.
@@ -10,6 +10,6 @@
  * Deletes a file from the `require` cache.
  * @param {string} file - File
  */
-exports.unloadFile = file => {
+exports.unloadFile = (file) => {
   delete require.cache[require.resolve(file)];
 };

package/lib/nodejs/parallel-buffered-runner.js

@@ -4,7 +4,7 @@
  * @private
  */
 
-'use strict';
+"use strict";
 
 /**
  * @typedef {import('../types.d.ts').FileRunner} FileRunner
@@ -13,29 +13,29 @@
  * @typedef {import('../types.d.ts').SigIntListener} SigIntListener
  */
 
-const Runner = require('../runner');
-const {EVENT_RUN_BEGIN, EVENT_RUN_END} = Runner.constants;
-const debug = require('debug')('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 Runner = require("../runner");
+const { EVENT_RUN_BEGIN, EVENT_RUN_END } = Runner.constants;
+const debug = require("debug")("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'
+  "./reporters/parallel-buffered",
 );
 
 /**
  * List of options to _not_ serialize for transmission to workers
  */
 const DENY_OPTIONS = [
-  'globalSetup',
-  'globalTeardown',
-  'parallel',
-  'p',
-  'jobs',
-  'j'
+  "globalSetup",
+  "globalTeardown",
+  "parallel",
+  "p",
+  "jobs",
+  "j",
 ];
 
 /**
@@ -43,14 +43,14 @@ const DENY_OPTIONS = [
  * @param {BufferedWorkerPool} pool - Worker pool
  */
 /* istanbul ignore next */
-const debugStats = pool => {
-  const {totalWorkers, busyWorkers, idleWorkers, pendingTasks} = pool.stats();
+const debugStats = (pool) => {
+  const { totalWorkers, busyWorkers, idleWorkers, pendingTasks } = pool.stats();
   debug(
-    '%d/%d busy workers; %d idle; %d tasks queued',
+    "%d/%d busy workers; %d idle; %d tasks queued",
     busyWorkers,
     totalWorkers,
     idleWorkers,
-    pendingTasks
+    pendingTasks,
   );
 };
 
@@ -59,13 +59,13 @@ const debugStats = pool => {
  */
 const DEBUG_STATS_INTERVAL = 5000;
 
-const ABORTED = 'ABORTED';
-const IDLE = 'IDLE';
-const ABORTING = 'ABORTING';
-const RUNNING = 'RUNNING';
-const BAILING = 'BAILING';
-const BAILED = 'BAILED';
-const COMPLETE = 'COMPLETE';
+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]),
@@ -74,7 +74,7 @@ const states = createMap({
   [ABORTED]: new Set(),
   [ABORTING]: new Set([ABORTED]),
   [BAILING]: new Set([BAILED, ABORTING]),
-  [BAILED]: new Set([COMPLETE, ABORTING])
+  [BAILED]: new Set([COMPLETE, ABORTING]),
 });
 
 /**
@@ -87,7 +87,7 @@ class ParallelBufferedRunner extends Runner {
     super(...args);
 
     let state = IDLE;
-    Object.defineProperty(this, '_state', {
+    Object.defineProperty(this, "_state", {
       get() {
         return state;
       },
@@ -97,7 +97,7 @@ class ParallelBufferedRunner extends Runner {
         } else {
           throw new Error(`invalid state transition: ${state} => ${newState}`);
         }
-      }
+      },
     });
 
     this._workerReporter = DEFAULT_WORKER_REPORTER;
@@ -130,7 +130,7 @@ class ParallelBufferedRunner extends Runner {
         event.data._bail &&
         (failureCount || event.error)
       ) {
-        debug('run(): nonzero failure count & found bail flag');
+        debug("run(): nonzero failure count & found bail flag");
         // we need to let the events complete for this file, as the worker
         // should run any cleanup hooks
         this._state = BAILING;
@@ -141,13 +141,13 @@ class ParallelBufferedRunner extends Runner {
      * 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'}];
+    const linkEvent = (event) => {
+      const stack = [{ parent: event, prop: "data" }];
       while (stack.length) {
-        const {parent, prop} = stack.pop();
+        const { parent, prop } = stack.pop();
         const obj = parent[prop];
         let newObj;
-        if (obj && typeof obj === 'object') {
+        if (obj && typeof obj === "object") {
           if (obj[MOCHA_ID_PROP_NAME]) {
             const id = obj[MOCHA_ID_PROP_NAME];
             newObj = this._linkedObjectMap.has(id)
@@ -157,24 +157,24 @@ class ParallelBufferedRunner extends Runner {
             parent[prop] = newObj;
           } else {
             throw createFatalError(
-              'Object missing ID received in event data',
-              obj
+              "Object missing ID received in event data",
+              obj,
             );
           }
         }
-        Object.keys(newObj).forEach(key => {
+        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});
+          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);
+    return async (file) => {
+      debug("run(): enqueueing test file %s", file);
       try {
-        const {failureCount, events} = await pool.run(file, options);
+        const { failureCount, events } = await pool.run(file, options);
 
         if (this._state === BAILED) {
           // short-circuit after a graceful bail. if this happens,
@@ -184,10 +184,10 @@ class ParallelBufferedRunner extends Runner {
           return;
         }
         debug(
-          'run(): completed run of file %s; %d failures / %d events',
+          "run(): completed run of file %s; %d failures / %d events",
           file,
           failureCount,
-          events.length
+          events.length,
         );
         this.failures += failureCount; // can this ever be non-numeric?
         let event = events.shift();
@@ -212,12 +212,12 @@ class ParallelBufferedRunner extends Runner {
       } catch (err) {
         if (this._state === BAILED || this._state === ABORTING) {
           debug(
-            'run(): worker pool terminated with intent; skipping file %s',
-            file
+            "run(): worker pool terminated with intent; skipping file %s",
+            file,
           );
         } else {
           // this is an uncaught exception
-          debug('run(): encountered uncaught exception: %O', err);
+          debug("run(): encountered uncaught exception: %O", err);
           if (this.allowUncaught) {
             // still have to clean up
             this._state = ABORTING;
@@ -226,7 +226,7 @@ class ParallelBufferedRunner extends Runner {
           throw err;
         }
       } finally {
-        debug('run(): done running file %s', file);
+        debug("run(): done running file %s", file);
       }
     };
   }
@@ -240,27 +240,27 @@ class ParallelBufferedRunner extends Runner {
    */
   _bindSigIntListener(pool) {
     const sigIntListener = async () => {
-      debug('run(): caught a SIGINT');
+      debug("run(): caught a SIGINT");
       this._state = ABORTING;
 
       try {
-        debug('run(): force-terminating worker pool');
+        debug("run(): force-terminating worker pool");
         await pool.terminate(true);
       } catch (err) {
         console.error(
-          `Error while attempting to force-terminate worker pool: ${err}`
+          `Error while attempting to force-terminate worker pool: ${err}`,
         );
         process.exitCode = 1;
       } finally {
         process.nextTick(() => {
-          debug('run(): imminent death');
+          debug("run(): imminent death");
           this._state = ABORTED;
-          process.kill(process.pid, 'SIGINT');
+          process.kill(process.pid, "SIGINT");
         });
       }
     };
 
-    process.once('SIGINT', sigIntListener);
+    process.once("SIGINT", sigIntListener);
 
     return sigIntListener;
   }
@@ -279,7 +279,7 @@ class ParallelBufferedRunner extends Runner {
    * number of test failures.
    * @param {RunnerOptions} [opts] - options
    */
-  run(callback, {files, options = {}} = {}) {
+  run(callback, { files, options = {} } = {}) {
     /**
      * Listener on `Process.SIGINT` which tries to cleanly terminate the worker pool.
      */
@@ -287,7 +287,7 @@ class ParallelBufferedRunner extends Runner {
 
     // assign the reporter the worker will use, which will be different than the
     // main process' reporter
-    options = {...options, reporter: this._workerReporter};
+    options = { ...options, reporter: this._workerReporter };
 
     // This function should _not_ return a `Promise`; its parent (`Runner#run`)
     // returns this instance, so this should do the same. However, we want to make
@@ -304,14 +304,14 @@ class ParallelBufferedRunner extends Runner {
       let pool;
 
       try {
-        pool = BufferedWorkerPool.create({maxWorkers: options.jobs});
+        pool = BufferedWorkerPool.create({ maxWorkers: options.jobs });
 
         sigIntListener = this._bindSigIntListener(pool);
 
         /* istanbul ignore next */
         debugInterval = setInterval(
           () => debugStats(pool),
-          DEBUG_STATS_INTERVAL
+          DEBUG_STATS_INTERVAL,
         ).unref();
 
         // this is set for uncaught exception handling in `Runner#uncaught`
@@ -321,21 +321,21 @@ class ParallelBufferedRunner extends Runner {
 
         this.emit(EVENT_RUN_BEGIN);
 
-        options = {...options};
-        DENY_OPTIONS.forEach(opt => {
+        options = { ...options };
+        DENY_OPTIONS.forEach((opt) => {
           delete options[opt];
         });
 
         const results = await Promise.allSettled(
-          files.map(this._createFileRunner(pool, options))
+          files.map(this._createFileRunner(pool, options)),
         );
 
         // note that pool may already be terminated due to --bail
         await pool.terminate();
 
         results
-          .filter(({status}) => status === 'rejected')
-          .forEach(({reason}) => {
+          .filter(({ status }) => status === "rejected")
+          .forEach(({ reason }) => {
             if (this.allowUncaught) {
               // yep, just the first one.
               throw reason;
@@ -350,19 +350,19 @@ class ParallelBufferedRunner extends Runner {
         }
 
         this.emit(EVENT_RUN_END);
-        debug('run(): completing with failure count %d', this.failures);
+        debug("run(): completing with failure count %d", this.failures);
         callback(this.failures);
       } catch (err) {
         // this `nextTick` takes us out of the `Promise` scope, so the
         // exception will not be caught and returned as a rejected `Promise`,
         // which would lead to an `unhandledRejection` event.
         process.nextTick(() => {
-          debug('run(): re-throwing uncaught exception');
+          debug("run(): re-throwing uncaught exception");
           throw err;
         });
       } finally {
         clearInterval(debugInterval);
-        process.removeListener('SIGINT', sigIntListener);
+        process.removeListener("SIGINT", sigIntListener);
       }
     })();
     return this;

package/lib/nodejs/reporters/parallel-buffered.js

@@ -4,7 +4,7 @@
  * @public
  */
 
-'use strict';
+"use strict";
 
 /**
  * @typedef {import('../../types.d.ts').BufferedEvent} BufferedEvent
@@ -28,11 +28,14 @@ const {
   EVENT_DELAY_END,
   EVENT_HOOK_BEGIN,
   EVENT_HOOK_END,
-  EVENT_RUN_END
-} = require('../../runner').constants;
-const {SerializableEvent, SerializableWorkerResult} = require('../serializer');
-const debug = require('debug')('mocha:reporters:buffered');
-const Base = require('../../reporters/base');
+  EVENT_RUN_END,
+} = require("../../runner").constants;
+const {
+  SerializableEvent,
+  SerializableWorkerResult,
+} = require("../serializer");
+const debug = require("debug")("mocha:reporters:buffered");
+const Base = require("../../reporters/base");
 
 /**
  * List of events to listen to; these will be buffered and sent
@@ -48,7 +51,7 @@ const EVENT_NAMES = [
   EVENT_TEST_RETRY,
   EVENT_TEST_END,
   EVENT_HOOK_BEGIN,
-  EVENT_HOOK_END
+  EVENT_HOOK_END,
 ];
 
 /**
@@ -122,15 +125,15 @@ class ParallelBuffered extends Base {
    * @chainable
    */
   createListeners(runner) {
-    EVENT_NAMES.forEach(evt => {
+    EVENT_NAMES.forEach((evt) => {
       runner.on(evt, this.createListener(evt));
     });
-    ONCE_EVENT_NAMES.forEach(evt => {
+    ONCE_EVENT_NAMES.forEach((evt) => {
       runner.once(evt, this.createListener(evt));
     });
 
     runner.once(EVENT_RUN_END, () => {
-      debug('received EVENT_RUN_END');
+      debug("received EVENT_RUN_END");
       this.listeners.forEach((listener, evt) => {
         runner.removeListener(evt, listener);
         this.listeners.delete(evt);