mocha 5.1.0 → 6.0.0-1

package/lib/runner.js

@@ -12,6 +12,7 @@ var utils = require('./utils');
 var inherits = utils.inherits;
 var debug = require('debug')('mocha:runner');
 var Runnable = require('./runnable');
+var createStatsCollector = require('./stats-collector');
 var stackFilter = utils.stackTraceFilter();
 var stringify = utils.stringify;
 var type = utils.type;
@@ -58,12 +59,11 @@ module.exports = Runner;
  * @memberof Mocha
  * @public
  * @class
- * @api public
  * @param {Suite} [suite] Root suite
  * @param {boolean} [delay] Whether or not to delay execution of root suite
  * until ready.
  */
-function Runner (suite, delay) {
+function Runner(suite, delay) {
   var self = this;
   this._globals = [];
   this._abort = false;
@@ -72,22 +72,23 @@ function Runner (suite, delay) {
   this.started = false;
   this.total = suite.total();
   this.failures = 0;
-  this.on('test end', function (test) {
+  this.on('test end', function(test) {
     self.checkGlobals(test);
   });
-  this.on('hook end', function (hook) {
+  this.on('hook end', function(hook) {
     self.checkGlobals(hook);
   });
   this._defaultGrep = /.*/;
   this.grep(this._defaultGrep);
   this.globals(this.globalProps().concat(extraGlobals()));
+  createStatsCollector(this);
 }
 
 /**
  * Wrapper for setImmediate, process.nextTick, or browser polyfill.
  *
  * @param {Function} fn
- * @api private
+ * @private
  */
 Runner.immediately = global.setImmediate || process.nextTick;
 
@@ -100,14 +101,13 @@ inherits(Runner, EventEmitter);
  * Run tests with full titles matching `re`. Updates runner.total
  * with number of tests matched.
  *
- * @api public
  * @public
  * @memberof Mocha.Runner
  * @param {RegExp} re
  * @param {boolean} invert
  * @return {Runner} Runner instance.
  */
-Runner.prototype.grep = function (re, invert) {
+Runner.prototype.grep = function(re, invert) {
   debug('grep %s', re);
   this._grep = re;
   this._invert = invert;
@@ -120,16 +120,15 @@ Runner.prototype.grep = function (re, invert) {
  * given suite.
  *
  * @memberof Mocha.Runner
- * @api public
  * @public
  * @param {Suite} suite
  * @return {number}
  */
-Runner.prototype.grepTotal = function (suite) {
+Runner.prototype.grepTotal = function(suite) {
   var self = this;
   var total = 0;
 
-  suite.eachTest(function (test) {
+  suite.eachTest(function(test) {
     var match = self._grep.test(test.fullTitle());
     if (self._invert) {
       match = !match;
@@ -146,9 +145,9 @@ Runner.prototype.grepTotal = function (suite) {
  * Return a list of global properties.
  *
  * @return {Array}
- * @api private
+ * @private
  */
-Runner.prototype.globalProps = function () {
+Runner.prototype.globalProps = function() {
   var props = Object.keys(global);
 
   // non-enumerables
@@ -165,13 +164,12 @@ Runner.prototype.globalProps = function () {
 /**
  * Allow the given `arr` of globals.
  *
- * @api public
  * @public
  * @memberof Mocha.Runner
  * @param {Array} arr
  * @return {Runner} Runner instance.
  */
-Runner.prototype.globals = function (arr) {
+Runner.prototype.globals = function(arr) {
   if (!arguments.length) {
     return this._globals;
   }
@@ -183,9 +181,9 @@ Runner.prototype.globals = function (arr) {
 /**
  * Check for global variable leaks.
  *
- * @api private
+ * @private
  */
-Runner.prototype.checkGlobals = function (test) {
+Runner.prototype.checkGlobals = function(test) {
   if (this.ignoreLeaks) {
     return;
   }
@@ -207,7 +205,10 @@ Runner.prototype.checkGlobals = function (test) {
   this._globals = this._globals.concat(leaks);
 
   if (leaks.length > 1) {
-    this.fail(test, new Error('global leaks detected: ' + leaks.join(', ') + ''));
+    this.fail(
+      test,
+      new Error('global leaks detected: ' + leaks.join(', ') + '')
+    );
   } else if (leaks.length) {
     this.fail(test, new Error('global leak detected: ' + leaks[0]));
   }
@@ -216,11 +217,11 @@ Runner.prototype.checkGlobals = function (test) {
 /**
  * Fail the given `test`.
  *
- * @api private
+ * @private
  * @param {Test} test
  * @param {Error} err
  */
-Runner.prototype.fail = function (test, err) {
+Runner.prototype.fail = function(test, err) {
   if (test.isPending()) {
     return;
   }
@@ -228,15 +229,14 @@ Runner.prototype.fail = function (test, err) {
   ++this.failures;
   test.state = 'failed';
 
-  if (!(err instanceof Error || (err && typeof err.message === 'string'))) {
-    err = new Error('the ' + type(err) + ' ' + stringify(err) + ' was thrown, throw an Error :)');
+  if (!isError(err)) {
+    err = thrown2Error(err);
   }
 
   try {
-    err.stack = (this.fullStackTrace || !err.stack)
-      ? err.stack
-      : stackFilter(err.stack);
-  } catch (ignored) {
+    err.stack =
+      this.fullStackTrace || !err.stack ? err.stack : stackFilter(err.stack);
+  } catch (ignore) {
     // some environments do not take kindly to monkeying with the stack
   }
 
@@ -247,7 +247,8 @@ Runner.prototype.fail = function (test, err) {
  * Fail the given `hook` with `err`.
  *
  * Hook failures work in the following pattern:
- * - If bail, then exit
+ * - If bail, run corresponding `after each` and `after` hooks,
+ *   then exit
  * - Failed `before` hook skips all tests in a suite and subsuites,
  *   but jumps to corresponding `after` hook
  * - Failed `before each` hook skips remaining tests in a
@@ -259,36 +260,34 @@ Runner.prototype.fail = function (test, err) {
  *   suite and subsuites, but executes other `after each`
  *   hooks
  *
- * @api private
+ * @private
  * @param {Hook} hook
  * @param {Error} err
  */
-Runner.prototype.failHook = function (hook, err) {
+Runner.prototype.failHook = function(hook, err) {
   if (hook.ctx && hook.ctx.currentTest) {
     hook.originalTitle = hook.originalTitle || hook.title;
-    hook.title = hook.originalTitle + ' for "' + hook.ctx.currentTest.title + '"';
+    hook.title =
+      hook.originalTitle + ' for "' + hook.ctx.currentTest.title + '"';
   }
 
-  if (this.suite.bail()) {
-    this.emit('end');
-  }
   this.fail(hook, err);
 };
 
 /**
  * Run hook `name` callbacks and then invoke `fn()`.
  *
- * @api private
+ * @private
  * @param {string} name
  * @param {Function} fn
  */
 
-Runner.prototype.hook = function (name, fn) {
+Runner.prototype.hook = function(name, fn) {
   var suite = this.suite;
   var hooks = suite['_' + name];
   var self = this;
 
-  function next (i) {
+  function next(i) {
     var hook = hooks[i];
     if (!hook) {
       return fn();
@@ -300,12 +299,12 @@ Runner.prototype.hook = function (name, fn) {
     self.emit('hook', hook);
 
     if (!hook.listeners('error').length) {
-      hook.on('error', function (err) {
+      hook.on('error', function(err) {
         self.failHook(hook, err);
       });
     }
 
-    hook.run(function (err) {
+    hook.run(function(err) {
       var testError = hook.error();
       if (testError) {
         self.fail(self.test, testError);
@@ -315,9 +314,12 @@ Runner.prototype.hook = function (name, fn) {
           if (name === 'beforeEach' || name === 'afterEach') {
             self.test.pending = true;
           } else {
-            suite.tests.forEach(function (test) {
+            suite.tests.forEach(function(test) {
               test.pending = true;
             });
+            suite.suites.forEach(function(suite) {
+              suite.pending = true;
+            });
             // a pending hook won't be executed twice.
             hook.pending = true;
           }
@@ -334,7 +336,7 @@ Runner.prototype.hook = function (name, fn) {
     });
   }
 
-  Runner.immediately(function () {
+  Runner.immediately(function() {
     next(0);
   });
 };
@@ -343,16 +345,16 @@ Runner.prototype.hook = function (name, fn) {
  * Run hook `name` for the given array of `suites`
  * in order, and callback `fn(err, errSuite)`.
  *
- * @api private
+ * @private
  * @param {string} name
  * @param {Array} suites
  * @param {Function} fn
  */
-Runner.prototype.hooks = function (name, suites, fn) {
+Runner.prototype.hooks = function(name, suites, fn) {
   var self = this;
   var orig = this.suite;
 
-  function next (suite) {
+  function next(suite) {
     self.suite = suite;
 
     if (!suite) {
@@ -360,7 +362,7 @@ Runner.prototype.hooks = function (name, suites, fn) {
       return fn();
     }
 
-    self.hook(name, function (err) {
+    self.hook(name, function(err) {
       if (err) {
         var errSuite = self.suite;
         self.suite = orig;
@@ -379,9 +381,9 @@ Runner.prototype.hooks = function (name, suites, fn) {
  *
  * @param {String} name
  * @param {Function} fn
- * @api private
+ * @private
  */
-Runner.prototype.hookUp = function (name, fn) {
+Runner.prototype.hookUp = function(name, fn) {
   var suites = [this.suite].concat(this.parents()).reverse();
   this.hooks(name, suites, fn);
 };
@@ -391,9 +393,9 @@ Runner.prototype.hookUp = function (name, fn) {
  *
  * @param {String} name
  * @param {Function} fn
- * @api private
+ * @private
  */
-Runner.prototype.hookDown = function (name, fn) {
+Runner.prototype.hookDown = function(name, fn) {
   var suites = [this.suite].concat(this.parents());
   this.hooks(name, suites, fn);
 };
@@ -403,9 +405,9 @@ Runner.prototype.hookDown = function (name, fn) {
  * closest to furthest.
  *
  * @return {Array}
- * @api private
+ * @private
  */
-Runner.prototype.parents = function () {
+Runner.prototype.parents = function() {
   var suite = this.suite;
   var suites = [];
   while (suite.parent) {
@@ -419,9 +421,9 @@ Runner.prototype.parents = function () {
  * Run the current test and callback `fn(err)`.
  *
  * @param {Function} fn
- * @api private
+ * @private
  */
-Runner.prototype.runTest = function (fn) {
+Runner.prototype.runTest = function(fn) {
   var self = this;
   var test = this.test;
 
@@ -435,7 +437,7 @@ Runner.prototype.runTest = function (fn) {
   if (this.asyncOnly) {
     test.asyncOnly = true;
   }
-  test.on('error', function (err) {
+  test.on('error', function(err) {
     self.fail(test, err);
   });
   if (this.allowUncaught) {
@@ -452,16 +454,16 @@ Runner.prototype.runTest = function (fn) {
 /**
  * Run tests in the given `suite` and invoke the callback `fn()` when complete.
  *
- * @api private
+ * @private
  * @param {Suite} suite
  * @param {Function} fn
  */
-Runner.prototype.runTests = function (suite, fn) {
+Runner.prototype.runTests = function(suite, fn) {
   var self = this;
   var tests = suite.tests.slice();
   var test;
 
-  function hookErr (_, errSuite, after) {
+  function hookErr(_, errSuite, after) {
     // before/after Each hook for errSuite failed:
     var orig = self.suite;
 
@@ -471,7 +473,7 @@ Runner.prototype.runTests = function (suite, fn) {
 
     if (self.suite) {
       // call hookUp afterEach
-      self.hookUp('afterEach', function (err2, errSuite2) {
+      self.hookUp('afterEach', function(err2, errSuite2) {
         self.suite = orig;
         // some hooks may fail even now
         if (err2) {
@@ -487,10 +489,10 @@ Runner.prototype.runTests = function (suite, fn) {
     }
   }
 
-  function next (err, errSuite) {
+  function next(err, errSuite) {
     // if we bail after first err
     if (self.failures && suite._bail) {
-      return fn();
+      tests = [];
     }
 
     if (self._abort) {
@@ -544,8 +546,8 @@ Runner.prototype.runTests = function (suite, fn) {
     }
 
     // execute test and hook(s)
-    self.emit('test', self.test = test);
-    self.hookDown('beforeEach', function (err, errSuite) {
+    self.emit('test', (self.test = test));
+    self.hookDown('beforeEach', function(err, errSuite) {
       if (test.isPending()) {
         if (self.forbidPending) {
           test.isPending = alwaysFalse;
@@ -561,7 +563,7 @@ Runner.prototype.runTests = function (suite, fn) {
         return hookErr(err, errSuite, false);
       }
       self.currentRunnable = self.test;
-      self.runTest(function (err) {
+      self.runTest(function(err) {
         test = self.test;
         if (err) {
           var retry = test.currentRetry();
@@ -575,6 +577,8 @@ Runner.prototype.runTests = function (suite, fn) {
             clonedTest.currentRetry(retry + 1);
             tests.unshift(clonedTest);
 
+            self.emit('retry', test, err);
+
             // Early return + hook trigger so that it doesn't
             // increment the count wrong
             return self.hookUp('afterEach', next);
@@ -603,18 +607,18 @@ Runner.prototype.runTests = function (suite, fn) {
   next();
 };
 
-function alwaysFalse () {
+function alwaysFalse() {
   return false;
 }
 
 /**
  * Run the given `suite` and invoke the callback `fn()` when complete.
  *
- * @api private
+ * @private
  * @param {Suite} suite
  * @param {Function} fn
  */
-Runner.prototype.runSuite = function (suite, fn) {
+Runner.prototype.runSuite = function(suite, fn) {
   var i = 0;
   var self = this;
   var total = this.grepTotal(suite);
@@ -626,9 +630,9 @@ Runner.prototype.runSuite = function (suite, fn) {
     return fn();
   }
 
-  this.emit('suite', this.suite = suite);
+  this.emit('suite', (this.suite = suite));
 
-  function next (errSuite) {
+  function next(errSuite) {
     if (errSuite) {
       // current suite failed on a hook from errSuite
       if (errSuite === suite) {
@@ -654,7 +658,7 @@ Runner.prototype.runSuite = function (suite, fn) {
     // huge recursive loop and thus a maximum call stack error.
     // See comment in `this.runTests()` for more information.
     if (self._grep !== self._defaultGrep) {
-      Runner.immediately(function () {
+      Runner.immediately(function() {
         self.runSuite(curr, next);
       });
     } else {
@@ -662,7 +666,7 @@ Runner.prototype.runSuite = function (suite, fn) {
     }
   }
 
-  function done (errSuite) {
+  function done(errSuite) {
     self.suite = suite;
     self.nextSuite = next;
 
@@ -676,7 +680,7 @@ Runner.prototype.runSuite = function (suite, fn) {
       // remove reference to test
       delete self.test;
 
-      self.hook('afterAll', function () {
+      self.hook('afterAll', function() {
         self.emit('suite end', suite);
         fn(errSuite);
       });
@@ -685,7 +689,7 @@ Runner.prototype.runSuite = function (suite, fn) {
 
   this.nextSuite = next;
 
-  this.hook('beforeAll', function (err) {
+  this.hook('beforeAll', function(err) {
     if (err) {
       return done();
     }
@@ -697,17 +701,27 @@ Runner.prototype.runSuite = function (suite, fn) {
  * Handle uncaught exceptions.
  *
  * @param {Error} err
- * @api private
+ * @private
  */
-Runner.prototype.uncaught = function (err) {
+Runner.prototype.uncaught = function(err) {
   if (err) {
-    debug('uncaught exception %s', err === (function () {
-      return this;
-    }.call(err)) ? (err.message || err) : err);
+    debug(
+      'uncaught exception %s',
+      err ===
+        function() {
+          return this;
+        }.call(err)
+        ? err.message || err
+        : err
+    );
   } else {
     debug('uncaught undefined exception');
     err = undefinedError();
   }
+
+  if (!isError(err)) {
+    err = thrown2Error(err);
+  }
   err.uncaught = true;
 
   var runnable = this.currentRunnable;
@@ -776,8 +790,8 @@ Runner.prototype.uncaught = function (err) {
  *
  * @param {Suite} suite
  */
-function cleanSuiteReferences (suite) {
-  function cleanArrReferences (arr) {
+function cleanSuiteReferences(suite) {
+  function cleanArrReferences(arr) {
     for (var i = 0; i < arr.length; i++) {
       delete arr[i].fn;
     }
@@ -808,32 +822,36 @@ function cleanSuiteReferences (suite) {
  * Run the root suite and invoke `fn(failures)`
  * on completion.
  *
- * @api public
  * @public
  * @memberof Mocha.Runner
  * @param {Function} fn
  * @return {Runner} Runner instance.
  */
-Runner.prototype.run = function (fn) {
+Runner.prototype.run = function(fn) {
   var self = this;
   var rootSuite = this.suite;
 
-  fn = fn || function () {};
+  fn = fn || function() {};
 
-  function uncaught (err) {
+  function uncaught(err) {
     self.uncaught(err);
   }
 
-  function start () {
+  function start() {
     // If there is an `only` filter
     if (hasOnly(rootSuite)) {
       filterOnly(rootSuite);
     }
     self.started = true;
-    self.emit('start');
-    self.runSuite(rootSuite, function () {
+    Runner.immediately(function() {
+      self.emit('start');
+    });
+
+    self.runSuite(rootSuite, function() {
       debug('finished running');
-      self.emit('end');
+      Runner.immediately(function() {
+        self.emit('end');
+      });
     });
   }
 
@@ -843,7 +861,7 @@ Runner.prototype.run = function (fn) {
   this.on('suite end', cleanSuiteReferences);
 
   // callback
-  this.on('end', function () {
+  this.on('end', function() {
     debug('end');
     process.removeListener('uncaughtException', uncaught);
     fn(self.failures);
@@ -869,10 +887,9 @@ Runner.prototype.run = function (fn) {
  *
  * @memberof Mocha.Runner
  * @public
- * @api public
  * @return {Runner} Runner instance.
  */
-Runner.prototype.abort = function () {
+Runner.prototype.abort = function() {
   debug('aborting');
   this._abort = true;
 
@@ -884,9 +901,9 @@ Runner.prototype.abort = function () {
  *
  * @param {Array} suite
  * @returns {Boolean}
- * @api private
+ * @private
  */
-function filterOnly (suite) {
+function filterOnly(suite) {
   if (suite._onlyTests.length) {
     // If the suite contains `only` tests, run those and ignore any nested suites.
     suite.tests = suite._onlyTests;
@@ -894,7 +911,7 @@ function filterOnly (suite) {
   } else {
     // Otherwise, do not run any of the tests in this suite.
     suite.tests = [];
-    suite._onlySuites.forEach(function (onlySuite) {
+    suite._onlySuites.forEach(function(onlySuite) {
       // If there are other `only` tests/suites nested in the current `only` suite, then filter that `only` suite.
       // Otherwise, all of the tests on this `only` suite should be run, so don't filter it.
       if (hasOnly(onlySuite)) {
@@ -902,8 +919,10 @@ function filterOnly (suite) {
       }
     });
     // Run the `only` suites, as well as any other suites that have `only` tests/suites as descendants.
-    suite.suites = suite.suites.filter(function (childSuite) {
-      return suite._onlySuites.indexOf(childSuite) !== -1 || filterOnly(childSuite);
+    suite.suites = suite.suites.filter(function(childSuite) {
+      return (
+        suite._onlySuites.indexOf(childSuite) !== -1 || filterOnly(childSuite)
+      );
     });
   }
   // Keep the suite only if there is something to run
@@ -915,22 +934,26 @@ function filterOnly (suite) {
  *
  * @param {Array} suite
  * @returns {Boolean}
- * @api private
+ * @private
  */
-function hasOnly (suite) {
-  return suite._onlyTests.length || suite._onlySuites.length || suite.suites.some(hasOnly);
+function hasOnly(suite) {
+  return (
+    suite._onlyTests.length ||
+    suite._onlySuites.length ||
+    suite.suites.some(hasOnly)
+  );
 }
 
 /**
  * Filter leaks with the given globals flagged as `ok`.
  *
- * @api private
+ * @private
  * @param {Array} ok
  * @param {Array} globals
  * @return {Array}
  */
-function filterLeaks (ok, globals) {
-  return globals.filter(function (key) {
+function filterLeaks(ok, globals) {
+  return globals.filter(function(key) {
     // Firefox and Chrome exposes iframes as index inside the window object
     if (/^\d+/.test(key)) {
       return false;
@@ -939,13 +962,13 @@ function filterLeaks (ok, globals) {
     // in firefox
     // if runner runs in an iframe, this iframe's window.getInterface method
     // not init at first it is assigned in some seconds
-    if (global.navigator && (/^getInterface/).test(key)) {
+    if (global.navigator && /^getInterface/.test(key)) {
       return false;
     }
 
     // an iframe could be approached by window[iframeIndex]
     // in ie6,7,8 and opera, iframeIndex is enumerable, this could cause leak
-    if (global.navigator && (/^\d+/).test(key)) {
+    if (global.navigator && /^\d+/.test(key)) {
       return false;
     }
 
@@ -954,7 +977,7 @@ function filterLeaks (ok, globals) {
       return false;
     }
 
-    var matched = ok.filter(function (ok) {
+    var matched = ok.filter(function(ok) {
       if (~ok.indexOf('*')) {
         return key.indexOf(ok.split('*')[0]) === 0;
       }
@@ -964,22 +987,48 @@ function filterLeaks (ok, globals) {
   });
 }
 
+/**
+ * Check if argument is an instance of Error object or a duck-typed equivalent.
+ *
+ * @private
+ * @param {Object} err - object to check
+ * @param {string} err.message - error message
+ * @returns {boolean}
+ */
+function isError(err) {
+  return err instanceof Error || (err && typeof err.message === 'string');
+}
+
+/**
+ *
+ * Converts thrown non-extensible type into proper Error.
+ *
+ * @private
+ * @param {*} thrown - Non-extensible type thrown by code
+ * @return {Error}
+ */
+function thrown2Error(err) {
+  return new Error(
+    'the ' + type(err) + ' ' + stringify(err) + ' was thrown, throw an Error :)'
+  );
+}
+
 /**
  * Array of globals dependent on the environment.
  *
  * @return {Array}
- * @api private
+ * @private
  */
-function extraGlobals () {
+function extraGlobals() {
   if (typeof process === 'object' && typeof process.version === 'string') {
     var parts = process.version.split('.');
-    var nodeVersion = parts.reduce(function (a, v) {
-      return a << 8 | v;
+    var nodeVersion = parts.reduce(function(a, v) {
+      return (a << 8) | v;
     });
 
     // 'errno' was renamed to process._errno in v0.9.11.
 
-    if (nodeVersion < 0x00090B) {
+    if (nodeVersion < 0x00090b) {
       return ['errno'];
     }
   }