jasmine-core 2.0.2 → 2.1.0

data/lib/jasmine-core/spec/core/ExpectationSpec.js

@@ -1,14 +1,14 @@
 describe("Expectation", function() {
-  it(".addMatchers makes matchers available to any expectation", function() {
+  it("makes custom matchers available to this expectation", function() {
     var matchers = {
         toFoo: function() {},
         toBar: function() {}
       },
       expectation;
 
-    j$.Expectation.addMatchers(matchers);
-
-    expectation = new j$.Expectation({});
+    expectation = new j$.Expectation({
+      customMatchers: matchers
+    });
 
     expect(expectation.toFoo).toBeDefined();
     expect(expectation.toBar).toBeDefined();
@@ -27,25 +27,6 @@ describe("Expectation", function() {
     expect(expectation.toQuux).toBeDefined();
   });
 
-  it(".resetMatchers should keep only core matchers", function() {
-    var matchers = {
-        toFoo: function() {}
-      },
-      coreMatchers = {
-        toQuux: function() {}
-      },
-      expectation;
-
-    j$.Expectation.addCoreMatchers(coreMatchers);
-    j$.Expectation.addMatchers(matchers);
-    j$.Expectation.resetMatchers();
-
-    expectation = new j$.Expectation({});
-
-    expect(expectation.toQuux).toBeDefined();
-    expect(expectation.toFoo).toBeUndefined();
-  });
-
   it("Factory builds an expectation/negative expectation", function() {
     var builtExpectation = j$.Expectation.Factory();
 
@@ -65,10 +46,9 @@ describe("Expectation", function() {
       addExpectationResult = jasmine.createSpy("addExpectationResult"),
       expectation;
 
-    j$.Expectation.addMatchers(matchers);
-
     expectation = new j$.Expectation({
       util: util,
+      customMatchers: matchers,
       customEqualityTesters: customEqualityTesters,
       actual: "an actual",
       addExpectationResult: addExpectationResult
@@ -94,10 +74,9 @@ describe("Expectation", function() {
       addExpectationResult = jasmine.createSpy("addExpectationResult"),
       expectation;
 
-    j$.Expectation.addMatchers(matchers);
-
     expectation = new j$.Expectation({
       util: util,
+      customMatchers: matchers,
       actual: "an actual",
       addExpectationResult: addExpectationResult
     });
@@ -121,10 +100,8 @@ describe("Expectation", function() {
       addExpectationResult = jasmine.createSpy("addExpectationResult"),
       expectation;
 
-    j$.Expectation.addMatchers(matchers);
-
     expectation = new j$.Expectation({
-      matchers: matchers,
+      customMatchers: matchers,
       util: util,
       actual: "an actual",
       addExpectationResult: addExpectationResult
@@ -155,10 +132,8 @@ describe("Expectation", function() {
       addExpectationResult = jasmine.createSpy("addExpectationResult"),
       expectation;
 
-    j$.Expectation.addMatchers(matchers);
-
     expectation = new j$.Expectation({
-      matchers: matchers,
+      customMatchers: matchers,
       util: util,
       actual: "an actual",
       addExpectationResult: addExpectationResult
@@ -191,10 +166,9 @@ describe("Expectation", function() {
       addExpectationResult = jasmine.createSpy("addExpectationResult"),
       expectation;
 
-    j$.Expectation.addMatchers(matchers);
-
     expectation = new j$.Expectation({
       actual: "an actual",
+      customMatchers: matchers,
       addExpectationResult: addExpectationResult
     });
 
@@ -225,10 +199,8 @@ describe("Expectation", function() {
       addExpectationResult = jasmine.createSpy("addExpectationResult"),
       expectation;
 
-    j$.Expectation.addMatchers(matchers);
-
     expectation = new j$.Expectation({
-      matchers: matchers,
+      customMatchers: matchers,
       actual: "an actual",
       addExpectationResult: addExpectationResult
     });
@@ -259,10 +231,8 @@ describe("Expectation", function() {
       actual = "an actual",
       expectation;
 
-    j$.Expectation.addMatchers(matchers);
-
     expectation = new j$.Expectation({
-      matchers: matchers,
+      customMatchers: matchers,
       actual: "an actual",
       addExpectationResult: addExpectationResult,
       isNot: true
@@ -294,10 +264,8 @@ describe("Expectation", function() {
       actual = "an actual",
       expectation;
 
-    j$.Expectation.addMatchers(matchers);
-
     expectation = new j$.Expectation({
-      matchers: matchers,
+      customMatchers: matchers,
       actual: "an actual",
       util: util,
       addExpectationResult: addExpectationResult,
@@ -332,10 +300,8 @@ describe("Expectation", function() {
       actual = "an actual",
       expectation;
 
-    j$.Expectation.addMatchers(matchers);
-
     expectation = new j$.Expectation({
-      matchers: matchers,
+      customMatchers: matchers,
       actual: "an actual",
       addExpectationResult: addExpectationResult,
       isNot: true
@@ -365,10 +331,8 @@ describe("Expectation", function() {
       actual = "an actual",
       expectation;
 
-    j$.Expectation.addMatchers(matchers);
-
     expectation = new j$.Expectation({
-      matchers: matchers,
+      customMatchers: matchers,
       actual: "an actual",
       addExpectationResult: addExpectationResult,
       isNot: true
@@ -403,10 +367,8 @@ describe("Expectation", function() {
       actual = "an actual",
       expectation;
 
-    j$.Expectation.addMatchers(matchers);
-
     expectation = new j$.Expectation({
-      matchers: matchers,
+      customMatchers: matchers,
       actual: "an actual",
       addExpectationResult: addExpectationResult,
       isNot: true

data/lib/jasmine-core/spec/core/JsApiReporterSpec.js

@@ -178,6 +178,43 @@ describe("JsApiReporter", function() {
     });
   });
 
+  describe("#suiteResults", function(){
+    var reporter, suiteResult1, suiteResult2;
+    beforeEach(function() {
+      reporter = new j$.JsApiReporter({});
+      suiteStarted1 = {
+        id: 1
+      };
+      suiteResult1 = {
+        id: 1,
+        status: 'failed',
+        failedExpectations: [{ message: 'My After All Exception' }]
+      };
+      suiteResult2 = {
+        id: 2,
+        status: 'finished'
+      };
+
+      reporter.suiteStarted(suiteStarted1);
+      reporter.suiteDone(suiteResult1);
+      reporter.suiteDone(suiteResult2);
+    });
+
+    it('should not include suite starts', function(){
+      expect(reporter.suiteResults(0,3).length).toEqual(2);
+    });
+
+    it("should return a slice of results", function() {
+      expect(reporter.suiteResults(0, 1)).toEqual([suiteResult1]);
+      expect(reporter.suiteResults(1, 1)).toEqual([suiteResult2]);
+    });
+
+    it("returns nothing for out of bounds indicies", function() {
+      expect(reporter.suiteResults(0, 3)).toEqual([suiteResult1, suiteResult2]);
+      expect(reporter.suiteResults(2, 3)).toEqual([]);
+    });
+  });
+
   describe("#executionTime", function() {
     it("should start the timer when jasmine starts", function() {
       var timerSpy = jasmine.createSpyObj('timer', ['start', 'elapsed']),

data/lib/jasmine-core/spec/core/MockDateSpec.js

@@ -75,6 +75,7 @@ describe("FakeDate", function() {
 
     mockDate.install();
     expect(new fakeGlobal.Date()).toEqual(jasmine.any(Date));
+    expect(new fakeGlobal.Date() instanceof fakeGlobal.Date).toBe(true);
   });
 
   it("fakes current time when using Date.now()", function() {

data/lib/jasmine-core/spec/core/PrettyPrintSpec.js

@@ -26,6 +26,11 @@ describe("j$.pp", function () {
     expect(j$.pp(array1)).toEqual("[ 1, 2, [ <circular reference: Array> ] ]");
   });
 
+  it("should not indicate circular references incorrectly", function() {
+    var array = [ [1] ];
+    expect(j$.pp(array)).toEqual("[ [ 1 ] ]");
+  });
+
   it("should stringify objects properly", function() {
     expect(j$.pp({foo: 'bar'})).toEqual("{ foo: 'bar' }");
     expect(j$.pp({foo:'bar', baz:3, nullValue: null, undefinedValue: jasmine.undefined})).toEqual("{ foo: 'bar', baz: 3, nullValue: null, undefinedValue: undefined }");
@@ -130,7 +135,9 @@ describe("j$.pp", function () {
         },
         env = new j$.Env();
 
-    env.spyOn(TestObject, 'someFunction');
+    var spyRegistry = new j$.SpyRegistry({currentSpies: function() {return [];}});
+
+    spyRegistry.spyOn(TestObject, 'someFunction');
     expect(j$.pp(TestObject.someFunction)).toEqual("spy on someFunction");
 
     expect(j$.pp(j$.createSpy("something"))).toEqual("spy on something");
@@ -153,4 +160,3 @@ describe("j$.pp", function () {
     expect(j$.pp(obj)).toEqual("{ foo: 'bar' }");
   });
 });
-

data/lib/jasmine-core/spec/core/QueueRunnerSpec.js

@@ -2,15 +2,15 @@ describe("QueueRunner", function() {
 
   it("runs all the functions it's passed", function() {
     var calls = [],
-      fn1 = jasmine.createSpy('fn1'),
-      fn2 = jasmine.createSpy('fn2'),
+      queueableFn1 = { fn: jasmine.createSpy('fn1') },
+      queueableFn2 = { fn: jasmine.createSpy('fn2') },
       queueRunner = new j$.QueueRunner({
-        fns: [fn1, fn2]
+        queueableFns: [queueableFn1, queueableFn2]
       });
-    fn1.and.callFake(function() {
+    queueableFn1.fn.and.callFake(function() {
       calls.push('fn1');
     });
-    fn2.and.callFake(function() {
+    queueableFn2.fn.and.callFake(function() {
       calls.push('fn2');
     });
 
@@ -20,19 +20,19 @@ describe("QueueRunner", function() {
   });
 
   it("calls each function with a consistent 'this'-- an empty object", function() {
-    var fn1 = jasmine.createSpy('fn1'),
-        fn2 = jasmine.createSpy('fn2'),
-        fn3 = function(done) { asyncContext = this; done(); },
+    var queueableFn1 = { fn: jasmine.createSpy('fn1') },
+        queueableFn2 = { fn: jasmine.createSpy('fn2') },
+        queueableFn3 = { fn: function(done) { asyncContext = this; done(); } },
         queueRunner = new j$.QueueRunner({
-          fns: [fn1, fn2, fn3]
+          queueableFns: [queueableFn1, queueableFn2, queueableFn3]
         }),
         asyncContext;
 
     queueRunner.execute();
 
-    var context = fn1.calls.first().object;
+    var context = queueableFn1.fn.calls.first().object;
     expect(context).toEqual({});
-    expect(fn2.calls.first().object).toBe(context);
+    expect(queueableFn2.fn.calls.first().object).toBe(context);
     expect(asyncContext).toBe(context);
   });
 
@@ -53,20 +53,20 @@ describe("QueueRunner", function() {
         beforeCallback = jasmine.createSpy('beforeCallback'),
         fnCallback = jasmine.createSpy('fnCallback'),
         afterCallback = jasmine.createSpy('afterCallback'),
-        fn1 = function(done) {
+        queueableFn1 = { fn: function(done) {
           beforeCallback();
           setTimeout(done, 100);
-        },
-        fn2 = function(done) {
+        } },
+        queueableFn2 = { fn: function(done) {
           fnCallback();
           setTimeout(done, 100);
-        },
-        fn3 = function(done) {
+        } },
+        queueableFn3 = { fn: function(done) {
           afterCallback();
           setTimeout(done, 100);
-        },
+        } },
         queueRunner = new j$.QueueRunner({
-          fns: [fn1, fn2, fn3],
+          queueableFns: [queueableFn1, queueableFn2, queueableFn3],
           onComplete: onComplete
         });
 
@@ -93,55 +93,77 @@ describe("QueueRunner", function() {
       expect(onComplete).toHaveBeenCalled();
     });
 
+    it("explicitly fails an async function with a provided fail function and moves to the next function", function() {
+      var queueableFn1 = { fn: function(done) {
+          setTimeout(function() { done.fail('foo'); }, 100);
+        } },
+        queueableFn2 = { fn: jasmine.createSpy('fn2') },
+        failFn = jasmine.createSpy('fail'),
+        queueRunner = new j$.QueueRunner({
+          queueableFns: [queueableFn1, queueableFn2],
+          fail: failFn
+        });
+
+      queueRunner.execute();
+
+      expect(failFn).not.toHaveBeenCalled();
+      expect(queueableFn2.fn).not.toHaveBeenCalled();
+
+      jasmine.clock().tick(100);
+
+      expect(failFn).toHaveBeenCalledWith('foo');
+      expect(queueableFn2.fn).toHaveBeenCalled();
+    });
+
     it("sets a timeout if requested for asynchronous functions so they don't go on forever", function() {
-      var beforeFn = function(done) { },
-        fn = jasmine.createSpy('fn'),
+      var timeout = 3,
+        beforeFn = { fn: function(done) { }, type: 'before', timeout: function() { return timeout; } },
+        queueableFn = { fn: jasmine.createSpy('fn'), type: 'queueable' },
         onComplete = jasmine.createSpy('onComplete'),
         onException = jasmine.createSpy('onException'),
         queueRunner = new j$.QueueRunner({
-          fns: [beforeFn, fn],
+          queueableFns: [beforeFn, queueableFn],
           onComplete: onComplete,
-          onException: onException,
-          enforceTimeout: function() { return true; }
+          onException: onException
         });
 
       queueRunner.execute();
-      expect(fn).not.toHaveBeenCalled();
+      expect(queueableFn.fn).not.toHaveBeenCalled();
 
-      jasmine.clock().tick(j$.DEFAULT_TIMEOUT_INTERVAL);
+      jasmine.clock().tick(timeout);
 
       expect(onException).toHaveBeenCalledWith(jasmine.any(Error));
-      expect(fn).toHaveBeenCalled();
+      expect(queueableFn.fn).toHaveBeenCalled();
       expect(onComplete).toHaveBeenCalled();
     });
 
     it("by default does not set a timeout for asynchronous functions", function() {
-      var beforeFn = function(done) { },
-        fn = jasmine.createSpy('fn'),
+      var beforeFn = { fn: function(done) { } },
+        queueableFn = { fn: jasmine.createSpy('fn') },
         onComplete = jasmine.createSpy('onComplete'),
         onException = jasmine.createSpy('onException'),
         queueRunner = new j$.QueueRunner({
-          fns: [beforeFn, fn],
+          queueableFns: [beforeFn, queueableFn],
           onComplete: onComplete,
           onException: onException,
         });
 
       queueRunner.execute();
-      expect(fn).not.toHaveBeenCalled();
+      expect(queueableFn.fn).not.toHaveBeenCalled();
 
       jasmine.clock().tick(j$.DEFAULT_TIMEOUT_INTERVAL);
 
       expect(onException).not.toHaveBeenCalled();
-      expect(fn).not.toHaveBeenCalled();
+      expect(queueableFn.fn).not.toHaveBeenCalled();
       expect(onComplete).not.toHaveBeenCalled();
     });
 
-    it("clears the timeout when an async function throws an exception, to prevent additional onException calls", function() {
-       var fn = function(done) { throw new Error("error!"); },
+    it("clears the timeout when an async function throws an exception, to prevent additional exception reporting", function() {
+       var queueableFn = { fn: function(done) { throw new Error("error!"); } },
         onComplete = jasmine.createSpy('onComplete'),
         onException = jasmine.createSpy('onException'),
         queueRunner = new j$.QueueRunner({
-          fns: [fn],
+          queueableFns: [queueableFn],
           onComplete: onComplete,
           onException: onException
         });
@@ -156,11 +178,11 @@ describe("QueueRunner", function() {
     });
 
     it("clears the timeout when the done callback is called", function() {
-      var fn = function(done) { done(); },
+      var queueableFn = { fn: function(done) { done(); } },
         onComplete = jasmine.createSpy('onComplete'),
         onException = jasmine.createSpy('onException'),
         queueRunner = new j$.QueueRunner({
-          fns: [fn],
+          queueableFns: [queueableFn],
           onComplete: onComplete,
           onException: onException
         });
@@ -174,75 +196,78 @@ describe("QueueRunner", function() {
     });
 
     it("only moves to the next spec the first time you call done", function() {
-      var fn = function(done) {done(); done();},
-        nextFn = jasmine.createSpy('nextFn');
+      var queueableFn = { fn: function(done) {done(); done();} },
+        nextQueueableFn = { fn: jasmine.createSpy('nextFn') };
       queueRunner = new j$.QueueRunner({
-        fns: [fn, nextFn]
+        queueableFns: [queueableFn, nextQueueableFn]
       });
 
       queueRunner.execute();
-      expect(nextFn.calls.count()).toEqual(1);
+      expect(nextQueueableFn.fn.calls.count()).toEqual(1);
     });
 
     it("does not move to the next spec if done is called after an exception has ended the spec", function() {
-       var fn = function(done) {
+       var queueableFn = { fn: function(done) {
          setTimeout(done, 1);
          throw new Error('error!');
-       },
-        nextFn = jasmine.createSpy('nextFn');
+       } },
+        nextQueueableFn = { fn: jasmine.createSpy('nextFn') };
       queueRunner = new j$.QueueRunner({
-        fns: [fn, nextFn]
+        queueableFns: [queueableFn, nextQueueableFn]
       });
 
       queueRunner.execute();
       jasmine.clock().tick(1);
-      expect(nextFn.calls.count()).toEqual(1);
+      expect(nextQueueableFn.fn.calls.count()).toEqual(1);
     });
   });
 
-  it("calls an exception handler when an exception is thrown in a fn", function() {
-    var fn = function() {
+  it("calls exception handlers when an exception is thrown in a fn", function() {
+    var queueableFn = { type: 'queueable',
+      fn: function() {
         throw new Error('fake error');
-      },
-      exceptionCallback = jasmine.createSpy('exception callback'),
+      } },
+      onExceptionCallback = jasmine.createSpy('on exception callback'),
       queueRunner = new j$.QueueRunner({
-        fns: [fn],
-        onException: exceptionCallback
+        queueableFns: [queueableFn],
+        onException: onExceptionCallback
       });
 
     queueRunner.execute();
 
-    expect(exceptionCallback).toHaveBeenCalledWith(jasmine.any(Error));
+    expect(onExceptionCallback).toHaveBeenCalledWith(jasmine.any(Error));
   });
 
   it("rethrows an exception if told to", function() {
-    var fn = function() {
+    var queueableFn = { fn: function() {
         throw new Error('fake error');
-      },
+      } },
       queueRunner = new j$.QueueRunner({
-        fns: [fn],
+        queueableFns: [queueableFn],
         catchException: function(e) { return false; }
       });
 
-    expect(queueRunner.execute).toThrow();
+    expect(function() {
+      queueRunner.execute();
+    }).toThrowError('fake error');
   });
 
   it("continues running the functions even after an exception is thrown in an async spec", function() {
-    var fn = function(done) { throw new Error("error"); },
-      nextFn = jasmine.createSpy("nextFunction"),
+    var queueableFn = { fn: function(done) { throw new Error("error"); } },
+      nextQueueableFn = { fn: jasmine.createSpy("nextFunction") },
       queueRunner = new j$.QueueRunner({
-        fns: [fn, nextFn]
+        queueableFns: [queueableFn, nextQueueableFn]
       });
 
     queueRunner.execute();
-    expect(nextFn).toHaveBeenCalled();
+    expect(nextQueueableFn.fn).toHaveBeenCalled();
   });
 
   it("calls a provided complete callback when done", function() {
-    var fn = jasmine.createSpy('fn'),
+    var queueableFn = { fn: jasmine.createSpy('fn') },
       completeCallback = jasmine.createSpy('completeCallback'),
       queueRunner = new j$.QueueRunner({
-        fns: [fn],
+        queueableFns: [queueableFn],
         onComplete: completeCallback
       });
 
@@ -252,12 +277,12 @@ describe("QueueRunner", function() {
   });
 
   it("calls a provided stack clearing function when done", function() {
-    var asyncFn = function(done) { done() },
-        afterFn = jasmine.createSpy('afterFn'),
+    var asyncFn = { fn: function(done) { done() } },
+        afterFn = { fn: jasmine.createSpy('afterFn') },
         completeCallback = jasmine.createSpy('completeCallback'),
         clearStack = jasmine.createSpy('clearStack'),
         queueRunner = new j$.QueueRunner({
-          fns: [asyncFn, afterFn],
+          queueableFns: [asyncFn, afterFn],
           clearStack: clearStack,
           onComplete: completeCallback
         });
@@ -265,7 +290,7 @@ describe("QueueRunner", function() {
     clearStack.and.callFake(function(fn) { fn(); });
 
     queueRunner.execute();
-    expect(afterFn).toHaveBeenCalled();
+    expect(afterFn.fn).toHaveBeenCalled();
     expect(clearStack).toHaveBeenCalledWith(completeCallback);
   });
 });