diff --git a/lib/jasmine-core/jasmine.js b/lib/jasmine-core/jasmine.js index a9ed5975..1a00063f 100644 --- a/lib/jasmine-core/jasmine.js +++ b/lib/jasmine-core/jasmine.js @@ -79,6 +79,7 @@ var getJasmineRequireObj = (function (jasmineGlobal) { j$.DiffBuilder = jRequire.DiffBuilder(j$); j$.NullDiffBuilder = jRequire.NullDiffBuilder(j$); j$.ObjectPath = jRequire.ObjectPath(j$); + j$.GlobalErrors = jRequire.GlobalErrors(j$); j$.matchers = jRequire.requireMatchers(jRequire, j$); @@ -581,6 +582,8 @@ getJasmineRequireObj().Env = function(j$) { 'specDone' ]); + var globalErrors = new j$.GlobalErrors(); + this.specFilter = function() { return true; }; @@ -728,6 +731,7 @@ getJasmineRequireObj().Env = function(j$) { options.clearStack = options.clearStack || clearStack; options.timeout = {setTimeout: realSetTimeout, clearTimeout: realClearTimeout}; options.fail = self.fail; + options.globalErrors = globalErrors; new j$.QueueRunner(options).execute(); }; @@ -791,9 +795,11 @@ getJasmineRequireObj().Env = function(j$) { currentlyExecutingSuites.push(topSuite); + globalErrors.install(); processor.execute(function() { clearResourcesForRunnable(topSuite.id); currentlyExecutingSuites.pop(); + globalErrors.uninstall(); reporter.jasmineDone({ order: order, @@ -1912,6 +1918,52 @@ getJasmineRequireObj().formatErrorMsg = function() { return generateErrorMsg; }; +getJasmineRequireObj().GlobalErrors = function(j$) { + function GlobalErrors(global) { + var handlers = []; + global = global || j$.getGlobal(); + + var onerror = function onerror() { + var handler = handlers[handlers.length - 1]; + handler.apply(null, Array.prototype.slice.call(arguments, 0)); + }; + + this.uninstall = function noop() {}; + + this.install = function install() { + if (global.process && j$.isFunction_(global.process.on)) { + var originalHandlers = global.process.listeners('uncaughtException'); + global.process.removeAllListeners('uncaughtException'); + global.process.on('uncaughtException', onerror); + + this.uninstall = function uninstall() { + global.process.removeListener('uncaughtException', onerror); + for (var i = 0; i < originalHandlers.length; i++) { + global.process.on('uncaughtException', originalHandlers[i]); + } + }; + } else { + var originalHandler = global.onerror; + global.onerror = onerror; + + this.uninstall = function uninstall() { + global.onerror = originalHandler; + }; + } + }; + + this.pushListener = function pushListener(listener) { + handlers.push(listener); + }; + + this.popListener = function popListener() { + handlers.pop(); + }; + } + + return GlobalErrors; +}; + getJasmineRequireObj().DiffBuilder = function(j$) { return function DiffBuilder() { var path = new j$.ObjectPath(), @@ -3237,6 +3289,7 @@ getJasmineRequireObj().QueueRunner = function(j$) { this.userContext = attrs.userContext || {}; this.timeout = attrs.timeout || {setTimeout: setTimeout, clearTimeout: clearTimeout}; this.fail = attrs.fail || function() {}; + this.globalErrors = attrs.globalErrors || { pushListener: function() {}, popListener: function() {} }; } QueueRunner.prototype.execute = function() { @@ -3273,8 +3326,13 @@ getJasmineRequireObj().QueueRunner = function(j$) { var clearTimeout = function () { Function.prototype.apply.apply(self.timeout.clearTimeout, [j$.getGlobal(), [timeoutId]]); }, + handleError = function(error) { + onException(error); + next(); + }, next = once(function () { clearTimeout(timeoutId); + self.globalErrors.popListener(handleError); self.run(queueableFns, iterativeIndex + 1); }), timeoutId; @@ -3284,6 +3342,8 @@ getJasmineRequireObj().QueueRunner = function(j$) { next(); }; + self.globalErrors.pushListener(handleError); + if (queueableFn.timeout) { timeoutId = Function.prototype.apply.apply(self.timeout.setTimeout, [j$.getGlobal(), [function() { var error = new Error('Timeout - Async callback was not invoked within timeout specified by jasmine.DEFAULT_TIMEOUT_INTERVAL.'); diff --git a/spec/core/GlobalErrorsSpec.js b/spec/core/GlobalErrorsSpec.js new file mode 100644 index 00000000..a16cc005 --- /dev/null +++ b/spec/core/GlobalErrorsSpec.js @@ -0,0 +1,94 @@ +describe("GlobalErrors", function() { + it("calls the added handler on error", function() { + var fakeGlobal = { onerror: null }, + handler = jasmine.createSpy('errorHandler'), + errors = new jasmineUnderTest.GlobalErrors(fakeGlobal); + + errors.install(); + errors.pushListener(handler); + + fakeGlobal.onerror('foo'); + + expect(handler).toHaveBeenCalledWith('foo'); + }); + + it("only calls the most recent handler", function() { + var fakeGlobal = { onerror: null }, + handler1 = jasmine.createSpy('errorHandler1'), + handler2 = jasmine.createSpy('errorHandler2'), + errors = new jasmineUnderTest.GlobalErrors(fakeGlobal); + + errors.install(); + errors.pushListener(handler1); + errors.pushListener(handler2); + + fakeGlobal.onerror('foo'); + + expect(handler1).not.toHaveBeenCalled(); + expect(handler2).toHaveBeenCalledWith('foo'); + }); + + it("calls previous handlers when one is removed", function() { + var fakeGlobal = { onerror: null }, + handler1 = jasmine.createSpy('errorHandler1'), + handler2 = jasmine.createSpy('errorHandler2'), + errors = new jasmineUnderTest.GlobalErrors(fakeGlobal); + + errors.install(); + errors.pushListener(handler1); + errors.pushListener(handler2); + + errors.popListener(); + + fakeGlobal.onerror('foo'); + + expect(handler1).toHaveBeenCalledWith('foo'); + expect(handler2).not.toHaveBeenCalled(); + }); + + it("uninstalls itself, putting back a previous callback", function() { + var originalCallback = jasmine.createSpy('error'), + fakeGlobal = { onerror: originalCallback }, + errors = new jasmineUnderTest.GlobalErrors(fakeGlobal); + + expect(fakeGlobal.onerror).toBe(originalCallback); + + errors.install(); + + expect(fakeGlobal.onerror).not.toBe(originalCallback); + + errors.uninstall(); + + expect(fakeGlobal.onerror).toBe(originalCallback); + }); + + it("works in node.js", function() { + var fakeGlobal = { + process: { + on: jasmine.createSpy('process.on'), + removeListener: jasmine.createSpy('process.removeListener'), + listeners: jasmine.createSpy('process.listeners').and.returnValue(['foo']), + removeAllListeners: jasmine.createSpy('process.removeAllListeners') + } + }, + handler = jasmine.createSpy('errorHandler'), + errors = new jasmineUnderTest.GlobalErrors(fakeGlobal); + + errors.install(); + expect(fakeGlobal.process.on).toHaveBeenCalledWith('uncaughtException', jasmine.any(Function)); + expect(fakeGlobal.process.listeners).toHaveBeenCalledWith('uncaughtException'); + expect(fakeGlobal.process.removeAllListeners).toHaveBeenCalledWith('uncaughtException'); + + errors.pushListener(handler); + + var addedListener = fakeGlobal.process.on.calls.argsFor(0)[1]; + addedListener(new Error('bar')); + + expect(handler).toHaveBeenCalledWith(new Error('bar')); + + errors.uninstall(); + + expect(fakeGlobal.process.removeListener).toHaveBeenCalledWith('uncaughtException', addedListener); + expect(fakeGlobal.process.on).toHaveBeenCalledWith('uncaughtException', 'foo'); + }); +}); diff --git a/spec/core/QueueRunnerSpec.js b/spec/core/QueueRunnerSpec.js index 781aee5f..d23aedfd 100644 --- a/spec/core/QueueRunnerSpec.js +++ b/spec/core/QueueRunnerSpec.js @@ -234,6 +234,43 @@ describe("QueueRunner", function() { queueRunner.execute(); expect(doneReturn).toBe(null); }); + + it("continues running functions when an exception is thrown in async code without timing out", function() { + var queueableFn = { fn: function(done) { throwAsync(); }, timeout: function() { return 1; } }, + nextQueueableFn = { fn: jasmine.createSpy("nextFunction") }, + onException = jasmine.createSpy('onException'), + globalErrors = { pushListener: jasmine.createSpy('pushListener'), popListener: jasmine.createSpy('popListener') }, + queueRunner = new jasmineUnderTest.QueueRunner({ + queueableFns: [queueableFn, nextQueueableFn], + onException: onException, + globalErrors: globalErrors + }), + throwAsync = function() { + globalErrors.pushListener.calls.mostRecent().args[0](new Error('foo')); + jasmine.clock().tick(2); + }; + + nextQueueableFn.fn.and.callFake(function() { + // should remove the same function that was added + expect(globalErrors.popListener).toHaveBeenCalledWith(globalErrors.pushListener.calls.argsFor(0)[0]); + }); + + queueRunner.execute(); + + function errorWithMessage(message) { + return { + asymmetricMatch(other) { + return new RegExp(message).test(other.message); + }, + toString: function() { + return ''; + } + }; + } + expect(onException).not.toHaveBeenCalledWith(errorWithMessage(/DEFAULT_TIMEOUT_INTERVAL/)); + expect(onException).toHaveBeenCalledWith(errorWithMessage(/^foo$/)); + expect(nextQueueableFn.fn).toHaveBeenCalled(); + }); }); it("calls exception handlers when an exception is thrown in a fn", function() { diff --git a/spec/core/integration/EnvSpec.js b/spec/core/integration/EnvSpec.js index bbce668c..765b6a2b 100644 --- a/spec/core/integration/EnvSpec.js +++ b/spec/core/integration/EnvSpec.js @@ -1757,4 +1757,37 @@ describe("Env integration", function() { env.execute(); }); + + it("should associate errors thrown from async code with the correct runnable", function(done) { + var env = new jasmineUnderTest.Env(), + reporter = jasmine.createSpyObj('fakeReport', ['jasmineDone','suiteDone','specDone']); + + reporter.jasmineDone.and.callFake(function() { + expect(reporter.suiteDone).toHaveFailedExpecationsForRunnable('async suite', [ + /^(((Uncaught )?Error: suite( thrown)?)|(suite thrown))$/ + ]); + expect(reporter.specDone).toHaveFailedExpecationsForRunnable('suite async spec', [ + /^(((Uncaught )?Error: spec( thrown)?)|(spec thrown))$/ + ]); + done(); + }); + + env.addReporter(reporter); + + env.describe('async suite', function() { + env.afterAll(function(innerDone) { + setTimeout(function() { throw new Error('suite'); }, 1); + }, 10); + + env.it('spec', function() {}); + }); + + env.describe('suite', function() { + env.it('async spec', function(innerDone) { + setTimeout(function() { throw new Error('spec'); }, 1); + }, 10); + }); + + env.execute(); + }); }); diff --git a/src/core/Env.js b/src/core/Env.js index b7337774..91718aa6 100644 --- a/src/core/Env.js +++ b/src/core/Env.js @@ -40,6 +40,8 @@ getJasmineRequireObj().Env = function(j$) { 'specDone' ]); + var globalErrors = new j$.GlobalErrors(); + this.specFilter = function() { return true; }; @@ -187,6 +189,7 @@ getJasmineRequireObj().Env = function(j$) { options.clearStack = options.clearStack || clearStack; options.timeout = {setTimeout: realSetTimeout, clearTimeout: realClearTimeout}; options.fail = self.fail; + options.globalErrors = globalErrors; new j$.QueueRunner(options).execute(); }; @@ -250,9 +253,11 @@ getJasmineRequireObj().Env = function(j$) { currentlyExecutingSuites.push(topSuite); + globalErrors.install(); processor.execute(function() { clearResourcesForRunnable(topSuite.id); currentlyExecutingSuites.pop(); + globalErrors.uninstall(); reporter.jasmineDone({ order: order, diff --git a/src/core/GlobalErrors.js b/src/core/GlobalErrors.js new file mode 100644 index 00000000..599941cc --- /dev/null +++ b/src/core/GlobalErrors.js @@ -0,0 +1,45 @@ +getJasmineRequireObj().GlobalErrors = function(j$) { + function GlobalErrors(global) { + var handlers = []; + global = global || j$.getGlobal(); + + var onerror = function onerror() { + var handler = handlers[handlers.length - 1]; + handler.apply(null, Array.prototype.slice.call(arguments, 0)); + }; + + this.uninstall = function noop() {}; + + this.install = function install() { + if (global.process && j$.isFunction_(global.process.on)) { + var originalHandlers = global.process.listeners('uncaughtException'); + global.process.removeAllListeners('uncaughtException'); + global.process.on('uncaughtException', onerror); + + this.uninstall = function uninstall() { + global.process.removeListener('uncaughtException', onerror); + for (var i = 0; i < originalHandlers.length; i++) { + global.process.on('uncaughtException', originalHandlers[i]); + } + }; + } else { + var originalHandler = global.onerror; + global.onerror = onerror; + + this.uninstall = function uninstall() { + global.onerror = originalHandler; + }; + } + }; + + this.pushListener = function pushListener(listener) { + handlers.push(listener); + }; + + this.popListener = function popListener() { + handlers.pop(); + }; + } + + return GlobalErrors; +}; diff --git a/src/core/QueueRunner.js b/src/core/QueueRunner.js index e93bceea..7d320b44 100644 --- a/src/core/QueueRunner.js +++ b/src/core/QueueRunner.js @@ -20,6 +20,7 @@ getJasmineRequireObj().QueueRunner = function(j$) { this.userContext = attrs.userContext || {}; this.timeout = attrs.timeout || {setTimeout: setTimeout, clearTimeout: clearTimeout}; this.fail = attrs.fail || function() {}; + this.globalErrors = attrs.globalErrors || { pushListener: function() {}, popListener: function() {} }; } QueueRunner.prototype.execute = function() { @@ -56,8 +57,13 @@ getJasmineRequireObj().QueueRunner = function(j$) { var clearTimeout = function () { Function.prototype.apply.apply(self.timeout.clearTimeout, [j$.getGlobal(), [timeoutId]]); }, + handleError = function(error) { + onException(error); + next(); + }, next = once(function () { clearTimeout(timeoutId); + self.globalErrors.popListener(handleError); self.run(queueableFns, iterativeIndex + 1); }), timeoutId; @@ -67,6 +73,8 @@ getJasmineRequireObj().QueueRunner = function(j$) { next(); }; + self.globalErrors.pushListener(handleError); + if (queueableFn.timeout) { timeoutId = Function.prototype.apply.apply(self.timeout.setTimeout, [j$.getGlobal(), [function() { var error = new Error('Timeout - Async callback was not invoked within timeout specified by jasmine.DEFAULT_TIMEOUT_INTERVAL.'); diff --git a/src/core/requireCore.js b/src/core/requireCore.js index b82d1aa1..57831e78 100644 --- a/src/core/requireCore.js +++ b/src/core/requireCore.js @@ -57,6 +57,7 @@ var getJasmineRequireObj = (function (jasmineGlobal) { j$.DiffBuilder = jRequire.DiffBuilder(j$); j$.NullDiffBuilder = jRequire.NullDiffBuilder(j$); j$.ObjectPath = jRequire.ObjectPath(j$); + j$.GlobalErrors = jRequire.GlobalErrors(j$); j$.matchers = jRequire.requireMatchers(jRequire, j$);