pingerchips-js 1.0.0 → 2.0.0

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

@@ -1,153 +0,0 @@
-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

@@ -1,223 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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"
-      );
-    });
-  });
-});