pusher-js 7.0.2 → 7.0.6

package/spec/javascripts/unit/core/transports/transport_manager_spec.js

@@ -12,7 +12,7 @@ describe("TransportManager", function() {
       maxPingDelay: 2222
     });
 
-    spyOn(Factory, 'createAssistantToTheTransportManager').andReturn(assistant);
+    spyOn(Factory, 'createAssistantToTheTransportManager').and.returnValue(assistant);
 
     expect(manager.getAssistant(transportClass)).toBe(assistant);
     expect(Factory.createAssistantToTheTransportManager).toHaveBeenCalledWith(

package/spec/javascripts/unit/core/utils/periodic_timer_spec.js

@@ -6,7 +6,7 @@ describe("PeriodicTimer", function() {
   var timer;
 
   beforeEach(function() {
-    jasmine.Clock.useMock();
+    jasmine.clock().install();
 
     callback = jasmine.createSpy("callback");
     timer = new PeriodicTimer(123, callback);
@@ -14,30 +14,31 @@ describe("PeriodicTimer", function() {
 
   afterEach(function() {
     timer.ensureAborted();
+    jasmine.clock().uninstall();
   });
 
   it("should keep executing the callback with the specified interval", function() {
-    expect(callback.calls.length).toEqual(0);
-    jasmine.Clock.tick(122);
-    expect(callback.calls.length).toEqual(0);
-    jasmine.Clock.tick(1);
-    expect(callback.calls.length).toEqual(1);
+    expect(callback.calls.count()).toEqual(0);
+    jasmine.clock().tick(122);
+    expect(callback.calls.count()).toEqual(0);
+    jasmine.clock().tick(1);
+    expect(callback.calls.count()).toEqual(1);
 
-    expect(callback.calls.length).toEqual(1);
-    jasmine.Clock.tick(122);
-    expect(callback.calls.length).toEqual(1);
-    jasmine.Clock.tick(1);
-    expect(callback.calls.length).toEqual(2);
+    expect(callback.calls.count()).toEqual(1);
+    jasmine.clock().tick(122);
+    expect(callback.calls.count()).toEqual(1);
+    jasmine.clock().tick(1);
+    expect(callback.calls.count()).toEqual(2);
   });
 
   describe("#isRunning", function() {
     it("should return true before first execution", function() {
-      jasmine.Clock.tick(122);
+      jasmine.clock().tick(122);
       expect(timer.isRunning()).toBe(true);
     });
 
     it("should return true after execution", function() {
-      jasmine.Clock.tick(123);
+      jasmine.clock().tick(123);
       expect(timer.isRunning()).toBe(true);
     });
 
@@ -50,12 +51,12 @@ describe("PeriodicTimer", function() {
   describe("#ensureAborted", function() {
     it("should abort the timer before execution", function() {
       timer.ensureAborted();
-      jasmine.Clock.tick(1000000);
+      jasmine.clock().tick(1000000);
       expect(callback).not.toHaveBeenCalled();
     });
 
     it("should play nice after first execution", function() {
-      jasmine.Clock.tick(1000);
+      jasmine.clock().tick(1000);
       timer.ensureAborted();
     });
 
@@ -63,7 +64,7 @@ describe("PeriodicTimer", function() {
       // IE has some edge-case with clearInterval not working, let's simulate it
       spyOn(global, "clearInterval");
       timer.ensureAborted();
-      jasmine.Clock.tick(1000);
+      jasmine.clock().tick(1000);
       expect(callback).not.toHaveBeenCalled();
     });
   });

package/spec/javascripts/unit/core/utils/timers_spec.js

@@ -1,12 +1,17 @@
 var timers = require('core/utils/timers');
 
 describe("timers", function() {
+  afterEach(() => {
+    jasmine.clock().uninstall();
+  });
+
   describe("Timer", function() {
     var callback;
     var timer;
 
     beforeEach(function() {
-      jasmine.Clock.useMock();
+      jasmine.clock().uninstall();
+      jasmine.clock().install();
 
       callback = jasmine.createSpy("callback");
       timer = new timers.OneOffTimer(123, callback);
@@ -18,25 +23,25 @@ describe("timers", function() {
 
     it("should execute the callback with the specified delay", function() {
       expect(callback).not.toHaveBeenCalled();
-      jasmine.Clock.tick(122);
+      jasmine.clock().tick(122);
       expect(callback).not.toHaveBeenCalled();
-      jasmine.Clock.tick(1);
+      jasmine.clock().tick(1);
       expect(callback).toHaveBeenCalled();
     });
 
     it("should execute the callback exactly once", function() {
-      jasmine.Clock.tick(1000);
-      expect(callback.calls.length).toEqual(1);
+      jasmine.clock().tick(1000);
+      expect(callback.calls.count()).toEqual(1);
     });
 
     describe("#isRunning", function() {
       it("should return true before execution", function() {
-        jasmine.Clock.tick(122);
+        jasmine.clock().tick(122);
         expect(timer.isRunning()).toBe(true);
       });
 
       it("should return false after execution", function() {
-        jasmine.Clock.tick(123);
+        jasmine.clock().tick(123);
         expect(timer.isRunning()).toBe(false);
       });
 
@@ -49,12 +54,12 @@ describe("timers", function() {
     describe("#ensureAborted", function() {
       it("should abort the timer before execution", function() {
         timer.ensureAborted();
-        jasmine.Clock.tick(1000);
+        jasmine.clock().tick(1000);
         expect(callback).not.toHaveBeenCalled();
       });
 
       it("should play nice after execution", function() {
-        jasmine.Clock.tick(1000);
+        jasmine.clock().tick(1000);
         timer.ensureAborted();
       });
 
@@ -62,7 +67,7 @@ describe("timers", function() {
         // IE has some edge-case with clearTimeout not working, let's simulate it
         spyOn(global, "clearTimeout");
         timer.ensureAborted();
-        jasmine.Clock.tick(1000);
+        jasmine.clock().tick(1000);
         expect(callback).not.toHaveBeenCalled();
       });
     });
@@ -73,7 +78,8 @@ describe("timers", function() {
     var timer;
 
     beforeEach(function() {
-      jasmine.Clock.useMock();
+      jasmine.clock().uninstall();
+      jasmine.clock().install();
 
       callback = jasmine.createSpy("callback");
       timer = new timers.PeriodicTimer(123, callback);
@@ -85,27 +91,27 @@ describe("timers", function() {
 
     it("should execute the callback with the specified delay", function() {
       expect(callback).not.toHaveBeenCalled();
-      jasmine.Clock.tick(122);
+      jasmine.clock().tick(122);
       expect(callback).not.toHaveBeenCalled();
-      jasmine.Clock.tick(1);
+      jasmine.clock().tick(1);
       expect(callback).toHaveBeenCalled();
     });
 
     it("should execute the callback periodically", function() {
-      jasmine.Clock.tick(123);
-      expect(callback.calls.length).toEqual(1);
-      jasmine.Clock.tick(123);
-      expect(callback.calls.length).toEqual(2);
+      jasmine.clock().tick(123);
+      expect(callback.calls.count()).toEqual(1);
+      jasmine.clock().tick(123);
+      expect(callback.calls.count()).toEqual(2);
     });
 
     describe("#isRunning", function() {
       it("should return true before execution", function() {
-        jasmine.Clock.tick(122);
+        jasmine.clock().tick(122);
         expect(timer.isRunning()).toBe(true);
       });
 
       it("should return true after execution", function() {
-        jasmine.Clock.tick(123);
+        jasmine.clock().tick(123);
         expect(timer.isRunning()).toBe(true);
       });
 
@@ -118,22 +124,22 @@ describe("timers", function() {
     describe("#ensureAborted", function() {
       it("should abort the timer before execution", function() {
         timer.ensureAborted();
-        jasmine.Clock.tick(1000);
+        jasmine.clock().tick(1000);
         expect(callback).not.toHaveBeenCalled();
       });
 
       it("should abort the timer after first execution", function() {
-        jasmine.Clock.tick(123);
-        expect(callback.calls.length).toEqual(1);
+        jasmine.clock().tick(123);
+        expect(callback.calls.count()).toEqual(1);
         timer.ensureAborted();
-        jasmine.Clock.tick(1000);
-        expect(callback.calls.length).toEqual(1);
+        jasmine.clock().tick(1000);
+        expect(callback.calls.count()).toEqual(1);
       });
 
       it("should be idempotent", function() {
         timer.ensureAborted();
         timer.ensureAborted();
-        jasmine.Clock.tick(1000);
+        jasmine.clock().tick(1000);
         expect(callback).not.toHaveBeenCalled();
       });
 
@@ -141,7 +147,7 @@ describe("timers", function() {
         // IE has some edge-case with clearTimeout not working, let's simulate it
         spyOn(global, "clearTimeout");
         timer.ensureAborted();
-        jasmine.Clock.tick(1000);
+        jasmine.clock().tick(1000);
         expect(callback).not.toHaveBeenCalled();
       });
     });

package/spec/javascripts/unit/isomorphic/transports/hosts_and_ports_spec.js

@@ -13,30 +13,34 @@ describe("Host/Port Configuration", function() {
   var Transports;
 
   beforeEach(function() {
-    spyOn(Runtime, 'getNetwork').andCallFake(function(){
+    spyOn(Runtime, 'getNetwork').and.callFake(function(){
       var network = new NetInfo();
       network.isOnline = jasmine.createSpy("isOnline")
-        .andReturn(true);
+        .and.returnValue(true);
       return network;
     });
-    spyOn(Runtime, "getLocalStorage").andReturn({});
+    spyOn(Runtime, "getLocalStorage").and.returnValue({});
   });
 
   afterEach(function() {
-    pusher.disconnect();
+    try {
+      pusher.disconnect();
+    } catch (e) {
+      console.log(`Received an error when tried to disconnect. Error message: ${e}`);
+    }
   });
 
   describe("WebSockets", function() {
     var _WebSocket;
 
     beforeEach(function() {
-      spyOn(Runtime, 'createWebSocket').andReturn(Mocks.getTransport());
+      spyOn(Runtime, 'createWebSocket').and.returnValue(Mocks.getTransport());
 
       var Transports = Runtime.Transports;
 
-      spyOn(Transports.ws, "isSupported").andReturn(true);
-      spyOn(Transports.xhr_streaming, "isSupported").andReturn(false);
-      spyOn(Transports.xhr_polling, "isSupported").andReturn(false);
+      spyOn(Transports.ws, "isSupported").and.returnValue(true);
+      spyOn(Transports.xhr_streaming, "isSupported").and.returnValue(false);
+      spyOn(Transports.xhr_polling, "isSupported").and.returnValue(false);
     });
 
     it("should connect to wss://ws-mt1.pusher.com:443 by default", function() {

package/spec/javascripts/unit/isomorphic/transports/transports_spec.js

@@ -38,7 +38,7 @@ describe("Transports", function() {
         "ws://example.com:123/path/app/foobar?protocol=7&client=js&version=" + VERSION + "&flash=false"
       );
     });
- 
+
     it("should generate correct TLS URLs with custom path prefix", function() {
       var url = Transports.ws.hooks.urls.getInitial("foobar", {
         useTLS: true,
@@ -81,9 +81,9 @@ describe("Transports", function() {
         var FakeWebSocket = function(url) {
           this.url = url;
         }
-        spyOn(Runtime, 'getWebSocketAPI').andReturn(FakeWebSocket);
+        spyOn(Runtime, 'getWebSocketAPI').and.returnValue(FakeWebSocket);
         var socket = Transports.ws.hooks.getSocket("testurl");
-        expect(Runtime.getWebSocketAPI.calls.length).toEqual(1);
+        expect(Runtime.getWebSocketAPI.calls.count()).toEqual(1);
         expect(socket).toEqual(jasmine.any(FakeWebSocket));
         expect(socket.url).toEqual("testurl");
       });
@@ -170,12 +170,12 @@ describe("Transports", function() {
     describe(transport, function() {
       describe("getSocket hook", function() {
         it("should return a new streaming HTTPSocket object", function() {
-          spyOn(HTTP, "createStreamingSocket").andCallFake(function(url) {
+          spyOn(HTTP, "createStreamingSocket").and.callFake(function(url) {
             return "streaming socket mock";
           });
 
           var socket = Transports[transport].hooks.getSocket("streamurl");
-          expect(HTTP.createStreamingSocket.calls.length).toEqual(1);
+          expect(HTTP.createStreamingSocket.calls.count()).toEqual(1);
           expect(HTTP.createStreamingSocket).toHaveBeenCalledWith("streamurl");
           expect(socket).toEqual("streaming socket mock");
         });
@@ -187,12 +187,12 @@ describe("Transports", function() {
     describe(transport, function() {
       describe("getSocket hook", function() {
         it("should return a new polling HTTPSocket object", function() {
-          spyOn(HTTP, "createPollingSocket").andCallFake(function(url) {
+          spyOn(HTTP, "createPollingSocket").and.callFake(function(url) {
             return "polling socket mock";
           });
 
           var socket = Transports[transport].hooks.getSocket("streamurl");
-          expect(HTTP.createPollingSocket.calls.length).toEqual(1);
+          expect(HTTP.createPollingSocket.calls.count()).toEqual(1);
           expect(HTTP.createPollingSocket).toHaveBeenCalledWith("streamurl");
           expect(socket).toEqual("polling socket mock");
         });

package/spec/javascripts/unit/node/timeline_sender_spec.js

@@ -7,8 +7,8 @@ describe("TimelineSender", function() {
 
   beforeEach(function(){
     timeline = Mocks.getTimeline();
-    timeline.isEmpty.andReturn(false);
-    timeline.send.andCallFake(function(sendXHR, callback) {
+    timeline.isEmpty.and.returnValue(false);
+    timeline.send.and.callFake(function(sendXHR, callback) {
       sendXHR({ events: [1, 2, 3]}, callback);
     });
 
@@ -23,7 +23,7 @@ describe("TimelineSender", function() {
     var xhrRequest;
 
     beforeEach(function() {
-      spyOn(Runtime, "createXHR").andCallFake(function() {
+      spyOn(Runtime, "createXHR").and.callFake(function() {
         xhrRequest = Mocks.getXHR();
         return xhrRequest;
       });
@@ -47,7 +47,7 @@ describe("TimelineSender", function() {
       it("should send a non-empty timeline", function() {
         sender.send(false, onSend);
 
-        expect(Runtime.createXHR.calls.length).toEqual(1);
+        expect(Runtime.createXHR.calls.count()).toEqual(1);
         var encodedParams = 'WzEsMiwzXQ%3D%3D';
 
         expect(xhrRequest.open).toHaveBeenCalledWith(
@@ -59,7 +59,7 @@ describe("TimelineSender", function() {
       });
 
       it("should not send an empty timeline", function() {
-        timeline.isEmpty.andReturn(true);
+        timeline.isEmpty.and.returnValue(true);
         sender.send(false, onSend);
         expect(Runtime.createXHR).not.toHaveBeenCalled();
       });

package/spec/javascripts/unit/web/dom/dependency_loader_spec.js

@@ -15,8 +15,8 @@ describe("DependencyLoader", function() {
     doc = Mocks.getDocument();
     doc.location.protocol = "http:";
 
-    spyOn(Runtime, "getDocument").andReturn(doc);
-    spyOn(Runtime, "createScriptRequest").andCallFake(function() {
+    spyOn(Runtime, "getDocument").and.returnValue(doc);
+    spyOn(Runtime, "createScriptRequest").and.callFake(function() {
       scriptRequest = Mocks.getScriptRequest();
       return scriptRequest;
     });
@@ -108,7 +108,7 @@ describe("DependencyLoader", function() {
     it("should send an non TLS script request when served via http", function() {
       doc.location.protocol = "http:";
       loader.load("resource", {}, onLoaded);
-      expect(Runtime.createScriptRequest.calls.length).toEqual(1);
+      expect(Runtime.createScriptRequest.calls.count()).toEqual(1);
       expect(Runtime.createScriptRequest).toHaveBeenCalledWith(
         "http://example.com/6.6.6/resource-test.js"
       );
@@ -117,7 +117,7 @@ describe("DependencyLoader", function() {
     it("should send a TLS script request when served via https", function() {
       doc.location.protocol = "https:";
       loader.load("resource", {}, onLoaded);
-      expect(Runtime.createScriptRequest.calls.length).toEqual(1);
+      expect(Runtime.createScriptRequest.calls.count()).toEqual(1);
       expect(Runtime.createScriptRequest).toHaveBeenCalledWith(
         "https://example.com/6.6.6/resource-test.js"
       );
@@ -126,25 +126,25 @@ describe("DependencyLoader", function() {
     it("should send a TLS script request when served via http, but passed TLS via options", function() {
       doc.location.protocol = "http:";
       loader.load("resource", { useTLS: true }, onLoaded);
-      expect(Runtime.createScriptRequest.calls.length).toEqual(1);
+      expect(Runtime.createScriptRequest.calls.count()).toEqual(1);
       expect(Runtime.createScriptRequest).toHaveBeenCalledWith(
         "https://example.com/6.6.6/resource-test.js"
       );
     });
 
     it("should only send one script request per resource at a time", function() {
-      expect(Runtime.createScriptRequest.calls.length).toEqual(0);
+      expect(Runtime.createScriptRequest.calls.count()).toEqual(0);
 
       loader.load("resource", {}, function() {});
       loader.load("resource", {}, function() {});
       loader.load("resource", {}, function() {});
-      expect(Runtime.createScriptRequest.calls.length).toEqual(1);
+      expect(Runtime.createScriptRequest.calls.count()).toEqual(1);
       expect(Runtime.createScriptRequest).toHaveBeenCalledWith(
         "http://example.com/6.6.6/resource-test.js"
       );
 
       loader.load("resource2", {}, function() {});
-      expect(Runtime.createScriptRequest.calls.length).toEqual(2);
+      expect(Runtime.createScriptRequest.calls.count()).toEqual(2);
       expect(Runtime.createScriptRequest).toHaveBeenCalledWith(
         "http://example.com/6.6.6/resource2-test.js"
       );
@@ -152,7 +152,7 @@ describe("DependencyLoader", function() {
 
     it("should register a receiver", function() {
       loader.load("resource", {}, onLoaded);
-      var receiver = scriptRequest.send.calls[0].args[0];
+      var receiver = scriptRequest.send.calls.first().args[0];
       expect(Pusher.ScriptReceivers[receiver.number]).toBe(
         receiver.callback
       );
@@ -160,7 +160,7 @@ describe("DependencyLoader", function() {
 
     it("should call back without an error if the resource loaded successfully", function() {
       loader.load("resource", {}, onLoaded);
-      var receiver = scriptRequest.send.calls[0].args[0];
+      var receiver = scriptRequest.send.calls.first().args[0];
 
       expect(onLoaded).not.toHaveBeenCalled();
       receiver.callback(null);
@@ -169,7 +169,7 @@ describe("DependencyLoader", function() {
 
     it("should call back with an error if the resource failed to load", function() {
       loader.load("resource", {}, onLoaded);
-      var receiver = scriptRequest.send.calls[0].args[0];
+      var receiver = scriptRequest.send.calls.first().args[0];
 
       expect(onLoaded).not.toHaveBeenCalled();
       receiver.callback("too bad");
@@ -185,23 +185,23 @@ describe("DependencyLoader", function() {
 
       loader.load("resource2", {}, onLoaded3);
 
-      expect(onLoaded.calls.length).toEqual(0);
-      expect(onLoaded2.calls.length).toEqual(0);
-      expect(onLoaded3.calls.length).toEqual(0);
+      expect(onLoaded.calls.count()).toEqual(0);
+      expect(onLoaded2.calls.count()).toEqual(0);
+      expect(onLoaded3.calls.count()).toEqual(0);
 
-      var firstReceiver = firstScriptRequest.send.calls[0].args[0];
+      var firstReceiver = firstScriptRequest.send.calls.first().args[0];
       firstReceiver.callback(null);
 
-      expect(onLoaded.calls.length).toEqual(1);
-      expect(onLoaded2.calls.length).toEqual(1);
-      expect(onLoaded3.calls.length).toEqual(0);
+      expect(onLoaded.calls.count()).toEqual(1);
+      expect(onLoaded2.calls.count()).toEqual(1);
+      expect(onLoaded3.calls.count()).toEqual(0);
 
-      var secondReceiver = scriptRequest.send.calls[0].args[0];
+      var secondReceiver = scriptRequest.send.calls.first().args[0];
       secondReceiver.callback(null);
 
-      expect(onLoaded.calls.length).toEqual(1);
-      expect(onLoaded2.calls.length).toEqual(1);
-      expect(onLoaded3.calls.length).toEqual(1);
+      expect(onLoaded.calls.count()).toEqual(1);
+      expect(onLoaded2.calls.count()).toEqual(1);
+      expect(onLoaded3.calls.count()).toEqual(1);
     });
 
     describe("after loading the resource", function() {
@@ -209,7 +209,7 @@ describe("DependencyLoader", function() {
 
       beforeEach(function() {
         loader.load("resource", {}, onLoaded);
-        receiver = scriptRequest.send.calls[0].args[0];
+        receiver = scriptRequest.send.calls.first().args[0];
         receiver.callback(null);
       });
 
@@ -220,29 +220,29 @@ describe("DependencyLoader", function() {
       });
 
       it("should not clean up the request when called back with true", function() {
-        var loadCallback = onLoaded.calls[0].args[1];
+        var loadCallback = onLoaded.calls.first().args[1];
         expect(scriptRequest.cleanup).not.toHaveBeenCalled();
         loadCallback(true);
         expect(scriptRequest.cleanup).not.toHaveBeenCalled();
       });
 
       it("should clean up the request when called back with false", function() {
-        var loadCallback = onLoaded.calls[0].args[1];
+        var loadCallback = onLoaded.calls.first().args[1];
         expect(scriptRequest.cleanup).not.toHaveBeenCalled();
         loadCallback(false);
-        expect(scriptRequest.cleanup.calls.length).toEqual(1);
+        expect(scriptRequest.cleanup.calls.count()).toEqual(1);
       });
 
       it("should not call old callbacks after loading the script", function() {
-        expect(onLoaded.calls.length).toEqual(1);
+        expect(onLoaded.calls.count()).toEqual(1);
 
         var onLoaded2 = jasmine.createSpy();
         loader.load("resource", {}, onLoaded2);
-        var receiver = scriptRequest.send.calls[0].args[0];
+        var receiver = scriptRequest.send.calls.first().args[0];
         receiver.callback(null);
 
-        expect(onLoaded.calls.length).toEqual(1);
-        expect(onLoaded2.calls.length).toEqual(1);
+        expect(onLoaded.calls.count()).toEqual(1);
+        expect(onLoaded2.calls.count()).toEqual(1);
       });
     });
   });

package/spec/javascripts/unit/web/dom/jsonp_request_spec.js

@@ -9,7 +9,7 @@ describe("JSONPRequest", function() {
   var scriptRequest;
 
   beforeEach(function() {
-    spyOn(Runtime, "createScriptRequest").andCallFake(function() {
+    spyOn(Runtime, "createScriptRequest").and.callFake(function() {
       scriptRequest = Mocks.getScriptRequest();
       return scriptRequest;
     });
@@ -21,7 +21,7 @@ describe("JSONPRequest", function() {
     it("should send the script request to a correct URL", function() {
       var request = new JSONPRequest("http://example.com", {});
       request.send(receiver);
-      expect(Runtime.createScriptRequest.calls.length).toEqual(1);
+      expect(Runtime.createScriptRequest.calls.count()).toEqual(1);
       expect(Runtime.createScriptRequest).toHaveBeenCalledWith(
         "http://example.com/" + receiver.number + "?"
       );
@@ -32,7 +32,7 @@ describe("JSONPRequest", function() {
       var request = new JSONPRequest("http://example.org", {});
       request.send(receiver);
       expect(callback).not.toHaveBeenCalled();
-      scriptRequest.send.calls[0].args[0].callback("first", "second");
+      scriptRequest.send.calls.first().args[0].callback("first", "second");
       expect(callback).toHaveBeenCalledWith("first", "second");
     });
 
@@ -44,7 +44,7 @@ describe("JSONPRequest", function() {
       });
 
       request.send(receiver);
-      var url = Runtime.createScriptRequest.calls[0].args[0];
+      var url = Runtime.createScriptRequest.calls.first().args[0];
       var queryString = url.match(/http:\/\/example.org\/[0-9]+\?(.*)$/)[1];
       var queryStringPairs = queryString.split("&");
       expect(queryStringPairs.length).toEqual(3);
@@ -111,9 +111,9 @@ describe("JSONPRequest", function() {
     it("should be idempotent", function() {
       var request = new JSONPRequest("http://example.org", {});
       request.send(receiver);
-      expect(Runtime.createScriptRequest.calls.length).toEqual(1);
+      expect(Runtime.createScriptRequest.calls.count()).toEqual(1);
       request.send(receiver);
-      expect(Runtime.createScriptRequest.calls.length).toEqual(1);
+      expect(Runtime.createScriptRequest.calls.count()).toEqual(1);
     });
   });
 
@@ -121,7 +121,7 @@ describe("JSONPRequest", function() {
     it("should call cleanup on the script request", function() {
       var request = new JSONPRequest("http://example.com", {});
       request.send(receiver);
-      expect(Runtime.createScriptRequest.calls.length).toEqual(1);
+      expect(Runtime.createScriptRequest.calls.count()).toEqual(1);
       expect(scriptRequest.cleanup).not.toHaveBeenCalled();
       request.cleanup();
       expect(scriptRequest.cleanup).toHaveBeenCalled();