@cendarsoss/pusher-js 8.4.11

package/spec/javascripts/unit/core/events_dispatcher_spec.js

@@ -0,0 +1,385 @@
+var EventsDispatcher = require('core/events/dispatcher').default;
+var Collections = require('core/utils/collections');
+
+describe("EventsDispatcher", function() {
+  var dispatcher;
+
+  beforeEach(function() {
+    dispatcher = new EventsDispatcher();
+  });
+
+  describe("#bind", function() {
+    it("should add the listener to a specific event", function() {
+      var onEvent = jasmine.createSpy("onEvent");
+
+      dispatcher.bind("event", onEvent);
+      dispatcher.emit("event", "test");
+      dispatcher.emit("boop", "nope");
+
+      expect(onEvent).toHaveBeenCalledWith("test");
+      expect(onEvent.calls.count()).toEqual(1);
+    });
+
+    it("should add the same listener to a specific event several times", function() {
+      var onEvent = jasmine.createSpy("onEvent");
+
+      dispatcher.bind("event", onEvent);
+      dispatcher.bind("event", onEvent);
+      dispatcher.emit("event", "test");
+
+      expect(onEvent).toHaveBeenCalledWith("test");
+      expect(onEvent.calls.count()).toEqual(2);
+    });
+
+    it("should add the listener with different contexts", function() {
+      var onEvent = jasmine.createSpy("onEvent");
+
+      dispatcher.bind("event", onEvent);
+      dispatcher.bind("event", onEvent, this);
+      dispatcher.bind("event", onEvent, {});
+      dispatcher.emit("event", "test");
+
+      expect(onEvent).toHaveBeenCalledWith("test");
+      expect(onEvent.calls.count()).toEqual(3);
+    });
+  });
+
+  describe("#bind_global", function() {
+    it("should add the listener to all events", function() {
+      var onAll = jasmine.createSpy("onAll");
+
+      dispatcher.bind_global(onAll);
+      dispatcher.emit("event", "test");
+      dispatcher.emit("boop", []);
+
+      expect(onAll).toHaveBeenCalledWith("event", "test");
+      expect(onAll).toHaveBeenCalledWith("boop", []);
+      expect(onAll.calls.count()).toEqual(2);
+    });
+  });
+
+  describe("#unbind", function() {
+    it("should remove the listener", function() {
+      var onEvent = jasmine.createSpy("onEvent");
+
+      dispatcher.bind("event", onEvent);
+      dispatcher.unbind("event", onEvent);
+      dispatcher.emit("event");
+
+      expect(onEvent).not.toHaveBeenCalled();
+    });
+
+    it("should remove the listener while emitting events (regression)", function() {
+      var onEvent1 = jasmine.createSpy("onEvent1").and.callFake(function() {
+        dispatcher.unbind("event", onEvent1);
+      });
+      var onEvent2 = jasmine.createSpy("onEvent2");
+
+      dispatcher.bind("event", onEvent1);
+      dispatcher.bind("event", onEvent2);
+
+      dispatcher.emit("event");
+      expect(onEvent1.calls.count()).toEqual(1);
+      expect(onEvent2.calls.count()).toEqual(1);
+
+      dispatcher.emit("event");
+      expect(onEvent1.calls.count()).toEqual(1);
+      expect(onEvent2.calls.count()).toEqual(2);
+    });
+
+    it("should not remove the last callback if unbinding a function that was not bound (regression)", function() {
+      var onEvent = jasmine.createSpy("onEvent");
+      var otherCallback = jasmine.createSpy("otherCallback");
+
+      dispatcher.bind("event", onEvent);
+      dispatcher.unbind("event", otherCallback);
+
+      dispatcher.emit("event");
+      expect(onEvent.calls.count()).toEqual(1);
+    });
+
+    it("should remove all listeners on omitted arguments", function() {
+      var onEvent1 = jasmine.createSpy("onEvent1");
+      var onEvent2 = jasmine.createSpy("onEvent2");
+
+      dispatcher.bind("event1", onEvent1);
+      dispatcher.bind("event2", onEvent2);
+      dispatcher.unbind();
+      dispatcher.emit("event1");
+      dispatcher.emit("event2");
+
+      expect(onEvent1).not.toHaveBeenCalled();
+      expect(onEvent2).not.toHaveBeenCalled();
+    });
+
+    it("should remove all event's listeners if only event name is given", function() {
+      var onEvent1 = jasmine.createSpy("onEvent1");
+      var onEvent2 = jasmine.createSpy("onEvent2");
+      var onOther = jasmine.createSpy("onOther");
+
+      dispatcher.bind("event", onEvent1);
+      dispatcher.bind("event", onEvent2, {});
+      dispatcher.bind("other", onOther);
+      dispatcher.unbind("event");
+
+      dispatcher.emit("event");
+      dispatcher.emit("other");
+
+      expect(onEvent1).not.toHaveBeenCalled();
+      expect(onEvent2).not.toHaveBeenCalled();
+      expect(onOther.calls.count()).toEqual(1);
+    });
+
+    it("should remove all listeners with given callback", function() {
+      var onEvent = jasmine.createSpy("onEvent");
+      var onOther = jasmine.createSpy("onOther");
+
+      dispatcher.bind("event", onEvent);
+      dispatcher.bind("event2", onEvent, {});
+      dispatcher.bind("event2", onOther);
+      dispatcher.unbind(null , onEvent);
+
+      dispatcher.emit("event");
+      dispatcher.emit("event2");
+
+      expect(onEvent).not.toHaveBeenCalled();
+      expect(onOther.calls.count()).toEqual(1);
+    });
+
+    it("should remove all event's listeners with given callback", function() {
+      var onEvent = jasmine.createSpy("onEvent");
+
+      dispatcher.bind("event", onEvent);
+      dispatcher.bind("event2", onEvent);
+      dispatcher.unbind("event" , onEvent);
+
+      dispatcher.emit("event");
+      expect(onEvent).not.toHaveBeenCalled();
+      dispatcher.emit("event2");
+      expect(onEvent.calls.count()).toEqual(1);
+    });
+
+    it("should remove all event's listeners with given context", function() {
+      var onEvent1 = jasmine.createSpy("onEvent1");
+      var onEvent2 = jasmine.createSpy("onEvent2");
+      var onEvent3 = jasmine.createSpy("onEvent3");
+      var context = {};
+
+      dispatcher.bind("event", onEvent1, context);
+      dispatcher.bind("event", onEvent2, context);
+      dispatcher.bind("event", onEvent3);
+      dispatcher.unbind("event", null, context);
+
+      dispatcher.emit("event");
+
+      expect(onEvent1).not.toHaveBeenCalled();
+      expect(onEvent2).not.toHaveBeenCalled();
+      expect(onEvent3.calls.count()).toEqual(1);
+    });
+
+    it("should remove all listeners with given context", function() {
+      var onEvent1 = jasmine.createSpy("onEvent1");
+      var onEvent2 = jasmine.createSpy("onEvent2");
+      var onEvent3 = jasmine.createSpy("onEvent3");
+      var context = {};
+
+      dispatcher.bind("event1", onEvent1, context);
+      dispatcher.bind("event2", onEvent2, context);
+      dispatcher.bind("event3", onEvent3);
+      dispatcher.unbind(null, null, context);
+
+      dispatcher.emit("event1");
+      dispatcher.emit("event2");
+      dispatcher.emit("event3");
+
+      expect(onEvent1).not.toHaveBeenCalled();
+      expect(onEvent2).not.toHaveBeenCalled();
+      expect(onEvent3.calls.count()).toEqual(1);
+    });
+
+    it("should remove all event's listeners with given callback and context", function() {
+      var onEvent = jasmine.createSpy("onEvent");
+      var context = {};
+
+      dispatcher.bind("event", onEvent, context);
+      dispatcher.bind("event2", onEvent, context);
+      dispatcher.unbind("event" , onEvent, context);
+
+      dispatcher.emit("event");
+      expect(onEvent).not.toHaveBeenCalled();
+
+      dispatcher.emit("event2");
+      expect(onEvent.calls.count()).toEqual(1);
+    });
+
+    it("should remove all listeners with given callback and context", function() {
+      var onEvent = jasmine.createSpy("onEvent");
+      var onOther = jasmine.createSpy("onOther");
+      var context = {};
+
+      dispatcher.bind("event", onEvent, context);
+      dispatcher.bind("event2", onEvent, context);
+      dispatcher.bind("event3", onEvent);
+      dispatcher.bind("other", onOther, context);
+      dispatcher.unbind(null , onEvent, context);
+
+      dispatcher.emit("event");
+      dispatcher.emit("event2");
+      expect(onEvent).not.toHaveBeenCalled();
+
+      dispatcher.emit("event3");
+      expect(onEvent.calls.count()).toEqual(1);
+
+      dispatcher.emit("other");
+      expect(onOther.calls.count()).toEqual(1);
+    });
+  });
+
+  describe("#emit", function() {
+    it("should call all listeners", function() {
+      var callbacks = Collections.map([1, 2, 3], function(i) {
+        return jasmine.createSpy("onTest" + i);
+      });
+      Collections.apply(callbacks, function(callback) {
+        dispatcher.bind("test", callback);
+      });
+
+      dispatcher.emit("test", { x: 1 });
+
+      Collections.apply(callbacks, function(callback) {
+        expect(callback).toHaveBeenCalledWith({ x: 1 });
+      });
+    });
+
+    it("should call all global listeners", function() {
+      var callbacks = Collections.map([1, 2, 3], function(i) {
+        return jasmine.createSpy("onGlobal" + i);
+      });
+      Collections.apply(callbacks, function(callback) {
+        dispatcher.bind_global(callback);
+      });
+
+      dispatcher.emit("g", { y: 2 });
+
+      Collections.apply(callbacks, function(callback) {
+        expect(callback).toHaveBeenCalledWith("g", { y: 2 });
+      });
+    });
+
+    it("should call fail through function when there are no listeners for an event", function() {
+      var failThrough = jasmine.createSpy("failThrough");
+      var dispatcher = new EventsDispatcher(failThrough);
+
+      dispatcher.emit("nothing", "data");
+
+      expect(failThrough).toHaveBeenCalledWith("nothing", "data");
+    });
+
+    it("should call fail through function after removing all event's listeners", function() {
+      var failThrough = jasmine.createSpy("failThrough");
+      var onEvent = jasmine.createSpy("onEvent");
+      var dispatcher = new EventsDispatcher(failThrough);
+
+      dispatcher.bind("event", onEvent);
+      dispatcher.unbind("event", onEvent);
+      dispatcher.emit("event", "data");
+
+      expect(onEvent).not.toHaveBeenCalled();
+      expect(failThrough).toHaveBeenCalledWith("event", "data");
+    });
+
+    it("should call listener with provided context", function() {
+      var context = {};
+      var boundContext, unboundContext;
+
+      var onEventBound = jasmine.createSpy("onEventBound").and.callFake(function(){
+        boundContext = this;
+      });
+      var onEventUnbound = jasmine.createSpy("onEventUnbound").and.callFake(function(){
+        unboundContext = this;
+      });
+
+      dispatcher.bind("event", onEventBound, context);
+      dispatcher.bind("event", onEventUnbound);
+      dispatcher.emit("event");
+
+      expect(boundContext).toEqual(context);
+      expect(unboundContext).toEqual(global);
+    });
+    it("should call listener with provided metadata", function() {
+      var callback = jasmine.createSpy("callback");
+      dispatcher.bind("some-event", callback);
+
+      dispatcher.emit("some-event", {data: 1}, {user_id: "123-abc"})
+
+      expect(callback).toHaveBeenCalledWith({data: 1}, {user_id: "123-abc"})
+    })
+  });
+
+  describe("#unbind_global", function() {
+    it("should remove a particular global callback if specified", function () {
+      var global1 = jasmine.createSpy("global1");
+      var global2 = jasmine.createSpy("global2");
+
+      dispatcher.bind_global(global1);
+      dispatcher.bind_global(global2);
+
+      dispatcher.unbind_global(global1);
+
+      dispatcher.emit("event", "test");
+
+      expect(global1).not.toHaveBeenCalled();
+      expect(global2).toHaveBeenCalledWith("event", "test");
+    });
+
+    it("should remove all global callbacks if called with no params", function () {
+      var global1 = jasmine.createSpy("global1");
+      var global2 = jasmine.createSpy("global2");
+
+      dispatcher.bind_global(global1);
+      dispatcher.bind_global(global2);
+
+      dispatcher.unbind_global();
+
+      dispatcher.emit("event", "test");
+
+      expect(global1).not.toHaveBeenCalled();
+      expect(global2).not.toHaveBeenCalled();
+    });
+
+    it("should not remove any event specific callbacks", function () {
+      var specific = jasmine.createSpy("specific");
+
+      dispatcher.bind("event", specific);
+
+      dispatcher.unbind_global();
+
+      dispatcher.emit("event", "test");
+
+      expect(specific).toHaveBeenCalledWith("test");
+    });
+  });
+
+  describe("#unbind_all", function () {
+    it("should remove all bindings – global and event specific", function () {
+      var global1 = jasmine.createSpy("global1");
+      var global2 = jasmine.createSpy("global2");
+      var specific1 = jasmine.createSpy("specific1");
+      var specific2 = jasmine.createSpy("specific2");
+
+      dispatcher.bind_global(global1);
+      dispatcher.bind_global(global2);
+      dispatcher.bind("event", specific1);
+      dispatcher.bind("event", specific2);
+
+      dispatcher.unbind_all();
+
+      dispatcher.emit("event", "test");
+
+      expect(global1).not.toHaveBeenCalled();
+      expect(global2).not.toHaveBeenCalled();
+      expect(specific1).not.toHaveBeenCalled();
+      expect(specific2).not.toHaveBeenCalled();
+    });
+  });
+});

package/spec/javascripts/unit/core/http/http_polling_socket_spec.js

@@ -0,0 +1,60 @@
+var Mocks = require('mocks');
+var HTTPFactory = require('runtime').default.HTTPFactory;
+
+describe("HTTP.createPollingSocket", function() {
+  var hooks;
+  var url;
+  var socket;
+
+  beforeEach(function() {
+    spyOn(HTTPFactory, "createSocket").and.callFake(function(h, u) {
+      socket = Mocks.getHTTPSocket();
+      hooks = h;
+      url = u;
+      return socket;
+    });
+  });
+
+  it("should pass the correct url", function() {
+    HTTPFactory.createPollingSocket("http://example.org/xyz");
+    expect(url).toEqual("http://example.org/xyz");
+  });
+
+  describe("hooks", function() {
+    beforeEach(function() {
+      HTTPFactory.createPollingSocket("http://example.com");
+    });
+
+    it("#getReceiveURL should generate a correct streaming URL", function() {
+      var url = { base: "foo/bar", queryString: "?foo=bar" };
+      var session = "012/asdf";
+      expect(hooks.getReceiveURL(url, session)).toEqual(
+        "foo/bar/012/asdf/xhr?foo=bar"
+      );
+    });
+
+    it("#onHeartbeat should not send anything", function() {
+      hooks.onHeartbeat(socket);
+      expect(socket.sendRaw).not.toHaveBeenCalled();
+    });
+
+    it("#sendHeartbeat should send an '[]' frame", function() {
+      hooks.sendHeartbeat(socket);
+      expect(socket.sendRaw).toHaveBeenCalledWith("[]");
+      expect(socket.sendRaw.calls.count()).toEqual(1);
+    });
+
+    it("#onFinished with status 200 should reconnect the socket", function() {
+      hooks.onFinished(socket, 200);
+      expect(socket.reconnect.calls.count()).toEqual(1);
+    });
+
+    it("#onFinished with non-200 status should close the socket", function() {
+      hooks.onFinished(socket, 500);
+      expect(socket.onClose).toHaveBeenCalledWith(
+        1006, "Connection interrupted (500)", false
+      );
+      expect(socket.onClose.calls.count()).toEqual(1);
+    });
+  });
+});

package/spec/javascripts/unit/core/http/http_request_spec.js

@@ -0,0 +1,185 @@
+var Mocks = require("mocks");
+
+var HTTPRequest = require("core/http/http_request").default;
+var Runtime = require("runtime").default;
+
+describe("HTTPRequest", function() {
+  var xhr;
+  var hooks;
+  var request;
+
+  var lastXHR;
+
+  beforeEach(function() {
+    hooks = {
+      getRequest: jasmine.createSpy().and.callFake(function() {
+        lastXHR = Mocks.getXHR();
+        return lastXHR;
+      }),
+      abortRequest: jasmine.createSpy()
+    };
+
+    spyOn(Runtime, "addUnloadListener");
+    spyOn(Runtime, "removeUnloadListener");
+
+    request = new HTTPRequest(hooks, "GET", "http://example.com");
+  });
+
+  describe("#start", function() {
+    it("should create a request using the getRequest hook", function() {
+      request.start("test");
+      expect(hooks.getRequest.calls.count()).toEqual(1);
+      expect(hooks.getRequest).toHaveBeenCalledWith(request);
+    });
+
+
+    it("should open and send the request", function() {
+      request.start("test payload");
+      expect(lastXHR.open).toHaveBeenCalledWith(
+        "GET", "http://example.com", true
+      );
+      expect(lastXHR.send).toHaveBeenCalledWith("test payload");
+    });
+
+    it("should register an unloader", function() {
+      request.start("test payload");
+
+      expect(Runtime.addUnloadListener).toHaveBeenCalledWith(
+        jasmine.any(Function)
+      );
+    });
+
+    it("raised by XMLHttpRequest#open", function() {
+      hooks.getRequest = function() {
+        xhr = Mocks.getXHR();
+        xhr.open.and.throwError("open exception");
+        return xhr;
+      };
+      expect(function() {
+        request.start();
+      }).toThrow(new Error('open exception'));
+    });
+
+    it("should re-throw the exception raised by XMLHttpRequest#send", function() {
+      hooks.getRequest = function() {
+        xhr = Mocks.getXHR();
+        xhr.send.and.throwError("send exception");
+        return xhr;
+      };
+      expect(function() {
+        request.start();
+      }).toThrow(new Error('send exception'));
+    });
+  });
+
+  describe("#close", function() {
+    beforeEach(function() {
+      request.start();
+    });
+
+    it("should abort the request using the abortRequest hook", function() {
+      request.close();
+      expect(hooks.abortRequest.calls.count()).toEqual(1);
+      expect(hooks.abortRequest).toHaveBeenCalledWith(lastXHR);
+    });
+
+    it("should unregister the unloader", function() {
+      var unloader = Runtime.addUnloadListener.calls.first().args[0];
+      request.close();
+      expect(Runtime.removeUnloadListener).toHaveBeenCalledWith(unloader);
+    });
+  });
+
+  describe("on chunk", function() {
+    var onChunk;
+
+    beforeEach(function() {
+      onChunk = jasmine.createSpy("onChunk");
+      request.bind("chunk", onChunk);
+      request.start();
+    });
+
+    it("should emit the first chunk", function() {
+      request.onChunk(200, "chunk1\n");
+      expect(onChunk).toHaveBeenCalledWith({ status: 200, data: "chunk1" });
+    });
+
+    it("should emit two chunks received one after another", function() {
+      request.onChunk(201, "c1\n");
+      expect(onChunk.calls.count()).toEqual(1);
+      expect(onChunk).toHaveBeenCalledWith({ status: 201, data: "c1" });
+
+      request.onChunk(201, "c1\nc2\n");
+      expect(onChunk.calls.count()).toEqual(2);
+      expect(onChunk).toHaveBeenCalledWith({ status: 201, data: "c2" });
+    });
+
+    it("should emit all chunks send in one batch", function() {
+      request.onChunk(200, "c1\nc2\nc3\n");
+      expect(onChunk.calls.count()).toEqual(3);
+      expect(onChunk.calls.first().args[0]).toEqual({ status: 200, data: "c1" });
+      expect(onChunk.calls.argsFor(1)[0]).toEqual({
+        status: 200,
+        data: 'c2'
+      });
+      expect(onChunk.calls.argsFor(2)[0]).toEqual({ status: 200, data: "c3" });
+    });
+
+    it("should not emit an unfinished chunk", function() {
+      request.onChunk(200, "whatever");
+      expect(onChunk).not.toHaveBeenCalled();
+    });
+
+    it("should emit 'buffer_too_long' after 256KB", function() {
+      var onBufferTooLong = jasmine.createSpy("onBufferTooLong");
+      request.bind("buffer_too_long", onBufferTooLong);
+
+      var kilobyteChunk = new Array(1024).join("x"); // 1023B
+
+      var response = new Array(256).join(kilobyteChunk + "\n");
+      request.onChunk(200, response); // 255KB
+      expect(onBufferTooLong).not.toHaveBeenCalled();
+
+      response = response + kilobyteChunk + "x"; // 256KB
+      request.onChunk(200, response); // 255KB
+      expect(onBufferTooLong).not.toHaveBeenCalled();
+
+      response = response + "\n"; // 256KB + 1B
+      request.onChunk(200, response); // 255KB
+      expect(onBufferTooLong).toHaveBeenCalled();
+    });
+
+    it("should emit all chunks before 'buffer_too_long'", function() {
+      request.bind("buffer_too_long", function() {
+        request.unbind_all();
+      });
+
+      var kilobyteChunk = new Array(1024).join("x"); // 1023B
+      request.onChunk(
+        200,
+        new Array(256).join(kilobyteChunk + "\n") + kilobyteChunk + "x" + "\n"
+      ); // 256KB + 1B
+      expect(onChunk.calls.count()).toEqual(256);
+    });
+  });
+
+  describe("on page unload", function() {
+    var unloader;
+
+    beforeEach(function() {
+      request.start("test payload");
+      unloader = Runtime.addUnloadListener.calls.first().args[0];
+    });
+
+    it("should abort the request using the abortRequest hook", function() {
+      unloader();
+      expect(hooks.abortRequest.calls.count()).toEqual(1);
+      expect(hooks.abortRequest).toHaveBeenCalledWith(lastXHR);
+    });
+
+    it("should unregister the unloader", function() {
+      unloader();
+      expect(Runtime.removeUnloadListener).toHaveBeenCalledWith(unloader);
+    });
+  });
+});