runner.spec.js

'use strict';

var path = require('path');
var sinon = require('sinon');
var Mocha = require('../../lib/mocha');
var Pending = require('../../lib/pending');
var Suite = Mocha.Suite;
var Runner = Mocha.Runner;
var Test = Mocha.Test;
var Runnable = Mocha.Runnable;
var Hook = Mocha.Hook;
var noop = Mocha.utils.noop;
var errors = require('../../lib/errors');
var EVENT_HOOK_BEGIN = Runner.constants.EVENT_HOOK_BEGIN;
var EVENT_HOOK_END = Runner.constants.EVENT_HOOK_END;
var EVENT_TEST_FAIL = Runner.constants.EVENT_TEST_FAIL;
var EVENT_TEST_PASS = Runner.constants.EVENT_TEST_PASS;
var EVENT_TEST_RETRY = Runner.constants.EVENT_TEST_RETRY;
var EVENT_TEST_END = Runner.constants.EVENT_TEST_END;
var EVENT_RUN_END = Runner.constants.EVENT_RUN_END;
var EVENT_SUITE_END = Runner.constants.EVENT_SUITE_END;
var STATE_FAILED = Runnable.constants.STATE_FAILED;
var STATE_IDLE = Runner.constants.STATE_IDLE;
var STATE_RUNNING = Runner.constants.STATE_RUNNING;
var STATE_STOPPED = Runner.constants.STATE_STOPPED;

describe('Runner', function() {
  var suite;
  var runner;

  beforeEach(function() {
    suite = new Suite('Suite', 'root');
    runner = new Runner(suite, {cleanReferencesAfterRun: true});
    runner.checkLeaks = true;
  });

  afterEach(function() {
    sinon.restore();
  });

  describe('.grep()', function() {
    it('should update the runner.total with number of matched tests', function() {
      suite.addTest(new Test('im a test about lions', noop));
      suite.addTest(new Test('im another test about lions', noop));
      suite.addTest(new Test('im a test about bears', noop));
      var newRunner = new Runner(suite);
      newRunner.grep(/lions/);
      expect(newRunner.total, 'to be', 2);
    });

    it('should update the runner.total with number of matched tests when inverted', function() {
      suite.addTest(new Test('im a test about lions', noop));
      suite.addTest(new Test('im another test about lions', noop));
      suite.addTest(new Test('im a test about bears', noop));
      var newRunner = new Runner(suite);
      newRunner.grep(/lions/, true);
      expect(newRunner.total, 'to be', 1);
    });
  });

  describe('.grepTotal()', function() {
    it('should return the total number of matched tests', function() {
      suite.addTest(new Test('im a test about lions', noop));
      suite.addTest(new Test('im another test about lions', noop));
      suite.addTest(new Test('im a test about bears', noop));
      runner.grep(/lions/);
      expect(runner.grepTotal(suite), 'to be', 2);
    });

    it('should return the total number of matched tests when inverted', function() {
      suite.addTest(new Test('im a test about lions', noop));
      suite.addTest(new Test('im another test about lions', noop));
      suite.addTest(new Test('im a test about bears', noop));
      runner.grep(/lions/, true);
      expect(runner.grepTotal(suite), 'to be', 1);
    });
  });

  describe('.globalProps()', function() {
    it('should include common non enumerable globals', function() {
      var props = runner.globalProps();
      expect(
        props,
        'to contain',
        'setTimeout',
        'clearTimeout',
        'setInterval',
        'clearInterval',
        'Date',
        'XMLHttpRequest'
      );
    });
  });

  describe('.globals()', function() {
    it('should default to the known globals', function() {
      expect(runner.globals().length, 'to be greater than', 16);
    });

    it('should white-list globals', function() {
      runner.globals(['foo', 'bar']);
      expect(runner.globals(), 'to contain', 'foo', 'bar');
    });
  });

  describe('.checkGlobals(test)', function() {
    before(function() {
      if (!Object.create) {
        this.skip();
      }
    });

    it('should allow variables that match a wildcard', function(done) {
      runner.globals(['foo*', 'giz*']);
      global.foo = 'baz';
      global.gizmo = 'quux';
      runner.checkGlobals();
      delete global.foo;
      delete global.gizmo;
      done();
    });

    it('should emit "fail" when a new global is introduced', function(done) {
      var test = new Test('im a test', noop);
      runner.checkGlobals();
      global.foo = 'bar';
      runner.on(EVENT_TEST_FAIL, function(_test, _err) {
        expect(_test, 'to be', test);
        expect(_err, 'to have message', "global leak(s) detected: 'foo'");
        delete global.foo;
        done();
      });
      runner.checkGlobals(test);
    });

    it('should emit "fail" when a single new disallowed global is introduced after a single extra global is allowed', function(done) {
      var doneCalled = false;
      runner.globals('good');
      global.bad = 1;
      runner.on(EVENT_TEST_FAIL, function() {
        delete global.bad;
        done();
        doneCalled = true;
      });
      runner.checkGlobals(new Test('yet another test', noop));
      if (!doneCalled) {
        done(Error('Expected test failure did not occur.'));
      }
    });

    it('should not fail when a new common global is introduced', function() {
      if (process.browser) {
        this.skip();
        return;
      }
      // verify that the prop isn't enumerable
      expect(
        Object.prototype.propertyIsEnumerable.call(global, 'XMLHttpRequest'),
        'to be',
        false
      );

      // create a new runner and keep a reference to the test.
      var test = new Test('im a test about bears', noop);
      suite.addTest(test);
      var newRunner = new Runner(suite);

      // make the prop enumerable again.
      global.XMLHttpRequest = noop;
      expect(
        Object.prototype.propertyIsEnumerable.call(global, 'XMLHttpRequest'),
        'to be',
        true
      );

      // verify the test hasn't failed.
      newRunner.checkGlobals(test);
      expect(test, 'not to have key', 'state');

      // clean up our global space.
      delete global.XMLHttpRequest;
    });

    it('should pluralize the error message when several are introduced', function(done) {
      var test = new Test('im a test', noop);
      runner.checkGlobals();
      global.foo = 'bar';
      global.bar = 'baz';
      runner.on(EVENT_TEST_FAIL, function(_test, _err) {
        expect(_test, 'to be', test);
        expect(_err.message, 'to be', "global leak(s) detected: 'foo', 'bar'");
        delete global.foo;
        delete global.bar;
        done();
      });
      runner.checkGlobals(test);
    });

    it('should respect per test whitelisted globals', function() {
      var test = new Test('im a test about lions', noop);
      test.globals(['foo']);

      suite.addTest(test);
      var runner = new Runner(suite);

      global.foo = 'bar';

      // verify the test hasn't failed.
      runner.checkGlobals(test);
      expect(test, 'not to have key', 'state');

      delete global.foo;
    });

    it('should respect per test whitelisted globals but still detect other leaks', function(done) {
      var test = new Test('im a test about lions', noop);
      test.globals(['foo']);

      suite.addTest(test);

      global.foo = 'whitelisted';
      global.bar = 'detect-me';
      runner.on(EVENT_TEST_FAIL, function(_test, _err) {
        expect(_test.title, 'to be', 'im a test about lions');
        expect(_err, 'to have message', "global leak(s) detected: 'bar'");
        delete global.foo;
        delete global.bar;
        done();
      });
      runner.checkGlobals(test);
    });

    it('should emit "fail" when a global beginning with "d" is introduced', function(done) {
      global.derp = 'bar';
      runner.on(EVENT_TEST_FAIL, function(_test, _err) {
        expect(_test.title, 'to be', 'herp');
        expect(_err, 'to have message', "global leak(s) detected: 'derp'");
        delete global.derp;
        done();
      });
      runner.checkGlobals(new Test('herp', noop));
    });
  });

  describe('.hook(name, fn)', function() {
    it('should execute hooks after failed test if suite bail is true', function(done) {
      runner.fail(new Test('failed test', noop), new Error());
      suite.bail(true);
      suite.afterEach(function() {
        suite.afterAll(function() {
          done();
        });
      });
      runner.hook('afterEach', noop);
      runner.hook('afterAll', noop);
    });

    it('should augment hook title with current test title', function(done) {
      var expectedHookTitle;
      function assertHookTitle() {
        expect(hook.title, 'to be', expectedHookTitle);
      }
      var failHook = false;
      var hookError = new Error('failed hook');
      suite.beforeEach(function() {
        assertHookTitle();
        if (failHook) {
          throw hookError;
        }
      });
      runner.on(EVENT_HOOK_BEGIN, assertHookTitle);
      runner.on(EVENT_HOOK_END, assertHookTitle);
      runner.on(EVENT_TEST_FAIL, assertHookTitle);
      runner.on(EVENT_TEST_PASS, assertHookTitle);
      var hook = suite._beforeEach[0];

      suite.addTest(new Test('should behave', noop));
      suite.addTest(new Test('should obey', noop));
      runner.suite = suite;

      runner.test = suite.tests[0];
      expectedHookTitle = '"before each" hook for "should behave"';
      runner.hook('beforeEach', function(err) {
        if (err && err !== hookError) return done(err);

        runner.test = suite.tests[1];
        failHook = true;
        expectedHookTitle = '"before each" hook for "should obey"';
        runner.hook('beforeEach', function(err) {
          if (err && err !== hookError) return done(err);
          return done();
        });
      });
    });
  });

  describe('fail()', function() {
    it('should increment `Runner#failures`', function() {
      expect(runner.failures, 'to be', 0);
      runner.fail(new Test('one', noop), {});
      expect(runner.failures, 'to be', 1);
      runner.fail(new Test('two', noop), new Error());
      expect(runner.failures, 'to be', 2);
    });

    it('should set `Test#state` to "failed"', function() {
      var test = new Test('some test', noop);
      runner.fail(test, 'some error');
      expect(test.state, 'to be', STATE_FAILED);
    });

    it('should emit "fail"', function(done) {
      var test = new Test('some other test', noop);
      var err = {};
      runner.on(EVENT_TEST_FAIL, function(_test, _err) {
        expect(_test, 'to be', test);
        expect(_err, 'to be an', Error);
        expect(_err, 'not to be', {});
        done();
      });
      runner.fail(test, err);
    });

    it('should emit a helpful message when failed with a string', function(done) {
      var test = new Test('helpful test', noop);
      var err = 'string';
      runner.on(EVENT_TEST_FAIL, function(_test, _err) {
        expect(_err, 'to be an', Error);
        expect(
          _err,
          'to have message',
          'the string "string" was thrown, throw an Error :)'
        );
        done();
      });
      runner.fail(test, err);
    });

    it('should emit a the error when failed with an Error instance', function(done) {
      var test = new Test('a test', noop);
      var err = new Error('an error message');
      runner.on(EVENT_TEST_FAIL, function(_test, _err) {
        expect(_err, 'to be an', Error);
        expect(_err, 'to have message', 'an error message');
        done();
      });
      runner.fail(test, err);
    });

    it('should emit the error when failed with an Error-like object', function(done) {
      var test = new Test('a test', noop);
      var err = {message: 'an error message'};
      runner.on(EVENT_TEST_FAIL, function(_test, _err) {
        expect(_err, 'not to be an', Error);
        expect(_err.message, 'to be', 'an error message');
        done();
      });
      runner.fail(test, err);
    });

    it('should emit a helpful message when failed with an Object', function(done) {
      var test = new Test('a test', noop);
      var err = {x: 1};
      runner.on(EVENT_TEST_FAIL, function(_test, _err) {
        expect(_err, 'to be an', Error);
        expect(
          _err,
          'to have message',
          'the object {\n  "x": 1\n} was thrown, throw an Error :)'
        );
        done();
      });
      runner.fail(test, err);
    });

    it('should emit a helpful message when failed with an Array', function(done) {
      var test = new Test('a test', noop);
      var err = [1, 2];
      runner.on(EVENT_TEST_FAIL, function(_test, _err) {
        expect(_err, 'to be an', Error);
        expect(
          _err,
          'to have message',
          'the array [\n  1\n  2\n] was thrown, throw an Error :)'
        );
        done();
      });
      runner.fail(test, err);
    });

    it('should recover if the error stack is not writable', function(done) {
      if (!Object.create) {
        this.skip();
        return;
      }

      var err = new Error('not evil');
      Object.defineProperty(err, 'stack', {
        value: err.stack
      });
      var test = new Test('a test', noop);

      runner.on(EVENT_TEST_FAIL, function(_test, _err) {
        expect(_err, 'to have message', 'not evil');
        done();
      });

      runner.fail(test, err);
    });

    it('should return and not increment failures when test is pending', function() {
      var test = new Test('a test');
      suite.addTest(test);
      test.pending = true;
      runner.fail(test, new Error());
      expect(runner.failures, 'to be', 0);
    });

    describe('when Runner has stopped', function() {
      beforeEach(function() {
        runner.state = STATE_STOPPED;
      });

      describe('when test is not pending', function() {
        describe('when error is the "multiple done" variety', function() {
          it('should throw the "multiple done" error', function() {
            var test = new Test('test', function() {});
            suite.addTest(test);
            var err = new Error();
            err.code = errors.constants.MULTIPLE_DONE;
            expect(
              function() {
                runner.fail(test, err);
              },
              'to throw',
              err
            );
          });
        });

        describe('when error is not of the "multiple done" variety', function() {
          it('should throw a "fatal" error', function() {
            var test = new Test('test', function() {});
            suite.addTest(test);
            var err = new Error();
            expect(
              function() {
                runner.fail(test, err);
              },
              'to throw',
              {
                code: errors.constants.FATAL
              }
            );
          });
        });
      });
    });
  });

  describe('.fail(hook, err)', function() {
    it('should increment .failures', function() {
      expect(runner.failures, 'to be', 0);
      var test1 = new Test('fail hook 1', noop);
      var test2 = new Test('fail hook 2', noop);
      suite.addTest(test1);
      suite.addTest(test2);
      runner.fail(test1, new Error('error1'));
      expect(runner.failures, 'to be', 1);
      runner.fail(test2, new Error('error2'));
      expect(runner.failures, 'to be', 2);
    });

    it('should emit "fail"', function(done) {
      var hook = new Hook();
      hook.parent = suite;
      var err = new Error('error');
      runner.on(EVENT_TEST_FAIL, function(_hook, _err) {
        expect(_hook, 'to be', hook);
        expect(_err, 'to be', err);
        done();
      });
      runner.fail(hook, err);
    });

    it('should not emit "end" if suite bail is not true', function(done) {
      var hook = new Hook();
      hook.parent = suite;
      var err = new Error('error');
      suite.bail(false);
      expect(
        function() {
          runner.fail(hook, err);
        },
        'not to emit from',
        hook,
        EVENT_RUN_END
      );
      done();
    });
  });

  describe('.run(fn)', function() {
    it('should emit "retry" when a retryable test fails', function(done) {
      var retries = 2;
      var retryableFails = 0;
      var err = new Error('bear error');

      var test = new Test('im a test about bears', function() {
        if (retryableFails < retries) {
          throw err;
        }
      });

      suite.retries(retries);
      suite.addTest(test);

      runner.on(EVENT_TEST_RETRY, function(testClone, testErr) {
        retryableFails += 1;
        expect(testClone.title, 'to be', test.title);
        expect(testErr, 'to be', err);
      });

      runner.run(function(failures) {
        expect(failures, 'to be', 0);
        expect(retryableFails, 'to be', retries);

        done();
      });
    });
    // karma-mocha is inexplicably doing this with a Hook
    it('should not throw an exception if something emits EVENT_TEST_END with a non-Test object', function() {
      expect(function() {
        runner.emit(EVENT_TEST_END, {});
      }, 'not to throw');
    });

    it('should clean references after a run', function() {
      runner = new Runner(suite, {delay: false, cleanReferencesAfterRun: true});
      var cleanReferencesStub = sinon.stub(suite, 'cleanReferences');
      runner.run();
      runner.emit(EVENT_SUITE_END, suite);
      expect(cleanReferencesStub, 'was called once');
    });

    it('should not clean references after a run when `cleanReferencesAfterRun` is `false`', function() {
      runner = new Runner(suite, {
        delay: false,
        cleanReferencesAfterRun: false
      });
      var cleanReferencesStub = sinon.stub(suite, 'cleanReferences');
      runner.run();
      runner.emit(EVENT_SUITE_END, suite);
      expect(cleanReferencesStub, 'was not called');
    });

    it('should not leak `Process.uncaughtException` listeners', function(done) {
      var normalUncaughtExceptionListenerCount = process.listenerCount(
        'uncaughtException'
      );

      runner.run();
      runner.run();
      runner.run();
      expect(
        process.listenerCount('uncaughtException'),
        'to be',
        normalUncaughtExceptionListenerCount + 1
      );
      done();
    });

    afterEach(function() {
      runner.dispose();
    });
  });

  describe('.dispose', function() {
    it('should remove all listeners from itself', function() {
      runner.on('disposeShouldRemoveThis', noop);
      runner.dispose();
      expect(runner.listenerCount('disposeShouldRemoveThis'), 'to be', 0);
    });

    it('should remove "error" listeners from a test', function() {
      var fn = sinon.stub();
      runner.test = new Test('test for dispose', fn);
      runner.runTest(noop);
      // sanity check
      expect(runner.test.listenerCount('error'), 'to be', 1);
      runner.dispose();
      expect(runner.test.listenerCount('error'), 'to be', 0);
    });

    it('should remove "uncaughtException" listeners from the process', function() {
      var normalUncaughtExceptionListenerCount = process.listenerCount(
        'uncaughtException'
      );
      runner.run(noop);
      // sanity check
      expect(
        process.listenerCount('uncaughtException'),
        'to be',
        normalUncaughtExceptionListenerCount + 1
      );
      runner.dispose();
      expect(
        process.listenerCount('uncaughtException'),
        'to be',
        normalUncaughtExceptionListenerCount
      );
    });
  });

  describe('.runTest(fn)', function() {
    it('should return when no tests to run', function() {
      runner.test = undefined;
      expect(runner.runTest(noop), 'to be undefined');
    });
  });

  describe('allowUncaught', function() {
    it('should allow unhandled errors to propagate through', function() {
      var newRunner = new Runner(suite);
      newRunner.allowUncaught = true;
      newRunner.test = new Test('failing test', function() {
        throw new Error('allow unhandled errors');
      });
      function fail() {
        newRunner.runTest();
      }
      expect(fail, 'to throw', 'allow unhandled errors');
    });

    it('should not allow unhandled errors in sync hooks to propagate through', function(done) {
      suite.beforeEach(function() {
        throw new Error();
      });
      var runner = new Runner(suite);
      runner.allowUncaught = false;

      // We are monkey patching here with runner.once and a hook.run wrapper to effectively
      // capture thrown errors within the event loop phase where Runner.immediately executes
      runner.once(EVENT_HOOK_BEGIN, function(hook) {
        var _run = hook.run;
        hook.run = function(fn) {
          function throwError() {
            _run.call(hook, fn);
          }
          expect(throwError, 'not to throw');
          done();
        };
      });

      runner.hook('beforeEach', noop);
    });

    it('should allow unhandled errors in sync hooks to propagate through', function(done) {
      suite.beforeEach(function() {
        throw new Error('allow unhandled errors in sync hooks');
      });
      var runner = new Runner(suite);
      runner.allowUncaught = true;

      runner.once(EVENT_HOOK_BEGIN, function(hook) {
        var _run = hook.run;
        hook.run = function(fn) {
          function throwError() {
            _run.call(hook, fn);
          }
          var expected = 'allow unhandled errors in sync hooks';
          expect(throwError, 'to throw', expected);
          done();
        };
      });

      runner.hook('beforeEach', noop);
    });

    it('async - should allow unhandled errors in hooks to propagate through', function(done) {
      // the `done` argument, although unused, it triggers the async path
      // see this.async in the Runnable constructor
      suite.beforeEach(function(done) {
        throw new Error('allow unhandled errors in async hooks');
      });
      var runner = new Runner(suite);
      runner.allowUncaught = true;

      runner.once(EVENT_HOOK_BEGIN, function(hook) {
        var _run = hook.run;
        hook.run = function(fn) {
          function throwError() {
            _run.call(hook, fn);
          }
          var expected = 'allow unhandled errors in async hooks';
          expect(throwError, 'to throw', expected);
          done();
        };
      });

      runner.hook('beforeEach', noop);
    });
  });

  describe('stackTrace', function() {
    var stack = [
      'AssertionError: foo bar',
      'at EventEmitter.<anonymous> (/usr/local/dev/test.js:16:12)',
      'at Context.<anonymous> (/usr/local/dev/test.js:19:5)',
      'Test.Runnable.run (/usr/local/lib/node_modules/mocha/lib/runnable.js:244:7)',
      'Runner.runTest (/usr/local/lib/node_modules/mocha/lib/runner.js:374:10)',
      '/usr/local/lib/node_modules/mocha/lib/runner.js:452:12',
      'next (/usr/local/lib/node_modules/mocha/lib/runner.js:299:14)',
      '/usr/local/lib/node_modules/mocha/lib/runner.js:309:7',
      'next (/usr/local/lib/node_modules/mocha/lib/runner.js:248:23)',
      'Immediate._onImmediate (/usr/local/lib/node_modules/mocha/lib/runner.js:276:5)',
      'at processImmediate [as _immediateCallback] (timers.js:321:17)'
    ];

    before(function() {
      // Only for Node running on Windows
      if (process.platform === 'win32') {
        var addDrive = function(str) {
          var drive = 'C:';
          var pos = str.indexOf(path.posix.sep);
          return pos !== -1 ? str.slice(0, pos) + drive + str.slice(pos) : str;
        };

        var useWinPathSep = function(str) {
          return str.split(path.posix.sep).join(path.win32.sep);
        };

        // Fake Windows pathnames in stacktrace
        stack = stack.map(function(line) {
          return useWinPathSep(addDrive(line));
        });
      }
    });

    describe('shortStackTrace', function() {
      before(function() {
        if (process.browser) {
          this.skip();
        }
      });

      it('should prettify the stack-trace', function(done) {
        var hook = new Hook();
        hook.parent = suite;
        var err = new Error();
        // Fake stack-trace
        err.stack = stack.join('\n');

        runner.on(EVENT_TEST_FAIL, function(_hook, _err) {
          expect(_err.stack, 'to be', stack.slice(0, 3).join('\n'));
          done();
        });
        runner.fail(hook, err);
      });
    });

    describe('longStackTrace', function() {
      it('should display the full stack-trace', function(done) {
        var hook = new Hook();
        hook.parent = suite;
        var err = new Error();
        // Fake stack-trace
        err.stack = stack.join('\n');
        // Add --stack-trace option
        runner.fullStackTrace = true;

        runner.on(EVENT_TEST_FAIL, function(_hook, _err) {
          expect(_err.stack, 'to be', stack.join('\n'));
          done();
        });
        runner.fail(hook, err);
      });
    });

    describe('hugeStackTrace', function() {
      before(function() {
        if (process.browser) {
          this.skip();
        }
      });

      // Generate 64k string
      function genOverlongSingleLineMessage() {
        var n = 8200;
        var data = [];
        data.length = n;
        for (var i = 0; i < n; i++) {
          data[i] = {a: 1};
        }
        return JSON.stringify(data);
      }

      // Generate 64k string
      function genOverlongMultiLineMessage() {
        var n = 1150;
        var data = [];
        data.length = n;
        var str = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.';
        for (var i = 0; i < n; i++) {
          data[i] = str;
        }
        return data.join('\n');
      }

      it('should not hang if overlong error message is single line', function(done) {
        var hook = new Hook();
        hook.parent = suite;
        var message = genOverlongSingleLineMessage();
        var err = new Error();
        // Fake stack-trace
        err.stack = [message].concat(stack).join('\n');

        runner.on(EVENT_TEST_FAIL, function(_hook, _err) {
          var filteredErrStack = _err.stack.split('\n').slice(1);
          expect(
            filteredErrStack.join('\n'),
            'to be',
            stack.slice(0, 3).join('\n')
          );
          done();
        });
        runner.fail(hook, err);
      });

      it('should not hang if overlong error message is multiple lines', function(done) {
        var hook = new Hook();
        hook.parent = suite;
        var message = genOverlongMultiLineMessage();
        var err = new Error();
        // Fake stack-trace
        err.stack = [message].concat(stack).join('\n');

        runner.on(EVENT_TEST_FAIL, function(_hook, _err) {
          var filteredErrStack = _err.stack.split('\n').slice(-3);
          expect(
            filteredErrStack.join('\n'),
            'to be',
            stack.slice(0, 3).join('\n')
          );
          done();
        });
        runner.fail(hook, err);
      });
    });
  });

  describe('abort', function() {
    it('should set _abort property to true', function() {
      runner.abort();
      expect(runner._abort, 'to be true');
    });

    it('should return the Runner', function() {
      expect(runner.abort(), 'to be', runner);
    });
  });

  describe('_uncaught()', function() {
    describe('when called with a non-Runner context', function() {
      it('should throw', function() {
        expect(runner._uncaught.bind({}), 'to throw', {
          code: errors.constants.FATAL
        });
      });
    });
  });

  describe('uncaught()', function() {
    beforeEach(function() {
      sinon.stub(runner, 'fail');
    });

    describe('when allow-uncaught is set to true', function() {
      it('should propagate error and throw', function() {
        if (process.browser) this.skip();

        var err = new Error('should rethrow err');
        runner.allowUncaught = true;
        expect(
          function() {
            runner.uncaught(err);
          },
          'to throw',
          'should rethrow err'
        );
      });
    });

    describe('when provided an object argument', function() {
      describe('when argument is not an Error', function() {
        var err;
        beforeEach(function() {
          err = {whatever: 'yolo'};
        });

        it('should fail with a transient Runnable and a new Error coerced from the object', function() {
          runner.uncaught(err);

          expect(runner.fail, 'to have all calls satisfying', [
            expect.it('to be a', Runnable).and('to satisfy', {
              parent: runner.suite,
              title: /uncaught error outside test suite/i
            }),
            expect.it('to be an', Error).and('to satisfy', {
              message: /throw an error/i,
              uncaught: true
            })
          ]).and('was called once');
        });
      });

      describe('when argument is a Pending', function() {
        it('should ignore argument and return', function() {
          var err = new Pending();
          expect(runner.uncaught(err), 'to be undefined');
        });
      });

      describe('when argument is an Error', function() {
        var err;
        beforeEach(function() {
          err = new Error('sorry dave');
        });

        it('should add the "uncaught" property to the Error', function() {
          runner.uncaught(err);
          expect(err, 'to have property', 'uncaught', true);
        });

        describe('when no Runnables are running', function() {
          beforeEach(function() {
            delete runner.currentRunnable;
          });

          it('should fail with a transient Runnable and the error', function() {
            runner.uncaught(err);

            expect(runner.fail, 'to have all calls satisfying', [
              expect.it('to be a', Runnable).and('to satisfy', {
                parent: runner.suite,
                title: /uncaught error outside test suite/i
              }),
              err
            ]).and('was called once');
          });

          describe('when Runner is RUNNING', function() {
            beforeEach(function() {
              runner.state = STATE_RUNNING;
            });

            it('should not emit start/end events', function() {
              expect(
                function() {
                  runner.uncaught(err);
                },
                'not to emit from',
                runner,
                'start'
              ).and('not to emit from', runner, 'end');
            });
          });

          describe('when Runner is IDLE', function() {
            beforeEach(function() {
              runner.state = STATE_IDLE;
            });

            it('should emit start/end events for the benefit of reporters', function() {
              expect(
                function() {
                  runner.uncaught(err);
                },
                'to emit from',
                runner,
                'start'
              ).and('to emit from', runner, 'end');
            });
          });

          describe('when Runner is STOPPED', function() {
            beforeEach(function() {
              runner.state = STATE_STOPPED;
            });

            it('should not emit start/end events, since this presumably would have already happened', function() {
              expect(
                function() {
                  try {
                    runner.uncaught(err);
                  } catch (ignored) {}
                },
                'not to emit from',
                runner,
                'start'
              ).and('not to emit from', runner, 'end');
            });

            it('should throw', function() {
              expect(function() {
                runner.uncaught(err);
              }, 'to throw');
            });
          });
        });

        describe('when a Runnable is running or has run', function() {
          var runnable;
          beforeEach(function() {
            runnable = new Runnable();
            runnable.parent = runner.suite;
            sinon.stub(runnable, 'clearTimeout');
            runner.currentRunnable = runnable;
          });

          it('should clear any pending timeouts', function() {
            runnable.callback = sinon.fake();
            runner.uncaught(err);
            expect(runnable.clearTimeout, 'was called times', 1);
          });

          describe('when current Runnable has already failed', function() {
            beforeEach(function() {
              sinon.stub(runnable, 'isFailed').returns(true);
            });

            it('should not attempt to fail again', function() {
              runner.uncaught(err);
              expect(runner.fail, 'was not called');
            });
          });

          describe('when current Runnable has been marked pending', function() {
            beforeEach(function() {
              sinon.stub(runnable, 'isPending').returns(true);
            });

            it('should attempt to fail', function() {
              runner.uncaught(err);
              expect(runner.fail, 'was called once');
            });
          });

          describe('when the current Runnable has already passed', function() {
            beforeEach(function() {
              sinon.stub(runnable, 'isPassed').returns(true);
            });

            it('should fail with the current Runnable and the error', function() {
              runner.uncaught(err);

              expect(runner.fail, 'to have all calls satisfying', [
                expect.it('to be', runnable),
                err
              ]).and('was called once');
            });

            it('should abort the runner without emitting end event', function() {
              expect(
                function() {
                  runner.uncaught(err);
                },
                'not to emit from',
                runner,
                'end'
              );
              expect(runner._abort, 'to be', true);
            });
          });

          describe('when the current Runnable is still running', function() {
            describe('when the current Runnable is a Test', function() {
              beforeEach(function() {
                runnable = new Test('goomba', noop);
                runnable.parent = runner.suite;
                runner.currentRunnable = runnable;
                runnable.callback = sinon.fake();
              });

              it('should run callback(err) to handle failing and hooks', function() {
                runner.uncaught(err);

                expect(runner.fail, 'was not called');
                expect(runnable.callback, 'to have all calls satisfying', [
                  err
                ]).and('was called once');
              });

              it('should not notify test has ended', function() {
                expect(
                  function() {
                    runner.uncaught(err);
                  },
                  'not to emit from',
                  runner,
                  EVENT_TEST_END
                );
              });

              it('should not notify run has ended', function() {
                expect(
                  function() {
                    runner.uncaught(err);
                  },
                  'not to emit from',
                  runner,
                  EVENT_RUN_END
                );
              });
            });

            describe('when the current Runnable is a Hook', function() {
              beforeEach(function() {
                runnable = new Hook();
                runnable.parent = runner.suite;
                runner.currentRunnable = runnable;
                runnable.callback = sinon.fake();
              });

              it('should run callback(err) to handle failing hook pattern', function() {
                runner.uncaught(err);

                expect(runner.fail, 'was not called');
                expect(runnable.callback, 'to have all calls satisfying', [
                  err
                ]).and('was called once');
              });

              it('should not notify test has ended', function() {
                expect(
                  function() {
                    runner.uncaught(err);
                  },
                  'not to emit from',
                  runner,
                  EVENT_TEST_END
                );
              });

              it('should not notify run has ended', function() {
                expect(
                  function() {
                    runner.uncaught(err);
                  },
                  'not to emit from',
                  runner,
                  EVENT_RUN_END
                );
              });
            });
          });
        });
      });
    });
  });
});