Replace old "catch exceptions" logic with proper fail fast with error reporting

- Option is called stopOnSpecFailure

[#85966014]
- See #414
- See jasmine/jasmine-npm#16

spec/core/QueueRunnerSpec.js

@@ -158,6 +158,29 @@ describe("QueueRunner", function() {
       expect(queueableFn2.fn).toHaveBeenCalled();
     });
 
+    it("does not cause an explicit fail if execution is being stopped", function() {
+      var err = new jasmineUnderTest.StopExecutionError('foo'),
+        queueableFn1 = { fn: function(done) {
+          setTimeout(function() { done(err); }, 100);
+        } },
+        queueableFn2 = { fn: jasmine.createSpy('fn2') },
+        failFn = jasmine.createSpy('fail'),
+        queueRunner = new jasmineUnderTest.QueueRunner({
+          queueableFns: [queueableFn1, queueableFn2],
+          fail: failFn
+        });
+
+      queueRunner.execute();
+
+      expect(failFn).not.toHaveBeenCalled();
+      expect(queueableFn2.fn).not.toHaveBeenCalled();
+
+      jasmine.clock().tick(100);
+
+      expect(failFn).not.toHaveBeenCalled();
+      expect(queueableFn2.fn).toHaveBeenCalled();
+    });
+
     it("sets a timeout if requested for asynchronous functions so they don't go on forever", function() {
       var timeout = 3,
         beforeFn = { fn: function(done) { }, type: 'before', timeout: function() { return timeout; } },
@@ -442,20 +465,6 @@ describe("QueueRunner", function() {
     expect(onExceptionCallback).toHaveBeenCalledWith(jasmine.any(Error));
   });
 
-  it("rethrows an exception if told to", function() {
-    var queueableFn = { fn: function() {
-        throw new Error('fake error');
-      } },
-      queueRunner = new jasmineUnderTest.QueueRunner({
-        queueableFns: [queueableFn],
-        catchException: function(e) { return false; }
-      });
-
-    expect(function() {
-      queueRunner.execute();
-    }).toThrowError('fake error');
-  });
-
   it("continues running the functions even after an exception is thrown in an async spec", function() {
     var queueableFn = { fn: function(done) { throw new Error("error"); } },
       nextQueueableFn = { fn: jasmine.createSpy("nextFunction") },

spec/core/ReportDispatcherSpec.js

@@ -21,7 +21,8 @@ describe("ReportDispatcher", function() {
     dispatcher.foo(123, 456, completeCallback);
 
     expect(queueRunnerFactory).toHaveBeenCalledWith(jasmine.objectContaining({
-      queueableFns: [{fn: jasmine.any(Function)}, {fn: jasmine.any(Function)}]
+      queueableFns: [{fn: jasmine.any(Function)}, {fn: jasmine.any(Function)}],
+      isReporter: true
     }));
 
     var fns = queueRunnerFactory.calls.mostRecent().args[0].queueableFns;
@@ -38,7 +39,8 @@ describe("ReportDispatcher", function() {
     dispatcher.bar('a', 'b', completeCallback);
 
     expect(queueRunnerFactory).toHaveBeenCalledWith(jasmine.objectContaining({
-      queueableFns: [{fn: jasmine.any(Function)}, {fn: jasmine.any(Function)}]
+      queueableFns: [{fn: jasmine.any(Function)}, {fn: jasmine.any(Function)}],
+      isReporter: true
     }));
 
     fns = queueRunnerFactory.calls.mostRecent().args[0].queueableFns;
@@ -72,7 +74,8 @@ describe("ReportDispatcher", function() {
     dispatcher.foo(123, 456, completeCallback);
 
     expect(queueRunnerFactory).toHaveBeenCalledWith(jasmine.objectContaining({
-      queueableFns: [{fn: jasmine.any(Function)}]
+      queueableFns: [{fn: jasmine.any(Function)}],
+      isReporter: true
     }));
 
     var fns = queueRunnerFactory.calls.mostRecent().args[0].queueableFns;
@@ -92,7 +95,8 @@ describe("ReportDispatcher", function() {
     dispatcher.foo(123, 456, completeCallback);
 
     expect(queueRunnerFactory).toHaveBeenCalledWith(jasmine.objectContaining({
-      queueableFns: [{fn: jasmine.any(Function)}]
+      queueableFns: [{fn: jasmine.any(Function)}],
+      isReporter: true
     }));
 
     var fns = queueRunnerFactory.calls.mostRecent().args[0].queueableFns;
@@ -111,7 +115,8 @@ describe("ReportDispatcher", function() {
     dispatcher.addReporter(reporter1);
     dispatcher.foo(123, completeCallback);
     expect(queueRunnerFactory).toHaveBeenCalledWith(jasmine.objectContaining({
-      queueableFns: [{fn: jasmine.any(Function)}]
+      queueableFns: [{fn: jasmine.any(Function)}],
+      isReporter: true
     }));
 
     var fns = queueRunnerFactory.calls.mostRecent().args[0].queueableFns;
@@ -123,7 +128,8 @@ describe("ReportDispatcher", function() {
     dispatcher.bar(456, completeCallback);
 
     expect(queueRunnerFactory).toHaveBeenCalledWith(jasmine.objectContaining({
-      queueableFns: [{fn: jasmine.any(Function)}]
+      queueableFns: [{fn: jasmine.any(Function)}],
+      isReporter: true
     }));
 
     fns = queueRunnerFactory.calls.mostRecent().args[0].queueableFns;

spec/core/SpecSpec.js

@@ -157,7 +157,7 @@ describe("Spec", function() {
     spec.execute('cally-back', true);
 
     expect(fakeQueueRunner).toHaveBeenCalledWith(jasmine.objectContaining({
-      onComplete: 'cally-back',
+      onComplete: jasmine.any(Function),
       queueableFns: [{fn: jasmine.any(Function)}],
       cleanupFns: [{fn: jasmine.any(Function)}]
     }));
@@ -224,6 +224,23 @@ describe("Spec", function() {
     expect(done).toHaveBeenCalled();
   });
 
+  it("should call the done callback with an error if the spec is failed", function() {
+    var done = jasmine.createSpy('done callback'),
+      spec = new jasmineUnderTest.Spec({
+        queueableFn: { fn: function() {} },
+        catchExceptions: function() { return false; },
+        resultCallback: function() {},
+        queueRunnerFactory: function(attrs) {
+          spec.result.status = 'failed';
+          attrs.onComplete();
+        }
+      });
+
+    spec.execute(done);
+
+    expect(done).toHaveBeenCalledWith(jasmine.any(jasmineUnderTest.StopExecutionError));
+  });
+
   it("#status returns passing by default", function() {
     var spec = new jasmineUnderTest.Spec({queueableFn: { fn: jasmine.createSpy("spec body")} });
     expect(spec.status()).toBe('passed');

spec/core/integration/SpecRunningSpec.js

@@ -947,4 +947,30 @@ describe("spec running", function () {
       env.execute();
     });
   });
+
+  describe("when stopOnSpecFailure is on", function() {
+    it("does not run further specs when one fails", function(done) {
+      var actions = [];
+
+      env.it('fails', function() {
+        actions.push('fails');
+        env.expect(1).toBe(2);
+      });
+
+      env.it('does not run', function() {
+        actions.push('does not run');
+      });
+
+      env.randomizeTests(false);
+      env.stopOnSpecFailure(true);
+
+      var assertions = function() {
+        expect(actions).toEqual(['fails']);
+        done();
+      };
+
+      env.addReporter({ jasmineDone: assertions });
+      env.execute();
+    });
+  });
 });