angular-scroll-animate/bower_components/jasmine/spec/core/ExceptionsSpec.js

An Angular.js directive which allows you to perform any javascript actions (in the controller, or on the element) when an element is scrolled into, or out of, the users viewport, without any other dependencies.

describe('Exceptions:', function() {
  var env;

  beforeEach(function() {
    env = new jasmine.Env();
    env.updateInterval = 0;
  });

  it('jasmine.formatException formats Firefox exception messages as expected', function() {
    var sampleFirefoxException = {
      fileName: 'foo.js',
      line: '1978',
      message: 'you got your foo in my bar',
      name: 'A Classic Mistake'
    };

    var expected = 'A Classic Mistake: you got your foo in my bar in foo.js (line 1978)';

    expect(jasmine.util.formatException(sampleFirefoxException)).toEqual(expected);
  });

  it('jasmine.formatException formats Webkit exception messages as expected', function() {
    var sampleWebkitException = {
      sourceURL: 'foo.js',
      lineNumber: '1978',
      message: 'you got your foo in my bar',
      name: 'A Classic Mistake'
    };

    var expected = 'A Classic Mistake: you got your foo in my bar in foo.js (line 1978)';

    expect(jasmine.util.formatException(sampleWebkitException)).toEqual(expected);
  });

  describe('with break on exception', function() {
    it('should not catch the exception', function() {
      var suite = env.describe('suite for break on exceptions', function() {
        env.it('should break when an exception is thrown', function() {
          throw new Error('I should hit a breakpoint!');
        });
      });
      var runner = env.currentRunner();
      var dont_change = 'I will never change!';

      var oldCatch = jasmine.CATCH_EXCEPTIONS;
      jasmine.CATCH_EXCEPTIONS = false;
      try {
        suite.execute();
        dont_change = 'oops I changed';
      }
      catch (e) {}
      finally {
        jasmine.CATCH_EXCEPTIONS = oldCatch;
      }

      expect(dont_change).toEqual('I will never change!');
    });
  });

  describe("with catch on exception", function() {
    it('should handle exceptions thrown, but continue', function() {
      var fakeTimer = new jasmine.FakeTimer();
      env.setTimeout = fakeTimer.setTimeout;
      env.clearTimeout = fakeTimer.clearTimeout;
      env.setInterval = fakeTimer.setInterval;
      env.clearInterval = fakeTimer.clearInterval;

      //we run two exception tests to make sure we continue after throwing an exception
      var suite = env.describe('Suite for handles exceptions', function () {
        env.it('should be a test that fails because it throws an exception', function() {
          throw new Error('fake error 1');
        });

        env.it('should be another test that fails because it throws an exception', function() {
          this.runs(function () {
            throw new Error('fake error 2');
          });
          this.runs(function () {
            this.expect(true).toEqual(true);
          });
        });

        env.it('should be a passing test that runs after exceptions are thrown', function() {
          this.expect(true).toEqual(true);
        });

        env.it('should be another test that fails because it throws an exception after a wait', function() {
          this.runs(function () {
            var foo = 'foo';
          });
          this.waits(250);
          this.runs(function () {
            throw new Error('fake error 3');
          });
        });

        env.it('should be a passing test that runs after exceptions are thrown from a async test', function() {
          this.expect(true).toEqual(true);
        });
      });

      var runner = env.currentRunner();
      suite.execute();
      fakeTimer.tick(2500);

      var suiteResults = suite.results();
      var specResults = suiteResults.getItems();

      expect(suiteResults.passed()).toEqual(false);
      //
      expect(specResults.length).toEqual(5);
      expect(specResults[0].passed()).toMatch(false);
      var blockResults = specResults[0].getItems();
      expect(blockResults[0].passed()).toEqual(false);
      expect(blockResults[0].message).toMatch(/fake error 1/);

      expect(specResults[1].passed()).toEqual(false);
      blockResults = specResults[1].getItems();
      expect(blockResults[0].passed()).toEqual(false);
      expect(blockResults[0].message).toMatch(/fake error 2/);
      expect(blockResults[1].passed()).toEqual(true);

      expect(specResults[2].passed()).toEqual(true);

      expect(specResults[3].passed()).toEqual(false);
      blockResults = specResults[3].getItems();
      expect(blockResults[0].message).toMatch(/fake error 3/);

      expect(specResults[4].passed()).toEqual(true);
    });

    it("should handle exceptions thrown directly in top-level describe blocks and continue", function () {
      var suite = env.describe("a top level describe block that throws an exception", function () {
        env.it("is a test that should pass", function () {
         this.expect(true).toEqual(true);
        });

        throw new Error("top level error");
      });

      suite.execute();
      var suiteResults = suite.results();
      var specResults = suiteResults.getItems();

      expect(suiteResults.passed()).toEqual(false);
      expect(specResults.length).toEqual(2);

      expect(specResults[1].description).toMatch(/encountered a declaration exception/);
    });

    it("should handle exceptions thrown directly in nested describe blocks and continue", function () {
      var suite = env.describe("a top level describe", function () {
        env.describe("a mid-level describe that throws an exception", function () {
          env.it("is a test that should pass", function () {
            this.expect(true).toEqual(true);
          });

          throw new Error("a mid-level error");
        });
      });

      suite.execute();
      var suiteResults = suite.results();
      var specResults = suiteResults.getItems();

      expect(suiteResults.passed()).toEqual(false);
      expect(specResults.length).toEqual(1);

      var nestedSpecResults = specResults[0].getItems();

      expect(nestedSpecResults.length).toEqual(2);
      expect(nestedSpecResults[1].description).toMatch(/encountered a declaration exception/);
    });
  });
});