mocha 11.7.4 → 11.7.6

package/lib/nodejs/serializer.js

@@ -4,21 +4,21 @@
  * @private
  */
 
-'use strict';
+"use strict";
 
 /**
  * @typedef {import('../types.d.ts').SerializedEvent} SerializedEvent
  * @typedef {import('../types.d.ts').SerializedWorkerResult} SerializedWorkerResult
  */
 
-const {type, breakCircularDeps} = require('../utils');
-const {createInvalidArgumentTypeError} = require('../errors');
+const { type, breakCircularDeps } = require("../utils");
+const { createInvalidArgumentTypeError } = require("../errors");
 // this is not named `mocha:parallel:serializer` because it's noisy and it's
 // helpful to be able to write `DEBUG=mocha:parallel*` and get everything else.
-const debug = require('debug')('mocha:serializer');
+const debug = require("debug")("mocha:serializer");
 
-const SERIALIZABLE_RESULT_NAME = 'SerializableWorkerResult';
-const SERIALIZABLE_TYPES = new Set(['object', 'array', 'function', 'error']);
+const SERIALIZABLE_RESULT_NAME = "SerializableWorkerResult";
+const SERIALIZABLE_TYPES = new Set(["object", "array", "function", "error"]);
 
 /**
  * The serializable result of a test file run from a worker.
@@ -51,10 +51,10 @@ class SerializableWorkerResult {
      * this object (once it's been received over IPC).
      * @type {Readonly<"SerializableWorkerResult">}
      */
-    Object.defineProperty(this, '__type', {
+    Object.defineProperty(this, "__type", {
       value: SERIALIZABLE_RESULT_NAME,
       enumerable: true,
-      writable: false
+      writable: false,
     });
   }
 
@@ -73,7 +73,7 @@ class SerializableWorkerResult {
    * @returns {Readonly<SerializableWorkerResult>}
    */
   serialize() {
-    this.events.forEach(event => {
+    this.events.forEach((event) => {
       event.serialize();
     });
     return Object.freeze(this);
@@ -87,7 +87,7 @@ class SerializableWorkerResult {
    * @returns {SerializedWorkerResult}
    */
   static deserialize(obj) {
-    obj.events.forEach(event => {
+    obj.events.forEach((event) => {
       SerializableEvent.deserialize(event);
     });
     return obj;
@@ -102,7 +102,7 @@ class SerializableWorkerResult {
   static isSerializedWorkerResult(value) {
     return (
       value instanceof SerializableWorkerResult ||
-      (type(value) === 'object' && value.__type === SERIALIZABLE_RESULT_NAME)
+      (type(value) === "object" && value.__type === SERIALIZABLE_RESULT_NAME)
     );
   }
 }
@@ -137,9 +137,9 @@ class SerializableEvent {
   constructor(eventName, originalValue, originalError) {
     if (!eventName) {
       throw createInvalidArgumentTypeError(
-        'Empty `eventName` string argument',
-        'eventName',
-        'string'
+        "Empty `eventName` string argument",
+        "eventName",
+        "string",
       );
     }
     /**
@@ -148,20 +148,20 @@ class SerializableEvent {
      */
     this.eventName = eventName;
     const originalValueType = type(originalValue);
-    if (originalValueType !== 'object' && originalValueType !== 'undefined') {
+    if (originalValueType !== "object" && originalValueType !== "undefined") {
       throw createInvalidArgumentTypeError(
         `Expected object but received ${originalValueType}`,
-        'originalValue',
-        'object'
+        "originalValue",
+        "object",
       );
     }
     /**
      * An error, if present.
      * @memberof SerializableEvent
      */
-    Object.defineProperty(this, 'originalError', {
+    Object.defineProperty(this, "originalError", {
       value: originalError,
-      enumerable: false
+      enumerable: false,
     });
 
     /**
@@ -171,9 +171,9 @@ class SerializableEvent {
      *
      * @memberof SerializableEvent
      */
-    Object.defineProperty(this, 'originalValue', {
+    Object.defineProperty(this, "originalValue", {
       value: originalValue,
-      enumerable: false
+      enumerable: false,
     });
   }
 
@@ -197,44 +197,44 @@ class SerializableEvent {
   static _serialize(pairs, parent, key) {
     let value = parent[key];
     let _type = type(value);
-    if (_type === 'error') {
+    if (_type === "error") {
       // we need to reference the stack prop b/c it's lazily-loaded.
       // `__type` is necessary for deserialization to create an `Error` later.
       // `message` is apparently not enumerable, so we must handle it specifically.
       value = Object.assign(Object.create(null), value, {
         stack: value.stack,
         message: value.message,
-        __type: 'Error'
+        __type: "Error",
       });
       parent[key] = value;
       // after this, set the result of type(value) to be `object`, and we'll throw
       // whatever other junk is in the original error into the new `value`.
-      _type = 'object';
+      _type = "object";
     }
     switch (_type) {
-      case 'object':
-        if (type(value.serialize) === 'function') {
+      case "object":
+        if (type(value.serialize) === "function") {
           parent[key] = value.serialize();
         } else {
           // by adding props to the `pairs` array, we will process it further
           pairs.push(
             ...Object.keys(value)
-              .filter(key => SERIALIZABLE_TYPES.has(type(value[key])))
-              .map(key => [value, key])
+              .filter((key) => SERIALIZABLE_TYPES.has(type(value[key])))
+              .map((key) => [value, key]),
           );
         }
         break;
-      case 'function':
+      case "function":
         // we _may_ want to dig in to functions for some assertion libraries
         // that might put a usable property on a function.
         // for now, just zap it.
         delete parent[key];
         break;
-      case 'array':
+      case "array":
         pairs.push(
           ...value
-            .filter(value => SERIALIZABLE_TYPES.has(type(value)))
-            .map((value, index) => [value, index])
+            .filter((value) => SERIALIZABLE_TYPES.has(type(value)))
+            .map((value, index) => [value, index]),
         );
         break;
     }
@@ -256,17 +256,17 @@ class SerializableEvent {
     const originalValue = this.originalValue;
     const result = Object.assign(Object.create(null), {
       data:
-        type(originalValue) === 'object' &&
-        type(originalValue.serialize) === 'function'
+        type(originalValue) === "object" &&
+        type(originalValue.serialize) === "function"
           ? originalValue.serialize()
           : originalValue,
-      error: this.originalError
+      error: this.originalError,
     });
 
     // mutates the object
     breakCircularDeps(result.error);
 
-    const pairs = Object.keys(result).map(key => [result, key]);
+    const pairs = Object.keys(result).map((key) => [result, key]);
     const seenPairs = new Set();
     let pair;
 
@@ -307,7 +307,7 @@ class SerializableEvent {
    * @param {string|number} key - Some prop name or array index within `parent`
    */
   static _deserializeObject(parent, key) {
-    if (key === '__proto__') {
+    if (key === "__proto__") {
       delete parent[key];
       return;
     }
@@ -315,21 +315,21 @@ class SerializableEvent {
     // keys beginning with `$$` are converted into functions returning the value
     // and renamed, stripping the `$$` prefix.
     // functions defined this way cannot be array members!
-    if (type(key) === 'string' && key.startsWith('$$')) {
+    if (type(key) === "string" && key.startsWith("$$")) {
       const newKey = key.slice(2);
       parent[newKey] = () => value;
       delete parent[key];
       key = newKey;
     }
-    if (type(value) === 'array') {
+    if (type(value) === "array") {
       value.forEach((_, idx) => {
         SerializableEvent._deserializeObject(value, idx);
       });
-    } else if (type(value) === 'object') {
-      if (value.__type === 'Error') {
+    } else if (type(value) === "object") {
+      if (value.__type === "Error") {
         parent[key] = SerializableEvent._deserializeError(value);
       } else {
-        Object.keys(value).forEach(key => {
+        Object.keys(value).forEach((key) => {
           SerializableEvent._deserializeObject(value, key);
         });
       }
@@ -345,13 +345,13 @@ class SerializableEvent {
    */
   static deserialize(obj) {
     if (!obj) {
-      throw createInvalidArgumentTypeError('Expected value', obj);
+      throw createInvalidArgumentTypeError("Expected value", obj);
     }
 
     obj = Object.assign(Object.create(null), obj);
 
     if (obj.data) {
-      Object.keys(obj.data).forEach(key => {
+      Object.keys(obj.data).forEach((key) => {
         SerializableEvent._deserializeObject(obj.data, key);
       });
     }
@@ -373,10 +373,10 @@ class SerializableEvent {
  */
 exports.serialize = function serialize(value) {
   const result =
-    type(value) === 'object' && type(value.serialize) === 'function'
+    type(value) === "object" && type(value.serialize) === "function"
       ? value.serialize()
       : value;
-  debug('serialized: %O', result);
+  debug("serialized: %O", result);
   return result;
 };
 
@@ -392,7 +392,7 @@ exports.deserialize = function deserialize(value) {
   const result = SerializableWorkerResult.isSerializedWorkerResult(value)
     ? SerializableWorkerResult.deserialize(value)
     : value;
-  debug('deserialized: %O', result);
+  debug("deserialized: %O", result);
   return result;
 };
 

package/lib/nodejs/worker.js

@@ -4,7 +4,7 @@
  * @private
  */
 
-'use strict';
+"use strict";
 
 /**
  * @typedef {import('../types.d.ts').BufferedEvent} BufferedEvent
@@ -13,22 +13,22 @@
 
 const {
   createInvalidArgumentTypeError,
-  createInvalidArgumentValueError
-} = require('../errors');
-const workerpool = require('workerpool');
-const Mocha = require('../mocha');
-const {handleRequires, validateLegacyPlugin} = require('../cli/run-helpers');
-const d = require('debug');
+  createInvalidArgumentValueError,
+} = require("../errors");
+const workerpool = require("workerpool");
+const Mocha = require("../mocha");
+const { handleRequires, validateLegacyPlugin } = require("../cli/run-helpers");
+const d = require("debug");
 const debug = d.debug(`mocha:parallel:worker:${process.pid}`);
 const isDebugEnabled = d.enabled(`mocha:parallel:worker:${process.pid}`);
-const {serialize} = require('./serializer');
-const {setInterval, clearInterval} = global;
+const { serialize } = require("./serializer");
+const { setInterval, clearInterval } = global;
 
 let rootHooks;
 
 if (workerpool.isMainThread) {
   throw new Error(
-    'This script is intended to be run as a worker (by the `workerpool` package).'
+    "This script is intended to be run as a worker (by the `workerpool` package).",
   );
 }
 
@@ -43,16 +43,16 @@ if (workerpool.isMainThread) {
  *
  * @param {MochaOptions} argv - Command-line options
  */
-let bootstrap = async argv => {
+let bootstrap = async (argv) => {
   // globalSetup and globalTeardown do not run in workers
   const plugins = await handleRequires(argv.require, {
-    ignoredPlugins: ['mochaGlobalSetup', 'mochaGlobalTeardown']
+    ignoredPlugins: ["mochaGlobalSetup", "mochaGlobalTeardown"],
   });
-  validateLegacyPlugin(argv, 'ui', Mocha.interfaces);
+  validateLegacyPlugin(argv, "ui", Mocha.interfaces);
 
   rootHooks = plugins.rootHooks;
   bootstrap = () => {};
-  debug('bootstrap(): finished with args: %O', argv);
+  debug("bootstrap(): finished with args: %O", argv);
 };
 
 /**
@@ -63,43 +63,43 @@ let bootstrap = async argv => {
  * @returns {Promise<{failures: number, events: BufferedEvent[]}>} - Test
  * failure count and list of events.
  */
-async function run(filepath, serializedOptions = '{}') {
+async function run(filepath, serializedOptions = "{}") {
   if (!filepath) {
     throw createInvalidArgumentTypeError(
       'Expected a non-empty "filepath" argument',
-      'file',
-      'string'
+      "file",
+      "string",
     );
   }
 
-  debug('run(): running test file %s', filepath);
+  debug("run(): running test file %s", filepath);
 
-  if (typeof serializedOptions !== 'string') {
+  if (typeof serializedOptions !== "string") {
     throw createInvalidArgumentTypeError(
-      'run() expects second parameter to be a string which was serialized by the `serialize-javascript` module',
-      'serializedOptions',
-      'string'
+      "run() expects second parameter to be a string which was serialized by the `serialize-javascript` module",
+      "serializedOptions",
+      "string",
     );
   }
   let argv;
   try {
     // eslint-disable-next-line no-eval
-    argv = eval('(' + serializedOptions + ')');
+    argv = eval("(" + serializedOptions + ")");
   } catch (err) {
     throw createInvalidArgumentValueError(
-      'run() was unable to deserialize the options',
-      'serializedOptions',
-      serializedOptions
+      "run() was unable to deserialize the options",
+      "serializedOptions",
+      serializedOptions,
     );
   }
 
-  const opts = Object.assign({ui: 'bdd'}, argv, {
+  const opts = Object.assign({ ui: "bdd" }, argv, {
     // if this was true, it would cause infinite recursion.
     parallel: false,
     // this doesn't work in parallel mode
     forbidOnly: true,
     // it's useful for a Mocha instance to know if it's running in a worker process.
-    isWorker: true
+    isWorker: true,
   });
 
   await bootstrap(opts);
@@ -111,7 +111,7 @@ async function run(filepath, serializedOptions = '{}') {
   try {
     await mocha.loadFilesAsync();
   } catch (err) {
-    debug('run(): could not load file %s: %s', filepath, err);
+    debug("run(): could not load file %s: %s", filepath, err);
     throw err;
   }
 
@@ -120,25 +120,25 @@ async function run(filepath, serializedOptions = '{}') {
     /* istanbul ignore next */
     if (isDebugEnabled) {
       debugInterval = setInterval(() => {
-        debug('run(): still running %s...', filepath);
+        debug("run(): still running %s...", filepath);
       }, 5000).unref();
     }
-    mocha.run(result => {
+    mocha.run((result) => {
       // Runner adds these; if we don't remove them, we'll get a leak.
-      process.removeAllListeners('uncaughtException');
-      process.removeAllListeners('unhandledRejection');
+      process.removeAllListeners("uncaughtException");
+      process.removeAllListeners("unhandledRejection");
 
       try {
         const serialized = serialize(result);
         debug(
-          'run(): completed run with %d test failures; returning to main process',
-          typeof result.failures === 'number' ? result.failures : 0
+          "run(): completed run with %d test failures; returning to main process",
+          typeof result.failures === "number" ? result.failures : 0,
         );
         resolve(serialized);
       } catch (err) {
         // TODO: figure out exactly what the sad path looks like here.
         // rejection should only happen if an error is "unrecoverable"
-        debug('run(): serialization failed; rejecting: %O', err);
+        debug("run(): serialization failed; rejecting: %O", err);
         reject(err);
       } finally {
         clearInterval(debugInterval);
@@ -148,9 +148,9 @@ async function run(filepath, serializedOptions = '{}') {
 }
 
 // this registers the `run` function.
-workerpool.worker({run});
+workerpool.worker({ run });
 
-debug('started worker process');
+debug("started worker process");
 
 // for testing
 exports.run = run;

package/lib/pending.js

@@ -1,4 +1,4 @@
-'use strict';
+"use strict";
 
 /**
  @module Pending