@cendarsoss/pusher-js 8.4.11

package/spec/javascripts/unit/web/http/http_xdomain_request_spec.js

@@ -0,0 +1,222 @@
+var Mocks = require('mocks');
+var Errors = require('core/errors');
+var Factory = require('core/utils/factory').default;
+
+describe("HTTP.getXDR", function() {
+  var _XDomainRequest = window.XDomainRequest;
+
+  var hooks, method, url;
+  var request;
+  var HTTPFactory;
+
+  beforeEach(function() {
+    HTTPFactory = require('runtime').default.HTTPFactory;
+
+
+    window.XDomainRequest = jasmine.createSpy().and.callFake(
+      Mocks.getXHR
+    );;
+
+    spyOn(HTTPFactory, "createRequest").and.callFake(function(h, m, u) {
+      hooks = h;
+      method = m;
+      url = u;
+      return Mocks.getHTTPRequest(m, u);
+    });
+
+    request = HTTPFactory.createXDR("HEAD", "http://example.net");
+  });
+
+  afterEach(function() {
+    window.XDomainRequest = _XDomainRequest;
+  });
+
+  it("should pass the correct method to the request", function() {
+    expect(request.method).toEqual("HEAD");
+  });
+
+  it("should pass the correct URL to the request", function() {
+    expect(request.url).toEqual("http://example.net");
+  });
+
+  describe("hooks", function() {
+    var xdr;
+    var socket;
+
+    beforeEach(function() {
+      socket = Mocks.getHTTPSocket();
+      xdr = hooks.getRequest(socket);
+    });
+
+    describe("request returned from #getRequest", function() {
+      describe("on XDR timeout", function() {
+        it("should close the socket", function() {
+          xdr.ontimeout();
+          expect(socket.close.calls.count()).toEqual(1);
+        });
+
+        it("should emit an RequestTimedOut error before closing the socket", function() {
+          var onError = jasmine.createSpy();
+          socket.bind("error", onError);
+
+          socket.close.and.callFake(function() {
+            expect(onError.calls.count()).toEqual(1);
+            expect(onError).toHaveBeenCalledWith(
+              jasmine.any(Errors.RequestTimedOut)
+            );
+          });
+
+          xdr.ontimeout();
+        });
+      });
+
+      describe("on XDR error", function() {
+        it("should close the socket", function() {
+          xdr.onerror("test error");
+          expect(socket.close.calls.count()).toEqual(1);
+        });
+
+        it("should emit the error before closing the socket", function() {
+          var onError = jasmine.createSpy();
+          socket.bind("error", onError);
+
+          socket.close.and.callFake(function() {
+            expect(onError.calls.count()).toEqual(1);
+            expect(onError).toHaveBeenCalledWith("test error");
+          });
+
+          xdr.onerror("test error");
+        });
+      });
+
+      describe("on XDR progress", function() {
+        it("should not call socket.onChunk if there is no responseText", function() {
+          xdr.responseText = undefined;
+
+          xdr.onprogress();
+          expect(socket.onChunk).not.toHaveBeenCalled();
+        });
+
+        it("should not call socket.onChunk if responseText is an empty string", function() {
+          xdr.responseText = "";
+
+          xdr.onprogress();
+          expect(socket.onChunk).not.toHaveBeenCalled();
+        });
+
+        it("should call socket.onChunk if responseText is not empty", function() {
+          xdr.responseText = "asdf";
+
+          xdr.onprogress();
+          expect(socket.onChunk.calls.count()).toEqual(1);
+          expect(socket.onChunk).toHaveBeenCalledWith(200, "asdf");
+        });
+
+        it("should always call socket.onChunk with the whole responseText", function() {
+          xdr.responseText = "asdf";
+
+          xdr.onprogress();
+          expect(socket.onChunk.calls.count()).toEqual(1);
+          expect(socket.onChunk).toHaveBeenCalledWith(200, "asdf");
+
+          xdr.responseText = "asdfghjkl";
+          xdr.onprogress();
+          expect(socket.onChunk.calls.count()).toEqual(2);
+          expect(socket.onChunk).toHaveBeenCalledWith(200, "asdfghjkl");
+        });
+      });
+
+      describe("on XDR load", function() {
+        it("should close the socket", function() {
+          xdr.responseText = "";
+
+          xdr.onload();
+          expect(socket.close.calls.count()).toEqual(1);
+        });
+
+        it("should not call socket.onChunk if there is no responseText", function() {
+          xdr.responseText = undefined;
+
+          xdr.onload();
+          expect(socket.onChunk).not.toHaveBeenCalled();
+        });
+
+        it("should not call socket.onChunk if responseText is an empty string", function() {
+          xdr.responseText = "";
+
+          xdr.onload();
+          expect(socket.onChunk).not.toHaveBeenCalled();
+        });
+
+        it("should call socket.onChunk before closing if responseText is not empty", function() {
+          xdr.responseText = "12356890";
+
+          socket.close.and.callFake(function() {
+            expect(socket.onChunk.calls.count()).toEqual(1);
+            expect(socket.onChunk).toHaveBeenCalledWith(200, "12356890");
+          });
+
+          xdr.onload();
+        });
+
+        it("should emit finished with status code 200 before closing", function() {
+          xdr.responseText = "";
+
+          var onFinished = jasmine.createSpy();
+          socket.bind("finished", onFinished);
+
+          socket.close.and.callFake(function() {
+            expect(onFinished.calls.count()).toEqual(1);
+            expect(onFinished).toHaveBeenCalledWith(200);
+          });
+
+          xdr.onload();
+        });
+      });
+    });
+
+    describe("#abortRequest", function() {
+      it("should abort the passed request", function() {
+        expect(xdr.abort.calls.count()).toEqual(0);
+        hooks.abortRequest(xdr);
+        expect(xdr.abort.calls.count()).toEqual(1);
+      });
+
+      it("should set the ontimeout listener to null before calling abort", function() {
+        xdr.ontimeout = function() {};
+        xdr.abort.and.callFake(function() {
+          expect(xdr.ontimeout).toBe(null);
+        });
+
+        hooks.abortRequest(xdr);
+      });
+
+      it("should set the onerror listener to null before calling abort", function() {
+        xdr.onerror = function() {};
+        xdr.abort.and.callFake(function() {
+          expect(xdr.onerror).toBe(null);
+        });
+
+        hooks.abortRequest(xdr);
+      });
+
+      it("should set the onprogress listener to null before calling abort", function() {
+        xdr.onprogress = function() {};
+        xdr.abort.and.callFake(function() {
+          expect(xdr.onprogress).toBe(null);
+        });
+
+        hooks.abortRequest(xdr);
+      });
+
+      it("should set the onload listener to null before calling abort", function() {
+        xdr.onload = function() {};
+        xdr.abort.and.callFake(function() {
+          expect(xdr.onload).toBe(null);
+        });
+
+        hooks.abortRequest(xdr);
+      });
+    });
+  });
+});

package/spec/javascripts/unit/web/pusher_authorizer_spec.js

@@ -0,0 +1,64 @@
+var ChannelAuthorizer = require('core/auth/channel_authorizer').default;
+var Logger = require('core/logger');
+var Mocks = require('mocks');
+var Util = require('core/util').default;
+var Factory = require('core/utils/factory').default;
+var Logger = require('core/logger').default;
+var Runtime = require('runtime').default;
+
+describe('JSONP Authorizer', function() {
+  it('should raise a warning if headers are passed', function() {
+    var headers = { foo: 'bar', n: 42 };
+    var channelAuthorizer = ChannelAuthorizer({
+      transport: 'jsonp',
+      headers: headers
+    })
+
+    var document = Mocks.getDocument();
+    var script = Mocks.getDocumentElement();
+    var documentElement = Mocks.getDocumentElement();
+
+    document.createElement.and.returnValue(script);
+    document.getElementsByTagName.and.returnValue([]);
+    document.documentElement = documentElement;
+    spyOn(Runtime, 'getDocument').and.returnValue(document);
+
+    spyOn(Logger, 'warn');
+    channelAuthorizer({
+      socketId: '1.23',
+      channelName: 'chan',
+    }, function() {})
+
+    expect(Logger.warn).toHaveBeenCalledWith(
+      'To send headers with the channel-authorization request, you must use AJAX, rather than JSONP.'
+    );
+  });
+
+  it('should raise a warning if headersProvider is passed', function() {
+    var headers = { foo: 'bar', n: 42 };
+    var channelAuthorizer = ChannelAuthorizer({
+      transport: 'jsonp',
+      headersProvider:  () => headers
+    })
+
+    var document = Mocks.getDocument();
+    var script = Mocks.getDocumentElement();
+    var documentElement = Mocks.getDocumentElement();
+
+    document.createElement.and.returnValue(script);
+    document.getElementsByTagName.and.returnValue([]);
+    document.documentElement = documentElement;
+    spyOn(Runtime, 'getDocument').and.returnValue(document);
+
+    spyOn(Logger, 'warn');
+    channelAuthorizer({
+      socketId: '1.23',
+      channelName: 'chan',
+    }, function() {})
+
+    expect(Logger.warn).toHaveBeenCalledWith(
+      'To send headers with the channel-authorization request, you must use AJAX, rather than JSONP.'
+    );
+  });
+
+});

package/spec/javascripts/unit/web/timeline/timeline_sender_spec.js

@@ -0,0 +1,131 @@
+var Mocks = require('mocks');
+var TimelineSender = require('core/timeline/timeline_sender').default;
+var Runtime = require('runtime').default;
+var ScriptReceivers = require('dom/script_receiver_factory').ScriptReceivers;
+
+describe("TimelineSender", function() {
+  var jsonpRequest;
+  var timeline, onSend, sender;
+
+  beforeEach(function() {
+    timeline = Mocks.getTimeline();
+    timeline.isEmpty.and.returnValue(false);
+    timeline.send.and.callFake(function(sendJSONP, callback) {
+      sendJSONP({ events: [1, 2, 3]}, callback);
+    });
+
+    onSend = jasmine.createSpy("onSend");
+    spyOn(Runtime, "createJSONPRequest").and.callFake(function() {
+      // JSONPRequest and ScriptRequest have compatible interfaces
+      jsonpRequest = Mocks.getScriptRequest();
+      return jsonpRequest;
+    });
+
+    sender = new TimelineSender(timeline, {
+      host: "example.com",
+      path: "/timeline"
+    });
+  });
+
+  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.createJSONPRequest.calls.count()).toEqual(1);
+      expect(Runtime.createJSONPRequest).toHaveBeenCalledWith(
+        "http://example.com/timeline",
+        { "events": [1, 2, 3] }
+      );
+      expect(jsonpRequest.send).toHaveBeenCalled();
+    });
+
+    it("should send secure JSONP requests when using TLS", function() {
+      var sender = new TimelineSender(timeline, {
+        useTLS: true,
+        host: "example.com",
+        path: "/timeline"
+      });
+      sender.send(true, onSend);
+
+      expect(Runtime.createJSONPRequest.calls.count()).toEqual(1);
+      expect(Runtime.createJSONPRequest).toHaveBeenCalledWith(
+        "https://example.com/timeline",
+        { "events": [1, 2, 3] }
+      );
+    });
+
+    it("should register a receiver using ScriptReceivers", function() {
+      sender.send(false, onSend);
+
+      var jsonpReceiver = jsonpRequest.send.calls.first().args[0];
+      expect(ScriptReceivers[jsonpReceiver.number]).toBe(jsonpReceiver.callback);
+    });
+
+    it("should call back after a successful JSONP request", function() {
+      sender.send(false, onSend);
+
+      expect(onSend).not.toHaveBeenCalled();
+      var jsonpReceiver = jsonpRequest.send.calls.first().args[0];
+      jsonpReceiver.callback(null, { result: "ok" });
+      expect(onSend).toHaveBeenCalledWith(null, { result: "ok" });
+    });
+
+    it("should call back after an unsuccessful JSONP request", function() {
+      sender.send(false, onSend);
+
+      expect(onSend).not.toHaveBeenCalled();
+      var jsonpReceiver = jsonpRequest.send.calls.first().args[0];
+      jsonpReceiver.callback("ERROR!", undefined);
+      expect(onSend).toHaveBeenCalledWith("ERROR!", undefined);
+    });
+
+    it("should remove the receiver from ScriptReceivers", function() {
+      sender.send(false, onSend);
+
+      var jsonpReceiver = jsonpRequest.send.calls.first().args[0];
+      jsonpReceiver.callback(null, {});
+      expect(ScriptReceivers[jsonpReceiver.number]).toBe(undefined);
+    });
+
+    it("should clean up the JSONP request", function() {
+      sender.send(false, onSend);
+
+      expect(jsonpRequest.cleanup).not.toHaveBeenCalled();
+      var jsonpReceiver = jsonpRequest.send.calls.first().args[0];
+      jsonpReceiver.callback(null, {});
+      expect(jsonpRequest.cleanup).toHaveBeenCalled();
+    });
+
+    it("should not send an empty timeline", function() {
+      timeline.isEmpty.and.returnValue(true);
+      sender.send(false, onSend);
+      expect(Runtime.createJSONPRequest).not.toHaveBeenCalled();
+    });
+
+    it("should use returned hostname for subsequent requests", function() {
+      sender.send(false);
+
+      var jsonpReceiver = jsonpRequest.send.calls.first().args[0];
+      jsonpReceiver.callback(null, { host: "returned.example.com" });
+
+      sender.send(false);
+      expect(Runtime.createJSONPRequest).toHaveBeenCalledWith(
+        "http://returned.example.com/timeline",
+        { "events": [1, 2, 3] }
+      );
+    });
+  });
+});

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

@@ -0,0 +1,127 @@
+var Runtime = require('runtime').default;
+var Dependencies = require('dom/dependencies').Dependencies;
+var Mocks = require('mocks');
+var NetInfo  = require('net_info').NetInfo;
+var Pusher = require('core/pusher').default;
+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;
+
+describe("Host/Port Configuration", function() {
+
+  var transport;
+  var pusher;
+  var Transports;
+
+  beforeEach(function() {
+    jasmine.clock().uninstall();
+    jasmine.clock().install();
+
+    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();
+    jasmine.clock().uninstall();
+  });
+
+  describe("SockJS", function() {
+    var _SockJS;
+
+    beforeEach(function() {
+      spyOn(Transports.ws, "isSupported").and.returnValue(false);
+      spyOn(Transports.xdr_streaming, "isSupported").and.returnValue(false);
+      spyOn(Transports.xhr_streaming, "isSupported").and.returnValue(false);
+      spyOn(Transports.xdr_polling, "isSupported").and.returnValue(false);
+      spyOn(Transports.xhr_polling, "isSupported").and.returnValue(false);
+      spyOn(Transports.sockjs, "isSupported").and.returnValue(true);
+
+      spyOn(Dependencies, "load").and.callFake(function(file, callback) {
+        callback();
+      });
+
+      _SockJS = window.WebSocket;
+      window.SockJS = jasmine.createSpy("WebSocket").and.callFake(function() {
+        return Mocks.getTransport();
+      });
+    });
+
+    afterEach(function() {
+      window.SockJS = _SockJS;
+    });
+
+    it("should connect to https://sockjs-<cluster>.pusher.com:443 by default", function() {
+      pusher = new Pusher("foobar", {cluster: "mt1"});
+      pusher.connect();
+
+      expect(window.SockJS).toHaveBeenCalledWith(
+        "https://sockjs-mt1.pusher.com:443/pusher",
+        null,
+        { js_path: cdn_https + '/' + version + '/sockjs'+dependency_suffix+'.js',
+          ignore_null_origin: undefined
+        }
+      );
+    });
+
+    it("should connect to http://sockjs-<cluster>.pusher.com:80 by default when forceTLS disabled", function() {
+      pusher = new Pusher("foobar", { cluster: "mt1", forceTLS: false });
+      pusher.connect();
+
+      expect(window.SockJS).toHaveBeenCalledWith(
+        "http://sockjs-mt1.pusher.com:80/pusher",
+        null,
+        { js_path: cdn_http+'/'+version +'/sockjs'+dependency_suffix+'.js',
+          ignore_null_origin: undefined
+        }
+      );
+    });
+
+    it("should connect using httpHost and httpsPort when specified in options", function() {
+      pusher = new Pusher("foobar", { cluster: "mt1", httpHost: "example.com", httpsPort: 1999 });
+      pusher.connect();
+
+      expect(window.SockJS).toHaveBeenCalledWith(
+        "https://example.com:1999/pusher",
+        null,
+        { js_path: cdn_https + '/' + version + '/sockjs'+dependency_suffix+'.js',
+          ignore_null_origin: undefined
+        }
+      );
+    });
+
+    it("should connect using httpHost and httpPort when specified in options and forceTLS disabled", function() {
+      pusher = new Pusher("foobar", { cluster: "mt1", httpHost: "example.org", httpPort: 4444, forceTLS: false });
+      pusher.connect();
+
+      expect(window.SockJS).toHaveBeenCalledWith(
+        "http://example.org:4444/pusher",
+        null,
+        { js_path: cdn_http+'/'+version +'/sockjs'+dependency_suffix+'.js',
+          ignore_null_origin: undefined
+        }
+      );
+    });
+
+    it("should connect using httpPath when specified in options", function() {
+      pusher = new Pusher("foobar", { cluster: "mt1", httpPath: "/test" });
+      pusher.connect();
+
+      expect(window.SockJS).toHaveBeenCalledWith(
+        "https://sockjs-mt1.pusher.com:443/test",
+        null,
+        { js_path: cdn_https + '/' + version + '/sockjs'+dependency_suffix+'.js',
+          ignore_null_origin: undefined
+        }
+      );
+    });
+  });
+});