mocha 7.0.0-esm1 → 7.1.1

package/LICENSE

@@ -1,6 +1,6 @@
 (The MIT License)
 
-Copyright (c) 2011-2018 JS Foundation and contributors, https://js.foundation
+Copyright (c) 2011-2020 OpenJS Foundation and contributors, https://openjsf.org
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

package/README.md

@@ -100,6 +100,6 @@ Finally, come [chat with the maintainers](https://gitter.im/mochajs/contributors
 
 ## License
 
-[MIT](LICENSE)
+Copyright 2011-2020 OpenJS Foundation and contributors. Licensed [MIT](https://github.com/mochajs/mocha/blob/master/LICENSE).
 
 [![FOSSA Status](https://app.fossa.io/api/projects/git%2Bhttps%3A%2F%2Fgithub.com%2Fmochajs%2Fmocha.svg?type=large)](https://app.fossa.io/projects/git%2Bhttps%3A%2F%2Fgithub.com%2Fmochajs%2Fmocha?ref=badge_large)

package/browser-entry.js

@@ -60,7 +60,7 @@ process.on = function(e, fn) {
   if (e === 'uncaughtException') {
     global.onerror = function(err, url, line) {
       fn(new Error(err + ' (' + url + ':' + line + ')'));
-      return !mocha.allowUncaught;
+      return !mocha.options.allowUncaught;
     };
     uncaughtExceptionHandlers.push(fn);
   }
@@ -129,7 +129,7 @@ mocha.setup = function(opts) {
     opts = {ui: opts};
   }
   for (var opt in opts) {
-    if (opts.hasOwnProperty(opt)) {
+    if (Object.prototype.hasOwnProperty.call(opts, opt)) {
       this[opt](opts[opt]);
     }
   }

package/lib/cli/run-helpers.js

@@ -15,8 +15,6 @@ const collectFiles = require('./collect-files');
 
 const cwd = (exports.cwd = process.cwd());
 
-exports.watchRun = watchRun;
-
 /**
  * Exits Mocha when tests + code under test has finished execution (default)
  * @param {number} code - Exit code; typically # of failures
@@ -92,7 +90,7 @@ exports.handleRequires = (requires = []) => {
 };
 
 /**
- * Collect test files and run mocha instance.
+ * Collect and load test files, then run mocha instance.
  * @param {Mocha} mocha - Mocha instance
  * @param {Options} [opts] - Command line options
  * @param {boolean} [opts.exit] - Whether or not to force-exit after tests are complete
@@ -101,18 +99,13 @@ exports.handleRequires = (requires = []) => {
  * @returns {Promise<Runner>}
  * @private
  */
-exports.singleRun = (mocha, {exit}, fileCollectParams) => {
+const singleRun = async (mocha, {exit}, fileCollectParams) => {
   const files = collectFiles(fileCollectParams);
   debug('running tests with files', files);
   mocha.files = files;
 
-  return mocha.runAsync().then(exitCode => {
-    if (exit) {
-      exitMocha(exitCode);
-    } else {
-      exitMochaLater(exitCode);
-    }
-  });
+  await mocha.loadFilesAsync();
+  return mocha.run(exit ? exitMocha : exitMochaLater);
 };
 
 /**
@@ -122,7 +115,7 @@ exports.singleRun = (mocha, {exit}, fileCollectParams) => {
  * @private
  * @returns {Promise}
  */
-exports.runMocha = (mocha, options) => {
+exports.runMocha = async (mocha, options) => {
   const {
     watch = false,
     extension = [],
@@ -148,7 +141,7 @@ exports.runMocha = (mocha, options) => {
   if (watch) {
     watchRun(mocha, {watchFiles, watchIgnore}, fileCollectParams);
   } else {
-    return exports.singleRun(mocha, {exit}, fileCollectParams);
+    await singleRun(mocha, {exit}, fileCollectParams);
   }
 };
 

package/lib/cli/run.js

@@ -87,7 +87,6 @@ exports.builder = yargs =>
       },
       extension: {
         default: defaults.extension,
-        defaultDescription: 'js',
         description: 'File extension(s) to load',
         group: GROUPS.FILES,
         requiresArg: true,
@@ -306,7 +305,7 @@ exports.handler = async function(argv) {
   try {
     await runMocha(mocha, argv);
   } catch (err) {
-    console.error(err.stack || `Error: ${err.message || err}`);
+    console.error('\n' + (err.stack || `Error: ${err.message || err}`));
     process.exit(1);
   }
 };

package/lib/esm-utils.js

@@ -1,17 +1,13 @@
-// This file is allowed to use async/await because it is not exposed to browsers (see the `eslintrc`),
-// and Node supports async/await in all its non-dead version.
-
 const url = require('url');
 const path = require('path');
 
-exports.requireOrImport = async file => {
+const requireOrImport = async file => {
   file = path.resolve(file);
 
   if (path.extname(file) === '.mjs') {
     return import(url.pathToFileURL(file));
   }
-  // This way of figuring out whether a test file is CJS or ESM is currently the only known
-  // way of figuring out whether a file is CJS or ESM.
+  // This is currently the only known way of figuring out whether a file is CJS or ESM.
   // If Node.js or the community establish a better procedure for that, we can fix this code.
   // Another option here would be to always use `import()`, as this also supports CJS, but I would be
   // wary of using it for _all_ existing test files, till ESM is fully stable.
@@ -29,7 +25,7 @@ exports.requireOrImport = async file => {
 exports.loadFilesAsync = async (files, preLoadFunc, postLoadFunc) => {
   for (const file of files) {
     preLoadFunc(file);
-    const result = await exports.requireOrImport(file);
+    const result = await requireOrImport(file);
     postLoadFunc(file, result);
   }
 };

package/lib/mocha.js

@@ -101,7 +101,10 @@ function Mocha(options) {
   this.grep(options.grep)
     .fgrep(options.fgrep)
     .ui(options.ui)
-    .reporter(options.reporter, options.reporterOption)
+    .reporter(
+      options.reporter,
+      options.reporterOption || options.reporterOptions // reporterOptions was previously the only way to specify options to reporter
+    )
     .slow(options.slow)
     .global(options.global);
 
@@ -322,16 +325,22 @@ Mocha.prototype.loadFiles = function(fn) {
  * the test interface functions and will be subject to its cache.
  * Supports both CJS and ESM modules.
  *
- * @private
+ * @public
  * @see {@link Mocha#addFile}
  * @see {@link Mocha#run}
  * @see {@link Mocha#unloadFiles}
- *
  * @returns {Promise}
+ * @example
+ *
+ * // loads ESM (and CJS) test files asynchronously, then runs root suite
+ * mocha.loadFilesAsync()
+ *   .then(() => mocha.run(failures => process.exitCode = failures ? 1 : 0))
+ *   .catch(() => process.exitCode = 1);
  */
 Mocha.prototype.loadFilesAsync = function() {
   var self = this;
   var suite = this.suite;
+  this.loadAsync = true;
 
   if (!esmUtils) {
     return new Promise(function(resolve) {
@@ -367,8 +376,9 @@ Mocha.unloadFile = function(file) {
  * Unloads `files` from Node's `require` cache.
  *
  * @description
- * This allows files to be "freshly" reloaded, providing the ability
+ * This allows required files to be "freshly" reloaded, providing the ability
  * to reuse a Mocha instance programmatically.
+ * Note: does not clear ESM module files from the cache
  *
  * <strong>Intended for consumers &mdash; not used internally</strong>
  *
@@ -875,31 +885,26 @@ Object.defineProperty(Mocha.prototype, 'version', {
  * already in the `require` cache), make sure to clear them from
  * the cache first!
  *
- * This method supports only CommonJS test files, and not ES modules ones.
- * To use ES module (and CommonJS) test files, call Mocha#runAsync instead.
- *
  * @public
- * @see {@link Mocha#runAsync}
  * @see {@link Mocha#unloadFiles}
  * @see {@link Runner#run}
  * @param {DoneCB} [fn] - Callback invoked when test execution completed.
- * @return {Runner} runner instance
+ * @returns {Runner} runner instance
+ * @example
+ *
+ * // exit with non-zero status if there were test failures
+ * mocha.run(failures => process.exitCode = failures ? 1 : 0);
  */
 Mocha.prototype.run = function(fn) {
-  if (this.files.length) {
+  if (this.files.length && !this.loadAsync) {
     this.loadFiles();
   }
-  return this._startRunning(fn);
-};
-
-Mocha.prototype._startRunning = function(fn) {
-  var self = this;
-  var suite = self.suite;
-  var options = self.options;
-  options.files = self.files;
+  var suite = this.suite;
+  var options = this.options;
+  options.files = this.files;
   var runner = new exports.Runner(suite, options.delay);
   createStatsCollector(runner);
-  var reporter = new self._reporter(runner, options);
+  var reporter = new this._reporter(runner, options);
   runner.checkLeaks = options.checkLeaks === true;
   runner.fullStackTrace = options.fullTrace;
   runner.asyncOnly = options.asyncOnly;
@@ -913,7 +918,7 @@ Mocha.prototype._startRunning = function(fn) {
     runner.globals(options.global);
   }
   if (options.growl) {
-    self._growl(runner);
+    this._growl(runner);
   }
   if (options.color !== undefined) {
     exports.reporters.Base.useColors = options.color;
@@ -932,33 +937,3 @@ Mocha.prototype._startRunning = function(fn) {
 
   return runner.run(done);
 };
-
-/**
- * Runs root suite and invokes `fn()` when complete. Supports ES Modules.
- *
- * @description
- * To run tests multiple times (or to run tests in files that are
- * already in the `require` cache), make sure to clear them from
- * the cache first!
- *
- * This method supports both ES Modules and CommonJS test files.
- *
- * @public
- * @see {@link Mocha#unloadFiles}
- * @see {@link Runner#run}
- * @return {Promise<Runner>} runner instance
- */
-Mocha.prototype.runAsync = function() {
-  var loadResult = this.files.length
-    ? this.loadFilesAsync()
-    : Promise.resolve();
-
-  var self = this;
-  return loadResult.then(function() {
-    return new Promise(function(resolve) {
-      self._startRunning(function(result) {
-        resolve(result);
-      });
-    });
-  });
-};

package/lib/runnable.js

@@ -335,9 +335,18 @@ Runnable.prototype.run = function(fn) {
     fn(err);
   }
 
-  // for .resetTimeout()
+  // for .resetTimeout() and Runner#uncaught()
   this.callback = done;
 
+  if (this.fn && typeof this.fn.call !== 'function') {
+    done(
+      new TypeError(
+        'A runnable must be passed a function as its second argument.'
+      )
+    );
+    return;
+  }
+
   // explicit async with `done` argument
   if (this.async) {
     this.resetTimeout();

package/lib/runner.js

@@ -135,6 +135,11 @@ function Runner(suite, delay) {
   this.total = suite.total();
   this.failures = 0;
   this.on(constants.EVENT_TEST_END, function(test) {
+    if (test.retriedTest() && test.parent) {
+      var idx =
+        test.parent.tests && test.parent.tests.indexOf(test.retriedTest());
+      if (idx > -1) test.parent.tests[idx] = test;
+    }
     self.checkGlobals(test);
   });
   this.on(constants.EVENT_HOOK_END, function(hook) {
@@ -654,7 +659,7 @@ Runner.prototype.runTests = function(suite, fn) {
         self.emit(constants.EVENT_TEST_END, test);
         // skip inner afterEach hooks below errSuite level
         var origSuite = self.suite;
-        self.suite = errSuite;
+        self.suite = errSuite || self.suite;
         return self.hookUp(HOOK_TYPE_AFTER_EACH, function(e, eSuite) {
           self.suite = origSuite;
           next(e, eSuite);
@@ -724,7 +729,6 @@ Runner.prototype.runSuite = function(suite, fn) {
   var i = 0;
   var self = this;
   var total = this.grepTotal(suite);
-  var afterAllHookCalled = false;
 
   debug('run suite %s', suite.fullTitle());
 
@@ -772,21 +776,13 @@ Runner.prototype.runSuite = function(suite, fn) {
     self.suite = suite;
     self.nextSuite = next;
 
-    if (afterAllHookCalled) {
-      fn(errSuite);
-    } else {
-      // mark that the afterAll block has been called once
-      // and so can be skipped if there is an error in it.
-      afterAllHookCalled = true;
-
-      // remove reference to test
-      delete self.test;
+    // remove reference to test
+    delete self.test;
 
-      self.hook(HOOK_TYPE_AFTER_ALL, function() {
-        self.emit(constants.EVENT_SUITE_END, suite);
-        fn(errSuite);
-      });
-    }
+    self.hook(HOOK_TYPE_AFTER_ALL, function() {
+      self.emit(constants.EVENT_SUITE_END, suite);
+      fn(errSuite);
+    });
   }
 
   this.nextSuite = next;
@@ -800,7 +796,7 @@ Runner.prototype.runSuite = function(suite, fn) {
 };
 
 /**
- * Handle uncaught exceptions.
+ * Handle uncaught exceptions within runner.
  *
  * @param {Error} err
  * @private
@@ -809,7 +805,8 @@ Runner.prototype.uncaught = function(err) {
   if (err instanceof Pending) {
     return;
   }
-  if (this.allowUncaught) {
+  // browser does not exit script when throwing in global.onerror()
+  if (this.allowUncaught && !process.browser) {
     throw err;
   }
 
@@ -861,36 +858,24 @@ Runner.prototype.uncaught = function(err) {
 
   // we cannot recover gracefully if a Runnable has already passed
   // then fails asynchronously
-  var alreadyPassed = runnable.isPassed();
-  // this will change the state to "failed" regardless of the current value
-  this.fail(runnable, err);
-  if (!alreadyPassed) {
-    // recover from test
-    if (runnable.type === constants.EVENT_TEST_BEGIN) {
-      this.emit(constants.EVENT_TEST_END, runnable);
-      this.hookUp(HOOK_TYPE_AFTER_EACH, this.next);
-      return;
-    }
+  if (runnable.isPassed()) {
+    this.fail(runnable, err);
+    this.abort();
+  } else {
     debug(runnable);
-
-    // recover from hooks
-    var errSuite = this.suite;
-
-    // XXX how about a less awful way to determine this?
-    // if hook failure is in afterEach block
-    if (runnable.fullTitle().indexOf('after each') > -1) {
-      return this.hookErr(err, errSuite, true);
-    }
-    // if hook failure is in beforeEach block
-    if (runnable.fullTitle().indexOf('before each') > -1) {
-      return this.hookErr(err, errSuite, false);
-    }
-    // if hook failure is in after or before blocks
-    return this.nextSuite(errSuite);
+    return runnable.callback(err);
   }
+};
 
-  // bail
-  this.abort();
+/**
+ * Handle uncaught exceptions after runner's end event.
+ *
+ * @param {Error} err
+ * @private
+ */
+Runner.prototype.uncaughtEnd = function uncaughtEnd(err) {
+  if (err instanceof Pending) return;
+  throw err;
 };
 
 /**
@@ -940,16 +925,12 @@ Runner.prototype.run = function(fn) {
   this.on(constants.EVENT_RUN_END, function() {
     debug(constants.EVENT_RUN_END);
     process.removeListener('uncaughtException', uncaught);
-    process.on('uncaughtException', function(err) {
-      if (err instanceof Pending) {
-        return;
-      }
-      throw err;
-    });
+    process.on('uncaughtException', self.uncaughtEnd);
     fn(self.failures);
   });
 
   // uncaught exception
+  process.removeListener('uncaughtException', self.uncaughtEnd);
   process.on('uncaughtException', uncaught);
 
   if (this._delay) {
@@ -958,7 +939,9 @@ Runner.prototype.run = function(fn) {
     this.emit(constants.EVENT_DELAY_BEGIN, rootSuite);
     rootSuite.once(EVENT_ROOT_SUITE_RUN, start);
   } else {
-    start();
+    Runner.immediately(function() {
+      start();
+    });
   }
 
   return this;

package/lib/test.js

@@ -36,6 +36,18 @@ function Test(title, fn) {
  */
 utils.inherits(Test, Runnable);
 
+/**
+ * Set or get retried test
+ *
+ * @private
+ */
+Test.prototype.retriedTest = function(n) {
+  if (!arguments.length) {
+    return this._retriedTest;
+  }
+  this._retriedTest = n;
+};
+
 Test.prototype.clone = function() {
   var test = new Test(this.title, this.fn);
   test.timeout(this.timeout());
@@ -43,6 +55,7 @@ Test.prototype.clone = function() {
   test.enableTimeouts(this.enableTimeouts());
   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;

package/lib/utils.js

@@ -838,39 +838,18 @@ exports.defineConstants = function(obj) {
  * @description
  * Versions prior to 10 did not support ES Modules, and version 10 has an old incompatibile version of ESM.
  * This function returns whether Node.JS has ES Module supports that is compatible with Mocha's needs,
- * which is version 12 and older
+ * which is version >=12.11.
  *
- * @param {Boolean} unflagged whether the support is unflagged (`true`) or only using the `--experimental-modules` flag (`false`)
- * @returns {Boolean} whether the current version of Node.JS supports ES Modules in a way that is compatbile with Mocha
+ * @returns {Boolean} whether the current version of Node.JS supports ES Modules in a way that is compatible with Mocha
  */
-exports.supportsEsModules = function(unflagged) {
-  if (typeof document !== 'undefined') {
-    return false;
-  }
-  if (
-    typeof process !== 'object' ||
-    !process.versions ||
-    !process.versions.node
-  ) {
-    return false;
-  }
-  var versionFields = process.versions.node.split('.');
-  var major = +versionFields[0];
-  var minor = +versionFields[1];
-
-  if (major >= 13) {
-    if (unflagged) {
-      return minor >= 2;
+exports.supportsEsModules = function() {
+  if (!process.browser && process.versions && process.versions.node) {
+    var versionFields = process.versions.node.split('.');
+    var major = +versionFields[0];
+    var minor = +versionFields[1];
+
+    if (major >= 13 || (major === 12 && minor >= 11)) {
+      return true;
     }
-    return true;
   }
-  if (unflagged) {
-    return false;
-  }
-  if (major < 12) {
-    return false;
-  }
-  // major === 12
-
-  return minor >= 11;
 };