pusher-js 7.0.2 → 7.0.6

package/spec/javascripts/unit/core/http/http_xhr_request_spec.js

@@ -10,9 +10,9 @@ describe("HTTP.getXHR", function() {
   beforeEach(function() {
     HTTPFactory = require('runtime').default.HTTPFactory;
 
-    spyOn(Runtime, 'getXHRAPI').andReturn(Mocks.getXHR);
+    spyOn(Runtime, 'getXHRAPI').and.returnValue(Mocks.getXHR);
 
-    spyOn(HTTPFactory, "createRequest").andCallFake(function(h, m, u) {
+    spyOn(HTTPFactory, "createRequest").and.callFake(function(h, m, u) {
       hooks = h;
       return Mocks.getHTTPRequest(m, u);
     });
@@ -64,7 +64,7 @@ describe("HTTP.getXHR", function() {
           xhr.responseText = "asdf";
 
           xhr.onreadystatechange();
-          expect(socket.onChunk.calls.length).toEqual(1);
+          expect(socket.onChunk.calls.count()).toEqual(1);
           expect(socket.onChunk).toHaveBeenCalledWith(201, "asdf");
         });
 
@@ -73,12 +73,12 @@ describe("HTTP.getXHR", function() {
           xhr.responseText = "asdf";
 
           xhr.onreadystatechange();
-          expect(socket.onChunk.calls.length).toEqual(1);
+          expect(socket.onChunk.calls.count()).toEqual(1);
           expect(socket.onChunk).toHaveBeenCalledWith(201, "asdf");
 
           xhr.responseText = "asdfghjkl";
           xhr.onreadystatechange();
-          expect(socket.onChunk.calls.length).toEqual(2);
+          expect(socket.onChunk.calls.count()).toEqual(2);
           expect(socket.onChunk).toHaveBeenCalledWith(201, "asdfghjkl");
         });
       });
@@ -93,7 +93,7 @@ describe("HTTP.getXHR", function() {
           xhr.responseText = "";
 
           xhr.onreadystatechange();
-          expect(socket.close.calls.length).toEqual(1);
+          expect(socket.close.calls.count()).toEqual(1);
         });
 
         it("should not call socket.onChunk if there is no responseText", function() {
@@ -116,8 +116,8 @@ describe("HTTP.getXHR", function() {
           xhr.status = 234;
           xhr.responseText = "12356890";
 
-          socket.close.andCallFake(function() {
-            expect(socket.onChunk.calls.length).toEqual(1);
+          socket.close.and.callFake(function() {
+            expect(socket.onChunk.calls.count()).toEqual(1);
             expect(socket.onChunk).toHaveBeenCalledWith(234, "12356890");
           });
 
@@ -131,8 +131,8 @@ describe("HTTP.getXHR", function() {
           var onFinished = jasmine.createSpy();
           socket.bind("finished", onFinished);
 
-          socket.close.andCallFake(function() {
-            expect(onFinished.calls.length).toEqual(1);
+          socket.close.and.callFake(function() {
+            expect(onFinished.calls.count()).toEqual(1);
             expect(onFinished).toHaveBeenCalledWith(404);
           });
 
@@ -145,15 +145,15 @@ describe("HTTP.getXHR", function() {
       it("should abort the passed request", function() {
         var xhr = Mocks.getXHR();
 
-        expect(xhr.abort.calls.length).toEqual(0);
+        expect(xhr.abort.calls.count()).toEqual(0);
         hooks.abortRequest(xhr);
-        expect(xhr.abort.calls.length).toEqual(1);
+        expect(xhr.abort.calls.count()).toEqual(1);
       });
 
       it("should set the onreadystatechange listener to null before calling abort", function() {
         var xhr = Mocks.getXHR();
         xhr.onreadystatechange = function() {};
-        xhr.abort.andCallFake(function() {
+        xhr.abort.and.callFake(function() {
           expect(xhr.onreadystatechange).toBe(null);
         });
 

package/spec/javascripts/unit/core/pusher_authorizer_spec.js

@@ -52,9 +52,9 @@ if (TestEnv !== "worker") {
       xhr = new Mocks.getXHR();
 
       if (TestEnv === "web" && !window.XMLHttpRequest) {
-        spyOn(Runtime, "createMicrosoftXHR").andReturn(xhr);
+        spyOn(Runtime, "createMicrosoftXHR").and.returnValue(xhr);
       } else {
-        spyOn(Runtime, "createXHR").andReturn(xhr);
+        spyOn(Runtime, "createXHR").and.returnValue(xhr);
       }
     });
 
@@ -70,7 +70,7 @@ if (TestEnv !== "worker") {
       );
       authorizer.authorize("1.23", function() {});
 
-      expect(xhr.setRequestHeader.calls.length).toEqual(3);
+      expect(xhr.setRequestHeader.calls.count()).toEqual(3);
       expect(xhr.setRequestHeader).toHaveBeenCalledWith(
         "Content-Type", "application/x-www-form-urlencoded"
       );
@@ -90,7 +90,7 @@ if (TestEnv !== "worker") {
       );
       authorizer.authorize("1.23", function() {});
 
-      expect(xhr.send.calls.length).toEqual(1);
+      expect(xhr.send.calls.count()).toEqual(1);
       expect(xhr.send).toHaveBeenCalledWith(
         "socket_id=1.23&channel_name=chan&a=1&b=2"
       );
@@ -109,9 +109,9 @@ if (TestEnv !== "worker") {
       authorizer.authorize("1.23", callback);
 
       if (TestEnv === "web" && !window.XMLHttpRequest) {
-        expect(Runtime.createMicrosoftXHR.calls.length).toEqual(1);
+        expect(Runtime.createMicrosoftXHR.calls.count()).toEqual(1);
       } else {
-        expect(Runtime.createXHR.calls.length).toEqual(1);
+        expect(Runtime.createXHR.calls.count()).toEqual(1);
       }
 
       xhr.readyState = 4;
@@ -119,7 +119,7 @@ if (TestEnv !== "worker") {
       xhr.responseText = dataJSON;
       xhr.onreadystatechange();
 
-      expect(callback.calls.length).toEqual(1);
+      expect(callback.calls.count()).toEqual(1);
       expect(callback).toHaveBeenCalledWith(null, data);
     });
 
@@ -133,9 +133,9 @@ if (TestEnv !== "worker") {
       authorizer.authorize("1.23", callback);
 
       if (TestEnv === "web" && !window.XMLHttpRequest) {
-        expect(Runtime.createMicrosoftXHR.calls.length).toEqual(1);
+        expect(Runtime.createMicrosoftXHR.calls.count()).toEqual(1);
       } else {
-        expect(Runtime.createXHR.calls.length).toEqual(1);
+        expect(Runtime.createXHR.calls.count()).toEqual(1);
       }
 
       xhr.readyState = 4;
@@ -143,10 +143,10 @@ if (TestEnv !== "worker") {
       xhr.responseText = invalidJSON;
       xhr.onreadystatechange();
 
-      expect(callback.calls.length).toEqual(1);
+      expect(callback.calls.count()).toEqual(1);
       // For some reason comparing the Error types doesn't work properly in
       // Safari on Mojave. Manually check the arguments.
-      let args = callback.calls[0].args;
+      let args = callback.calls.first().args;
       expect(args.length).toEqual(2)
       expect(args[0]).toEqual(jasmine.any(Error))
       expect(args[0].message).toEqual(

package/spec/javascripts/unit/core/pusher_spec.js

@@ -32,23 +32,23 @@ describe("Pusher", function() {
     Pusher.isReady = false;
     Pusher.instances = [];
 
-    spyOn(Runtime, "getDefaultStrategy").andCallFake(function() {
+    spyOn(Runtime, "getDefaultStrategy").and.callFake(function() {
       return Mocks.getStrategy(true);
     });
 
-    spyOn(Factory, "createConnectionManager").andCallFake(function(key, options, config) {
+    spyOn(Factory, "createConnectionManager").and.callFake(function(key, options, config) {
       var manager = Mocks.getConnectionManager();
       manager.key = key;
       manager.options = options;
       manager.config = config;
       return manager;
     });
-    spyOn(Factory, "createChannel").andCallFake(function(name, _) {
+    spyOn(Factory, "createChannel").and.callFake(function(name, _) {
       return Mocks.getChannel(name);
     });
 
     if (TestEnv === "web") {
-      spyOn(Runtime, "getDocument").andReturn({
+      spyOn(Runtime, "getDocument").and.returnValue({
         location: {
           protocol: "http:"
         }
@@ -116,7 +116,7 @@ describe("Pusher", function() {
     });
 
     it("should pass a feature list to the timeline", function() {
-      spyOn(Pusher, "getClientFeatures").andReturn(["foo", "bar"]);
+      spyOn(Pusher, "getClientFeatures").and.returnValue(["foo", "bar"]);
       var pusher = new Pusher("foo");
       expect(pusher.timeline.options.features).toEqual(["foo", "bar"]);
     });
@@ -154,7 +154,7 @@ describe("Pusher", function() {
 
       if (TestEnv === "web") {
         it("should be on when using https", function() {
-          Runtime.getDocument.andReturn({
+          Runtime.getDocument.and.returnValue({
             location: {
               protocol: "https:"
             }
@@ -455,16 +455,20 @@ describe("Pusher", function() {
     var timelineSender;
 
     beforeEach(function() {
-      jasmine.Clock.useMock();
+      jasmine.clock().install();
 
       timelineSender = Mocks.getTimelineSender();
-      spyOn(Factory, "createTimelineSender").andReturn(timelineSender);
+      spyOn(Factory, "createTimelineSender").and.returnValue(timelineSender);
 
     });
 
+    afterEach(function() {
+      jasmine.clock().uninstall();
+    });
+
     it("should be sent to stats.pusher.com", function() {
       var pusher = new Pusher("foo", { enableStats: true });
-      expect(Factory.createTimelineSender.calls.length).toEqual(1);
+      expect(Factory.createTimelineSender.calls.count()).toEqual(1);
       expect(Factory.createTimelineSender).toHaveBeenCalledWith(
         pusher.timeline, { host: "stats.pusher.com", path: "/timeline/v2/" + timelineTransport }
       );
@@ -484,15 +488,15 @@ describe("Pusher", function() {
       var pusher = new Pusher("foo");
       pusher.connect();
       pusher.connection.options.timeline.info({});
-      jasmine.Clock.tick(1000000);
-      expect(timelineSender.send.calls.length).toEqual(0);
+      jasmine.clock().tick(1000000);
+      expect(timelineSender.send.calls.count()).toEqual(0);
     });
 
     it("should be sent if disableStats set to false", function() {
       var pusher = new Pusher("foo", { disableStats: false });
       pusher.connect();
       pusher.connection.options.timeline.info({});
-      expect(Factory.createTimelineSender.calls.length).toEqual(1);
+      expect(Factory.createTimelineSender.calls.count()).toEqual(1);
       expect(Factory.createTimelineSender).toHaveBeenCalledWith(
         pusher.timeline, { host: "stats.pusher.com", path: "/timeline/v2/" + timelineTransport }
       );
@@ -502,7 +506,7 @@ describe("Pusher", function() {
       var pusher = new Pusher("foo", { disableStats: true, enableStats: true });
       pusher.connect();
       pusher.connection.options.timeline.info({});
-      expect(Factory.createTimelineSender.calls.length).toEqual(1);
+      expect(Factory.createTimelineSender.calls.count()).toEqual(1);
       expect(Factory.createTimelineSender).toHaveBeenCalledWith(
         pusher.timeline, { host: "stats.pusher.com", path: "/timeline/v2/" + timelineTransport }
       );
@@ -511,23 +515,23 @@ describe("Pusher", function() {
     it("should not be sent before calling connect", function() {
       var pusher = new Pusher("foo", { enableStats: true });
       pusher.connection.options.timeline.info({});
-      jasmine.Clock.tick(1000000);
-      expect(timelineSender.send.calls.length).toEqual(0);
+      jasmine.clock().tick(1000000);
+      expect(timelineSender.send.calls.count()).toEqual(0);
     });
 
     it("should be sent every 60 seconds after calling connect", function() {
       var pusher = new Pusher("foo", { enableStats: true });
       pusher.connect();
-      expect(Factory.createTimelineSender.calls.length).toEqual(1);
+      expect(Factory.createTimelineSender.calls.count()).toEqual(1);
 
       pusher.connection.options.timeline.info({});
 
-      jasmine.Clock.tick(59999);
-      expect(timelineSender.send.calls.length).toEqual(0);
-      jasmine.Clock.tick(1);
-      expect(timelineSender.send.calls.length).toEqual(1);
-      jasmine.Clock.tick(60000);
-      expect(timelineSender.send.calls.length).toEqual(2);
+      jasmine.clock().tick(59999);
+      expect(timelineSender.send.calls.count()).toEqual(0);
+      jasmine.clock().tick(1);
+      expect(timelineSender.send.calls.count()).toEqual(1);
+      jasmine.clock().tick(60000);
+      expect(timelineSender.send.calls.count()).toEqual(2);
     });
 
     it("should be sent after connecting", function() {
@@ -538,7 +542,7 @@ describe("Pusher", function() {
       pusher.connection.state = "connected";
       pusher.connection.emit("connected");
 
-      expect(timelineSender.send.calls.length).toEqual(1);
+      expect(timelineSender.send.calls.count()).toEqual(1);
     });
 
     it("should not be sent after disconnecting", function() {
@@ -548,13 +552,13 @@ describe("Pusher", function() {
 
       pusher.connection.options.timeline.info({});
 
-      jasmine.Clock.tick(1000000);
-      expect(timelineSender.send.calls.length).toEqual(0);
+      jasmine.clock().tick(1000000);
+      expect(timelineSender.send.calls.count()).toEqual(0);
     });
 
     it("should be sent without TLS if connection is not using TLS", function() {
       var pusher = new Pusher("foo", { enableStats: true });
-      pusher.connection.isUsingTLS.andReturn(false);
+      pusher.connection.isUsingTLS.and.returnValue(false);
 
       pusher.connect();
       pusher.connection.options.timeline.info({});
@@ -567,7 +571,7 @@ describe("Pusher", function() {
 
     it("should be sent with TLS if connection is over TLS", function() {
       var pusher = new Pusher("foo", { enableStats: true });
-      pusher.connection.isUsingTLS.andReturn(true);
+      pusher.connection.isUsingTLS.and.returnValue(true);
 
       pusher.connect();
       pusher.connection.options.timeline.info({});

package/spec/javascripts/unit/core/strategies/best_connected_ever_strategy_spec.js

@@ -32,7 +32,7 @@ describe("BestConnectedEverStrategy", function() {
         expect(this.callback).toHaveBeenCalledWith(null, {
           transport: transport1
         });
-        expect(this.callback.calls.length).toEqual(1);
+        expect(this.callback.calls.count()).toEqual(1);
       });
 
       it("should force min priorities on all substrategies", function() {
@@ -50,7 +50,7 @@ describe("BestConnectedEverStrategy", function() {
         expect(this.callback).toHaveBeenCalledWith(null, {
           transport: transport2
         });
-        expect(this.callback.calls.length).toEqual(2);
+        expect(this.callback.calls.count()).toEqual(2);
       });
     });
 
@@ -67,12 +67,12 @@ describe("BestConnectedEverStrategy", function() {
       it("should not pass errors after one substrategy succeeded", function() {
         var transport = Mocks.getTransport();
         this.substrategies[0]._callback(null, { transport: transport });
-        expect(this.callback.calls.length).toEqual(1);
+        expect(this.callback.calls.count()).toEqual(1);
 
         this.substrategies[1]._callback(true);
-        expect(this.callback.calls.length).toEqual(1);
+        expect(this.callback.calls.count()).toEqual(1);
         this.substrategies[2]._callback(true);
-        expect(this.callback.calls.length).toEqual(1);
+        expect(this.callback.calls.count()).toEqual(1);
       });
     });
   });

package/spec/javascripts/unit/core/strategies/cached_strategy_spec.js

@@ -5,7 +5,11 @@ var Util = require('core/util').default;
 
 describe("CachedStrategy", function() {
   beforeEach(function() {
-    jasmine.Clock.useMock();
+    jasmine.clock().install();
+  });
+
+  afterEach(function() {
+    jasmine.clock().uninstall();
   });
 
   describe("after calling isSupported", function() {
@@ -24,7 +28,7 @@ describe("CachedStrategy", function() {
 
   describe("on browsers not supporting localStorage", function() {
     beforeEach(function() {
-      spyOn(Runtime, "getLocalStorage").andReturn(undefined);
+      spyOn(Runtime, "getLocalStorage").and.returnValue(undefined);
     });
 
     it("should try the substrategy immediately", function() {
@@ -41,7 +45,7 @@ describe("CachedStrategy", function() {
 
     beforeEach(function() {
       localStorage = {};
-      spyOn(Runtime, "getLocalStorage").andReturn(localStorage);
+      spyOn(Runtime, "getLocalStorage").and.returnValue(localStorage);
     });
 
     function buildCachedTransportTests(useTLS) {
@@ -114,10 +118,10 @@ describe("CachedStrategy", function() {
 
           beforeEach(function() {
             startTimestamp = Util.now();
-            spyOn(Util, "now").andReturn(startTimestamp);
+            spyOn(Util, "now").and.returnValue(startTimestamp);
 
             strategy.connect(0, callback);
-            Util.now.andReturn(startTimestamp + 1000);
+            Util.now.and.returnValue(startTimestamp + 1000);
 
             transport = Mocks.getTransport(true);
             transport.name = "test";
@@ -208,10 +212,10 @@ describe("CachedStrategy", function() {
 
           beforeEach(function() {
             startTimestamp = Util.now();
-            spyOn(Util, "now").andReturn(startTimestamp);
+            spyOn(Util, "now").and.returnValue(startTimestamp);
 
             strategy.connect(0, callback);
-            Util.now.andReturn(startTimestamp + 2000);
+            Util.now.and.returnValue(startTimestamp + 2000);
 
             transport = Mocks.getTransport(true);
             transport.name = "test";
@@ -240,12 +244,12 @@ describe("CachedStrategy", function() {
         describe("after double the cached latency + 1s", function() {
           beforeEach(function() {
             startTimestamp = Util.now();
-            spyOn(Util, "now").andReturn(startTimestamp);
+            spyOn(Util, "now").and.returnValue(startTimestamp);
 
             strategy.connect(0, callback);
 
-            Util.now.andReturn(startTimestamp + 3000);
-            jasmine.Clock.tick(3000);
+            Util.now.and.returnValue(startTimestamp + 3000);
+            jasmine.clock().tick(3000);
           });
 
           it("should abort the cached strategy", function() {
@@ -267,13 +271,13 @@ describe("CachedStrategy", function() {
 
           beforeEach(function() {
             startTimestamp = Util.now();
-            spyOn(Util, "now").andReturn(startTimestamp);
+            spyOn(Util, "now").and.returnValue(startTimestamp);
 
             runner = strategy.connect(0, callback);
             runner.forceMinPriority(666);
-            Util.now.andReturn(startTimestamp + 2000);
+            Util.now.and.returnValue(startTimestamp + 2000);
             transports.test._callback("error");
-            Util.now.andReturn(startTimestamp + 2500);
+            Util.now.and.returnValue(startTimestamp + 2500);
           });
 
           it("should fall back to the substrategy", function() {

package/spec/javascripts/unit/core/strategies/delayed_strategy_spec.js

@@ -7,7 +7,11 @@ describe("DelayedStrategy", function() {
     this.strategy = new DelayedStrategy(this.substrategy, { delay: 0 });
     this.callback = jasmine.createSpy();
 
-    jasmine.Clock.useMock();
+    jasmine.clock().install();
+  });
+
+  afterEach(function() {
+    jasmine.clock().uninstall();
   });
 
   describe("after calling isSupported", function() {
@@ -33,9 +37,9 @@ describe("DelayedStrategy", function() {
       strategy.connect(0, this.callback);
 
       expect(this.substrategy.connect).not.toHaveBeenCalled();
-      jasmine.Clock.tick(99);
+      jasmine.clock().tick(99);
       expect(this.substrategy.connect).not.toHaveBeenCalled();
-      jasmine.Clock.tick(1);
+      jasmine.clock().tick(1);
       expect(this.substrategy.connect).toHaveBeenCalled();
 
       var handshake = {};
@@ -46,7 +50,7 @@ describe("DelayedStrategy", function() {
 
     it("should pass an error when substrategy fails", function() {
       this.strategy.connect(0, this.callback);
-      jasmine.Clock.tick(0);
+      jasmine.clock().tick(0);
       this.substrategy._callback(true);
 
       expect(this.callback).toHaveBeenCalledWith(true);
@@ -56,7 +60,7 @@ describe("DelayedStrategy", function() {
   describe("on abort", function() {
     it("should abort substrategy when connecting", function() {
       var runner = this.strategy.connect(0);
-      jasmine.Clock.tick(0);
+      jasmine.clock().tick(0);
       runner.abort();
       expect(this.substrategy._abort).toHaveBeenCalled();
     });
@@ -65,7 +69,7 @@ describe("DelayedStrategy", function() {
       var run = this.strategy.connect(0);
       expect(this.substrategy.connect).not.toHaveBeenCalled();
       run.abort();
-      jasmine.Clock.tick(10000);
+      jasmine.clock().tick(10000);
       expect(this.substrategy._abort).not.toHaveBeenCalled();
       expect(this.substrategy.connect).not.toHaveBeenCalled();
     });
@@ -75,14 +79,14 @@ describe("DelayedStrategy", function() {
     it("should force the priority while waiting", function() {
       var runner = this.strategy.connect(0, this.callback);
       runner.forceMinPriority(5);
-      jasmine.Clock.tick(0);
+      jasmine.clock().tick(0);
       expect(this.substrategy.connect)
         .toHaveBeenCalledWith(5, jasmine.any(Function));
     });
 
     it("should force the priority while connecting", function() {
       var runner = this.strategy.connect(0, this.callback);
-      jasmine.Clock.tick(0);
+      jasmine.clock().tick(0);
       runner.forceMinPriority(5);
       expect(this.substrategy._forceMinPriority).toHaveBeenCalledWith(5);
     });

package/spec/javascripts/unit/core/strategies/sequential_strategy_spec.js

@@ -7,7 +7,11 @@ describe("SequentialStrategy", function() {
     this.substrategies = Mocks.getStrategies([true, true]);
     this.strategy = new SequentialStrategy(this.substrategies, {});
 
-    jasmine.Clock.useMock();
+    jasmine.clock().install();
+  });
+
+  afterEach(function() {
+    jasmine.clock().uninstall();
   });
 
   describe("after calling isSupported", function() {
@@ -51,7 +55,7 @@ describe("SequentialStrategy", function() {
       this.substrategies[1]._callback(true);
       expect(this.substrategies[1]._abort).not.toHaveBeenCalled();
       expect(this.callback).toHaveBeenCalledWith(true);
-      expect(this.callback.calls.length).toEqual(1);
+      expect(this.callback.calls.count()).toEqual(1);
     });
 
     it("should support looping", function() {
@@ -60,18 +64,18 @@ describe("SequentialStrategy", function() {
       });
       var runner = strategy.connect(0, this.callback);
 
-      expect(this.substrategies[0].connect.calls.length).toEqual(1);
-      expect(this.substrategies[1].connect.calls.length).toEqual(0);
+      expect(this.substrategies[0].connect.calls.count()).toEqual(1);
+      expect(this.substrategies[1].connect.calls.count()).toEqual(0);
 
       this.substrategies[0]._callback(true);
 
-      expect(this.substrategies[0].connect.calls.length).toEqual(1);
-      expect(this.substrategies[1].connect.calls.length).toEqual(1);
+      expect(this.substrategies[0].connect.calls.count()).toEqual(1);
+      expect(this.substrategies[1].connect.calls.count()).toEqual(1);
 
       this.substrategies[1]._callback(true);
 
-      expect(this.substrategies[0].connect.calls.length).toEqual(2);
-      expect(this.substrategies[1].connect.calls.length).toEqual(1);
+      expect(this.substrategies[0].connect.calls.count()).toEqual(2);
+      expect(this.substrategies[1].connect.calls.count()).toEqual(1);
 
       runner.abort();
       expect(this.substrategies[0]._abort).toHaveBeenCalled();
@@ -111,7 +115,7 @@ describe("SequentialStrategy", function() {
       expect(this.substrategies[1].connect).not.toHaveBeenCalled();
 
       runner.abort();
-      jasmine.Clock.tick(100);
+      jasmine.clock().tick(100);
       expect(this.substrategies[1].connect).not.toHaveBeenCalled();
     });
   });
@@ -126,9 +130,9 @@ describe("SequentialStrategy", function() {
       strategy.connect(0, this.callback);
       substrategy._callback(true);
 
-      jasmine.Clock.tick(99);
+      jasmine.clock().tick(99);
       expect(this.callback).not.toHaveBeenCalled();
-      jasmine.Clock.tick(1);
+      jasmine.clock().tick(1);
       expect(this.callback).toHaveBeenCalled();
     });
 
@@ -160,31 +164,31 @@ describe("SequentialStrategy", function() {
       expect(substrategies[0].connect).toHaveBeenCalled();
       expect(substrategies[1].connect).not.toHaveBeenCalled();
 
-      jasmine.Clock.tick(99);
+      jasmine.clock().tick(99);
       expect(substrategies[1].connect).not.toHaveBeenCalled();
 
-      jasmine.Clock.tick(1);
+      jasmine.clock().tick(1);
       expect(substrategies[1].connect).toHaveBeenCalled();
       expect(substrategies[2].connect).not.toHaveBeenCalled();
 
-      jasmine.Clock.tick(199);
+      jasmine.clock().tick(199);
       expect(substrategies[2].connect).not.toHaveBeenCalled();
 
-      jasmine.Clock.tick(1);
+      jasmine.clock().tick(1);
       expect(substrategies[2].connect).toHaveBeenCalled();
       expect(substrategies[3].connect).not.toHaveBeenCalled();
 
-      jasmine.Clock.tick(399);
+      jasmine.clock().tick(399);
       expect(substrategies[3].connect).not.toHaveBeenCalled();
 
-      jasmine.Clock.tick(1);
+      jasmine.clock().tick(1);
       expect(substrategies[3].connect).toHaveBeenCalled();
       expect(substrategies[4].connect).not.toHaveBeenCalled();
 
-      jasmine.Clock.tick(399);
+      jasmine.clock().tick(399);
       expect(substrategies[4].connect).not.toHaveBeenCalled();
 
-      jasmine.Clock.tick(1);
+      jasmine.clock().tick(1);
       expect(substrategies[4].connect).toHaveBeenCalled();
     });
   });