jasmine-core 2.8.0 → 2.9.0

data/lib/jasmine-core/node_boot.js

@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2008-2017 Pivotal Labs
+Copyright (c) 2008-2018 Pivotal Labs
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

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

@@ -1,5 +1,7 @@
 describe("Clock", function() {
 
+  var NODE_JS = typeof process !== 'undefined' && process.versions && typeof process.versions.node === 'string';
+
   it("does not replace setTimeout until it is installed", function() {
     var fakeSetTimeout = jasmine.createSpy("global setTimeout"),
       fakeGlobal = { setTimeout: fakeSetTimeout },
@@ -294,13 +296,19 @@ describe("Clock", function() {
       fakeGlobal = { setTimeout: fakeSetTimeout },
       delayedFn = jasmine.createSpy('delayedFn'),
       mockDate = { install: function() {}, tick: function() {}, uninstall: function() {} },
-      clock = new jasmineUnderTest.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate);
+      clock = new jasmineUnderTest.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate),
+      timeout = new clock.FakeTimeout();
 
     clock.install();
     clock.setTimeout(delayedFn, 0, 'a', 'b');
 
     expect(fakeSetTimeout).not.toHaveBeenCalled();
-    expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalledWith(delayedFn, 0, ['a', 'b']);
+
+    if (!NODE_JS) {
+      expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalledWith(delayedFn, 0, ['a', 'b']);
+    } else {
+      expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalledWith(delayedFn, 0, ['a', 'b'], false, timeout);
+    }
   });
 
   it("returns an id for the delayed function", function() {
@@ -312,12 +320,16 @@ describe("Clock", function() {
       delayedFn = jasmine.createSpy('delayedFn'),
       mockDate = { install: function() {}, tick: function() {}, uninstall: function() {} },
       clock = new jasmineUnderTest.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate),
-      timeoutId;
+      timeout;
 
     clock.install();
-    timeoutId = clock.setTimeout(delayedFn, 0);
+    timeout = clock.setTimeout(delayedFn, 0);
 
-    expect(timeoutId).toEqual(123);
+    if (!NODE_JS) {
+      expect(timeout).toEqual(123);
+    } else {
+      expect(timeout.constructor.name).toEqual('FakeTimeout');
+    }
   });
 
   it("clears the scheduled function with the scheduler", function() {
@@ -342,13 +354,19 @@ describe("Clock", function() {
       fakeGlobal = { setInterval: fakeSetInterval },
       delayedFn = jasmine.createSpy('delayedFn'),
       mockDate = { install: function() {}, tick: function() {}, uninstall: function() {} },
-      clock = new jasmineUnderTest.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate);
+      clock = new jasmineUnderTest.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate),
+      timeout = new clock.FakeTimeout;
 
     clock.install();
     clock.setInterval(delayedFn, 0, 'a', 'b');
 
     expect(fakeSetInterval).not.toHaveBeenCalled();
-    expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalledWith(delayedFn, 0, ['a', 'b'], true);
+
+    if (!NODE_JS) {
+      expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalledWith(delayedFn, 0, ['a', 'b'], true);
+    } else {
+      expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalledWith(delayedFn, 0, ['a', 'b'], true, timeout);
+    }
   });
 
   it("returns an id for the delayed function", function() {
@@ -360,12 +378,16 @@ describe("Clock", function() {
       delayedFn = jasmine.createSpy('delayedFn'),
       mockDate = { install: function() {}, tick: function() {}, uninstall: function() {} },
       clock = new jasmineUnderTest.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate),
-      intervalId;
+      interval;
 
     clock.install();
-    intervalId = clock.setInterval(delayedFn, 0);
+    interval = clock.setInterval(delayedFn, 0);
 
-    expect(intervalId).toEqual(123);
+    if (!NODE_JS) {
+      expect(interval).toEqual(123);
+    } else {
+      expect(interval.constructor.name).toEqual('FakeTimeout');
+    }
   });
 
   it("clears the scheduled function with the scheduler", function() {
@@ -401,7 +423,8 @@ describe("Clock", function() {
         setInterval: fakeSetInterval
       },
       mockDate = { install: function() {}, tick: function() {}, uninstall: function() {} },
-      clock = new jasmineUnderTest.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate);
+      clock = new jasmineUnderTest.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate),
+      timeout = new clock.FakeTimeout();
 
     fakeSetTimeout.apply = null;
     fakeSetInterval.apply = null;
@@ -409,13 +432,25 @@ describe("Clock", function() {
     clock.install();
 
     clock.setTimeout(fn, 0);
-    expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalledWith(fn, 0, []);
+
+    if (!NODE_JS) {
+      expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalledWith(fn, 0, []);
+    } else {
+      expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalledWith(fn, 0, [], false, timeout);
+    }
+
     expect(function() {
       clock.setTimeout(fn, 0, 'extra');
     }).toThrow();
 
     clock.setInterval(fn, 0);
-    expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalledWith(fn, 0, [], true);
+    
+    if (!NODE_JS) {
+      expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalledWith(fn, 0, [], true);
+    } else {
+      expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalledWith(fn, 0, [], true, timeout);
+    }
+
     expect(function() {
       clock.setInterval(fn, 0, 'extra');
     }).toThrow();
@@ -679,4 +714,41 @@ describe("Clock (acceptance)", function() {
 
     expect(actualTimes).toEqual([baseTime.getTime(), baseTime.getTime() + 1, baseTime.getTime() + 3]);
   })
+
+  it('correctly clears a scheduled timeout while the Clock is advancing', function () {
+    var delayedFunctionScheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
+      global = {Date: Date, setTimeout: undefined},
+      mockDate = new jasmineUnderTest.MockDate(global),
+      clock = new jasmineUnderTest.Clock(global, function () { return delayedFunctionScheduler; }, mockDate);
+
+    clock.install();
+
+    var timerId2;
+
+    global.setTimeout(function () {
+      global.clearTimeout(timerId2);
+    }, 100);
+
+    timerId2 = global.setTimeout(fail, 100);
+
+    clock.tick(100);
+  });
+
+  it('correctly clears a scheduled interval while the Clock is advancing', function () {
+    var delayedFunctionScheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
+      global = {Date: Date, setTimeout: undefined},
+      mockDate = new jasmineUnderTest.MockDate(global),
+      clock = new jasmineUnderTest.Clock(global, function () { return delayedFunctionScheduler; }, mockDate);
+
+    clock.install();
+
+    var timerId2;
+    var timerId1 = global.setInterval(function () {
+      global.clearInterval(timerId2);
+    }, 100);
+
+    timerId2 = global.setInterval(fail, 100);
+
+    clock.tick(400);
+  });
 });

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

@@ -216,21 +216,23 @@ describe("DelayedFunctionScheduler", function() {
 
   it("removes functions during a tick that runs the function", function() {
     var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
-      fn = jasmine.createSpy('fn'),
+      spy = jasmine.createSpy('fn'),
+      spyAndRemove = jasmine.createSpy('fn'),
       fnDelay = 10,
       timeoutKey;
 
-    timeoutKey = scheduler.scheduleFunction(fn, fnDelay, [], true);
-    scheduler.scheduleFunction(function () {
+    spyAndRemove.and.callFake(function() {
       scheduler.removeFunctionWithId(timeoutKey);
-    }, 2 * fnDelay);
+    });
 
-    expect(fn).not.toHaveBeenCalled();
+    scheduler.scheduleFunction(spyAndRemove, fnDelay);
 
-    scheduler.tick(3 * fnDelay);
+    timeoutKey = scheduler.scheduleFunction(spy, fnDelay, [], true);
 
-    expect(fn).toHaveBeenCalled();
-    expect(fn.calls.count()).toBe(2);
+    scheduler.tick(2 * fnDelay);
+
+    expect(spy).not.toHaveBeenCalled();
+    expect(spyAndRemove).toHaveBeenCalled();
   });
 
   it("removes functions during the first tick that runs the function", function() {

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

@@ -17,7 +17,10 @@ describe("jasmineUnderTest.pp", function () {
   describe('stringify sets', function() {
     it("should stringify sets properly", function() {
       jasmine.getEnv().requireFunctioningSets();
-      expect(jasmineUnderTest.pp(new Set([1, 2]))).toEqual("Set( 1, 2 )");
+      var set = new Set();
+      set.add(1);
+      set.add(2);
+      expect(jasmineUnderTest.pp(set)).toEqual("Set( 1, 2 )");
     });
 
     it("should truncate sets with more elments than jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH", function() {
@@ -26,7 +29,11 @@ describe("jasmineUnderTest.pp", function () {
 
       try {
         jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = 2;
-        expect(jasmineUnderTest.pp(new Set(["a", "b", "c"]))).toEqual("Set( 'a', 'b', ... )");
+        var set = new Set();
+        set.add('a');
+        set.add('b');
+        set.add('c');
+        expect(jasmineUnderTest.pp(set)).toEqual("Set( 'a', 'b', ... )");
       } finally {
         jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = originalMaxSize;
       }
@@ -36,7 +43,9 @@ describe("jasmineUnderTest.pp", function () {
   describe('stringify maps', function() {
     it("should stringify maps properly", function() {
       jasmine.getEnv().requireFunctioningMaps();
-      expect(jasmineUnderTest.pp(new Map([[1, 2]]))).toEqual("Map( [ 1, 2 ] )");
+      var map = new Map();
+      map.set(1,2);
+      expect(jasmineUnderTest.pp(map)).toEqual("Map( [ 1, 2 ] )");
     });
 
     it("should truncate maps with more elments than jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH", function() {
@@ -45,7 +54,11 @@ describe("jasmineUnderTest.pp", function () {
 
       try {
         jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = 2;
-        expect(jasmineUnderTest.pp(new Map([["a", 1], ["b", 2], ["c", 3]]))).toEqual("Map( [ 'a', 1 ], [ 'b', 2 ], ... )");
+        var map = new Map();
+        map.set("a",1);
+        map.set("b",2);
+        map.set("c",3);
+        expect(jasmineUnderTest.pp(map)).toEqual("Map( [ 'a', 1 ], [ 'b', 2 ], ... )");
       } finally {
         jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = originalMaxSize;
       }
@@ -120,15 +133,50 @@ describe("jasmineUnderTest.pp", function () {
   });
 
   it("should truncate objects with too many keys", function () {
-      var originalMaxLength = jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH;
-      var long = {a: 1, b: 2, c: 3};
+    var originalMaxLength = jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH;
+    var long = {a: 1, b: 2, c: 3};
 
-      try {
-        jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = 2;
-        expect(jasmineUnderTest.pp(long)).toEqual("Object({ a: 1, b: 2, ... })");
-      } finally {
-        jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = originalMaxLength;
-      }
+    try {
+      jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = 2;
+      expect(jasmineUnderTest.pp(long)).toEqual("Object({ a: 1, b: 2, ... })");
+    } finally {
+      jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = originalMaxLength;
+    }
+  });
+
+  function withMaxChars(maxChars, fn) {
+    var originalMaxChars = jasmineUnderTest.MAX_PRETTY_PRINT_CHARS;
+
+    try {
+      jasmineUnderTest.MAX_PRETTY_PRINT_CHARS = maxChars;
+      fn();
+    } finally {
+      jasmineUnderTest.MAX_PRETTY_PRINT_CHARS = originalMaxChars;
+    }
+  }
+
+  it("should truncate outputs that are too long", function() {
+    var big = [
+      { a: 1, b: "a long string" },
+      {}
+    ];
+
+    withMaxChars(34, function() {
+      expect(jasmineUnderTest.pp(big)).toEqual("[ Object({ a: 1, b: 'a long st ...");
+    });
+  });
+
+  it("should not serialize more objects after hitting MAX_PRETTY_PRINT_CHARS", function() {
+    var a = { jasmineToString: function() { return 'object a'; } },
+      b = { jasmineToString: function() { return 'object b'; } },
+      c = { jasmineToString: jasmine.createSpy('c jasmineToString').and.returnValue('') },
+      d = { jasmineToString: jasmine.createSpy('d jasmineToString').and.returnValue('') };
+
+    withMaxChars(30, function() {
+      jasmineUnderTest.pp([{a: a, b: b, c: c}, d]);
+      expect(c.jasmineToString).not.toHaveBeenCalled();
+      expect(d.jasmineToString).not.toHaveBeenCalled();
+    });
   });
 
   it("should print 'null' as the constructor of an object with its own constructor property", function() {
@@ -216,9 +264,9 @@ describe("jasmineUnderTest.pp", function () {
 
   it("should stringify spy objects properly", function() {
     var TestObject = {
-          someFunction: function() {}
-        },
-        env = new jasmineUnderTest.Env();
+      someFunction: function() {}
+    },
+    env = new jasmineUnderTest.Env();
 
     var spyRegistry = new jasmineUnderTest.SpyRegistry({currentSpies: function() {return [];}});
 

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

@@ -375,27 +375,30 @@ describe("QueueRunner", function() {
       expect(onComplete).toHaveBeenCalled();
     });
 
-    it("fails the function when the promise is rejected", function() {
+    it("handles a rejected promise like an unhandled exception", function() {
       var promise = new StubPromise(),
         queueableFn1 = { fn: function() {
-          setTimeout(function() { promise.rejectHandler('foo'); }, 100);
+          setTimeout(function() {
+            promise.rejectHandler('foo')
+          }, 100);
           return promise;
         } },
         queueableFn2 = { fn: jasmine.createSpy('fn2') },
         failFn = jasmine.createSpy('fail'),
+        onExceptionCallback = jasmine.createSpy('on exception callback'),
         queueRunner = new jasmineUnderTest.QueueRunner({
           queueableFns: [queueableFn1, queueableFn2],
-          fail: failFn
+          onException: onExceptionCallback
         });
 
       queueRunner.execute();
 
-      expect(failFn).not.toHaveBeenCalled();
+      expect(onExceptionCallback).not.toHaveBeenCalled();
       expect(queueableFn2.fn).not.toHaveBeenCalled();
 
       jasmine.clock().tick(100);
 
-      expect(failFn).toHaveBeenCalledWith('foo');
+      expect(onExceptionCallback).toHaveBeenCalledWith('foo');
       expect(queueableFn2.fn).toHaveBeenCalled();
     });
   });

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

@@ -287,6 +287,24 @@ describe("SpyRegistry", function() {
 
       expect(jasmineUnderTest.isSpy(subject.spiedFunc)).toBe(false);
     });
+
+    it("restores window.onerror by overwriting, not deleting", function() {
+      function FakeWindow() {
+      }
+      FakeWindow.prototype.onerror = function() {};
+
+      var spies = [],
+        global = new FakeWindow(),
+        spyRegistry = new jasmineUnderTest.SpyRegistry({
+          currentSpies: function() { return spies; },
+          global: global
+        });
+
+      spyRegistry.spyOn(global, 'onerror');
+      spyRegistry.clearSpies();
+      expect(global.onerror).toBe(FakeWindow.prototype.onerror);
+      expect(global.hasOwnProperty('onerror')).toBe(true);
+    });
   });
 
     describe('spying on properties', function() {

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

@@ -92,12 +92,35 @@ describe("SpyStrategy", function() {
     expect(returnValue).toEqual(67);
   });
 
+  it("allows a fake async function to be called instead", function(done) {
+    jasmine.getEnv().requireAsyncAwait();
+    var originalFn = jasmine.createSpy("original"),
+        fakeFn = jasmine.createSpy("fake").and.callFake(eval("async () => { return 67; }")),
+        spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn}),
+        returnValue;
+
+    spyStrategy.callFake(fakeFn);
+    spyStrategy.exec().then(function (returnValue) {
+      expect(originalFn).not.toHaveBeenCalled();
+      expect(fakeFn).toHaveBeenCalled();
+      expect(returnValue).toEqual(67);
+      done();
+    }).catch(function (err) {
+      done.fail(err);
+    })
+  });
+
   it('throws an error when a non-function is passed to callFake strategy', function() {
     var originalFn = jasmine.createSpy('original'),
         spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn}),
         invalidFakes = [5, 'foo', {}, true, false, null, void 0, new Date(), /.*/];
 
     spyOn(jasmineUnderTest, 'isFunction_').and.returnValue(false);
+    spyOn(jasmineUnderTest, 'isAsyncFunction_').and.returnValue(false);
+
+    expect(function () {
+      spyStrategy.callFake(function() {});
+    }).toThrowError(/^Argument passed to callFake should be a function, got/);
 
     expect(function () {
       spyStrategy.callFake(function() {});

data/lib/jasmine-core/spec/core/asymmetric_equality/AnySpec.js

@@ -29,6 +29,38 @@ describe("Any", function() {
     expect(any.asymmetricMatch(true)).toBe(true);
   });
 
+  it("matches a Map", function() {
+    jasmine.getEnv().requireFunctioningMaps();
+
+    var any = new jasmineUnderTest.Any(Map);
+
+    expect(any.asymmetricMatch(new Map())).toBe(true);
+  });
+
+  it("matches a Set", function() {
+    jasmine.getEnv().requireFunctioningSets();
+
+    var any = new jasmineUnderTest.Any(Set);
+
+    expect(any.asymmetricMatch(new Set())).toBe(true);
+  });
+
+  it("matches a TypedArray", function() {
+    jasmine.getEnv().requireFunctioningTypedArrays();
+
+    var any = new jasmineUnderTest.Any(Uint32Array);
+
+    expect(any.asymmetricMatch(new Uint32Array([]))).toBe(true);
+  });
+
+  it("matches a Symbol", function() {
+    jasmine.getEnv().requireFunctioningSymbols();
+
+    var any = new jasmineUnderTest.Any(Symbol);
+
+    expect(any.asymmetricMatch(Symbol())).toBe(true);
+  });
+
   it("matches another constructed object", function() {
     var Thing = function() {},
       any = new jasmineUnderTest.Any(Thing);