@cendarsoss/pusher-js 8.4.11

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

@@ -0,0 +1,83 @@
+var Mocks = require('mocks');
+var TimelineSender = require('core/timeline/timeline_sender').default;
+var Runtime = require('runtime').default;
+
+describe("TimelineSender", function() {
+  var timeline, onSend, sender;
+
+  beforeEach(function(){
+    timeline = Mocks.getTimeline();
+    timeline.isEmpty.and.returnValue(false);
+    timeline.send.and.callFake(function(sendXHR, callback) {
+      sendXHR({ events: [1, 2, 3]}, callback);
+    });
+
+    onSend = jasmine.createSpy("onSend");
+    sender = new TimelineSender(timeline, {
+      host: "example.com",
+      path: "/timeline"
+    });
+  });
+
+  describe("XHR", function(){
+    var xhrRequest;
+
+    beforeEach(function() {
+      spyOn(Runtime, "createXHR").and.callFake(function() {
+        xhrRequest = Mocks.getXHR();
+        return xhrRequest;
+      });
+    });
+
+    describe("on construction", function() {
+      it("should expose options", function() {
+        sender = new TimelineSender(timeline, {
+          host: "localhost",
+          port: 666
+        });
+
+        expect(sender.options).toEqual({
+          host: "localhost",
+          port: 666
+        });
+      });
+    });
+
+    describe("on send", function() {
+      it("should send a non-empty timeline", function() {
+        sender.send(false, onSend);
+
+        expect(Runtime.createXHR.calls.count()).toEqual(1);
+        var encodedParams = 'WzEsMiwzXQ%3D%3D';
+
+        expect(xhrRequest.open).toHaveBeenCalledWith(
+          "GET",
+          'http://example.com/timeline/2?events=WzEsMiwzXQ%3D%3D',
+          true);
+
+        expect(xhrRequest.send).toHaveBeenCalled();
+      });
+
+      it("should not send an empty timeline", function() {
+        timeline.isEmpty.and.returnValue(true);
+        sender.send(false, onSend);
+        expect(Runtime.createXHR).not.toHaveBeenCalled();
+      });
+
+      it("should use returned hostname for subsequent requests", function() {
+        sender.send(false);
+        xhrRequest.readyState = 4;
+        xhrRequest.status = 200;
+        xhrRequest.responseText = JSON.stringify({host: "returned.example.com"});
+        xhrRequest.onreadystatechange();
+
+        sender.send(false);
+        expect(xhrRequest.open).toHaveBeenCalledWith(
+          'GET',
+          'http://returned.example.com/timeline/2?events=WzEsMiwzXQ%3D%3D',
+          true
+        );
+      });
+    });
+  });
+});

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

@@ -0,0 +1,249 @@
+var Pusher = require('core/pusher').default;
+var Mocks = require('../../../helpers/mocks');
+var Runtime = require('runtime').default;
+var Factory = require('core/utils/factory').default;
+var DependencyLoader = require('dom/dependency_loader').default;
+
+describe("DependencyLoader", function() {
+  var doc;
+  var receivers;
+  var scriptRequest;
+  var onLoaded;
+  var loader;
+
+  beforeEach(function() {
+    doc = Mocks.getDocument();
+    doc.location.protocol = "http:";
+
+    spyOn(Runtime, "getDocument").and.returnValue(doc);
+    spyOn(Runtime, "createScriptRequest").and.callFake(function() {
+      scriptRequest = Mocks.getScriptRequest();
+      return scriptRequest;
+    });
+
+    onLoaded = jasmine.createSpy("onLoaded");
+
+    loader = new DependencyLoader({
+      cdn_http: "http://example.com",
+      cdn_https: "https://example.com",
+      version: "6.6.6",
+      suffix: "-test",
+      receivers: Pusher.ScriptReceivers
+    });
+  });
+
+  describe("#getRoot", function() {
+    it("should return correct URL when using HTTP", function() {
+      doc.location.protocol = "http:";
+      expect(loader.getRoot()).toEqual(
+        "http://example.com/6.6.6"
+      );
+    });
+
+    it("should return correct URL when using HTTP, but TLS is requested", function() {
+      doc.location.protocol = "http:";
+      expect(loader.getRoot({ useTLS: true })).toEqual(
+        "https://example.com/6.6.6"
+      );
+    });
+
+    it("should return correct URL when using HTTPS", function() {
+      doc.location.protocol = "https:";
+      expect(loader.getRoot()).toEqual(
+        "https://example.com/6.6.6"
+      );
+    });
+
+    it("should strip trailing slashes from the CDN url", function() {
+      var loader = new DependencyLoader({
+        cdn_http: "http://example.com/",
+        cdn_https: "https://example.com/",
+        version: "6.6.6",
+        suffix: "-test",
+        receivers: Pusher.ScriptReceivers
+      });
+      expect(loader.getRoot()).toEqual(
+        "http://example.com/6.6.6"
+      );
+    });
+  });
+
+  describe("#getPath", function() {
+    it("should return correct URL when using HTTP", function() {
+      doc.location.protocol = "http:";
+      expect(loader.getPath("something")).toEqual(
+        "http://example.com/6.6.6/something-test.js"
+      );
+    });
+
+    it("should return correct URL when using HTTP, but TLS is requested", function() {
+      doc.location.protocol = "http:";
+      expect(loader.getPath("something", { useTLS: true })).toEqual(
+        "https://example.com/6.6.6/something-test.js"
+      );
+    });
+
+    it("should return correct URL when using HTTPS", function() {
+      doc.location.protocol = "https:";
+      expect(loader.getPath("something_else")).toEqual(
+        "https://example.com/6.6.6/something_else-test.js"
+      );
+    });
+
+    it("should strip trailing slashes from the CDN url", function() {
+      var loader = new DependencyLoader({
+        cdn_http: "http://example.com/",
+        cdn_https: "https://example.com/",
+        version: "6.6.6",
+        suffix: "-test",
+        receivers: Pusher.ScriptReceivers
+      });
+      expect(loader.getPath("something_else")).toEqual(
+        "http://example.com/6.6.6/something_else-test.js"
+      );
+    });
+  });
+
+  describe("#load", 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.count()).toEqual(1);
+      expect(Runtime.createScriptRequest).toHaveBeenCalledWith(
+        "http://example.com/6.6.6/resource-test.js"
+      );
+    });
+
+    it("should send a TLS script request when served via https", function() {
+      doc.location.protocol = "https:";
+      loader.load("resource", {}, onLoaded);
+      expect(Runtime.createScriptRequest.calls.count()).toEqual(1);
+      expect(Runtime.createScriptRequest).toHaveBeenCalledWith(
+        "https://example.com/6.6.6/resource-test.js"
+      );
+    });
+
+    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.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.count()).toEqual(0);
+
+      loader.load("resource", {}, function() {});
+      loader.load("resource", {}, function() {});
+      loader.load("resource", {}, function() {});
+      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.count()).toEqual(2);
+      expect(Runtime.createScriptRequest).toHaveBeenCalledWith(
+        "http://example.com/6.6.6/resource2-test.js"
+      );
+    });
+
+    it("should register a receiver", function() {
+      loader.load("resource", {}, onLoaded);
+      var receiver = scriptRequest.send.calls.first().args[0];
+      expect(Pusher.ScriptReceivers[receiver.number]).toBe(
+        receiver.callback
+      );
+    });
+
+    it("should call back without an error if the resource loaded successfully", function() {
+      loader.load("resource", {}, onLoaded);
+      var receiver = scriptRequest.send.calls.first().args[0];
+
+      expect(onLoaded).not.toHaveBeenCalled();
+      receiver.callback(null);
+      expect(onLoaded).toHaveBeenCalledWith(null, jasmine.any(Function));
+    });
+
+    it("should call back with an error if the resource failed to load", function() {
+      loader.load("resource", {}, onLoaded);
+      var receiver = scriptRequest.send.calls.first().args[0];
+
+      expect(onLoaded).not.toHaveBeenCalled();
+      receiver.callback("too bad");
+      expect(onLoaded).toHaveBeenCalledWith("too bad", jasmine.any(Function));
+    });
+
+    it("should trigger all resource's callbacks", function() {
+      var onLoaded2 = jasmine.createSpy();
+      var onLoaded3 = jasmine.createSpy();
+      loader.load("resource", {}, onLoaded);
+      loader.load("resource", {}, onLoaded2);
+      var firstScriptRequest = scriptRequest;
+
+      loader.load("resource2", {}, onLoaded3);
+
+      expect(onLoaded.calls.count()).toEqual(0);
+      expect(onLoaded2.calls.count()).toEqual(0);
+      expect(onLoaded3.calls.count()).toEqual(0);
+
+      var firstReceiver = firstScriptRequest.send.calls.first().args[0];
+      firstReceiver.callback(null);
+
+      expect(onLoaded.calls.count()).toEqual(1);
+      expect(onLoaded2.calls.count()).toEqual(1);
+      expect(onLoaded3.calls.count()).toEqual(0);
+
+      var secondReceiver = scriptRequest.send.calls.first().args[0];
+      secondReceiver.callback(null);
+
+      expect(onLoaded.calls.count()).toEqual(1);
+      expect(onLoaded2.calls.count()).toEqual(1);
+      expect(onLoaded3.calls.count()).toEqual(1);
+    });
+
+    describe("after loading the resource", function() {
+      var receiver;
+
+      beforeEach(function() {
+        loader.load("resource", {}, onLoaded);
+        receiver = scriptRequest.send.calls.first().args[0];
+        receiver.callback(null);
+      });
+
+      it("should remove the receiver", function() {
+        expect(Pusher.ScriptReceivers[receiver.number]).toBe(
+          undefined
+        );
+      });
+
+      it("should not clean up the request when called back with true", function() {
+        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.first().args[1];
+        expect(scriptRequest.cleanup).not.toHaveBeenCalled();
+        loadCallback(false);
+        expect(scriptRequest.cleanup.calls.count()).toEqual(1);
+      });
+
+      it("should not call old callbacks after loading the script", function() {
+        expect(onLoaded.calls.count()).toEqual(1);
+
+        var onLoaded2 = jasmine.createSpy();
+        loader.load("resource", {}, onLoaded2);
+        var receiver = scriptRequest.send.calls.first().args[0];
+        receiver.callback(null);
+
+        expect(onLoaded.calls.count()).toEqual(1);
+        expect(onLoaded2.calls.count()).toEqual(1);
+      });
+    });
+  });
+});

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

@@ -0,0 +1,130 @@
+var JSONPRequest = require('dom/jsonp_request').default;
+var Runtime = require('runtime').default;
+var Pusher = require('core/pusher').default;
+var Mocks = require('../../../helpers/mocks');
+
+describe("JSONPRequest", function() {
+  var callback;
+  var receiver;
+  var scriptRequest;
+
+  beforeEach(function() {
+    spyOn(Runtime, "createScriptRequest").and.callFake(function() {
+      scriptRequest = Mocks.getScriptRequest();
+      return scriptRequest;
+    });
+    callback = jasmine.createSpy();
+    receiver = Pusher.ScriptReceivers.create(callback);
+  });
+
+  describe("#send", 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.count()).toEqual(1);
+      expect(Runtime.createScriptRequest).toHaveBeenCalledWith(
+        "http://example.com/" + receiver.number + "?"
+      );
+      expect(scriptRequest.send).toHaveBeenCalledWith(receiver);
+    });
+
+    it("should call back after the script request is completed", function() {
+      var request = new JSONPRequest("http://example.org", {});
+      request.send(receiver);
+      expect(callback).not.toHaveBeenCalled();
+      scriptRequest.send.calls.first().args[0].callback("first", "second");
+      expect(callback).toHaveBeenCalledWith("first", "second");
+    });
+
+    it("should concatenate multiple keys correctly", function() {
+      var request = new JSONPRequest("http://example.org", {
+        a: 1,
+        b: 2,
+        c: 3
+      });
+
+      request.send(receiver);
+      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);
+      expect(queryStringPairs).toContain("a=MQ%3D%3D");
+      expect(queryStringPairs).toContain("b=Mg%3D%3D");
+      expect(queryStringPairs).toContain("c=Mw%3D%3D");
+    });
+
+    it("should not include undefined values", function() {
+      var request = new JSONPRequest("http://example.org", {
+        test: undefined,
+      });
+
+      request.send(receiver);
+      expect(Runtime.createScriptRequest).toHaveBeenCalledWith(
+        "http://example.org/" + receiver.number + "?"
+      );
+    });
+
+    it("should encode string parameters correctly", function() {
+      var request = new JSONPRequest("http://example.org", {
+        test: "foo foo",
+      });
+
+      request.send(receiver);
+      expect(Runtime.createScriptRequest).toHaveBeenCalledWith(
+        "http://example.org/" + receiver.number + "?test=Zm9vIGZvbw%3D%3D"
+      );
+    });
+
+    it("should encode numers correctly", function() {
+      var request = new JSONPRequest("http://example.org", {
+        something: 1111
+      });
+
+      request.send(receiver);
+      expect(Runtime.createScriptRequest).toHaveBeenCalledWith(
+        "http://example.org/" + receiver.number + "?something=MTExMQ%3D%3D"
+      );
+    });
+
+    it("should encode arrays correctly", function() {
+      var request = new JSONPRequest("http://example.org", {
+        arrr: [1, 2, "string", 123.456]
+      });
+
+      request.send(receiver);
+      expect(Runtime.createScriptRequest).toHaveBeenCalledWith(
+        "http://example.org/" + receiver.number + "?arrr=WzEsMiwic3RyaW5nIiwxMjMuNDU2XQ%3D%3D"
+      );
+    });
+
+    it("should encode objects correctly", function() {
+      var request = new JSONPRequest("http://example.org", {
+        obj: { key: "val", num: 123, fl: 666.999 }
+      });
+
+      request.send(receiver);
+      expect(Runtime.createScriptRequest).toHaveBeenCalledWith(
+        "http://example.org/" + receiver.number + "?obj=eyJrZXkiOiJ2YWwiLCJudW0iOjEyMywiZmwiOjY2Ni45OTl9"
+      );
+    });
+
+    it("should be idempotent", function() {
+      var request = new JSONPRequest("http://example.org", {});
+      request.send(receiver);
+      expect(Runtime.createScriptRequest.calls.count()).toEqual(1);
+      request.send(receiver);
+      expect(Runtime.createScriptRequest.calls.count()).toEqual(1);
+    });
+  });
+
+  describe("#cleanup", function() {
+    it("should call cleanup on the script request", function() {
+      var request = new JSONPRequest("http://example.com", {});
+      request.send(receiver);
+      expect(Runtime.createScriptRequest.calls.count()).toEqual(1);
+      expect(scriptRequest.cleanup).not.toHaveBeenCalled();
+      request.cleanup();
+      expect(scriptRequest.cleanup).toHaveBeenCalled();
+    });
+  });
+});

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

@@ -0,0 +1,68 @@
+var ScriptReceiverFactory = require('dom/script_receiver_factory').ScriptReceiverFactory;
+
+describe("ScriptReceiverFactory", function() {
+  var receivers;
+  var callback1, callback2;
+  var receiver1, receiver2;
+
+  beforeEach(function() {
+    receivers = new ScriptReceiverFactory("test_prefix", "Recv");
+    callback1 = jasmine.createSpy();
+    callback2 = jasmine.createSpy();
+    receiver1 = receivers.create(callback1);
+    receiver2 = receivers.create(callback2);
+  });
+
+  describe("#create", function() {
+    it("should set sequential ids with the supplied prefix", function() {
+      expect(receiver1.id).toEqual("test_prefix1");
+      expect(receiver2.id).toEqual("test_prefix2");
+    });
+
+    it("should set correct names", function() {
+      expect(receiver1.name).toEqual("Recv[1]");
+      expect(receiver2.name).toEqual("Recv[2]");
+    });
+
+    it("should set correct callbacks", function() {
+      expect(callback1).not.toHaveBeenCalled();
+      expect(callback2).not.toHaveBeenCalled();
+
+      receiver1.callback();
+      expect(callback1).toHaveBeenCalled();
+      expect(callback2).not.toHaveBeenCalled();
+
+      receiver2.callback();
+      expect(callback1).toHaveBeenCalled();
+      expect(callback2).toHaveBeenCalled();
+    });
+
+    it("should bind correct callbacks to the factory", function() {
+      expect(callback1).not.toHaveBeenCalled();
+      expect(callback2).not.toHaveBeenCalled();
+
+      receivers[1]();
+      expect(callback1).toHaveBeenCalled();
+      expect(callback2).not.toHaveBeenCalled();
+
+      receivers[2]();
+      expect(callback1).toHaveBeenCalled();
+      expect(callback2).toHaveBeenCalled();
+    });
+  });
+
+  describe("#remove", function() {
+    it("should unbind correct callbacks from the factory", function() {
+      expect(receivers[1]).not.toEqual(undefined);
+      expect(receivers[2]).not.toEqual(undefined);
+
+      receivers.remove(receiver1);
+      expect(receivers[1]).toEqual(undefined);
+      expect(receivers[2]).not.toEqual(undefined);
+
+      receivers.remove(receiver2);
+      expect(receivers[1]).toEqual(undefined);
+      expect(receivers[2]).toEqual(undefined);
+    });
+  });
+});