Catch unhandled promise rejections during tests

lib/runner.js

@@ -783,16 +783,19 @@ Runner.prototype.runSuite = function(suite, fn) {
  * Handle uncaught exceptions.
  *
  * @param {Error} err
+ * @param {string} unwhat It this an 'uncaught' exception, or 'unhandled' rejection
  * @private
  */
-Runner.prototype.uncaught = function(err) {
+Runner.prototype.uncaught = function(err, unwhat) {
+ unwhat = unwhat || 'uncaught';
+
  if (err instanceof Pending) {
  return;
  }
  if (err) {
- debug('uncaught exception %O', err);
+ debug('%s exception %O', unwhat, err);
  } else {
- debug('uncaught undefined/falsy exception');
+ debug('%s undefined/falsy exception', unwhat);
  err = createInvalidExceptionError(
  'Caught falsy/undefined exception which would otherwise be uncaught. No stack trace found; try a debugger',
  err
@@ -802,12 +805,13 @@ Runner.prototype.uncaught = function(err) {
  if (!isError(err)) {
  err = thrown2Error(err);
  }
- err.uncaught = true;
+ err[unwhat] = true;
 
  var runnable = this.currentRunnable;
 
  if (!runnable) {
- runnable = new Runnable('Uncaught error outside test suite');
+ var capitalisedUnwhat = unwhat === 'uncaught' ? 'Uncaught' : 'Unhandled';
+ runnable = new Runnable(capitalisedUnwhat + ' error outside test suite');
  runnable.parent = this.suite;
 
  if (this.started) {
@@ -879,7 +883,10 @@ Runner.prototype.run = function(fn) {
  fn = fn || function() {};
 
  function uncaught(err) {
- self.uncaught(err);
+ self.uncaught(err, 'uncaught');
+ }
+ function unhandled(err) {
+ self.uncaught(err, 'unhandled');
  }
 
  function start() {
@@ -910,11 +917,14 @@ Runner.prototype.run = function(fn) {
  this.on(constants.EVENT_RUN_END, function() {
  debug(constants.EVENT_RUN_END);
  process.removeListener('uncaughtException', uncaught);
+ process.removeListener('unhandledRejection', unhandled);
  fn(self.failures);
  });
 
  // uncaught exception
  process.on('uncaughtException', uncaught);
+ // unhandled rejection
+ process.on('unhandledRejection', unhandled);
 
  if (this._delay) {
  // for reporters, I guess.

test/integration/fixtures/unhandled.fixture.js

@@ -0,0 +1,40 @@
+'use strict';
+
+function rejectWith(err) {
+ return new Promise(function (resolve, reject) {
+ reject(err);
+ });
+}
+
+// We wish to test unhandled rejections, which happen after a tick at the
+// earliest, so we need a way some way to signal mocha our tests are async. One
+// way is to accept the `done` parameter without ever using it. Another is
+// returning a promise which never resolves. Since this tests promise handling,
+// why don't we go all the way with the promises?
+var unresolvedPromise = new Promise(function () {});
+
+it('fails when faced with an unhandled rejection', function () {
+ rejectWith(new Error('rejection'));
+
+ return unresolvedPromise;
+});
+
+it('fails exactly once when a global promise is rejected first', function () {
+ setTimeout(function () {
+ rejectWith(new Error('global error'));
+ }, 0);
+
+ return unresolvedPromise;
+});
+
+it('fails exactly once when a global promise is rejected second', function () {
+ setTimeout(function () {
+ rejectWith(new Error('test error'));
+ }, 0);
+
+ setTimeout(function () {
+ rejectWith(new Error('global error'));
+ }, 0);
+
+ return unresolvedPromise;
+});

test/integration/uncaught.spec.js

@@ -71,3 +71,22 @@ describe('uncaught exceptions', function() {
  });
  });
 });
+
+describe('unhandled rejections', function() {
+ it('handles unhandled rejections from async specs', function(done) {
+ run('unhandled.fixture.js', args, function(err, res) {
+ if (err) {
+ done(err);
+ return;
+ }
+
+ assert.strictEqual(res.stats.pending, 0);
+ assert.strictEqual(res.stats.passes, 0);
+ assert.strictEqual(res.stats.failures, 3);
+
+ assert.strictEqual(res.code, 3);
+
+ done();
+ });
+ });
+});