mocha 2.2.5 → 2.3.3

package/lib/runner.js

@@ -2,16 +2,19 @@
  * Module dependencies.
  */
 
-var EventEmitter = require('events').EventEmitter
-  , debug = require('debug')('mocha:runner')
-  , Pending = require('./pending')
-  , Test = require('./test')
-  , utils = require('./utils')
-  , filter = utils.filter
-  , keys = utils.keys
-  , type = utils.type
-  , stringify = utils.stringify
-  , stackFilter = utils.stackTraceFilter();
+var EventEmitter = require('events').EventEmitter;
+var Pending = require('./pending');
+var utils = require('./utils');
+var inherits = utils.inherits;
+var debug = require('debug')('mocha:runner');
+var Runnable = require('./runnable');
+var filter = utils.filter;
+var indexOf = utils.indexOf;
+var keys = utils.keys;
+var stackFilter = utils.stackTraceFilter();
+var stringify = utils.stringify;
+var type = utils.type;
+var undefinedError = utils.undefinedError;
 
 /**
  * Non-enumerable globals.
@@ -51,23 +54,28 @@ module.exports = Runner;
  *   - `fail`  (test, err) test failed
  *   - `pending`  (test) test pending
  *
+ * @api public
  * @param {Suite} suite Root suite
  * @param {boolean} [delay] Whether or not to delay execution of root suite
- *   until ready.
- * @api public
+ * until ready.
  */
-
 function Runner(suite, delay) {
   var self = this;
   this._globals = [];
   this._abort = false;
   this._delay = delay;
   this.suite = suite;
+  this.started = false;
   this.total = suite.total();
   this.failures = 0;
-  this.on('test end', function(test){ self.checkGlobals(test); });
-  this.on('hook end', function(hook){ self.checkGlobals(hook); });
-  this.grep(/.*/);
+  this.on('test end', function(test) {
+    self.checkGlobals(test);
+  });
+  this.on('hook end', function(hook) {
+    self.checkGlobals(hook);
+  });
+  this._defaultGrep = /.*/;
+  this.grep(this._defaultGrep);
   this.globals(this.globalProps().concat(extraGlobals()));
 }
 
@@ -77,14 +85,12 @@ function Runner(suite, delay) {
  * @param {Function} fn
  * @api private
  */
-
 Runner.immediately = global.setImmediate || process.nextTick;
 
 /**
  * Inherit from `EventEmitter.prototype`.
  */
-
-Runner.prototype.__proto__ = EventEmitter.prototype;
+inherits(Runner, EventEmitter);
 
 /**
  * Run tests with full titles matching `re`. Updates runner.total
@@ -94,9 +100,11 @@ Runner.prototype.__proto__ = EventEmitter.prototype;
  * @param {Boolean} invert
  * @return {Runner} for chaining
  * @api public
+ * @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;
@@ -111,16 +119,21 @@ Runner.prototype.grep = function(re, invert){
  * @param {Suite} suite
  * @return {Number}
  * @api public
+ * @param {Suite} suite
+ * @return {number}
  */
-
 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;
-    if (match) total++;
+    if (self._invert) {
+      match = !match;
+    }
+    if (match) {
+      total++;
+    }
   });
 
   return total;
@@ -132,13 +145,14 @@ Runner.prototype.grepTotal = function(suite) {
  * @return {Array}
  * @api private
  */
-
 Runner.prototype.globalProps = function() {
-  var props = utils.keys(global);
+  var props = keys(global);
 
   // non-enumerables
   for (var i = 0; i < globals.length; ++i) {
-    if (~utils.indexOf(props, globals[i])) continue;
+    if (~indexOf(props, globals[i])) {
+      continue;
+    }
     props.push(globals[i]);
   }
 
@@ -151,10 +165,13 @@ Runner.prototype.globalProps = function() {
  * @param {Array} arr
  * @return {Runner} for chaining
  * @api public
+ * @param {Array} arr
+ * @return {Runner} Runner instance.
  */
-
-Runner.prototype.globals = function(arr){
-  if (0 == arguments.length) return this._globals;
+Runner.prototype.globals = function(arr) {
+  if (!arguments.length) {
+    return this._globals;
+  }
   debug('globals %j', arr);
   this._globals = this._globals.concat(arr);
   return this;
@@ -165,9 +182,10 @@ Runner.prototype.globals = function(arr){
  *
  * @api private
  */
-
-Runner.prototype.checkGlobals = function(test){
-  if (this.ignoreLeaks) return;
+Runner.prototype.checkGlobals = function(test) {
+  if (this.ignoreLeaks) {
+    return;
+  }
   var ok = this._globals;
 
   var globals = this.globalProps();
@@ -177,7 +195,9 @@ Runner.prototype.checkGlobals = function(test){
     ok = ok.concat(test._allowedGlobals || []);
   }
 
-  if(this.prevGlobalsLength == globals.length) return;
+  if (this.prevGlobalsLength === globals.length) {
+    return;
+  }
   this.prevGlobalsLength = globals.length;
 
   leaks = filterLeaks(ok, globals);
@@ -193,16 +213,15 @@ Runner.prototype.checkGlobals = function(test){
 /**
  * Fail the given `test`.
  *
+ * @api private
  * @param {Test} test
  * @param {Error} err
- * @api private
  */
-
 Runner.prototype.fail = function(test, err) {
   ++this.failures;
   test.state = 'failed';
 
-  if (!(err instanceof Error)) {
+  if (!(err instanceof Error || err && typeof err.message === 'string')) {
     err = new Error('the ' + type(err) + ' ' + stringify(err) + ' was thrown, throw an Error :)');
   }
 
@@ -229,12 +248,16 @@ Runner.prototype.fail = function(test, err) {
  *   suite and subsuites, but executes other `after each`
  *   hooks
  *
+ * @api private
  * @param {Hook} hook
  * @param {Error} err
- * @api private
  */
+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 + '"';
+  }
 
-Runner.prototype.failHook = function(hook, err){
   this.fail(hook, err);
   if (this.suite.bail()) {
     this.emit('end');
@@ -244,34 +267,38 @@ Runner.prototype.failHook = function(hook, err){
 /**
  * Run hook `name` callbacks and then invoke `fn()`.
  *
- * @param {String} name
- * @param {Function} function
  * @api private
+ * @param {string} name
+ * @param {Function} fn
  */
 
-Runner.prototype.hook = function(name, fn){
-  var suite = this.suite
-    , hooks = suite['_' + name]
-    , self = this
-    , timer;
+Runner.prototype.hook = function(name, fn) {
+  var suite = this.suite;
+  var hooks = suite['_' + name];
+  var self = this;
 
   function next(i) {
     var hook = hooks[i];
-    if (!hook) return fn();
+    if (!hook) {
+      return fn();
+    }
     self.currentRunnable = hook;
 
     hook.ctx.currentTest = self.test;
 
     self.emit('hook', hook);
 
-    hook.on('error', function(err){
-      self.failHook(hook, err);
-    });
+    if (!hook.listeners('error').length) {
+      hook.on('error', function(err) {
+        self.failHook(hook, err);
+      });
+    }
 
-    hook.run(function(err){
-      hook.removeAllListeners('error');
+    hook.run(function(err) {
       var testError = hook.error();
-      if (testError) self.fail(self.test, testError);
+      if (testError) {
+        self.fail(self.test, testError);
+      }
       if (err) {
         if (err instanceof Pending) {
           suite.pending = true;
@@ -288,7 +315,7 @@ Runner.prototype.hook = function(name, fn){
     });
   }
 
-  Runner.immediately(function(){
+  Runner.immediately(function() {
     next(0);
   });
 };
@@ -297,15 +324,14 @@ Runner.prototype.hook = function(name, fn){
  * Run hook `name` for the given array of `suites`
  * in order, and callback `fn(err, errSuite)`.
  *
- * @param {String} name
+ * @api private
+ * @param {string} name
  * @param {Array} suites
  * @param {Function} fn
- * @api private
  */
-
-Runner.prototype.hooks = function(name, suites, fn){
-  var self = this
-    , orig = this.suite;
+Runner.prototype.hooks = function(name, suites, fn) {
+  var self = this;
+  var orig = this.suite;
 
   function next(suite) {
     self.suite = suite;
@@ -315,7 +341,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;
@@ -336,8 +362,7 @@ Runner.prototype.hooks = function(name, suites, fn){
  * @param {Function} fn
  * @api 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);
 };
@@ -349,8 +374,7 @@ Runner.prototype.hookUp = function(name, fn){
  * @param {Function} fn
  * @api 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);
 };
@@ -362,11 +386,13 @@ Runner.prototype.hookDown = function(name, fn){
  * @return {Array}
  * @api private
  */
-
-Runner.prototype.parents = function(){
-  var suite = this.suite
-    , suites = [];
-  while (suite = suite.parent) suites.push(suite);
+Runner.prototype.parents = function() {
+  var suite = this.suite;
+  var suites = [];
+  while (suite.parent) {
+    suite = suite.parent;
+    suites.push(suite);
+  }
   return suites;
 };
 
@@ -376,15 +402,20 @@ Runner.prototype.parents = function(){
  * @param {Function} fn
  * @api private
  */
+Runner.prototype.runTest = function(fn) {
+  var self = this;
+  var test = this.test;
 
-Runner.prototype.runTest = function(fn){
-  var test = this.test
-    , self = this;
-
-  if (this.asyncOnly) test.asyncOnly = true;
+  if (this.asyncOnly) {
+    test.asyncOnly = true;
+  }
 
+  if (this.allowUncaught) {
+    test.allowUncaught = true;
+    return test.run(fn);
+  }
   try {
-    test.on('error', function(err){
+    test.on('error', function(err) {
       self.fail(test, err);
     });
     test.run(fn);
@@ -394,21 +425,18 @@ Runner.prototype.runTest = function(fn){
 };
 
 /**
- * Run tests in the given `suite` and invoke
- * the callback `fn()` when complete.
+ * Run tests in the given `suite` and invoke the callback `fn()` when complete.
  *
+ * @api private
  * @param {Suite} suite
  * @param {Function} fn
- * @api private
  */
+Runner.prototype.runTests = function(suite, fn) {
+  var self = this;
+  var tests = suite.tests.slice();
+  var test;
 
-Runner.prototype.runTests = function(suite, fn){
-  var self = this
-    , tests = suite.tests.slice()
-    , test;
-
-
-  function hookErr(err, errSuite, after) {
+  function hookErr(_, errSuite, after) {
     // before/after Each hook for errSuite failed:
     var orig = self.suite;
 
@@ -421,7 +449,9 @@ Runner.prototype.runTests = function(suite, fn){
       self.hookUp('afterEach', function(err2, errSuite2) {
         self.suite = orig;
         // some hooks may fail even now
-        if (err2) return hookErr(err2, errSuite2, true);
+        if (err2) {
+          return hookErr(err2, errSuite2, true);
+        }
         // report error suite
         fn(errSuite);
       });
@@ -434,22 +464,47 @@ Runner.prototype.runTests = function(suite, fn){
 
   function next(err, errSuite) {
     // if we bail after first err
-    if (self.failures && suite._bail) return fn();
+    if (self.failures && suite._bail) {
+      return fn();
+    }
 
-    if (self._abort) return fn();
+    if (self._abort) {
+      return fn();
+    }
 
-    if (err) return hookErr(err, errSuite, true);
+    if (err) {
+      return hookErr(err, errSuite, true);
+    }
 
     // next test
     test = tests.shift();
 
     // all done
-    if (!test) return fn();
+    if (!test) {
+      return fn();
+    }
 
     // grep
     var match = self._grep.test(test.fullTitle());
-    if (self._invert) match = !match;
-    if (!match) return next();
+    if (self._invert) {
+      match = !match;
+    }
+    if (!match) {
+      // Run immediately only if we have defined a grep. When we
+      // define a grep — It can cause maximum callstack error if
+      // the grep is doing a large recursive loop by neglecting
+      // all tests. The run immediately function also comes with
+      // a performance cost. So we don't want to run immediately
+      // if we run the whole test suite, because running the whole
+      // test suite don't do any immediate recursive loops. Thus,
+      // allowing a JS runtime to breathe.
+      if (self._grep !== self._defaultGrep) {
+        Runner.immediately(next);
+      } else {
+        next();
+      }
+      return;
+    }
 
     // pending
     if (test.pending) {
@@ -460,17 +515,17 @@ Runner.prototype.runTests = function(suite, fn){
 
     // execute test and hook(s)
     self.emit('test', self.test = test);
-    self.hookDown('beforeEach', function(err, errSuite){
-
+    self.hookDown('beforeEach', function(err, errSuite) {
       if (suite.pending) {
         self.emit('pending', test);
         self.emit('test end', test);
         return next();
       }
-      if (err) return hookErr(err, errSuite, false);
-
+      if (err) {
+        return hookErr(err, errSuite, false);
+      }
       self.currentRunnable = self.test;
-      self.runTest(function(err){
+      self.runTest(function(err) {
         test = self.test;
 
         if (err) {
@@ -497,60 +552,88 @@ Runner.prototype.runTests = function(suite, fn){
   }
 
   this.next = next;
+  this.hookErr = hookErr;
   next();
 };
 
 /**
- * Run the given `suite` and invoke the
- * callback `fn()` when complete.
+ * Run the given `suite` and invoke the callback `fn()` when complete.
  *
+ * @api private
  * @param {Suite} suite
  * @param {Function} fn
- * @api private
  */
-
-Runner.prototype.runSuite = function(suite, fn){
-  var total = this.grepTotal(suite)
-    , self = this
-    , i = 0;
+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());
 
-  if (!total) return fn();
+  if (!total || (self.failures && suite._bail)) {
+    return fn();
+  }
 
   this.emit('suite', this.suite = suite);
 
   function next(errSuite) {
     if (errSuite) {
       // current suite failed on a hook from errSuite
-      if (errSuite == suite) {
+      if (errSuite === suite) {
         // if errSuite is current suite
         // continue to the next sibling suite
         return done();
-      } else {
-        // errSuite is among the parents of current suite
-        // stop execution of errSuite and all sub-suites
-        return done(errSuite);
       }
+      // errSuite is among the parents of current suite
+      // stop execution of errSuite and all sub-suites
+      return done(errSuite);
     }
 
-    if (self._abort) return done();
+    if (self._abort) {
+      return done();
+    }
 
     var curr = suite.suites[i++];
-    if (!curr) return done();
-    self.runSuite(curr, next);
+    if (!curr) {
+      return done();
+    }
+
+    // Avoid grep neglecting large number of tests causing a
+    // 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() {
+        self.runSuite(curr, next);
+      });
+    } else {
+      self.runSuite(curr, next);
+    }
   }
 
   function done(errSuite) {
     self.suite = suite;
-    self.hook('afterAll', function(){
-      self.emit('suite end', 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;
+      self.hook('afterAll', function() {
+        self.emit('suite end', suite);
+        fn(errSuite);
+      });
+    }
   }
 
-  this.hook('beforeAll', function(err){
-    if (err) return done();
+  this.nextSuite = next;
+
+  this.hook('beforeAll', function(err) {
+    if (err) {
+      return done();
+    }
     self.runTests(suite, next);
   });
 };
@@ -561,35 +644,66 @@ Runner.prototype.runSuite = function(suite, fn){
  * @param {Error} err
  * @api private
  */
-
-Runner.prototype.uncaught = function(err){
+Runner.prototype.uncaught = function(err) {
   if (err) {
-    debug('uncaught exception %s', err !== function () {
+    debug('uncaught exception %s', err !== function() {
       return this;
-    }.call(err) ? err : ( err.message || err ));
+    }.call(err) ? err : (err.message || err));
   } else {
     debug('uncaught undefined exception');
-    err = utils.undefinedError();
+    err = undefinedError();
   }
   err.uncaught = true;
 
   var runnable = this.currentRunnable;
-  if (!runnable) return;
+
+  if (!runnable) {
+    runnable = new Runnable('Uncaught error outside test suite');
+    runnable.parent = this.suite;
+
+    if (this.started) {
+      this.fail(runnable, err);
+    } else {
+      // Can't recover from this failure
+      this.emit('start');
+      this.fail(runnable, err);
+      this.emit('end');
+    }
+
+    return;
+  }
 
   runnable.clearTimeout();
 
   // Ignore errors if complete
-  if (runnable.state) return;
+  if (runnable.state) {
+    return;
+  }
   this.fail(runnable, err);
 
   // recover from test
-  if ('test' == runnable.type) {
+  if (runnable.type === 'test') {
     this.emit('test end', runnable);
     this.hookUp('afterEach', this.next);
     return;
   }
 
-  // bail on hooks
+ // recover from hooks
+  if (runnable.type === 'hook') {
+    var errSuite = this.suite;
+    // 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);
+  }
+
+  // bail
   this.emit('end');
 };
 
@@ -600,21 +714,23 @@ Runner.prototype.uncaught = function(err){
  * @param {Function} fn
  * @return {Runner} for chaining
  * @api public
+ * @param {Function} fn
+ * @return {Runner} Runner instance.
  */
+Runner.prototype.run = function(fn) {
+  var self = this;
+  var rootSuite = this.suite;
 
-Runner.prototype.run = function(fn){
-  var self = this,
-    rootSuite = this.suite;
-
-  fn = fn || function(){};
+  fn = fn || function() {};
 
-  function uncaught(err){
+  function uncaught(err) {
     self.uncaught(err);
   }
 
   function start() {
+    self.started = true;
     self.emit('start');
-    self.runSuite(rootSuite, function(){
+    self.runSuite(rootSuite, function() {
       debug('finished running');
       self.emit('end');
     });
@@ -623,7 +739,7 @@ Runner.prototype.run = function(fn){
   debug('start');
 
   // callback
-  this.on('end', function(){
+  this.on('end', function() {
     debug('end');
     process.removeListener('uncaughtException', uncaught);
     fn(self.failures);
@@ -637,8 +753,7 @@ Runner.prototype.run = function(fn){
     // might be nice to debounce some dots while we wait.
     this.emit('waiting', rootSuite);
     rootSuite.once('run', start);
-  }
-  else {
+  } else {
     start();
   }
 
@@ -646,47 +761,58 @@ Runner.prototype.run = function(fn){
 };
 
 /**
- * Cleanly abort execution
+ * Cleanly abort execution.
  *
- * @return {Runner} for chaining
  * @api public
+ * @return {Runner} Runner instance.
  */
-Runner.prototype.abort = function(){
+Runner.prototype.abort = function() {
   debug('aborting');
   this._abort = true;
+
+  return this;
 };
 
 /**
  * Filter leaks with the given globals flagged as `ok`.
  *
+ * @api private
  * @param {Array} ok
  * @param {Array} globals
  * @return {Array}
- * @api private
  */
-
 function filterLeaks(ok, globals) {
-  return filter(globals, function(key){
+  return filter(globals, function(key) {
     // Firefox and Chrome exposes iframes as index inside the window object
-    if (/^d+/.test(key)) return false;
+    if (/^d+/.test(key)) {
+      return false;
+    }
 
     // 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)) return false;
+    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)) return false;
+    if (global.navigator && (/^\d+/).test(key)) {
+      return false;
+    }
 
     // Opera and IE expose global variables for HTML element IDs (issue #243)
-    if (/^mocha-/.test(key)) return false;
+    if (/^mocha-/.test(key)) {
+      return false;
+    }
 
-    var matched = filter(ok, function(ok){
-      if (~ok.indexOf('*')) return 0 == key.indexOf(ok.split('*')[0]);
-      return key == ok;
+    var matched = filter(ok, function(ok) {
+      if (~ok.indexOf('*')) {
+        return key.indexOf(ok.split('*')[0]) === 0;
+      }
+      return key === ok;
     });
-    return matched.length == 0 && (!global.navigator || 'onerror' !== key);
+    return !matched.length && (!global.navigator || key !== 'onerror');
   });
 }
 
@@ -696,21 +822,19 @@ function filterLeaks(ok, globals) {
  * @return {Array}
  * @api private
  */
-
 function extraGlobals() {
- if (typeof(process) === 'object' &&
-     typeof(process.version) === 'string') {
-
-   var nodeVersion = process.version.split('.').reduce(function(a, v) {
-     return a << 8 | v;
-   });
+  if (typeof process === 'object' && typeof process.version === 'string') {
+    var parts = process.version.split('.');
+    var nodeVersion = utils.reduce(parts, function(a, v) {
+      return a << 8 | v;
+    });
 
-   // 'errno' was renamed to process._errno in v0.9.11.
+    // 'errno' was renamed to process._errno in v0.9.11.
 
-   if (nodeVersion < 0x00090B) {
-     return ['errno'];
-   }
- }
+    if (nodeVersion < 0x00090B) {
+      return ['errno'];
+    }
+  }
 
- return [];
+  return [];
 }