pingerchips-js 1.0.1-a → 2.0.0

package/spec/javascripts/unit/core/connection/connection_spec.js

@@ -1,286 +0,0 @@
-var Connection = require('core/connection/connection').default;
-var Protocol = require('core/connection/protocol/protocol').default;
-var Mocks = require("mocks");
-
-describe("Connection", function() {
-  var transport;
-  var connection;
-
-  beforeEach(function() {
-    transport = Mocks.getTransport();
-    connection = new Connection("111.22", transport);
-  });
-
-  describe("#activityTimeout", function() {
-    it("should be set to undefined if the transport doesn't have a activityTimeout value", function() {
-      var transport = Mocks.getTransport();
-      var connection = new Connection("111.22", transport);
-      expect(connection.activityTimeout).toBe(undefined);
-    });
-
-    it("should be set to the transport's activityTimeout value", function() {
-      var transport = Mocks.getTransport();
-      transport.activityTimeout = 123123;
-      var connection = new Connection("111.22", transport);
-      expect(connection.activityTimeout).toEqual(123123);
-    });
-  });
-
-  describe("#handlesActivityChecks", function() {
-    it("should return true if transport handles activity checks by itself", function() {
-      transport.handlesActivityChecks.and.returnValue(true);
-      expect(connection.handlesActivityChecks()).toBe(true);
-    });
-
-    it("should return false if transport does not handle activity checks by itself", function() {
-      transport.handlesActivityChecks.and.returnValue(false);
-      expect(connection.handlesActivityChecks()).toBe(false);
-    });
-  });
-
-  describe("#send", function() {
-    it("should pass the data to the transport", function() {
-      transport.send.and.returnValue(true);
-      connection.send("proxy");
-      expect(transport.send).toHaveBeenCalledWith("proxy");
-    });
-
-    it("should return true if the transport sent the data", function() {
-      transport.send.and.returnValue(true);
-      expect(connection.send("proxy")).toBe(true);
-    });
-
-    it("should return false if the transport did not send the data", function() {
-      transport.send.and.returnValue(false);
-      expect(connection.send("proxy")).toBe(false);
-    });
-
-    it("should send events in correct format", function() {
-      expect(connection.send_event("test", [1,2,3])).toBe(true);
-      expect(transport.send).toHaveBeenCalledWith(JSON.stringify({
-        event: "test",
-        data: [1,2,3]
-      }));
-    });
-
-    it("should send events in correct format (including channel)", function() {
-      connection.send_event("test", [1,2,3], "chan");
-      expect(transport.send).toHaveBeenCalledWith(JSON.stringify({
-        event: "test",
-        data: [1,2,3],
-        channel: "chan"
-      }));
-    });
-  });
-
-  describe("#ping", function() {
-    it("should call ping on the transport if it's supported", function() {
-      transport.supportsPing.and.returnValue(true);
-      connection.ping();
-      expect(transport.ping).toHaveBeenCalled();
-      expect(transport.send).not.toHaveBeenCalled();
-    });
-
-    it("should send a pusher:ping event if ping is not supported", function() {
-      transport.supportsPing.and.returnValue(false);
-      connection.ping();
-
-      expect(transport.ping).not.toHaveBeenCalled();
-      var pingEvent = JSON.parse(transport.send.calls.first().args[0]);
-      expect(pingEvent).toEqual({
-        event: "pusher:ping",
-        data: {}
-      });
-    });
-  });
-
-  describe("#close", function() {
-    it("should call close on the transport", function() {
-      connection.close();
-      expect(transport.close).toHaveBeenCalled();
-    });
-  });
-
-  describe("after receiving a message", function() {
-    it("should emit generic messages", function() {
-      var onMessage = jasmine.createSpy("onMessage");
-      connection.bind("message", onMessage);
-
-      transport.emit("message", {
-        data: JSON.stringify({
-          event: "random",
-          data: { foo: "bar" }
-        })
-      });
-      expect(onMessage).toHaveBeenCalledWith({
-        event: "random",
-        data: { foo: "bar" },
-        channel: undefined,
-      });
-    });
-
-    it("should emit errors", function() {
-      var onError = jasmine.createSpy("onError");
-      connection.bind("error", onError);
-
-      transport.emit("message", {
-        data: JSON.stringify({
-          event: "pusher:error",
-          data: ":("
-        })
-      });
-      expect(onError).toHaveBeenCalledWith({
-        type: "PusherError",
-        data: ":("
-      });
-    });
-
-    it("should emit 'ping'", function() {
-      var onPing = jasmine.createSpy("onPing");
-      connection.bind("ping", onPing);
-
-      transport.emit("message", {
-        data: JSON.stringify({
-          event: "pusher:ping",
-          data: {}
-        })
-      });
-      expect(onPing).toHaveBeenCalled();
-    });
-
-    it("should emit 'pong'", function() {
-      var onPong = jasmine.createSpy("onPong");
-      connection.bind("pong", onPong);
-
-      transport.emit("message", {
-        data: JSON.stringify({
-          event: "pusher:pong",
-          data: {}
-        })
-      });
-      expect(onPong).toHaveBeenCalled();
-    });
-
-    it("should emit an error after receiving invalid JSON", function() {
-      var error = {};
-
-      var onMessage = jasmine.createSpy("onMessage");
-      var onError = jasmine.createSpy("onError").and.callFake(function(e) {
-        error = e;
-      });
-      connection.bind("message", onMessage);
-      connection.bind("error", onError);
-
-      transport.emit("message", {
-        data: "this is not json"
-      });
-      expect(onMessage).not.toHaveBeenCalled();
-      expect(error.type).toEqual("MessageParseError");
-      expect(error.data).toEqual("this is not json");
-    });
-  });
-
-  describe("after receiving an activity event", function() {
-    it("should emit an activity event too", function() {
-      var onActivity = jasmine.createSpy("onActivity");
-      connection.bind("activity", onActivity);
-
-      expect(onActivity).not.toHaveBeenCalled();
-      transport.emit("activity");
-      expect(onActivity).toHaveBeenCalled();
-    });
-  });
-
-  describe("after transport has closed", function() {
-    it("should emit 'closed'", function() {
-      var onClosed = jasmine.createSpy("onClosed");
-      connection.bind("closed", onClosed);
-
-      transport.emit("closed", { code: 1006, reason: "unknown" });
-
-      expect(onClosed).toHaveBeenCalled();
-    });
-
-    it("should 'closed' even if close codes are not supported", function() {
-      var onClosed = jasmine.createSpy("onClosed");
-      connection.bind("closed", onClosed);
-
-      transport.emit("closed", {});
-
-      expect(onClosed).toHaveBeenCalled();
-    });
-
-    it("should emit the action dispatched by protocol", function() {
-      var onMockAction = jasmine.createSpy("onMockAction");
-      connection.bind("mock_action", onMockAction);
-      spyOn(Protocol, "getCloseAction").and.returnValue("mock_action");
-      spyOn(Protocol, "getCloseError").and.returnValue(null);
-
-      transport.emit("closed", { code: 1006, reason: "unknown" });
-
-      expect(Protocol.getCloseAction).toHaveBeenCalledWith({
-        code: 1006,
-        reason: "unknown"
-      });
-      expect(onMockAction).toHaveBeenCalled();
-    });
-
-    it("should emit the error returned by protocol", function() {
-      var onError = jasmine.createSpy("onError");
-      connection.bind("error", onError);
-      spyOn(Protocol, "getCloseAction").and.returnValue("mock_action");
-      spyOn(Protocol, "getCloseError").and.returnValue({
-        type: "MockError",
-        data: {
-          code: 4123,
-          message: "something"
-        }
-      });
-
-      transport.emit("closed", { code: 4123, reason: "something" });
-
-      expect(Protocol.getCloseError).toHaveBeenCalledWith({
-        code: 4123,
-        reason: "something"
-      });
-      expect(onError).toHaveBeenCalledWith({
-        type: "MockError",
-        data: {
-          code: 4123,
-          message: "something"
-        }
-      });
-    });
-
-    it("should not emit 'error' if close codes are not supported", function() {
-      var onError = jasmine.createSpy("onError");
-      connection.bind("error", onError);
-
-      transport.emit("closed", {});
-
-      expect(onError).not.toHaveBeenCalled();
-    });
-
-    it("should not close the transport", function() {
-      transport.emit("closed", { code: 4001, reason: "reason" });
-
-      expect(transport.close).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("after receiving a transport error", function() {
-    it("should emit the error", function() {
-      var onError = jasmine.createSpy("onError");
-      connection.bind("error", onError);
-
-      transport.emit("error", {
-        type: "WebSocketError",
-        error: "wut"
-      });
-      expect(onError).toHaveBeenCalledWith({
-        type: "WebSocketError",
-        error: "wut"
-      });
-    });
-  });
-});

package/spec/javascripts/unit/core/connection/handshake_spec.js

@@ -1,160 +0,0 @@
-var Handshake = require('core/connection/handshake').default;
-var Protocol = require('core/connection/protocol/protocol').default;
-var Connection = require('core/connection/connection').default;
-var Mocks = require("mocks");
-
-describe("Handshake", function() {
-  var transport;
-  var callback;
-  var handshake;
-
-  beforeEach(function() {
-    transport = Mocks.getTransport();
-    callback = jasmine.createSpy("callback");
-    spyOn(Protocol, "processHandshake");
-
-    handshake = new Handshake(transport, callback);
-  });
-
-  describe("after a successful handshake", function() {
-    beforeEach(function() {
-      Protocol.processHandshake.and.returnValue({
-        action: "connected",
-        id: "9.9"
-      });
-      transport.emit("message", { data: "dummy" });
-    });
-
-    it("should call back with a connection", function() {
-      expect(callback).toHaveBeenCalledWith({
-        action: "connected",
-        transport: transport,
-        activityTimeout: undefined,
-        connection: jasmine.any(Connection)
-      });
-      expect(callback.calls.first().args[0].connection.id).toEqual("9.9");
-    });
-
-    it("should not call close on the transport", function() {
-      expect(transport.close).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("after a handshake with other action", function() {
-    beforeEach(function() {
-      Protocol.processHandshake.and.returnValue({
-        action: "boom",
-        error: "BOOM"
-      });
-      transport.emit("message", { data: "dummy "});
-    });
-
-    it("should call back with correct action and error", function() {
-      expect(callback).toHaveBeenCalledWith({
-        action: "boom",
-        transport: transport,
-        error: "BOOM"
-      });
-    });
-
-    it("should call close on the transport", function() {
-      expect(transport.close).toHaveBeenCalled();
-    });
-  });
-
-  describe("after a handshake raising an exception", function() {
-    beforeEach(function() {
-      Protocol.processHandshake.and.throwError("Invalid handshake");
-      transport.emit("message", { data: "dummy "});
-    });
-
-    it("should call back with an 'error' action", function() {
-      expect(callback).toHaveBeenCalledWith({
-        action: "error",
-        transport: transport,
-        error: new Error("Invalid handshake")
-      });
-    });
-
-    it("should call close on the transport", function() {
-      expect(transport.close).toHaveBeenCalled();
-    });
-  });
-
-  describe("on connection exception", function(){
-    it("should throw an error", function(){
-      var finishSpy = spyOn(handshake, 'finish');
-      var error = new Error("some exception");
-
-      finishSpy.and.callFake(function(action, params){
-        if (action === "connected") {
-          throw error
-        } else {
-          finishSpy.and.callThrough();
-        }
-      });
-
-      Protocol.processHandshake.and.returnValue({
-        action: "connected",
-        id: "9.9"
-      });
-
-      expect(function(){
-        transport.emit("message", {data: "dummy"});
-      }).toThrow(error);
-    });
-  })
-
-  describe("after receiving a 'closed' event from transport", function() {
-    describe("with defined action", function() {
-      beforeEach(function() {
-        spyOn(Protocol, "getCloseAction").and.returnValue("boo");
-        spyOn(Protocol, "getCloseError");
-
-        transport.emit("closed", {
-          code: 4321,
-          reason: "test"
-        });
-      });
-
-      it("should call back with correct action and error", function() {
-        expect(callback).toHaveBeenCalledWith({
-          action: "boo",
-          transport: transport,
-          error: undefined,
-        });
-      });
-
-      it("should not close the transport", function() {
-        expect(transport.close).not.toHaveBeenCalled();
-      });
-
-      it("should call protocol methods with correct arguments", function() {
-        expect(Protocol.getCloseAction).toHaveBeenCalledWith({
-          code: 4321,
-          reason: "test"
-        });
-      });
-    });
-
-    describe("with null action", function() {
-      beforeEach(function() {
-        spyOn(Protocol, "getCloseAction").and.returnValue(null);
-        spyOn(Protocol, "getCloseError").and.returnValue("???");
-
-        transport.emit("closed", {
-          code: 4321,
-          reason: "???"
-        });
-      });
-
-      it("should call back with 'backoff' action and error", function() {
-        expect(callback).toHaveBeenCalledWith({
-          action: "backoff",
-          error: "???",
-          transport: transport
-        });
-      });
-    });
-  });
-});