jasmine-core 1.1.0.rc1

data/spec/core/MockClockSpec.js

@@ -0,0 +1,38 @@
+describe("MockClock", function () {
+
+  beforeEach(function() {
+    jasmine.Clock.useMock();    
+  });
+
+  describe("setTimeout", function () {
+    it("should mock the clock when useMock is in a beforeEach", function() {
+      var expected = false;
+      setTimeout(function() {
+        expected = true;
+      }, 30000);
+      expect(expected).toBe(false);
+      jasmine.Clock.tick(30001);
+      expect(expected).toBe(true);
+    });
+  });
+
+  describe("setInterval", function () {
+    it("should mock the clock when useMock is in a beforeEach", function() {
+      var interval = 0;
+      setInterval(function() {
+        interval++;
+      }, 30000);
+      expect(interval).toEqual(0);
+      jasmine.Clock.tick(30001);
+      expect(interval).toEqual(1);
+      jasmine.Clock.tick(30001);
+      expect(interval).toEqual(2);
+      jasmine.Clock.tick(1);
+      expect(interval).toEqual(2);
+    });
+  });
+
+  it("shouldn't complain if you call jasmine.Clock.useMock() more than once", function() {
+    jasmine.Clock.useMock();
+  });
+});

data/spec/core/MultiReporterSpec.js

@@ -0,0 +1,45 @@
+describe("jasmine.MultiReporter", function() {
+  var multiReporter, fakeReporter1, fakeReporter2;
+
+  beforeEach(function() {
+    multiReporter = new jasmine.MultiReporter();
+    fakeReporter1 = jasmine.createSpyObj("fakeReporter1", ["reportSpecResults"]);
+    fakeReporter2 = jasmine.createSpyObj("fakeReporter2", ["reportSpecResults", "reportRunnerStarting"]);
+    multiReporter.addReporter(fakeReporter1);
+    multiReporter.addReporter(fakeReporter2);
+  });
+
+  it("should support all the method calls that jasmine.Reporter supports", function() {
+    var delegate = {};
+    multiReporter.addReporter(delegate);
+
+    this.addMatchers({
+      toDelegateMethod: function(methodName) {
+        delegate[methodName] = jasmine.createSpy(methodName);
+        this.actual[methodName]("whatever argument");
+
+        return delegate[methodName].wasCalled && 
+               delegate[methodName].mostRecentCall.args.length == 1 && 
+               delegate[methodName].mostRecentCall.args[0] == "whatever argument";
+      }
+    });
+
+    expect(multiReporter).toDelegateMethod('reportRunnerStarting');
+    expect(multiReporter).toDelegateMethod('reportRunnerResults');
+    expect(multiReporter).toDelegateMethod('reportSuiteResults');
+    expect(multiReporter).toDelegateMethod('reportSpecStarting');
+    expect(multiReporter).toDelegateMethod('reportSpecResults');
+    expect(multiReporter).toDelegateMethod('log');
+  });
+
+  it("should delegate to any and all subreporters", function() {
+    multiReporter.reportSpecResults('blah', 'foo');
+    expect(fakeReporter1.reportSpecResults).toHaveBeenCalledWith('blah', 'foo');
+    expect(fakeReporter2.reportSpecResults).toHaveBeenCalledWith('blah', 'foo');
+  });
+
+  it("should quietly skip delegating to any subreporters which lack the given method", function() {
+    multiReporter.reportRunnerStarting('blah', 'foo');
+    expect(fakeReporter2.reportRunnerStarting).toHaveBeenCalledWith('blah', 'foo');
+  });
+});

data/spec/core/NestedResultsSpec.js

@@ -0,0 +1,54 @@
+describe('jasmine.NestedResults', function() {
+  it('#addResult increments counters', function() {
+    // Leaf case
+    var results = new jasmine.NestedResults();
+
+    results.addResult(new jasmine.ExpectationResult({
+      matcherName: "foo", passed: true, message: 'Passed.', actual: 'bar', expected: 'bar'}
+    ));
+
+    expect(results.getItems().length).toEqual(1);
+    expect(results.totalCount).toEqual(1);
+    expect(results.passedCount).toEqual(1);
+    expect(results.failedCount).toEqual(0);
+
+    results.addResult(new jasmine.ExpectationResult({
+      matcherName: "baz", passed: false, message: 'FAIL.', actual: "corge", expected: "quux"
+    }));
+
+    expect(results.getItems().length).toEqual(2);
+    expect(results.totalCount).toEqual(2);
+    expect(results.passedCount).toEqual(1);
+    expect(results.failedCount).toEqual(1);
+  });
+
+  it('should roll up counts for nested results', function() {
+    // Branch case
+    var leafResultsOne = new jasmine.NestedResults();
+    leafResultsOne.addResult(new jasmine.ExpectationResult({
+      matcherName: "toSomething", passed: true, message: 'message', actual: '', expected:''
+    }));
+
+    leafResultsOne.addResult(new jasmine.ExpectationResult({
+      matcherName: "toSomethingElse", passed: false, message: 'message', actual: 'a', expected: 'b'
+    }));
+
+    var leafResultsTwo = new jasmine.NestedResults();
+    leafResultsTwo.addResult(new jasmine.ExpectationResult({
+      matcherName: "toSomething", passed: true, message: 'message', actual: '', expected: ''
+    }));
+    leafResultsTwo.addResult(new jasmine.ExpectationResult({
+      matcherName: "toSomethineElse", passed: false, message: 'message', actual: 'c', expected: 'd'
+    }));
+
+    var branchResults = new jasmine.NestedResults();
+    branchResults.addResult(leafResultsOne);
+    branchResults.addResult(leafResultsTwo);
+
+    expect(branchResults.getItems().length).toEqual(2);
+    expect(branchResults.totalCount).toEqual(4);
+    expect(branchResults.passedCount).toEqual(2);
+    expect(branchResults.failedCount).toEqual(2);
+  });
+
+});

data/spec/core/PrettyPrintSpec.js

@@ -0,0 +1,87 @@
+describe("jasmine.pp", function () {
+  it("should wrap strings in single quotes", function() {
+    expect(jasmine.pp("some string")).toEqual("'some string'");
+    expect(jasmine.pp("som' string")).toEqual("'som' string'");
+  });
+
+  it("should stringify primitives properly", function() {
+    expect(jasmine.pp(true)).toEqual("true");
+    expect(jasmine.pp(false)).toEqual("false");
+    expect(jasmine.pp(null)).toEqual("null");
+    expect(jasmine.pp(jasmine.undefined)).toEqual("undefined");
+    expect(jasmine.pp(3)).toEqual("3");
+    expect(jasmine.pp(-3.14)).toEqual("-3.14");
+  });
+
+  it("should stringify arrays properly", function() {
+    expect(jasmine.pp([1, 2])).toEqual("[ 1, 2 ]");
+    expect(jasmine.pp([1, 'foo', {}, jasmine.undefined, null])).toEqual("[ 1, 'foo', {  }, undefined, null ]");
+  });
+
+  it("should indicate circular array references", function() {
+    var array1 = [1, 2];
+    var array2 = [array1];
+    array1.push(array2);
+    expect(jasmine.pp(array1)).toEqual("[ 1, 2, [ <circular reference: Array> ] ]");
+  });
+
+  it("should stringify objects properly", function() {
+    expect(jasmine.pp({foo: 'bar'})).toEqual("{ foo : 'bar' }");
+    expect(jasmine.pp({foo:'bar', baz:3, nullValue: null, undefinedValue: jasmine.undefined})).toEqual("{ foo : 'bar', baz : 3, nullValue : null, undefinedValue : undefined }");
+    expect(jasmine.pp({foo: function () {
+    }, bar: [1, 2, 3]})).toEqual("{ foo : Function, bar : [ 1, 2, 3 ] }");
+  });
+
+  it("should stringify RegExp objects properly", function() {
+    expect(jasmine.pp(/x|y|z/)).toEqual("/x|y|z/");
+  });
+
+  it("should indicate circular object references", function() {
+    var sampleValue = {foo: 'hello'};
+    sampleValue.nested = sampleValue;
+    expect(jasmine.pp(sampleValue)).toEqual("{ foo : 'hello', nested : <circular reference: Object> }");
+  });
+
+  it("should indicate getters on objects as such", function() {
+    var sampleValue = {id: 1};
+    if (sampleValue.__defineGetter__) {
+      //not supported in IE!
+      sampleValue.__defineGetter__('calculatedValue', function() {
+        throw new Error("don't call me!");
+      });
+    }
+    if (sampleValue.__defineGetter__) {
+      expect(jasmine.pp(sampleValue)).toEqual("{ id : 1, calculatedValue : <getter> }");
+    }
+    else {
+      expect(jasmine.pp(sampleValue)).toEqual("{ id : 1 }");
+    }
+  });
+
+
+  it('should not do HTML escaping of strings', function() {
+    expect(jasmine.pp('some <b>html string</b> &', false)).toEqual('\'some <b>html string</b> &\'');
+  });
+
+  it("should abbreviate the global (usually window) object", function() {
+    expect(jasmine.pp(jasmine.getGlobal())).toEqual("<global>");
+  });
+
+  it("should stringify Date objects properly", function() {
+    var now = new Date();
+    expect(jasmine.pp(now)).toEqual("Date(" + now.toString() + ")");
+  });
+
+  it("should stringify spy objects properly", function() {
+    var TestObject = {
+      someFunction: function() {
+      }
+    };
+    spyOn(TestObject, 'someFunction');
+    expect(jasmine.pp(TestObject.someFunction)).toEqual("spy on someFunction");
+
+    expect(jasmine.pp(jasmine.createSpy("something"))).toEqual("spy on something");
+  });
+
+});
+

data/spec/core/QueueSpec.js

@@ -0,0 +1,23 @@
+describe("jasmine.Queue", function() {
+  it("should not call itself recursively, so we don't get stack overflow errors", function() {
+    var queue = new jasmine.Queue(new jasmine.Env());
+    queue.add(new jasmine.Block(null, function() {}));
+    queue.add(new jasmine.Block(null, function() {}));
+    queue.add(new jasmine.Block(null, function() {}));
+    queue.add(new jasmine.Block(null, function() {}));
+
+    var nestCount = 0;
+    var maxNestCount = 0;
+    var nextCallCount = 0;
+    queue.next_ = function() {
+      nestCount++;
+      if (nestCount > maxNestCount) maxNestCount = nestCount;
+
+      jasmine.Queue.prototype.next_.apply(queue, arguments);
+      nestCount--;
+    };
+
+    queue.start();
+    expect(maxNestCount).toEqual(1);
+  });
+});

data/spec/core/ReporterSpec.js

@@ -0,0 +1,56 @@
+describe('jasmine.Reporter', function() {
+  var env;
+
+
+  beforeEach(function() {
+    env = new jasmine.Env();
+    env.updateInterval = 0;
+  });
+
+  it('should get called from the test runner', function() {
+    env.describe('Suite for JSON Reporter with Callbacks', function () {
+      env.it('should be a test', function() {
+        this.runs(function () {
+          this.expect(true).toEqual(true);
+        });
+      });
+      env.it('should be a failing test', function() {
+        this.runs(function () {
+          this.expect(false).toEqual(true);
+        });
+      });
+    });
+    env.describe('Suite for JSON Reporter with Callbacks 2', function () {
+      env.it('should be a test', function() {
+        this.runs(function () {
+          this.expect(true).toEqual(true);
+        });
+      });
+
+    });
+
+    var foo = 0;
+    var bar = 0;
+    var baz = 0;
+
+    env.addReporter({
+      reportSpecResults: function() {
+        foo++;
+      },
+      reportSuiteResults: function() {
+        bar++;
+      },
+      reportRunnerResults: function() {
+        baz++;
+      }
+    });
+
+    var runner = env.currentRunner();
+    runner.execute();
+
+    expect(foo).toEqual(3); // 'foo was expected to be 3, was ' + foo);
+    expect(bar).toEqual(2); // 'bar was expected to be 2, was ' + bar);
+    expect(baz).toEqual(1); // 'baz was expected to be 1, was ' + baz);
+  });
+
+});

data/spec/core/RunnerSpec.js

@@ -0,0 +1,267 @@
+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 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()]);
+    });
+  });
+});