angular-scroll-animate/bower_components/jasmine/spec/core/RunnerSpec.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('RunnerTest', function() {
  var fakeTimer;
  var env;

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

    fakeTimer = new jasmine.FakeTimer();
    env.setTimeout = fakeTimer.setTimeout;
    env.clearTimeout = fakeTimer.clearTimeout;
    env.setInterval = fakeTimer.setInterval;
    env.clearInterval = fakeTimer.clearInterval;
  });

  describe('beforeEach', function() {
    it('should run before each spec for all suites', function () {
      var foo;
      env.beforeEach(function () {
        foo = 0;
      });

      env.describe('suite 1', function () {
        env.it('test 1-1', function() {
          foo++;
          this.expect(foo).toEqual(1);
        });
        env.it('test 1-2', function() {
          foo++;
          this.expect(foo).toEqual(1);
        });
      });

      env.describe('suite 2', function () {
        env.it('test 2-1', function() {
          foo++;
          this.expect(foo).toEqual(1);
        });
      });

      env.currentRunner().execute();

      var runnerResults = env.currentRunner().results();
      expect(runnerResults.totalCount).toEqual(3);
      expect(runnerResults.passedCount).toEqual(3);
    });


    it('should provide all specs', function () {
      var foo;
      env.beforeEach(function () {
        foo = 0;
      });

      env.describe('suite 1', function () {
        env.it('test 1-1', function() {
          foo++;
          this.expect(foo).toEqual(1);
        });
        env.it('test 1-2', function() {
          foo++;
          this.expect(foo).toEqual(1);
        });
      });

      env.describe('suite 2', function () {
        env.it('test 2-1', function() {
          foo++;
          this.expect(foo).toEqual(1);
        });
      });

      env.currentRunner().execute();


      expect(env.currentRunner().specs().length).toEqual(3);
    });
  });

  describe('afterEach', function() {
    it('should run after each spec for all suites', function () {
      var foo = 3;
      env.afterEach(function () {
        foo = foo - 1;
      });

      env.describe('suite 1', function () {
        env.it('test 1-1', function() {
          this.expect(foo).toEqual(3);
        });
        env.it('test 1-2', function() {
          this.expect(foo).toEqual(2);
        });
      });

      env.describe('suite 2', function () {
        env.it('test 2-1', function() {
          this.expect(foo).toEqual(1);
        });
      });

      env.currentRunner().execute();

      var runnerResults = env.currentRunner().results();
      expect(runnerResults.totalCount).toEqual(3);
      expect(runnerResults.passedCount).toEqual(3);
    });

    it('should run after a failing spec', function () {
      var afterEach = jasmine.createSpy();
      env.afterEach(afterEach);

      env.describe('suite', function () {
        env.it('fails', function () {
          this.explodes();
        });
      }).execute();

      expect(afterEach).toHaveBeenCalled();
    });
  });


  it('should run child suites and specs and generate results when execute is called', function() {
    env.describe('one suite description', function () {
      env.it('should be a test', function() {
        this.runs(function () {
          this.expect(true).toEqual(true);
        });
      });
    });

    env.describe('another suite description', function () {
      env.it('should be another test', function() {
        this.runs(function () {
          this.expect(true).toEqual(false);
        });
      });
    });

    env.currentRunner().execute();

    var runnerResults = env.currentRunner().results();
    expect(runnerResults.totalCount).toEqual(2);
    expect(runnerResults.passedCount).toEqual(1);
    expect(runnerResults.failedCount).toEqual(1);
  });


  it('should ignore suites that have been x\'d', function() {
    env.xdescribe('one suite description', function () {
      env.it('should be a test', function() {
        this.runs(function () {
          this.expect(true).toEqual(true);
        });
      });
    });

    env.describe('another suite description', function () {
      env.it('should be another test', function() {
        this.runs(function () {
          this.expect(true).toEqual(false);
        });
      });
    });

    env.currentRunner().execute();

    var runnerResults = env.currentRunner().results();
    expect(runnerResults.totalCount).toEqual(1);
    expect(runnerResults.passedCount).toEqual(0);
    expect(runnerResults.failedCount).toEqual(1);
  });

  it('should roll up results from all specs', function() {
    env.describe('one suite description', function () {
      env.it('should be a test', function() {
        this.runs(function () {
          this.expect(true).toEqual(true);
        });
      });
    });

    env.describe('another suite description', function () {
      env.it('should be another test', function() {
        this.runs(function () {
          this.expect(true).toEqual(false);
        });
      });
    });

    env.currentRunner().execute();

    var results = env.currentRunner().results();
    expect(results.totalCount).toEqual(2);
    expect(results.passedCount).toEqual(1);
    expect(results.failedCount).toEqual(1);
  });

  describe('reporting', function () {
    var fakeReporter;
    beforeEach(function () {
      fakeReporter = jasmine.createSpyObj("fakeReporter", ["log", "reportRunnerStarting", "reportRunnerResults"]);
      env.addReporter(fakeReporter);
    });

    it('should report runner results when the runner has completed running', function() {
      env.describe('one suite description', function () {
        env.it('should be a test', function() {
          this.runs(function () {
            this.expect(true).toEqual(true);
          });
        });
      });

      env.describe('another suite description', function () {
        env.it('should be another test', function() {
          this.waits(200);
          this.runs(function () {
            this.expect(true).toEqual(false);
          });
        });
      });

      env.currentRunner().execute();
      expect(fakeReporter.reportRunnerResults).not.toHaveBeenCalled();
      fakeTimer.tick(200);
      //This blows up the JSApiReporter.
      //expect(fakeReporter.reportRunnerResults).toHaveBeenCalledWith(env.currentRunner);
      expect(fakeReporter.reportRunnerResults).toHaveBeenCalled();
      expect(fakeReporter.reportRunnerResults.mostRecentCall.args[0].results()).toEqual(env.currentRunner().results());
    });
  });

  it("should report when the tests start running", function() {
    var fakeReporter = jasmine.createSpyObj("fakeReporter", ["log", "reportRunnerStarting"]);
    env.addReporter(fakeReporter);


    var runner = new jasmine.Runner(env);
    runner.arbitraryVariable = 'foo';
    spyOn(runner.queue, 'start');
    expect(fakeReporter.reportRunnerStarting).not.toHaveBeenCalled();
    runner.execute();
    expect(fakeReporter.reportRunnerStarting).toHaveBeenCalled();
    var reportedRunner = fakeReporter.reportRunnerStarting.mostRecentCall.args[0];
    expect(reportedRunner.arbitraryVariable).toEqual('foo');
    expect(runner.queue.start).toHaveBeenCalled();
  });

  describe("when suites are nested", function() {
    var suite1, suite2, suite3;

    function suiteNames(suites) {
      var suiteDescriptions = [];
      for (var i = 0; i < suites.length; i++) {
        suiteDescriptions.push(suites[i].getFullName());
      }
      return suiteDescriptions;
    }

    beforeEach(function() {
      suite1 = env.describe("suite 1", function() {
        suite2 = env.describe("suite 2", function() {
        });
      });
      suite3 = env.describe("suite 3", function() {});
    });

    it("#suites should return a flat array of all suites, including nested suites", function() {
      var suites = env.currentRunner().suites();
      expect(suiteNames(suites)).toEqual([suite1.getFullName(), suite2.getFullName(), suite3.getFullName()]);
    });

    it("#topLevelSuites should return a flat array of all top-level suites only", function() {
      var suites = env.currentRunner().topLevelSuites();
      expect(suiteNames(suites)).toEqual([suite1.getFullName(), suite3.getFullName()]);
    });
  });
});