pusher-js 7.0.2 → 7.0.6

package/spec/javascripts/unit/core/connection/handshake_spec.js

@@ -18,7 +18,7 @@ describe("Handshake", function() {
 
   describe("after a successful handshake", function() {
     beforeEach(function() {
-      Protocol.processHandshake.andReturn({
+      Protocol.processHandshake.and.returnValue({
         action: "connected",
         id: "9.9"
       });
@@ -29,9 +29,10 @@ describe("Handshake", function() {
       expect(callback).toHaveBeenCalledWith({
         action: "connected",
         transport: transport,
+        activityTimeout: undefined,
         connection: jasmine.any(Connection)
       });
-      expect(callback.calls[0].args[0].connection.id).toEqual("9.9");
+      expect(callback.calls.first().args[0].connection.id).toEqual("9.9");
     });
 
     it("should not call close on the transport", function() {
@@ -41,7 +42,7 @@ describe("Handshake", function() {
 
   describe("after a handshake with other action", function() {
     beforeEach(function() {
-      Protocol.processHandshake.andReturn({
+      Protocol.processHandshake.and.returnValue({
         action: "boom",
         error: "BOOM"
       });
@@ -63,7 +64,7 @@ describe("Handshake", function() {
 
   describe("after a handshake raising an exception", function() {
     beforeEach(function() {
-      Protocol.processHandshake.andThrow("Invalid handshake");
+      Protocol.processHandshake.and.throwError("Invalid handshake");
       transport.emit("message", { data: "dummy "});
     });
 
@@ -71,7 +72,7 @@ describe("Handshake", function() {
       expect(callback).toHaveBeenCalledWith({
         action: "error",
         transport: transport,
-        error: "Invalid handshake"
+        error: new Error("Invalid handshake")
       });
     });
 
@@ -85,15 +86,15 @@ describe("Handshake", function() {
       var finishSpy = spyOn(handshake, 'finish');
       var error = new Error("some exception");
 
-      finishSpy.andCallFake(function(action, params){
+      finishSpy.and.callFake(function(action, params){
         if (action === "connected") {
           throw error
         } else {
-          finishSpy.andCallThrough();
+          finishSpy.and.callThrough();
         }
       });
 
-      Protocol.processHandshake.andReturn({
+      Protocol.processHandshake.and.returnValue({
         action: "connected",
         id: "9.9"
       });
@@ -107,7 +108,7 @@ describe("Handshake", function() {
   describe("after receiving a 'closed' event from transport", function() {
     describe("with defined action", function() {
       beforeEach(function() {
-        spyOn(Protocol, "getCloseAction").andReturn("boo");
+        spyOn(Protocol, "getCloseAction").and.returnValue("boo");
         spyOn(Protocol, "getCloseError");
 
         transport.emit("closed", {
@@ -119,7 +120,8 @@ describe("Handshake", function() {
       it("should call back with correct action and error", function() {
         expect(callback).toHaveBeenCalledWith({
           action: "boo",
-          transport: transport
+          transport: transport,
+          error: undefined,
         });
       });
 
@@ -137,8 +139,8 @@ describe("Handshake", function() {
 
     describe("with null action", function() {
       beforeEach(function() {
-        spyOn(Protocol, "getCloseAction").andReturn(null);
-        spyOn(Protocol, "getCloseError").andReturn("???");
+        spyOn(Protocol, "getCloseAction").and.returnValue(null);
+        spyOn(Protocol, "getCloseError").and.returnValue("???");
 
         transport.emit("closed", {
           code: 4321,

package/spec/javascripts/unit/core/connection/protocol_spec.js

@@ -15,6 +15,7 @@ describe("Protocol", function() {
         data: {
           foo: "bar"
         },
+        channel: undefined,
       });
     });
 
@@ -29,6 +30,7 @@ describe("Protocol", function() {
       expect(Protocol.decodeMessage(message)).toEqual({
         event: "raw",
         data: "just a string",
+        channel: undefined,
       });
     });
 
@@ -46,6 +48,7 @@ describe("Protocol", function() {
           x: "y",
           z: 1
         },
+        channel: undefined
       });
     });
     it("should parse user_id message with user_id", function() {
@@ -54,13 +57,15 @@ describe("Protocol", function() {
           event: "raw",
           data: "just a string",
           user_id: "abc-def",
-        })
+        }),
+        channel: undefined,
       };
 
       expect(Protocol.decodeMessage(message)).toEqual({
-        event: "raw",
-        data: "just a string",
-        user_id: "abc-def"
+        event: 'raw',
+        data: 'just a string',
+        user_id: 'abc-def',
+        channel: undefined
       });
     });
 

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

@@ -8,7 +8,7 @@ describe("Default", function() {
     function buildTest(ws) {
       it("should be supported when ws=" + ws, function() {
         if (ws) {
-          spyOn(WSTransport, "isSupported").andReturn(true);
+          spyOn(WSTransport, "isSupported").and.returnValue(true);
         }
         var strategy = Runtime.getDefaultStrategy(
           Config.getConfig({}),

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

@@ -17,7 +17,7 @@ describe("EventsDispatcher", function() {
       dispatcher.emit("boop", "nope");
 
       expect(onEvent).toHaveBeenCalledWith("test");
-      expect(onEvent.calls.length).toEqual(1);
+      expect(onEvent.calls.count()).toEqual(1);
     });
 
     it("should add the same listener to a specific event several times", function() {
@@ -28,7 +28,7 @@ describe("EventsDispatcher", function() {
       dispatcher.emit("event", "test");
 
       expect(onEvent).toHaveBeenCalledWith("test");
-      expect(onEvent.calls.length).toEqual(2);
+      expect(onEvent.calls.count()).toEqual(2);
     });
 
     it("should add the listener with different contexts", function() {
@@ -40,7 +40,7 @@ describe("EventsDispatcher", function() {
       dispatcher.emit("event", "test");
 
       expect(onEvent).toHaveBeenCalledWith("test");
-      expect(onEvent.calls.length).toEqual(3);
+      expect(onEvent.calls.count()).toEqual(3);
     });
   });
 
@@ -54,7 +54,7 @@ describe("EventsDispatcher", function() {
 
       expect(onAll).toHaveBeenCalledWith("event", "test");
       expect(onAll).toHaveBeenCalledWith("boop", []);
-      expect(onAll.calls.length).toEqual(2);
+      expect(onAll.calls.count()).toEqual(2);
     });
   });
 
@@ -70,7 +70,7 @@ describe("EventsDispatcher", function() {
     });
 
     it("should remove the listener while emitting events (regression)", function() {
-      var onEvent1 = jasmine.createSpy("onEvent1").andCallFake(function() {
+      var onEvent1 = jasmine.createSpy("onEvent1").and.callFake(function() {
         dispatcher.unbind("event", onEvent1);
       });
       var onEvent2 = jasmine.createSpy("onEvent2");
@@ -79,12 +79,12 @@ describe("EventsDispatcher", function() {
       dispatcher.bind("event", onEvent2);
 
       dispatcher.emit("event");
-      expect(onEvent1.calls.length).toEqual(1);
-      expect(onEvent2.calls.length).toEqual(1);
+      expect(onEvent1.calls.count()).toEqual(1);
+      expect(onEvent2.calls.count()).toEqual(1);
 
       dispatcher.emit("event");
-      expect(onEvent1.calls.length).toEqual(1);
-      expect(onEvent2.calls.length).toEqual(2);
+      expect(onEvent1.calls.count()).toEqual(1);
+      expect(onEvent2.calls.count()).toEqual(2);
     });
 
     it("should not remove the last callback if unbinding a function that was not bound (regression)", function() {
@@ -95,7 +95,7 @@ describe("EventsDispatcher", function() {
       dispatcher.unbind("event", otherCallback);
 
       dispatcher.emit("event");
-      expect(onEvent.calls.length).toEqual(1);
+      expect(onEvent.calls.count()).toEqual(1);
     });
 
     it("should remove all listeners on omitted arguments", function() {
@@ -127,7 +127,7 @@ describe("EventsDispatcher", function() {
 
       expect(onEvent1).not.toHaveBeenCalled();
       expect(onEvent2).not.toHaveBeenCalled();
-      expect(onOther.calls.length).toEqual(1);
+      expect(onOther.calls.count()).toEqual(1);
     });
 
     it("should remove all listeners with given callback", function() {
@@ -143,7 +143,7 @@ describe("EventsDispatcher", function() {
       dispatcher.emit("event2");
 
       expect(onEvent).not.toHaveBeenCalled();
-      expect(onOther.calls.length).toEqual(1);
+      expect(onOther.calls.count()).toEqual(1);
     });
 
     it("should remove all event's listeners with given callback", function() {
@@ -156,7 +156,7 @@ describe("EventsDispatcher", function() {
       dispatcher.emit("event");
       expect(onEvent).not.toHaveBeenCalled();
       dispatcher.emit("event2");
-      expect(onEvent.calls.length).toEqual(1);
+      expect(onEvent.calls.count()).toEqual(1);
     });
 
     it("should remove all event's listeners with given context", function() {
@@ -174,7 +174,7 @@ describe("EventsDispatcher", function() {
 
       expect(onEvent1).not.toHaveBeenCalled();
       expect(onEvent2).not.toHaveBeenCalled();
-      expect(onEvent3.calls.length).toEqual(1);
+      expect(onEvent3.calls.count()).toEqual(1);
     });
 
     it("should remove all listeners with given context", function() {
@@ -194,7 +194,7 @@ describe("EventsDispatcher", function() {
 
       expect(onEvent1).not.toHaveBeenCalled();
       expect(onEvent2).not.toHaveBeenCalled();
-      expect(onEvent3.calls.length).toEqual(1);
+      expect(onEvent3.calls.count()).toEqual(1);
     });
 
     it("should remove all event's listeners with given callback and context", function() {
@@ -209,7 +209,7 @@ describe("EventsDispatcher", function() {
       expect(onEvent).not.toHaveBeenCalled();
 
       dispatcher.emit("event2");
-      expect(onEvent.calls.length).toEqual(1);
+      expect(onEvent.calls.count()).toEqual(1);
     });
 
     it("should remove all listeners with given callback and context", function() {
@@ -228,10 +228,10 @@ describe("EventsDispatcher", function() {
       expect(onEvent).not.toHaveBeenCalled();
 
       dispatcher.emit("event3");
-      expect(onEvent.calls.length).toEqual(1);
+      expect(onEvent.calls.count()).toEqual(1);
 
       dispatcher.emit("other");
-      expect(onOther.calls.length).toEqual(1);
+      expect(onOther.calls.count()).toEqual(1);
     });
   });
 
@@ -292,10 +292,10 @@ describe("EventsDispatcher", function() {
       var context = {};
       var boundContext, unboundContext;
 
-      var onEventBound = jasmine.createSpy("onEventBound").andCallFake(function(){
+      var onEventBound = jasmine.createSpy("onEventBound").and.callFake(function(){
         boundContext = this;
       });
-      var onEventUnbound = jasmine.createSpy("onEventUnbound").andCallFake(function(){
+      var onEventUnbound = jasmine.createSpy("onEventUnbound").and.callFake(function(){
         unboundContext = this;
       });
 

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

@@ -7,7 +7,7 @@ describe("HTTP.createPollingSocket", function() {
   var socket;
 
   beforeEach(function() {
-    spyOn(HTTPFactory, "createSocket").andCallFake(function(h, u) {
+    spyOn(HTTPFactory, "createSocket").and.callFake(function(h, u) {
       socket = Mocks.getHTTPSocket();
       hooks = h;
       url = u;
@@ -41,12 +41,12 @@ describe("HTTP.createPollingSocket", function() {
     it("#sendHeartbeat should send an '[]' frame", function() {
       hooks.sendHeartbeat(socket);
       expect(socket.sendRaw).toHaveBeenCalledWith("[]");
-      expect(socket.sendRaw.calls.length).toEqual(1);
+      expect(socket.sendRaw.calls.count()).toEqual(1);
     });
 
     it("#onFinished with status 200 should reconnect the socket", function() {
       hooks.onFinished(socket, 200);
-      expect(socket.reconnect.calls.length).toEqual(1);
+      expect(socket.reconnect.calls.count()).toEqual(1);
     });
 
     it("#onFinished with non-200 status should close the socket", function() {
@@ -54,7 +54,7 @@ describe("HTTP.createPollingSocket", function() {
       expect(socket.onClose).toHaveBeenCalledWith(
         1006, "Connection interrupted (500)", false
       );
-      expect(socket.onClose.calls.length).toEqual(1);
+      expect(socket.onClose.calls.count()).toEqual(1);
     });
   });
 });

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

@@ -12,7 +12,7 @@ describe("HTTPRequest", function() {
 
   beforeEach(function() {
     hooks = {
-      getRequest: jasmine.createSpy().andCallFake(function() {
+      getRequest: jasmine.createSpy().and.callFake(function() {
         lastXHR = Mocks.getXHR();
         return lastXHR;
       }),
@@ -28,7 +28,7 @@ describe("HTTPRequest", function() {
   describe("#start", function() {
     it("should create a request using the getRequest hook", function() {
       request.start("test");
-      expect(hooks.getRequest.calls.length).toEqual(1);
+      expect(hooks.getRequest.calls.count()).toEqual(1);
       expect(hooks.getRequest).toHaveBeenCalledWith(request);
     });
 
@@ -52,23 +52,23 @@ describe("HTTPRequest", function() {
     it("raised by XMLHttpRequest#open", function() {
       hooks.getRequest = function() {
         xhr = Mocks.getXHR();
-        xhr.open.andThrow("open exception");
+        xhr.open.and.throwError("open exception");
         return xhr;
       };
       expect(function() {
         request.start();
-      }).toThrow("open exception");
+      }).toThrow(new Error('open exception'));
     });
 
     it("should re-throw the exception raised by XMLHttpRequest#send", function() {
       hooks.getRequest = function() {
         xhr = Mocks.getXHR();
-        xhr.send.andThrow("send exception");
+        xhr.send.and.throwError("send exception");
         return xhr;
       };
       expect(function() {
         request.start();
-      }).toThrow("send exception");
+      }).toThrow(new Error('send exception'));
     });
   });
 
@@ -79,12 +79,12 @@ describe("HTTPRequest", function() {
 
     it("should abort the request using the abortRequest hook", function() {
       request.close();
-      expect(hooks.abortRequest.calls.length).toEqual(1);
+      expect(hooks.abortRequest.calls.count()).toEqual(1);
       expect(hooks.abortRequest).toHaveBeenCalledWith(lastXHR);
     });
 
     it("should unregister the unloader", function() {
-      var unloader = Runtime.addUnloadListener.calls[0].args[0];
+      var unloader = Runtime.addUnloadListener.calls.first().args[0];
       request.close();
       expect(Runtime.removeUnloadListener).toHaveBeenCalledWith(unloader);
     });
@@ -106,20 +106,23 @@ describe("HTTPRequest", function() {
 
     it("should emit two chunks received one after another", function() {
       request.onChunk(201, "c1\n");
-      expect(onChunk.calls.length).toEqual(1);
+      expect(onChunk.calls.count()).toEqual(1);
       expect(onChunk).toHaveBeenCalledWith({ status: 201, data: "c1" });
 
       request.onChunk(201, "c1\nc2\n");
-      expect(onChunk.calls.length).toEqual(2);
+      expect(onChunk.calls.count()).toEqual(2);
       expect(onChunk).toHaveBeenCalledWith({ status: 201, data: "c2" });
     });
 
     it("should emit all chunks send in one batch", function() {
       request.onChunk(200, "c1\nc2\nc3\n");
-      expect(onChunk.calls.length).toEqual(3);
-      expect(onChunk.calls[0].args[0]).toEqual({ status: 200, data: "c1" });
-      expect(onChunk.calls[1].args[0]).toEqual({ status: 200, data: "c2" });
-      expect(onChunk.calls[2].args[0]).toEqual({ status: 200, data: "c3" });
+      expect(onChunk.calls.count()).toEqual(3);
+      expect(onChunk.calls.first().args[0]).toEqual({ status: 200, data: "c1" });
+      expect(onChunk.calls.argsFor(1)[0]).toEqual({
+        status: 200,
+        data: 'c2'
+      });
+      expect(onChunk.calls.argsFor(2)[0]).toEqual({ status: 200, data: "c3" });
     });
 
     it("should not emit an unfinished chunk", function() {
@@ -156,7 +159,7 @@ describe("HTTPRequest", function() {
         200,
         new Array(256).join(kilobyteChunk + "\n") + kilobyteChunk + "x" + "\n"
       ); // 256KB + 1B
-      expect(onChunk.calls.length).toEqual(256);
+      expect(onChunk.calls.count()).toEqual(256);
     });
   });
 
@@ -171,12 +174,12 @@ describe("HTTPRequest", function() {
 
     beforeEach(function() {
       request.start("test payload");
-      unloader = Runtime.addUnloadListener.calls[0].args[0];
+      unloader = Runtime.addUnloadListener.calls.first().args[0];
     });
 
     it("should abort the request using the abortRequest hook", function() {
       unloader();
-      expect(hooks.abortRequest.calls.length).toEqual(1);
+      expect(hooks.abortRequest.calls.count()).toEqual(1);
       expect(hooks.abortRequest).toHaveBeenCalledWith(lastXHR);
     });
 

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

@@ -15,25 +15,25 @@ describe("HTTP.Socket", function() {
 
   beforeEach(function() {
     HTTPFactory = require('runtime').default.HTTPFactory;
-    jasmine.Clock.useMock();
+    jasmine.clock().install();
 
-    spyOn(HTTPFactory, "createXHR").andCallFake(function(method, url) {
+    spyOn(HTTPFactory, "createXHR").and.callFake(function(method, url) {
       lastXHR = Mocks.getHTTPRequest(method, url);
       return lastXHR;
     });
 
     if (TestEnv === "web") {
-      spyOn(HTTPFactory, "createXDR").andCallFake(function(method, url) {
+      spyOn(HTTPFactory, "createXDR").and.callFake(function(method, url) {
         lastXHR = Mocks.getHTTPRequest(method, url);
         return lastXHR;
       });
     }
 
-    spyOn(Runtime, "isXHRSupported").andReturn(true);
-    if (TestEnv === "web") spyOn(Runtime, "isXDRSupported").andReturn(false);
+    spyOn(Runtime, "isXHRSupported").and.returnValue(true);
+    if (TestEnv === "web") spyOn(Runtime, "isXDRSupported").and.returnValue(false);
 
     hooks = {
-      getReceiveURL: jasmine.createSpy().andCallFake(function(url, session) {
+      getReceiveURL: jasmine.createSpy().and.callFake(function(url, session) {
         return url.base + "/" + session + url.queryString;
       }),
       onHeartbeat: jasmine.createSpy(),
@@ -55,11 +55,12 @@ describe("HTTP.Socket", function() {
 
   afterEach(function() {
     socket.close();
+    jasmine.clock().uninstall();
   });
 
   it("should use XHR if it's supported", function() {
-    Runtime.isXHRSupported.andReturn(true);
-    if (TestEnv === "web" ) Runtime.isXDRSupported.andReturn(false);
+    Runtime.isXHRSupported.and.returnValue(true);
+    if (TestEnv === "web" ) Runtime.isXDRSupported.and.returnValue(false);
 
     var socket = new HTTPSocket(hooks, "http://example.com");
     expect(HTTPFactory.createXHR).toHaveBeenCalled();
@@ -68,8 +69,8 @@ describe("HTTP.Socket", function() {
 
   if (TestEnv === "web") {
     it("should use XDR if it's supported", function() {
-      Runtime.isXHRSupported.andReturn(false);
-      Runtime.isXDRSupported.andReturn(true);
+      Runtime.isXHRSupported.and.returnValue(false);
+      Runtime.isXDRSupported.and.returnValue(true);
 
       var socket = new HTTPSocket(hooks, "http://example.com");
       expect(HTTPFactory.createXDR).toHaveBeenCalled();
@@ -110,9 +111,9 @@ describe("HTTP.Socket", function() {
       // close the default socket
       socket.close();
 
-      HTTPFactory.createXHR.andCallFake(function() {
+      HTTPFactory.createXHR.and.callFake(function() {
         stream = Mocks.getHTTPRequest();
-        stream.start.andThrow("start exception");
+        stream.start.and.throwError("start exception");
         return stream;
       });
 
@@ -126,13 +127,15 @@ describe("HTTP.Socket", function() {
 
     it("should raise an error", function() {
       expect(onError).not.toHaveBeenCalled();
-      jasmine.Clock.tick(1);
-      expect(onError).toHaveBeenCalledWith("start exception");
+
+      jasmine.clock().tick(1);
+
+      expect(onError).toHaveBeenCalledWith(new Error('start exception'));
     });
 
     it("should close itself with code 1006", function() {
       expect(onClose).not.toHaveBeenCalled();
-      jasmine.Clock.tick(1);
+      jasmine.clock().tick(1);
       expect(onClose).toHaveBeenCalledWith({
         code: 1006,
         reason: "Could not start streaming",
@@ -142,12 +145,12 @@ describe("HTTP.Socket", function() {
 
     it("should unbind all listeners from the stream", function() {
       spyOn(stream, "unbind_all");
-      jasmine.Clock.tick(1);
+      jasmine.clock().tick(1);
       expect(stream.unbind_all).toHaveBeenCalled();
     });
 
     it("should close the stream", function() {
-      jasmine.Clock.tick(1);
+      jasmine.clock().tick(1);
       expect(stream.close).toHaveBeenCalled();
     });
   });
@@ -189,9 +192,9 @@ describe("HTTP.Socket", function() {
       });
 
       it("should not trigger any HTTP requests", function() {
-        expect(HTTPFactory.createXHR.calls.length).toEqual(1);
+        expect(HTTPFactory.createXHR.calls.count()).toEqual(1);
         socket.send("test");
-        expect(HTTPFactory.createXHR.calls.length).toEqual(1);
+        expect(HTTPFactory.createXHR.calls.count()).toEqual(1);
       });
     });
   });
@@ -199,9 +202,9 @@ describe("HTTP.Socket", function() {
   describe("when connecting", function() {
     describe("before the open frame", function() {
       it("should ignore heartbeat frames", function() {
-        var requestCount = HTTPFactory.createXHR.calls.length;
+        var requestCount = HTTPFactory.createXHR.calls.count();
         lastXHR.emit("chunk", { status: 200, data: "hhhhhhhhhhh" });
-        expect(HTTPFactory.createXHR.calls.length).toEqual(requestCount);
+        expect(HTTPFactory.createXHR.calls.count()).toEqual(requestCount);
       });
     });
 
@@ -221,10 +224,10 @@ describe("HTTP.Socket", function() {
 
     describe("#send", function() {
       it("should send an HTTP request to a correct URL", function() {
-        expect(HTTPFactory.createXHR.calls.length).toEqual(1);
+        expect(HTTPFactory.createXHR.calls.count()).toEqual(1);
         socket.send("test");
 
-        expect(HTTPFactory.createXHR.calls.length).toEqual(2);
+        expect(HTTPFactory.createXHR.calls.count()).toEqual(2);
         expect(lastXHR.method).toEqual("POST");
         expect(lastXHR.url).toMatch(
           new RegExp(
@@ -238,19 +241,19 @@ describe("HTTP.Socket", function() {
       it("should send a string payload", function() {
         var data = "test";
         socket.send(data);
-        expect(JSON.parse(lastXHR.start.calls[0].args[0])).toEqual([data]);
+        expect(JSON.parse(lastXHR.start.calls.first().args[0])).toEqual([data]);
       });
 
       it("should send an array payload", function() {
         var data = ["test", 1, { foo: "bar" }];
         socket.send(data);
-        expect(JSON.parse(lastXHR.start.calls[0].args[0])).toEqual([data]);
+        expect(JSON.parse(lastXHR.start.calls.first().args[0])).toEqual([data]);
       });
 
       it("should send an object payload", function() {
         var data = { num: 1, str: "data", arr: [1, 2, 3]};
         socket.send(data);
-        expect(JSON.parse(lastXHR.start.calls[0].args[0])).toEqual([data]);
+        expect(JSON.parse(lastXHR.start.calls.first().args[0])).toEqual([data]);
       });
 
       it("should return true if the request did not raise an exception", function() {
@@ -258,9 +261,9 @@ describe("HTTP.Socket", function() {
       });
 
       it("should return false if the request raised an exception", function() {
-        HTTPFactory.createXHR.andCallFake(function() {
+        HTTPFactory.createXHR.and.callFake(function() {
           var request = Mocks.getHTTPRequest();
-          request.start.andThrow("exception");
+          request.start.and.throwError("exception");
           return request;
         });
 
@@ -291,9 +294,9 @@ describe("HTTP.Socket", function() {
     describe("on a multi-message frame", function() {
       it("should emit all messages if status is 200", function() {
         lastXHR.emit("chunk", { status: 200, data: 'a[1,2,3]' });
-        expect(onMessage.calls[0].args[0]).toEqual({ data: 1 });
-        expect(onMessage.calls[1].args[0]).toEqual({ data: 2 });
-        expect(onMessage.calls[2].args[0]).toEqual({ data: 3 });
+        expect(onMessage.calls.first().args[0]).toEqual({ data: 1 });
+        expect(onMessage.calls.argsFor(1)[0]).toEqual({ data: 2 });
+        expect(onMessage.calls.argsFor(2)[0]).toEqual({ data: 3 });
       });
 
       it("should not emit any messages if status is not 200", function() {
@@ -351,7 +354,7 @@ describe("HTTP.Socket", function() {
       it("should send an HTTP request to the updated host", function() {
         socket.send("test");
         // opening the connection sends the first request
-        expect(HTTPFactory.createXHR.calls.length).toEqual(2);
+        expect(HTTPFactory.createXHR.calls.count()).toEqual(2);
         expect(lastXHR.method).toEqual("POST");
         expect(lastXHR.url).toMatch(
           new RegExp(

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

@@ -7,7 +7,7 @@ describe("HTTP.getStreamingSocket", function() {
   var socket;
 
   beforeEach(function() {
-    spyOn(HTTPFactory, "createSocket").andCallFake(function(h, u) {
+    spyOn(HTTPFactory, "createSocket").and.callFake(function(h, u) {
       socket = Mocks.getHTTPSocket();
       hooks = h;
       url = u;
@@ -36,13 +36,13 @@ describe("HTTP.getStreamingSocket", function() {
     it("#onHeartbeat should send an '[]' frame", function() {
       hooks.onHeartbeat(socket);
       expect(socket.sendRaw).toHaveBeenCalledWith("[]");
-      expect(socket.sendRaw.calls.length).toEqual(1);
+      expect(socket.sendRaw.calls.count()).toEqual(1);
     });
 
     it("#sendHeartbeat should send an '[]' frame", function() {
       hooks.sendHeartbeat(socket);
       expect(socket.sendRaw).toHaveBeenCalledWith("[]");
-      expect(socket.sendRaw.calls.length).toEqual(1);
+      expect(socket.sendRaw.calls.count()).toEqual(1);
     });
 
     it("#onFinished should close the socket", function() {
@@ -50,7 +50,7 @@ describe("HTTP.getStreamingSocket", function() {
       expect(socket.onClose).toHaveBeenCalledWith(
         1006, "Connection interrupted (200)", false
       );
-      expect(socket.onClose.calls.length).toEqual(1);
+      expect(socket.onClose.calls.count()).toEqual(1);
     });
   });
 });