pusher-js 7.0.2 → 7.0.6

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

@@ -13,7 +13,7 @@ describe("TransportStrategy", function() {
     transport = Mocks.getTransport(true);
     transportClass = Mocks.getTransportClass(true, transport);
 
-    spyOn(Factory, 'createHandshake').andCallFake(function(transport, callback) {
+    spyOn(Factory, 'createHandshake').and.callFake(function(transport, callback) {
       handshake = Mocks.getHandshake(transport, callback);
       return handshake;
     });
@@ -42,6 +42,14 @@ describe("TransportStrategy", function() {
   });
 
   describe("#connect", function() {
+    beforeEach(() => {
+      jasmine.clock().install();
+    });
+
+    afterEach(() => {
+      jasmine.clock().uninstall();
+    });
+
     it("should pass key and options to the transport", function() {
       var options = {
         key: "asdf",
@@ -129,32 +137,22 @@ describe("TransportStrategy", function() {
     });
 
     it("should call back with an error if transport's priority is too low", function() {
-      runs(function() {
-        strategy.connect(2, callback);
-      });
-      waitsFor(function() {
-        return callback.calls.length > 0;
-      }, "callback to be called");
-      runs(function() {
-        expect(callback).toHaveBeenCalledWith(
-          jasmine.any(Errors.TransportPriorityTooLow)
-        );
-      });
+      strategy.connect(2, callback);
+
+      jasmine.clock().tick(100);
+
+      expect(callback).toHaveBeenCalledWith(jasmine.any(Errors.TransportPriorityTooLow));
     });
 
     it("should call back with an error if transport is not supported", function() {
-      transportClass.isSupported.andReturn(false);
-      runs(function() {
-        strategy.connect(0, callback);
-      });
-      waitsFor(function() {
-        return callback.calls.length > 0;
-      }, "callback to be called", 100);
-      runs(function() {
-        expect(callback).toHaveBeenCalledWith(
-          jasmine.any(Errors.UnsupportedStrategy)
-        );
-      });
+      transportClass.isSupported.and.returnValue(false);
+
+      strategy.connect(0, callback);
+
+      jasmine.clock().tick(100);
+
+      expect(callback.calls.count()).toBeGreaterThan(0);
+      expect(callback).toHaveBeenCalledWith(jasmine.any(Errors.UnsupportedStrategy));
     });
   });
 

package/spec/javascripts/unit/core/timeline/timeline_spec.js

@@ -49,7 +49,7 @@ describe("Timeline", function() {
 
   describe("on send", function() {
     beforeEach(function() {
-      spyOn(Network, "isOnline").andReturn(true);
+      spyOn(Network, "isOnline").and.returnValue(true);
     });
 
     it("should include key, session id, cluster, features, version and params", function() {
@@ -84,21 +84,25 @@ describe("Timeline", function() {
     it("should include pushed events", function() {
       spyOn(util, "now");
 
-      util.now.andReturn(1000);
+      util.now.and.returnValue(1000);
       timeline.log(2, {a: 1});
-      util.now.andReturn(2000);
+      util.now.and.returnValue(2000);
       timeline.error({ b: 2.2 });
-      util.now.andReturn(100000);
+      util.now.and.returnValue(100000);
       timeline.info({ foo: "bar" });
-      util.now.andReturn(100001);
+      util.now.and.returnValue(100001);
       timeline.debug({ debug: true });
 
       expect(timeline.send(sendJSONP, onSend)).toBe(true);
       expect(sendJSONP).toHaveBeenCalledWith(
-        { bundle: 1,
-          key: "foo",
+        {
+          bundle: 1,
+          key: 'foo',
           session: 666,
-          lib: "js",
+          lib: 'js',
+          version: undefined,
+          cluster: undefined,
+          features: undefined,
           timeline: [
             { timestamp: 1000, a: 1 },
             { timestamp: 2000, b: 2.2 },
@@ -117,7 +121,7 @@ describe("Timeline", function() {
     });
 
     it("should respect the size limit", function() {
-      spyOn(util, "now").andReturn(123);
+      spyOn(util, "now").and.returnValue(123);
 
       var timeline = new Timeline("bar", 123, {
         level: TimelineLevel.INFO,
@@ -133,6 +137,9 @@ describe("Timeline", function() {
           key: "bar",
           session: 123,
           lib: "js",
+          version: undefined,
+          cluster: undefined,
+          features: undefined,
           timeline: [
             { timestamp: 123, i: 2},
             { timestamp: 123, i: 3},

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

@@ -7,8 +7,8 @@ describe("AssistantToTheTransportManager", function() {
   var manager;
 
   beforeEach(function() {
-    jasmine.Clock.useMock();
-    spyOn(Util, "now").andReturn(1);
+    jasmine.clock().install();
+    spyOn(Util, "now").and.returnValue(1);
 
     transport = Mocks.getTransport(true);
     transportManager = Mocks.getTransportManager();
@@ -21,6 +21,10 @@ describe("AssistantToTheTransportManager", function() {
     );
   });
 
+  afterEach(function() {
+    jasmine.clock().uninstall();
+  });
+
   describe("#isSupported", function() {
     it("should return true when transport is supported", function() {
       var assistant = new AssistantToTheTransportManager(
@@ -41,12 +45,12 @@ describe("AssistantToTheTransportManager", function() {
     });
 
     it("should return true if transport is alive", function() {
-      transportManager.isAlive.andReturn(true);
+      transportManager.isAlive.and.returnValue(true);
       expect(assistant.isSupported()).toBe(true);
     });
 
     it("should return false if transport is not alive", function() {
-      transportManager.isAlive.andReturn(false);
+      transportManager.isAlive.and.returnValue(false);
       expect(assistant.isSupported()).toBe(false);
     });
   });
@@ -54,8 +58,12 @@ describe("AssistantToTheTransportManager", function() {
   describe("#createConnection", function() {
     it("should pass parameters to the transport", function() {
       assistant.createConnection("foo", 66, "abc", { test: true });
-      expect(transportClass.createConnection)
-        .toHaveBeenCalledWith("foo", 66, "abc", { test: true });
+      expect(transportClass.createConnection).toHaveBeenCalledWith(
+        'foo',
+        66,
+        'abc',
+        { test: true, activityTimeout: undefined }
+      );
     });
 
     it("should return the transport instance", function() {
@@ -69,9 +77,9 @@ describe("AssistantToTheTransportManager", function() {
 
     beforeEach(function() {
       connection = assistant.createConnection("x", 1, "a", {});
-      Util.now.andReturn(1);
+      Util.now.and.returnValue(1);
       connection.emit("open");
-      Util.now.andReturn(100001);
+      Util.now.and.returnValue(100001);
       connection.emit("closed", { wasClean: true, code: 1002 });
     });
 
@@ -85,9 +93,9 @@ describe("AssistantToTheTransportManager", function() {
 
     beforeEach(function() {
       connection = assistant.createConnection("x", 1, "a", {});
-      Util.now.andReturn(1);
+      Util.now.and.returnValue(1);
       connection.emit("open");
-      Util.now.andReturn(100001);
+      Util.now.and.returnValue(100001);
       connection.emit("closed", { wasClean: true, code: 1003 });
     });
 
@@ -107,14 +115,14 @@ describe("AssistantToTheTransportManager", function() {
         { minPingDelay: 10000, maxPingDelay: 100000 }
       );
       connection = assistant.createConnection("x", 1, "a", {});
-      Util.now.andReturn(1);
+      Util.now.and.returnValue(1);
       connection.emit("open");
-      Util.now.andReturn(190001);
+      Util.now.and.returnValue(190001);
       connection.emit("closed", { wasClean: false });
     });
 
     it("should report its death once to the manager", function() {
-      expect(transportManager.reportDeath.calls.length).toEqual(1);
+      expect(transportManager.reportDeath.calls.count()).toEqual(1);
     });
 
     it("should set the activity timeout on the next connection to lifetime/2 ms", function() {
@@ -136,9 +144,9 @@ describe("AssistantToTheTransportManager", function() {
         { minPingDelay: 10000, maxPingDelay: 50000 }
       );
       connection = assistant.createConnection("x", 1, "a", {});
-      Util.now.andReturn(1);
+      Util.now.and.returnValue(1);
       connection.emit("open");
-      Util.now.andReturn(100002);
+      Util.now.and.returnValue(100002);
       connection.emit("closed", { wasClean: false });
     });
 
@@ -149,7 +157,10 @@ describe("AssistantToTheTransportManager", function() {
     it("should not set the activity timeout on the next connection", function() {
       var connection = assistant.createConnection("x", 1, "a", {});
       expect(transportClass.createConnection).toHaveBeenCalledWith(
-        "x", 1, "a", {}
+        'x',
+        1,
+        'a',
+        { activityTimeout: undefined }
       );
     });
   });
@@ -165,14 +176,14 @@ describe("AssistantToTheTransportManager", function() {
         { minPingDelay: 20000, maxPingDelay: 100000 }
       );
       connection = assistant.createConnection("x", 1, "a", {});
-      Util.now.andReturn(1);
+      Util.now.and.returnValue(1);
       connection.emit("open");
-      Util.now.andReturn(32001);
+      Util.now.and.returnValue(32001);
       connection.emit("closed", { wasClean: false });
     });
 
     it("should report its death once to the manager", function() {
-      expect(transportManager.reportDeath.calls.length).toEqual(1);
+      expect(transportManager.reportDeath.calls.count()).toEqual(1);
     });
 
     it("should set the activity timeout on the next connection to minPingDelay ms", function() {
@@ -188,9 +199,9 @@ describe("AssistantToTheTransportManager", function() {
 
     beforeEach(function() {
       connection = assistant.createConnection("x", 1, "a", {});
-      Util.now.andReturn(1);
+      Util.now.and.returnValue(1);
       connection.emit("open");
-      Util.now.andReturn(100001);
+      Util.now.and.returnValue(100001);
       connection.emit("closed", { wasClean: true });
     });
 
@@ -201,7 +212,10 @@ describe("AssistantToTheTransportManager", function() {
     it("should not set the activity timeout on the next connection", function() {
       var connection = assistant.createConnection("x", 1, "a", {});
       expect(transportClass.createConnection).toHaveBeenCalledWith(
-        "x", 1, "a", {}
+        'x',
+        1,
+        'a',
+        { activityTimeout: undefined }
       );
     });
   });

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

@@ -15,13 +15,13 @@ 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({});
     Transports = Runtime.Transports;
   });
 
@@ -33,16 +33,16 @@ describe("Host/Port Configuration", function() {
     var _WebSocket;
 
     beforeEach(function() {
-      spyOn(Runtime, 'createWebSocket').andReturn(Mocks.getTransport());
+      spyOn(Runtime, 'createWebSocket').and.returnValue(Mocks.getTransport());
 
-      spyOn(Transports.ws.hooks, "isInitialized").andReturn(true);
-      spyOn(Transports.ws, "isSupported").andReturn(true);
-      spyOn(Transports.xhr_streaming, "isSupported").andReturn(false);
-      spyOn(Transports.xhr_polling, "isSupported").andReturn(false);
+      spyOn(Transports.ws.hooks, "isInitialized").and.returnValue(true);
+      spyOn(Transports.ws, "isSupported").and.returnValue(true);
+      spyOn(Transports.xhr_streaming, "isSupported").and.returnValue(false);
+      spyOn(Transports.xhr_polling, "isSupported").and.returnValue(false);
 
       if (TestEnv == "web") {
-        spyOn(Transports.xdr_streaming, "isSupported").andReturn(false);
-        spyOn(Transports.xdr_polling, "isSupported").andReturn(false);
+        spyOn(Transports.xdr_streaming, "isSupported").and.returnValue(false);
+        spyOn(Transports.xdr_polling, "isSupported").and.returnValue(false);
       }
     });
 

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

@@ -1,9 +1,10 @@
-var TestEnv = require('testenv');
-var Mocks = require("mocks");
-var TransportConnection = require('core/transports/transport_connection').default;
-var Collections = require('core/utils/collections');
-var Timer = require('core/utils/timers').OneOffTimer;
-var Dependencies = require('dom/dependencies').Dependencies;
+const TestEnv = require('testenv');
+const Mocks = require('mocks');
+const TransportConnection = require('core/transports/transport_connection').default;
+const Collections = require('core/utils/collections');
+const OneOffTimer = require('core/utils/timers').OneOffTimer;
+const Dependencies = require('dom/dependencies').Dependencies;
+const waitsFor = require('../../../helpers/waitsFor');
 
 describe("TransportConnection", function() {
   function getTransport(hooks, key, options) {
@@ -36,7 +37,7 @@ describe("TransportConnection", function() {
     }
 
     timeline = Mocks.getTimeline();
-    timeline.generateUniqueID.andReturn(667);
+    timeline.generateUniqueID.and.returnValue(667);
 
     urls = {
       getInitial: function(key, params) {
@@ -47,8 +48,8 @@ describe("TransportConnection", function() {
     hooks = {
       urls: urls,
       supportsPing: false,
-      isInitialized: jasmine.createSpy().andReturn(true),
-      getSocket: jasmine.createSpy().andReturn(socket)
+      isInitialized: jasmine.createSpy().and.returnValue(true),
+      getSocket: jasmine.createSpy().and.returnValue(socket)
     };
 
     transport = getTransport(hooks, "foo", {
@@ -110,7 +111,7 @@ describe("TransportConnection", function() {
       beforeEach(function() {
         hooks = {
           supportsPing: false,
-          isInitialized: jasmine.createSpy().andReturn(true)
+          isInitialized: jasmine.createSpy().and.returnValue(true)
         };
         transport = getTransport(hooks, "foo", {
           timeline: timeline
@@ -134,8 +135,8 @@ describe("TransportConnection", function() {
       beforeEach(function() {
         hooks = {
           file: "test",
-          isInitialized: jasmine.createSpy().andReturn(false),
-          getSocket: jasmine.createSpy().andReturn(socket)
+          isInitialized: jasmine.createSpy().and.returnValue(false),
+          getSocket: jasmine.createSpy().and.returnValue(socket)
         };
         transport = getTransport(hooks, "foo", {
           timeline: timeline
@@ -154,7 +155,7 @@ describe("TransportConnection", function() {
 
         it("should load the resource file (useTLS=false)", function() {
           transport.initialize();
-          expect(Dependencies.load.calls.length).toEqual(1);
+          expect(Dependencies.load.calls.count()).toEqual(1);
           expect(Dependencies.load).toHaveBeenCalledWith(
             "test", { useTLS: false }, jasmine.any(Function)
           );
@@ -167,7 +168,7 @@ describe("TransportConnection", function() {
           });
 
           transport.initialize();
-          expect(Dependencies.load.calls.length).toEqual(1);
+          expect(Dependencies.load.calls.count()).toEqual(1);
           expect(Dependencies.load).toHaveBeenCalledWith(
             "test", { useTLS: true }, jasmine.any(Function)
           );
@@ -184,9 +185,9 @@ describe("TransportConnection", function() {
 
             transport.initialize();
             // after loading the resource, isInitialized will return true
-            hooks.isInitialized.andReturn(true);
+            hooks.isInitialized.and.returnValue(true);
             // fire the callback for the resource file load
-            Dependencies.load.calls[0].args[2](null, loadCallback);
+            Dependencies.load.calls.first().args[2](null, loadCallback);
           });
 
           it("should transition to 'initialized'", function() {
@@ -210,9 +211,9 @@ describe("TransportConnection", function() {
 
             transport.initialize();
             // after loading the resource, isInitialized will return true
-            hooks.isInitialized.andReturn(false);
+            hooks.isInitialized.and.returnValue(false);
             // fire the callback for the resource file load
-            Dependencies.load.calls[0].args[2](null, loadCallback);
+            Dependencies.load.calls.first().args[2](null, loadCallback);
           });
 
           it("should transition to 'closed'", function() {
@@ -271,7 +272,7 @@ describe("TransportConnection", function() {
       transport.initialize();
       transport.connect();
       expect(transport.state).toEqual("connecting");
-      expect(onConnecting.calls.length).toEqual(1);
+      expect(onConnecting.calls.count()).toEqual(1);
     });
 
     it("should transition to 'open' after connection is established", function() {
@@ -283,55 +284,53 @@ describe("TransportConnection", function() {
       socket.onopen();
 
       expect(transport.state).toEqual("open");
-      expect(onOpen.calls.length).toEqual(1);
+      expect(onOpen.calls.count()).toEqual(1);
     });
 
-    it("should emit the error raised by getSocket", function() {
-      hooks.getSocket.andThrow("test exception");
+    it("should emit the error raised by getSocket", async function() {
+      hooks.getSocket.and.throwError("test exception");
 
       var onError = jasmine.createSpy("onError");
       transport.bind("error", onError);
 
-      runs(function() {
-        transport.initialize();
-        transport.connect();
-      });
-      waitsFor(function () {
-        return onError.calls.length > 0;
+      transport.initialize();
+      transport.connect();
+
+      await waitsFor(function() {
+        return onError.calls.count();
       }, "error to be emitted", 50);
-      runs(function() {
-        expect(onError.calls.length).toEqual(1);
-        expect(onError).toHaveBeenCalledWith({
-          type: "WebSocketError",
-          error: "test exception"
-        });
+
+      expect(onError.calls.count()).toBeGreaterThan(0);
+      expect(onError.calls.count()).toEqual(1);
+      expect(onError).toHaveBeenCalledWith({
+        type: "WebSocketError",
+        error: new Error ("test exception")
       });
     });
 
-    it("should transition to 'closed' when getSocket raises an error", function() {
-      hooks.getSocket.andThrow("test exception");
+    it("should transition to 'closed' when getSocket raises an error", async function() {
+      hooks.getSocket.and.throwError("test exception");
 
       var onClosed = jasmine.createSpy("onClosed");
       transport.bind("closed", onClosed);
 
-      runs(function() {
-        transport.initialize();
-        transport.connect();
-      });
-      waitsFor(function () {
-        return onClosed.calls.length > 0;
+      transport.initialize();
+      transport.connect();
+
+      await waitsFor(function () {
+        return onClosed.calls.count();
       }, "transitioning to 'closed'", 50);
-      runs(function() {
-        expect(onClosed.calls.length).toEqual(1);
-        expect(transport.state).toEqual("closed");
-      });
+
+      expect(onClosed.calls.count()).toBeGreaterThan(0);
+      expect(onClosed.calls.count()).toEqual(1);
+      expect(transport.state).toEqual("closed");
     });
 
     it("should be idempotent", function() {
       transport.initialize();
 
       transport.connect();
-      expect(hooks.getSocket.calls.length).toEqual(1);
+      expect(hooks.getSocket.calls.count()).toEqual(1);
       expect(transport.state).toEqual("connecting");
 
       var onConnecting = jasmine.createSpy("onConnecting");
@@ -339,7 +338,7 @@ describe("TransportConnection", function() {
 
       transport.connect();
       expect(transport.state).toEqual("connecting");
-      expect(hooks.getSocket.calls.length).toEqual(1);
+      expect(hooks.getSocket.calls.count()).toEqual(1);
       expect(onConnecting).not.toHaveBeenCalled();
     });
   });
@@ -351,35 +350,29 @@ describe("TransportConnection", function() {
       socket.onopen();
     });
 
-    it("should defer sending data to the socket", function() {
-      var sendCalled = false;
-      socket.send = jasmine.createSpy("send").andCallFake(function() {
-        sendCalled = true;
-      });
+    it("should defer sending data to the socket", async function() {
+      socket.send.calls.reset();
 
-      runs(function() {
-        expect(transport.send("foobar")).toBe(true);
-        expect(socket.send).not.toHaveBeenCalled();
-      });
-      waitsFor(function () {
-        return sendCalled;
+      expect(socket.send).not.toHaveBeenCalled();
+
+      let sendCall = transport.send('foobar');
+
+      await waitsFor(function () {
+        return socket.send.calls.count();
       }, "socket.send to be called", 50);
-      runs(function() {
-        expect(socket.send).toHaveBeenCalledWith("foobar");
-      });
-    });
 
-    it("should not crash when socket is closed before next tick (will log to console only)", function() {
-      var timer;
-      runs(function() {
-        transport.send("foobar");
+      expect(sendCall).toBe(true);
+      expect(socket.send.calls.count()).toEqual(1);
+      expect(socket.send).toHaveBeenCalledWith("foobar");
+    });
 
-        transport.close();
-        socket.onclose({ wasClean: true });
+    it("should not crash when socket is closed before next tick (will log to console only)", async function() {
+      transport.send("foobar");
+      transport.close();
+      socket.onclose({ wasClean: true });
+      var timer = new OneOffTimer(100, function() {});
 
-        timer = new Timer(100, function() {});
-      });
-      waitsFor(function () {
+      await waitsFor(function () {
         return !timer.isRunning();
       }, "timer to run", 500);
     });
@@ -393,8 +386,8 @@ describe("TransportConnection", function() {
       var hooks = {
         urls: urls,
         supportsPing: true,
-        isInitialized: jasmine.createSpy().andReturn(true),
-        getSocket: jasmine.createSpy().andReturn(socket)
+        isInitialized: jasmine.createSpy().and.returnValue(true),
+        getSocket: jasmine.createSpy().and.returnValue(socket)
       };
       var transport = getTransport(hooks, "foo", {
         timeline: timeline
@@ -414,8 +407,8 @@ describe("TransportConnection", function() {
       var hooks = {
         urls: urls,
         supportsPing: false,
-        isInitialized: jasmine.createSpy().andReturn(true),
-        getSocket: jasmine.createSpy().andReturn(socket)
+        isInitialized: jasmine.createSpy().and.returnValue(true),
+        getSocket: jasmine.createSpy().and.returnValue(socket)
       };
       var transport = getTransport(hooks, "foo", {
         timeline: timeline
@@ -443,7 +436,7 @@ describe("TransportConnection", function() {
       expect(onClosed).not.toHaveBeenCalled();
 
       socket.onclose({ wasClean: true });
-      expect(onClosed).toHaveBeenCalledWith({ wasClean: true });
+      expect(onClosed).toHaveBeenCalledWith({ wasClean: true, code: undefined, reason: undefined });
     });
 
     it("should not fail if not open", function() {
@@ -477,8 +470,8 @@ describe("TransportConnection", function() {
       hooks = {
         urls: urls,
         supportsPing: true,
-        isInitialized: jasmine.createSpy().andReturn(true),
-        getSocket: jasmine.createSpy().andReturn(socket)
+        isInitialized: jasmine.createSpy().and.returnValue(true),
+        getSocket: jasmine.createSpy().and.returnValue(socket)
       };
       transport = getTransport(hooks, "foo", {
         timeline: timeline
@@ -517,7 +510,7 @@ describe("TransportConnection", function() {
           test: "We're doomed"
         }
       });
-      expect(onError.calls.length).toEqual(1);
+      expect(onError.calls.count()).toEqual(1);
     });
 
     it("should emit a closed event with correct params", function() {
@@ -536,7 +529,7 @@ describe("TransportConnection", function() {
         reason: "testing",
         wasClean: true
       });
-      expect(onClosed.calls.length).toEqual(1);
+      expect(onClosed.calls.count()).toEqual(1);
       expect(transport.state).toEqual("closed");
     });
 
@@ -547,7 +540,7 @@ describe("TransportConnection", function() {
       socket.onclose();
 
       expect(onClosed).toHaveBeenCalled();
-      expect(onClosed.calls.length).toEqual(1);
+      expect(onClosed.calls.count()).toEqual(1);
     });
 
     it("should log an error as a string to timeline", function() {
@@ -563,22 +556,24 @@ describe("TransportConnection", function() {
     it("should log the new state to timeline", function() {
       transport.initialize();
 
-      expect(timeline.info.calls.length).toEqual(2);
+      expect(timeline.info.calls.count()).toEqual(2);
       expect(timeline.info).toHaveBeenCalledWith({
         cid: 667,
         transport: "test"
       });
       expect(timeline.info).toHaveBeenCalledWith({
         cid: 667,
-        state: "initialized"
+        state: "initialized",
+        params: undefined,
       });
 
       transport.connect();
 
-      expect(timeline.info.calls.length).toEqual(3);
+      expect(timeline.info.calls.count()).toEqual(3);
       expect(timeline.info).toHaveBeenCalledWith({
         cid: 667,
-        state: "connecting"
+        state: "connecting",
+        params: undefined,
       });
     });
   });