@cendarsoss/pusher-js 8.4.11

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

@@ -0,0 +1,153 @@
+var Network = require('net_info').Network;
+var TimelineLevel = require('core/timeline/level').default;
+var Timeline = require("core/timeline/timeline").default;
+var util = require("core/util").default;
+
+describe("Timeline", function() {
+  var sendJSONP, onSend, timeline;
+
+  beforeEach(function() {
+    sendJSONP = jasmine.createSpy("sendJSONP");
+    onSend = jasmine.createSpy("onSend");
+    timeline = new Timeline("foo", 666, {
+      level: TimelineLevel.DEBUG
+    });
+  });
+
+  it("should expose the key, session id and options", function() {
+    var timeline = new Timeline("foobar", 666, {
+      level: TimelineLevel.INFO,
+      cluster: "test",
+      features: ["x", "y", "z"]
+    });
+    expect(timeline.key).toEqual("foobar");
+    expect(timeline.session).toEqual(666);
+    expect(timeline.options.features).toEqual(["x", "y", "z"]);
+    expect(timeline.options.cluster).toEqual("test");
+  });
+
+  it("should initially be empty", function() {
+    expect(timeline.isEmpty()).toBe(true);
+  });
+
+  it("should not be empty after pushing an event", function() {
+    timeline.log(TimelineLevel.INFO, {});
+    expect(timeline.isEmpty()).toBe(false);
+  });
+
+  it("should not log events with too low level", function() {
+    timeline = new Timeline("foo", 666, {
+      level: Timeline.ERROR
+    });
+    timeline.log(TimelineLevel.INFO, {});
+    expect(timeline.isEmpty()).toBe(true);
+  });
+
+  it("should generate different ids", function() {
+    expect(timeline.generateUniqueID()).not.toEqual(timeline.generateUniqueID());
+  });
+
+  describe("on send", function() {
+    beforeEach(function() {
+      spyOn(Network, "isOnline").and.returnValue(true);
+    });
+
+    it("should include key, session id, cluster, features, version and params", function() {
+      var timeline = new Timeline("foobar", 666, {
+        level: TimelineLevel.INFO,
+        cluster: "test",
+        features: ["x", "y", "z"],
+        version: "6.6.6",
+        params: {
+          x: 1,
+          y: "2"
+        }
+      });
+
+      expect(timeline.send(sendJSONP, onSend)).toBe(true);
+      expect(sendJSONP).toHaveBeenCalledWith(
+        { bundle: 1,
+          key: "foobar",
+          session: 666,
+          cluster: "test",
+          features: ["x", "y", "z"],
+          lib: "js",
+          version: "6.6.6",
+          x: 1,
+          y: "2",
+          timeline: []
+        },
+        jasmine.any(Function)
+      );
+    });
+
+    it("should include pushed events", function() {
+      spyOn(util, "now");
+
+      util.now.and.returnValue(1000);
+      timeline.log(2, {a: 1});
+      util.now.and.returnValue(2000);
+      timeline.error({ b: 2.2 });
+      util.now.and.returnValue(100000);
+      timeline.info({ foo: "bar" });
+      util.now.and.returnValue(100001);
+      timeline.debug({ debug: true });
+
+      expect(timeline.send(sendJSONP, onSend)).toBe(true);
+      expect(sendJSONP).toHaveBeenCalledWith(
+        {
+          bundle: 1,
+          key: 'foo',
+          session: 666,
+          lib: 'js',
+          version: undefined,
+          cluster: undefined,
+          features: undefined,
+          timeline: [
+            { timestamp: 1000, a: 1 },
+            { timestamp: 2000, b: 2.2 },
+            { timestamp: 100000, foo: "bar" },
+            { timestamp: 100001, debug: true }
+          ]
+        },
+        jasmine.any(Function)
+      );
+    });
+
+    it("should become empty again", function() {
+      timeline.log(TimelineLevel.INFO, {});
+      timeline.send(sendJSONP, onSend);
+      expect(timeline.isEmpty()).toBe(true);
+    });
+
+    it("should respect the size limit", function() {
+      spyOn(util, "now").and.returnValue(123);
+
+      var timeline = new Timeline("bar", 123, {
+        level: TimelineLevel.INFO,
+        limit: 3
+      });
+      for (var i = 1; i <= 4; i++) {
+        timeline.log(TimelineLevel.INFO, { i: i });
+      }
+
+      expect(timeline.send(sendJSONP, onSend)).toBe(true);
+      expect(sendJSONP).toHaveBeenCalledWith(
+        { bundle: 1,
+          key: "bar",
+          session: 123,
+          lib: "js",
+          version: undefined,
+          cluster: undefined,
+          features: undefined,
+          timeline: [
+            { timestamp: 123, i: 2},
+            { timestamp: 123, i: 3},
+            { timestamp: 123, i: 4}
+          ]
+        },
+        jasmine.any(Function)
+      );
+    });
+  });
+});

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

@@ -0,0 +1,223 @@
+var Mocks = require("mocks");
+var AssistantToTheTransportManager = require('core/transports/assistant_to_the_transport_manager').default;
+var Util = require('core/util').default;
+
+describe("AssistantToTheTransportManager", function() {
+  var transport, transportClass;
+  var manager;
+
+  beforeEach(function() {
+    jasmine.clock().uninstall();
+    jasmine.clock().install();
+    spyOn(Util, "now").and.returnValue(1);
+
+    transport = Mocks.getTransport(true);
+    transportManager = Mocks.getTransportManager();
+    transportClass = Mocks.getTransportClass(true, transport);
+
+    assistant = new AssistantToTheTransportManager(
+      transportManager,
+      transportClass,
+      { minPingDelay: 10000, maxPingDelay: 120000 }
+    );
+  });
+
+  afterEach(function() {
+    jasmine.clock().uninstall();
+  });
+
+  describe("#isSupported", function() {
+    it("should return true when transport is supported", function() {
+      var assistant = new AssistantToTheTransportManager(
+        transportManager,
+        Mocks.getTransportClass(true),
+        { minPingDelay: 10000, maxPingDelay: 50000 }
+      );
+      expect(assistant.isSupported()).toBe(true);
+    });
+
+    it("should return false when transport is not supported", function() {
+      var assistant = new AssistantToTheTransportManager(
+        transportManager,
+        Mocks.getTransportClass(false),
+        { minPingDelay: 10000, maxPingDelay: 50000 }
+      );
+      expect(assistant.isSupported()).toBe(false);
+    });
+
+    it("should return true if transport is alive", function() {
+      transportManager.isAlive.and.returnValue(true);
+      expect(assistant.isSupported()).toBe(true);
+    });
+
+    it("should return false if transport is not alive", function() {
+      transportManager.isAlive.and.returnValue(false);
+      expect(assistant.isSupported()).toBe(false);
+    });
+  });
+
+  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, activityTimeout: undefined }
+      );
+    });
+
+    it("should return the transport instance", function() {
+      var connection = assistant.createConnection("x", 1, "a", {});
+      expect(connection).toBe(transport);
+    });
+  });
+
+  describe("after an opened connection closed with a protocol error (code 1002)", function() {
+    var connection;
+
+    beforeEach(function() {
+      connection = assistant.createConnection("x", 1, "a", {});
+      Util.now.and.returnValue(1);
+      connection.emit("open");
+      Util.now.and.returnValue(100001);
+      connection.emit("closed", { wasClean: true, code: 1002 });
+    });
+
+    it("should report its death to the manager", function() {
+      expect(transportManager.reportDeath).toHaveBeenCalled();
+    });
+  });
+
+  describe("after an opened connection closed with a unsupported error (code 1003)", function() {
+    var connection;
+
+    beforeEach(function() {
+      connection = assistant.createConnection("x", 1, "a", {});
+      Util.now.and.returnValue(1);
+      connection.emit("open");
+      Util.now.and.returnValue(100001);
+      connection.emit("closed", { wasClean: true, code: 1003 });
+    });
+
+    it("should report its death to the manager", function() {
+      expect(transportManager.reportDeath).toHaveBeenCalled();
+    });
+  });
+
+  describe("after an opened connection died after less than 2*maxPingDelay", function() {
+    var connection;
+    var assistant;
+
+    beforeEach(function() {
+      assistant = new AssistantToTheTransportManager(
+        transportManager,
+        transportClass,
+        { minPingDelay: 10000, maxPingDelay: 100000 }
+      );
+      connection = assistant.createConnection("x", 1, "a", {});
+      Util.now.and.returnValue(1);
+      connection.emit("open");
+      Util.now.and.returnValue(190001);
+      connection.emit("closed", { wasClean: false });
+    });
+
+    it("should report its death once to the manager", function() {
+      expect(transportManager.reportDeath.calls.count()).toEqual(1);
+    });
+
+    it("should set the activity timeout on the next connection to lifetime/2 ms", function() {
+      var connection = assistant.createConnection("x", 1, "a", {});
+      expect(transportClass.createConnection).toHaveBeenCalledWith(
+        "x", 1, "a", { activityTimeout: 95000 }
+      );
+    });
+  });
+
+  describe("after an opened connection died after more than 2*maxPingDelay", function() {
+    var connection;
+    var assistant;
+
+    beforeEach(function() {
+      assistant = new AssistantToTheTransportManager(
+        transportManager,
+        transportClass,
+        { minPingDelay: 10000, maxPingDelay: 50000 }
+      );
+      connection = assistant.createConnection("x", 1, "a", {});
+      Util.now.and.returnValue(1);
+      connection.emit("open");
+      Util.now.and.returnValue(100002);
+      connection.emit("closed", { wasClean: false });
+    });
+
+    it("should not report its death to the manager", function() {
+      expect(transportManager.reportDeath).not.toHaveBeenCalled();
+    });
+
+    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',
+        { activityTimeout: undefined }
+      );
+    });
+  });
+
+  describe("after an opened connection died after less than 2*minPingDelay", function() {
+    var connection;
+    var assistant;
+
+    beforeEach(function() {
+      assistant = new AssistantToTheTransportManager(
+        transportManager,
+        transportClass,
+        { minPingDelay: 20000, maxPingDelay: 100000 }
+      );
+      connection = assistant.createConnection("x", 1, "a", {});
+      Util.now.and.returnValue(1);
+      connection.emit("open");
+      Util.now.and.returnValue(32001);
+      connection.emit("closed", { wasClean: false });
+    });
+
+    it("should report its death once to the manager", function() {
+      expect(transportManager.reportDeath.calls.count()).toEqual(1);
+    });
+
+    it("should set the activity timeout on the next connection to minPingDelay ms", function() {
+      var connection = assistant.createConnection("x", 1, "a", {});
+      expect(transportClass.createConnection).toHaveBeenCalledWith(
+        "x", 1, "a", { activityTimeout: 20000 }
+      );
+    });
+  });
+
+  describe("after an opened connection closed cleanly", function() {
+    var connection;
+
+    beforeEach(function() {
+      connection = assistant.createConnection("x", 1, "a", {});
+      Util.now.and.returnValue(1);
+      connection.emit("open");
+      Util.now.and.returnValue(100001);
+      connection.emit("closed", { wasClean: true });
+    });
+
+    it("should not report its death to the manager", function() {
+      expect(transportManager.reportDeath).not.toHaveBeenCalled();
+    });
+
+    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',
+        { activityTimeout: undefined }
+      );
+    });
+  });
+});

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

@@ -0,0 +1,85 @@
+var TestEnv = require('testenv');
+var Pusher = require('core/pusher').default;
+var NetInfo  = require('net_info').NetInfo;
+var Mocks = require('mocks');
+var Defaults = require('core/defaults').default;
+var version = Defaults.VERSION;
+var cdn_http = Defaults.cdn_http;
+var cdn_https = Defaults.cdn_https;
+var dependency_suffix = Defaults.dependency_suffix;
+var Runtime = require('runtime').default;
+
+describe("Host/Port Configuration", function() {
+  var transport;
+  var pusher;
+  var Transports;
+
+  beforeEach(function() {
+    spyOn(Runtime, 'getNetwork').and.callFake(function(){
+      var network = new NetInfo();
+      network.isOnline = jasmine.createSpy("isOnline")
+        .and.returnValue(true);
+      return network;
+    });
+    spyOn(Runtime, "getLocalStorage").and.returnValue({});
+    Transports = Runtime.Transports;
+  });
+
+  afterEach(function() {
+    pusher.disconnect();
+  });
+
+  describe("WebSockets", function() {
+    var _WebSocket;
+
+    beforeEach(function() {
+      spyOn(Runtime, 'createWebSocket').and.returnValue(Mocks.getTransport());
+
+      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").and.returnValue(false);
+        spyOn(Transports.xdr_polling, "isSupported").and.returnValue(false);
+      }
+    });
+
+    it("should connect to wss://ws-mt1.pusher.com:443 by default", function() {
+      pusher = new Pusher("foobar", {cluster: "mt1"});
+      pusher.connect();
+
+      expect(Runtime.createWebSocket).toHaveBeenCalledWith(
+        "wss://ws-mt1.pusher.com:443/app/foobar?protocol=7&client=js&version="+version+"&flash=false"
+      );
+    });
+
+    it("should connect to ws://ws-mt1.pusher.com:80 by default when forceTLS disabled", function() {
+      pusher = new Pusher("foobar", { cluster: "mt1", forceTLS: false });
+      pusher.connect();
+
+      expect(Runtime.createWebSocket).toHaveBeenCalledWith(
+        "ws://ws-mt1.pusher.com:80/app/foobar?protocol=7&client=js&version="+version+"&flash=false"
+      );
+    });
+
+    it("should connect using wsHost and wssPort when specified in options", function() {
+      pusher = new Pusher("foobar", { cluster: "mt1", wsHost: "example.com", wssPort: 1999 });
+      pusher.connect();
+
+      expect(Runtime.createWebSocket).toHaveBeenCalledWith(
+        "wss://example.com:1999/app/foobar?protocol=7&client=js&version="+version+"&flash=false"
+      );
+    });
+
+    it("should connect using wsHost and wsPort when specified in options and forceTLS disabled", function() {
+      pusher = new Pusher("foobar", { cluster: "mt1", wsHost: "example.org", wsPort: 4444, forceTLS: false });
+      pusher.connect();
+
+      expect(Runtime.createWebSocket).toHaveBeenCalledWith(
+        "ws://example.org:4444/app/foobar?protocol=7&client=js&version="+version+"&flash=false"
+      );
+    });
+  });
+});