mocha 9.2.0 → 10.0.0

package/lib/cli/commands.js

@@ -2,7 +2,7 @@
 
 /**
  * Exports Yargs commands
- * @see https://git.io/fpJ0G
+ * @see https://github.com/yargs/yargs/blob/main/docs/advanced.md
  * @private
  * @module
  */

package/lib/cli/config.js

@@ -30,10 +30,6 @@ exports.CONFIG_FILES = [
   '.mocharc.json'
 ];
 
-const isModuleNotFoundError = err =>
-  err.code === 'MODULE_NOT_FOUND' ||
-  err.message.indexOf('Cannot find module') !== -1;
-
 /**
  * Parsers for various config filetypes. Each accepts a filepath and
  * returns an object (but could throw)
@@ -41,17 +37,16 @@ const isModuleNotFoundError = err =>
 const parsers = (exports.parsers = {
   yaml: filepath => require('js-yaml').load(fs.readFileSync(filepath, 'utf8')),
   js: filepath => {
-    const cwdFilepath = path.resolve(filepath);
+    let cwdFilepath;
     try {
-      debug('parsers: load using cwd-relative path: "%s"', cwdFilepath);
+      debug('parsers: load cwd-relative path: "%s"', path.resolve(filepath));
+      cwdFilepath = require.resolve(path.resolve(filepath)); // evtl. throws
       return require(cwdFilepath);
     } catch (err) {
-      if (isModuleNotFoundError(err)) {
-        debug('parsers: retry load as module-relative path: "%s"', filepath);
-        return require(filepath);
-      } else {
-        throw err; // rethrow
-      }
+      if (cwdFilepath) throw err;
+
+      debug('parsers: retry load as module-relative path: "%s"', filepath);
+      return require(filepath);
     }
   },
   json: filepath =>

package/lib/cli/run-helpers.js

@@ -225,18 +225,18 @@ exports.validateLegacyPlugin = (opts, pluginType, map = {}) => {
 
   // if this exists, then it's already loaded, so nothing more to do.
   if (!map[pluginId]) {
+    let foundId;
     try {
-      map[pluginId] = require(pluginId);
+      foundId = require.resolve(pluginId);
+      map[pluginId] = require(foundId);
     } catch (err) {
-      if (err.code === 'MODULE_NOT_FOUND') {
-        // Try to load reporters from a path (absolute or relative)
-        try {
-          map[pluginId] = require(path.resolve(pluginId));
-        } catch (err) {
-          throw createUnknownError(err);
-        }
-      } else {
-        throw createUnknownError(err);
+      if (foundId) throw createUnknownError(err);
+
+      // Try to load reporters from a cwd-relative path
+      try {
+        map[pluginId] = require(path.resolve(pluginId));
+      } catch (e) {
+        throw createUnknownError(e);
       }
     }
   }

package/lib/cli/run-option-metadata.js

@@ -39,7 +39,6 @@ const TYPES = (exports.types = {
     'forbid-only',
     'forbid-pending',
     'full-trace',
-    'growl',
     'inline-diffs',
     'invert',
     'list-interfaces',
@@ -76,7 +75,6 @@ exports.aliases = {
   fgrep: ['f'],
   global: ['globals'],
   grep: ['g'],
-  growl: ['G'],
   ignore: ['exclude'],
   invert: ['i'],
   jobs: ['j'],

package/lib/cli/run.js

@@ -141,10 +141,6 @@ exports.builder = yargs =>
         group: GROUPS.FILTERS,
         requiresArg: true
       },
-      growl: {
-        description: 'Enable Growl notifications',
-        group: GROUPS.OUTPUT
-      },
       ignore: {
         defaultDescription: '(none)',
         description: 'Ignore file(s) or glob pattern(s)',
@@ -333,7 +329,7 @@ exports.builder = yargs =>
       if (argv.compilers) {
         throw createUnsupportedError(
           `--compilers is DEPRECATED and no longer supported.
-          See https://git.io/vdcSr for migration information.`
+          See https://github.com/mochajs/mocha/wiki/compilers-deprecation for migration information.`
         );
       }
 

package/lib/mocha.js

@@ -9,14 +9,12 @@
 var escapeRe = require('escape-string-regexp');
 var path = require('path');
 var builtinReporters = require('./reporters');
-var growl = require('./nodejs/growl');
 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 {
-  warn,
   createInvalidReporterError,
   createInvalidInterfaceError,
   createMochaInstanceAlreadyDisposedError,
@@ -166,7 +164,6 @@ exports.run = function (...args) {
  * @param {boolean} [options.fullTrace] - Full stacktrace upon failure?
  * @param {string[]} [options.global] - Variables expected in global scope.
  * @param {RegExp|string} [options.grep] - Test filter given regular expression.
- * @param {boolean} [options.growl] - Enable desktop notifications?
  * @param {boolean} [options.inlineDiffs] - Display inline diffs?
  * @param {boolean} [options.invert] - Invert test filter matches?
  * @param {boolean} [options.noHighlighting] - Disable syntax highlighting?
@@ -196,7 +193,7 @@ function Mocha(options = {}) {
     .ui(options.ui)
     .reporter(
       options.reporter,
-      options.reporterOption || options.reporterOptions // for backwards compability
+      options.reporterOption || options.reporterOptions // for backwards compatibility
     )
     .slow(options.slow)
     .global(options.global);
@@ -223,7 +220,6 @@ function Mocha(options = {}) {
     'forbidOnly',
     'forbidPending',
     'fullTrace',
-    'growl',
     'inlineDiffs',
     'invert'
   ].forEach(function (opt) {
@@ -335,35 +331,26 @@ Mocha.prototype.reporter = function (reporterName, reporterOptions) {
     }
     // Try to load reporters from process.cwd() and node_modules
     if (!reporter) {
+      let foundReporter;
       try {
-        reporter = require(reporterName);
+        foundReporter = require.resolve(reporterName);
+        reporter = require(foundReporter);
       } catch (err) {
-        if (err.code === 'MODULE_NOT_FOUND') {
-          // Try to load reporters from a path (absolute or relative)
-          try {
-            reporter = require(path.resolve(utils.cwd(), reporterName));
-          } catch (_err) {
-            _err.code === 'MODULE_NOT_FOUND'
-              ? warn(`'${reporterName}' reporter not found`)
-              : warn(
-                  `'${reporterName}' reporter blew up with error:\n ${err.stack}`
-                );
-          }
-        } else {
-          warn(`'${reporterName}' reporter blew up with error:\n ${err.stack}`);
+        if (foundReporter) {
+          throw createInvalidReporterError(err.message, foundReporter);
+        }
+        // Try to load reporters from a cwd-relative path
+        try {
+          reporter = require(path.resolve(reporterName));
+        } catch (e) {
+          throw createInvalidReporterError(e.message, reporterName);
         }
       }
     }
-    if (!reporter) {
-      throw createInvalidReporterError(
-        `invalid reporter '${reporterName}'`,
-        reporterName
-      );
-    }
     this._reporter = reporter;
   }
   this.options.reporterOption = reporterOptions;
-  // alias option name is used in public reporters xunit/tap/progress
+  // alias option name is used in built-in reporters xunit/tap/progress
   this.options.reporterOptions = reporterOptions;
   return this;
 };
@@ -478,7 +465,7 @@ Mocha.prototype.loadFilesAsync = function () {
 Mocha.unloadFile = function (file) {
   if (utils.isBrowser()) {
     throw createUnsupportedError(
-      'unloadFile() is only suported in a Node.js environment'
+      'unloadFile() is only supported in a Node.js environment'
     );
   }
   return require('./nodejs/file-unloader').unloadFile(file);
@@ -657,49 +644,6 @@ Mocha.prototype.fullTrace = function (fullTrace) {
   return this;
 };
 
-/**
- * Enables desktop notification support if prerequisite software installed.
- *
- * @public
- * @see [CLI option](../#-growl-g)
- * @return {Mocha} this
- * @chainable
- */
-Mocha.prototype.growl = function () {
-  this.options.growl = this.isGrowlCapable();
-  if (!this.options.growl) {
-    var detail = utils.isBrowser()
-      ? 'notification support not available in this browser...'
-      : 'notification support prerequisites not installed...';
-    console.error(detail + ' cannot enable!');
-  }
-  return this;
-};
-
-/**
- * @summary
- * Determines if Growl support seems likely.
- *
- * @description
- * <strong>Not available when run in browser.</strong>
- *
- * @private
- * @see {@link Growl#isCapable}
- * @see {@link Mocha#growl}
- * @return {boolean} whether Growl support can be expected
- */
-Mocha.prototype.isGrowlCapable = growl.isCapable;
-
-/**
- * Implements desktop notifications using a pseudo-reporter.
- *
- * @private
- * @see {@link Mocha#growl}
- * @see {@link Growl#notify}
- * @param {Runner} runner - Runner instance.
- */
-Mocha.prototype._growl = growl.notify;
-
 /**
  * Specifies whitelist of variable names to be expected in global scope.
  *
@@ -723,7 +667,7 @@ Mocha.prototype.global = function (global) {
     });
   return this;
 };
-// for backwards compability, 'globals' is an alias of 'global'
+// for backwards compatibility, 'globals' is an alias of 'global'
 Mocha.prototype.globals = Mocha.prototype.global;
 
 /**
@@ -1047,9 +991,6 @@ Mocha.prototype.run = function (fn) {
   if (options.global) {
     runner.globals(options.global);
   }
-  if (options.growl) {
-    this._growl(runner);
-  }
   if (options.color !== undefined) {
     exports.reporters.Base.useColors = options.color;
   }

package/lib/nodejs/esm-utils.js

@@ -10,7 +10,7 @@ const formattedImport = async file => {
       // the location of the syntax error in the error thrown.
       // This is problematic because the user can't see what file has the problem,
       // so we add the file location to the error.
-      // This `if` should be removed once Node.js fixes the problem.
+      // TODO: remove once Node.js fixes the problem.
       if (
         err instanceof SyntaxError &&
         err.message &&
@@ -30,64 +30,52 @@ const formattedImport = async file => {
   return import(file);
 };
 
-const hasStableEsmImplementation = (() => {
-  const [major, minor] = process.version.split('.');
-  // ESM is stable from v12.22.0 onward
-  // https://nodejs.org/api/esm.html#esm_modules_ecmascript_modules
-  const majorNumber = parseInt(major.slice(1), 10);
-  const minorNumber = parseInt(minor, 10);
-  return majorNumber > 12 || (majorNumber === 12 && minorNumber >= 22);
-})();
-
-exports.requireOrImport = hasStableEsmImplementation
-  ? async file => {
-      if (path.extname(file) === '.mjs') {
-        return formattedImport(file);
-      }
+exports.requireOrImport = async file => {
+  if (path.extname(file) === '.mjs') {
+    return formattedImport(file);
+  }
+  try {
+    return dealWithExports(await formattedImport(file));
+  } catch (err) {
+    if (
+      err.code === 'ERR_MODULE_NOT_FOUND' ||
+      err.code === 'ERR_UNKNOWN_FILE_EXTENSION' ||
+      err.code === 'ERR_UNSUPPORTED_DIR_IMPORT'
+    ) {
       try {
-        return dealWithExports(await formattedImport(file));
-      } catch (err) {
+        // Importing a file usually works, but the resolution of `import` is the ESM
+        // resolution algorithm, and not the CJS resolution algorithm. We may have
+        // failed because we tried the ESM resolution, so we try to `require` it.
+        return require(file);
+      } catch (requireErr) {
         if (
-          err.code === 'ERR_MODULE_NOT_FOUND' ||
-          err.code === 'ERR_UNKNOWN_FILE_EXTENSION' ||
-          err.code === 'ERR_UNSUPPORTED_DIR_IMPORT'
+          requireErr.code === 'ERR_REQUIRE_ESM' ||
+          (requireErr instanceof SyntaxError &&
+            requireErr
+              .toString()
+              .includes('Cannot use import statement outside a module'))
         ) {
-          try {
-            // Importing a file usually works, but the resolution of `import` is the ESM
-            // resolution algorithm, and not the CJS resolution algorithm. So in this case
-            // if we fail, we may have failed because we tried the ESM resolution and failed
-            // So we try to `require` it
-            return require(file);
-          } catch (requireErr) {
-            if (
-              requireErr.code === 'ERR_REQUIRE_ESM' ||
-              (requireErr instanceof SyntaxError &&
-                requireErr
-                  .toString()
-                  .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.
-              // This throws an `ERR_MODULE_NOT_FOUND` error above,
-              // and when we try to `require` it here, it throws an `ERR_REQUIRE_ESM`.
-              // What we want to do is throw the original error (the `ERR_MODULE_NOT_FOUND`),
-              // and not the `ERR_REQUIRE_ESM` error, which is a red herring.
-              //
-              // SyntaxError happens when in an edge case: when we're using an ESM loader that loads
-              // a `test.ts` file (i.e. unrecognized extension), and that file includes an unknown
-              // import (which thows an ERR_MODULE_NOT_FOUND). require-ing it will throw the
-              // syntax error, because we cannot require a file that has import-s.
-              throw err;
-            } else {
-              throw requireErr;
-            }
-          }
-        } else {
+          // 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.
+          // This throws an `ERR_MODULE_NOT_FOUND` error above,
+          // and when we try to `require` it here, it throws an `ERR_REQUIRE_ESM`.
+          // What we want to do is throw the original error (the `ERR_MODULE_NOT_FOUND`),
+          // and not the `ERR_REQUIRE_ESM` error, which is a red herring.
+          //
+          // SyntaxError happens when in an edge case: when we're using an ESM loader that loads
+          // a `test.ts` file (i.e. unrecognized extension), and that file includes an unknown
+          // import (which throws an ERR_MODULE_NOT_FOUND). `require`-ing it will throw the
+          // syntax error, because we cannot require a file that has `import`-s.
           throw err;
+        } else {
+          throw requireErr;
         }
       }
+    } else {
+      throw err;
     }
-  : implementationOfRequireOrImportForUnstableEsm;
+  }
+};
 
 function dealWithExports(module) {
   if (module.default) {
@@ -104,21 +92,3 @@ exports.loadFilesAsync = async (files, preLoadFunc, postLoadFunc) => {
     postLoadFunc(file, result);
   }
 };
-
-/* istanbul ignore next */
-async function implementationOfRequireOrImportForUnstableEsm(file) {
-  if (path.extname(file) === '.mjs') {
-    return formattedImport(file);
-  }
-  // This is currently the only known way of figuring out whether a file is CJS or ESM in
-  // Node.js that doesn't necessitate calling `import` first.
-  try {
-    return require(file);
-  } catch (err) {
-    if (err.code === 'ERR_REQUIRE_ESM') {
-      return formattedImport(file);
-    } else {
-      throw err;
-    }
-  }
-}

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

@@ -271,8 +271,9 @@ class ParallelBufferedRunner extends Runner {
    *
    * @param {Function} callback - Called with an exit code corresponding to
    * number of test failures.
-   * @param {{files: string[], options: Options}} opts - Files to run and
-   * command-line options, respectively.
+   * @param {Object} [opts] - options
+   * @param {string[]} opts.files - Files to run
+   * @param {Options} opts.options - command-line options
    */
   run(callback, {files, options = {}} = {}) {
     /**

package/lib/reporters/base.js

@@ -56,6 +56,11 @@ exports.useColors =
 
 exports.inlineDiffs = false;
 
+/**
+ * Truncate diffs longer than this value to avoid slow performance
+ */
+exports.maxDiffSize = 8192;
+
 /**
  * Default color map.
  */
@@ -188,18 +193,23 @@ function stringifyDiffObjs(err) {
  * @param {string} expected
  * @return {string} Diff
  */
+
 var generateDiff = (exports.generateDiff = function (actual, expected) {
   try {
-    const diffSize = 2048;
-    if (actual.length > diffSize) {
-      actual = actual.substring(0, diffSize) + ' ... Lines skipped';
+    var maxLen = exports.maxDiffSize;
+    var skipped = 0;
+    if (maxLen > 0) {
+      skipped = Math.max(actual.length - maxLen, expected.length - maxLen);
+      actual = actual.slice(0, maxLen);
+      expected = expected.slice(0, maxLen);
     }
-    if (expected.length > diffSize) {
-      expected = expected.substring(0, diffSize) + ' ... Lines skipped';
-    }
-    return exports.inlineDiffs
+    let result = exports.inlineDiffs
       ? inlineDiff(actual, expected)
       : unifiedDiff(actual, expected);
+    if (skipped > 0) {
+      result = `${result}\n      [mocha] output truncated to ${maxLen} characters, see "maxDiffSize" reporter-option\n`;
+    }
+    return result;
   } catch (err) {
     var msg =
       '\n      ' +
@@ -318,6 +328,12 @@ function Base(runner, options) {
   this.runner = runner;
   this.stats = runner.stats; // assigned so Reporters keep a closer reference
 
+  var maxDiffSizeOpt =
+    this.options.reporterOption && this.options.reporterOption.maxDiffSize;
+  if (maxDiffSizeOpt !== undefined && !isNaN(Number(maxDiffSizeOpt))) {
+    exports.maxDiffSize = Number(maxDiffSizeOpt);
+  }
+
   runner.on(EVENT_TEST_PASS, function (test) {
     if (test.duration > test.slow()) {
       test.speed = 'slow';

package/lib/reporters/html.js

@@ -181,7 +181,7 @@ function HTML(runner, options) {
       if (indexOfMessage === -1) {
         stackString = test.err.stack;
       } else {
-        stackString = test.err.stack.substr(
+        stackString = test.err.stack.slice(
           test.err.message.length + indexOfMessage
         );
       }

package/lib/runner.js

@@ -135,27 +135,15 @@ class Runner extends EventEmitter {
    * @public
    * @class
    * @param {Suite} suite - Root suite
-   * @param {Object|boolean} [opts] - Options. If `boolean` (deprecated), whether to delay execution of root suite until ready.
+   * @param {Object} [opts] - Settings object
    * @param {boolean} [opts.cleanReferencesAfterRun] - Whether to clean references to test fns and hooks when a suite is done.
    * @param {boolean} [opts.delay] - Whether to delay execution of root suite until ready.
    * @param {boolean} [opts.dryRun] - Whether to report tests without running them.
    * @param {boolean} [opts.failZero] - Whether to fail test run if zero tests encountered.
    */
-  constructor(suite, opts) {
+  constructor(suite, opts = {}) {
     super();
-    if (opts === undefined) {
-      opts = {};
-    }
-    if (typeof opts === 'boolean') {
-      // TODO: remove this
-      require('./errors').deprecate(
-        '"Runner(suite: Suite, delay: boolean)" is deprecated. Use "Runner(suite: Suite, {delay: boolean})" instead.'
-      );
-      this._delay = opts;
-      opts = {};
-    } else {
-      this._delay = opts.delay;
-    }
+
     var self = this;
     this._globals = [];
     this._abort = false;
@@ -655,7 +643,7 @@ Runner.prototype.parents = function () {
  * @private
  */
 Runner.prototype.runTest = function (fn) {
-  if (this._opts.dryRun) return fn();
+  if (this._opts.dryRun) return Runner.immediately(fn);
 
   var self = this;
   var test = this.test;
@@ -1031,7 +1019,9 @@ Runner.prototype._uncaught = function (err) {
  * @public
  * @memberof Runner
  * @param {Function} fn - Callback when finished
- * @param {{files: string[], options: Options}} [opts] - For subclasses
+ * @param {Object} [opts] - For subclasses
+ * @param {string[]} opts.files - Files to run
+ * @param {Options} opts.options - command-line options
  * @returns {Runner} Runner instance.
  */
 Runner.prototype.run = function (fn, opts = {}) {
@@ -1064,7 +1054,7 @@ Runner.prototype.run = function (fn, opts = {}) {
       debug('run(): filtered exclusive Runnables');
     }
     this.state = constants.STATE_RUNNING;
-    if (this._delay) {
+    if (this._opts.delay) {
       this.emit(constants.EVENT_DELAY_END);
       debug('run(): "delay" ended');
     }
@@ -1091,7 +1081,7 @@ Runner.prototype.run = function (fn, opts = {}) {
   this._addEventListener(process, 'uncaughtException', this.uncaught);
   this._addEventListener(process, 'unhandledRejection', this.unhandled);
 
-  if (this._delay) {
+  if (this._opts.delay) {
     // for reporters, I guess.
     // might be nice to debounce some dots while we wait.
     this.emit(constants.EVENT_DELAY_BEGIN, rootSuite);