@cendarsoss/pusher-js 8.4.11

package/spec/javascripts/integration/core/cluster_config_spec.js

@@ -0,0 +1,153 @@
+const TestEnv = require('testenv');
+const Pusher = require('pusher_integration');
+const DependenciesModule = require('dom/dependencies');
+const DependenciesReceiversModule = require('dom/dependency_loader');
+const waitsFor = require('../../helpers/waitsFor');
+
+if (TestEnv === "web") {
+  window.Pusher = Pusher;
+  var DependenciesReceivers = DependenciesModule.DependenciesReceivers;
+  var Dependencies = DependenciesModule.Dependencies;
+  var DependencyLoader = DependenciesReceiversModule.default;
+}
+
+const Integration = require("integration");
+const Collections = require("core/utils/collections");
+const Runtime = require('runtime').default;
+const Defaults = require('core/defaults').default;
+const TRANSPORTS = Runtime.Transports;
+
+
+module.exports = function(testConfigs) {
+  Integration.describe("Cluster Configuration", function() {
+    var pusher;
+
+    function subscribe(pusher, channelName, callback) {
+      var channel = pusher.subscribe(channelName);
+      channel.bind("pusher:subscription_succeeded", function(param) {
+        callback(channel, param);
+      });
+      return channel;
+    }
+
+
+    function describeClusterTest(options) {
+      var environment = { forceTLS: options.forceTLS };
+      if (!TRANSPORTS[options.transport].isSupported(environment)) {
+        return;
+      }
+
+      describe("with " + options.transport + ", forceTLS=" + options.forceTLS, function() {
+        var jasmineDefaultTimeout = jasmine.DEFAULT_TIMEOUT_INTERVAL;
+
+        beforeAll(() => {
+          jasmine.DEFAULT_TIMEOUT_INTERVAL = 21000;
+        });
+
+        afterAll(() => {
+          jasmine.DEFAULT_TIMEOUT_INTERVAL = jasmineDefaultTimeout;
+        });
+
+        beforeEach(function() {
+          Collections.objectApply(TRANSPORTS, function(transport, name) {
+            spyOn(transport, "isSupported").and.returnValue(false);
+          });
+          TRANSPORTS[options.transport].isSupported.and.returnValue(true);
+          spyOn(Runtime, "getLocalStorage").and.returnValue({});
+        });
+
+        it("should open a connection to the 'eu' cluster", async function() {
+          var authTransport = (TestEnv === "web") ? 'jsonp' : 'ajax';
+
+          pusher = new Pusher("cb7d5e50f5669e5c9ae6", {
+            authTransport: authTransport,
+            authEndpoint: Integration.API_EU_URL + "/auth",
+            cluster: "eu",
+            forceTLS: options.forceTLS,
+          });
+
+          await waitsFor(function() {
+            return pusher.connection.state === "connected";
+          }, "connection to be established", 20000);
+
+          expect(pusher.connection.state).toEqual('connected');
+        });
+
+        it("should subscribe and receive a message sent via REST API", async function() {
+          var channelName = Integration.getRandomName("private-integration");
+
+          var onSubscribed = jasmine.createSpy("onSubscribed");
+          var channel = subscribe(pusher, channelName, onSubscribed);
+
+          var eventName = "integration_event";
+          var data = { x: 1, y: "z" };
+          var received = null;
+
+          await waitsFor(function() {
+            return onSubscribed.calls.count();
+          }, "subscription to succeed", 10000);
+
+          channel.bind(eventName, function(message) {
+            received = message;
+          });
+          Integration.sendAPIMessage({
+            url: Integration.API_EU_URL + "/v2/send",
+            channel: channelName,
+            event: eventName,
+            data: data
+          });
+
+          await waitsFor(function() {
+            return received !== null;
+          }, "message to get delivered", 10000);
+
+          expect(received).toEqual(data);
+          pusher.unsubscribe(channelName);
+        });
+
+        it("should disconnect the connection", function() {
+          pusher.disconnect();
+        });
+      });
+    }
+
+    var _VERSION;
+    var _authTransport;
+    var _authEndpoint;
+    var _Dependencies;
+
+    it("should prepare the global config", function() {
+      // TODO fix how versions work in unit tests
+      _VERSION = Defaults.VERSION;
+      _authTransport = Defaults.authTransport;
+      _authEndpoint = Defaults.authEndpoint;
+      _Dependencies = Dependencies;
+
+      Defaults.VERSION = "8.8.8";
+      Defaults.authTransport = "";
+      Defaults.authEndpoint = "";
+
+      if (TestEnv === "web") {
+        Dependencies = new DependencyLoader({
+          cdn_http: Integration.JS_HOST,
+          cdn_https: Integration.JS_HOST,
+          version: Defaults.VERSION,
+          suffix: "",
+          receivers: DependenciesReceivers
+        });
+      }
+    });
+
+    for (testConfig of testConfigs) {
+      describeClusterTest(testConfig)
+    }
+
+
+    it("should restore the global config", function() {
+      Dependencies = _Dependencies;
+      Defaults.authEndpoint = _authEndpoint;
+      Defaults.authTransport = _authTransport;
+      Defaults.VERSION = _VERSION;
+    });
+  });
+}

package/spec/javascripts/integration/core/falling_back_spec.js

@@ -0,0 +1,195 @@
+const TestEnv = require('testenv');
+const Pusher = require('pusher_integration');
+
+if (TestEnv === "web") window.Pusher = Pusher;
+
+const Integration = require('integration');
+const Mocks = require("mocks");
+const Network = require('net_info').Network;
+const OneOffTimer = require('core/utils/timers').OneOffTimer;
+const Runtime = require('runtime').default;
+const transports = Runtime.Transports;
+const waitsFor = require('../../helpers/waitsFor')
+
+module.exports = function() {
+  Integration.describe("Falling back", function() {
+    var pusher;
+
+    beforeEach(function() {
+      spyOn(Network, "isOnline").and.returnValue(true);
+
+      spyOn(transports.ws, "isSupported").and.returnValue(false);
+      spyOn(transports.xhr_streaming, "isSupported").and.returnValue(false);
+      spyOn(transports.xhr_polling, "isSupported").and.returnValue(false);
+
+      if (TestEnv === "web") {
+        spyOn(transports.sockjs, "isSupported").and.returnValue(false);
+        spyOn(transports.xdr_streaming, "isSupported").and.returnValue(false);
+        spyOn(transports.xdr_polling, "isSupported").and.returnValue(false);
+      }
+
+      spyOn(Runtime, "getLocalStorage").and.returnValue({});
+    });
+
+    afterEach(function() {
+      pusher.disconnect();
+    });
+
+    it("should disable WebSockets after two broken connections", async function() {
+      var transport;
+
+      function createConnection() {
+        transport = Mocks.getTransport(true);
+        return transport;
+      }
+
+      transports.ws.isSupported.and.returnValue(true);
+      spyOn(transports.ws, "createConnection").and.callFake(createConnection);
+
+      var timer;
+
+      pusher = new Pusher("foobar", {cluster: "mt1"});
+      pusher.connect();
+
+      await waitsFor(function() {
+        return transports.ws.createConnection.calls.count() === 1;
+      }, "WS connection to be created", 500);
+
+      transport.state = "initialized";
+      transport.emit("initialized");
+
+      await waitsFor(function() {
+        return transport.connect.calls.count() === 1;
+      }, "connect to be called", 500);
+
+      transport.state = "open";
+      transport.emit("open");
+
+      var timer = new OneOffTimer(100, function() {
+        transport.emit("closed", {
+          code: 1006,
+          reason: "KABOOM!",
+          wasClean: false
+        });
+      });
+
+      await waitsFor(function() {
+        return transports.ws.createConnection.calls.count() === 2;
+      }, "WS connection to be created", 1500);
+
+      transport.state = "initialized";
+      transport.emit("initialized");
+
+      await waitsFor(function() {
+        return transport.connect.calls.count() === 1;
+      }, "connect to be called", 500);
+
+      transport.state = "open";
+      transport.emit("open");
+
+      timer = new OneOffTimer(100, function() {
+        transport.emit("closed", {
+          code: 1006,
+          reason: "KABOOM! AGAIN!",
+          wasClean: false
+        });
+      });
+
+
+      await waitsFor(function() {
+        return !timer.isRunning();
+      }, "the transport to close", 200);
+
+      timer = new OneOffTimer(500, function() {});
+
+      await waitsFor(function() {
+        return !timer.isRunning();
+      }, "a while", 600);
+
+      expect(transports.ws.createConnection.calls.count()).toEqual(2);
+      pusher.disconnect();
+    });
+
+    if (TestEnv === "web") {
+      it("should not close established SockJS connection when WebSocket is stuck in handshake", async function() {
+        var wsTransport, sockjsTransport;
+
+        function createWSConnection() {
+          wsTransport = Mocks.getTransport(true);
+          return wsTransport;
+        }
+        function createSockJSConnection() {
+          sockjsTransport = Mocks.getTransport(true);
+          return sockjsTransport;
+        }
+
+        transports.ws.isSupported.and.returnValue(true);
+        transports.sockjs.isSupported.and.returnValue(true);
+        spyOn(transports.ws, "createConnection").and.callFake(createWSConnection);
+        spyOn(transports.sockjs, "createConnection").and.callFake(createSockJSConnection);
+
+
+        // use TLS connection, to force sockjs to be the primary fallback
+        pusher = new Pusher("foobar", { cluster: "mt1", forceTLS: true });
+        pusher.connect();
+
+        await waitsFor(function() {
+          return transports.ws.createConnection.calls.count() === 1;
+        }, "WS connection to be created", 500);
+
+        wsTransport.state = "initialized";
+        wsTransport.emit("initialized");
+
+        await waitsFor(function() {
+          return wsTransport.connect.calls.count() === 1;
+        }, "connect on WS to be called", 500);
+
+        wsTransport.state = "open";
+        wsTransport.emit("open");
+        // start handshake, but don't do anything
+
+        await waitsFor(function() {
+          return transports.sockjs.createConnection.calls.count() === 1;
+        }, "SockJS connection to be created", 3000);
+
+        sockjsTransport.state = "initialized";
+        sockjsTransport.emit("initialized");
+
+        await waitsFor(function() {
+          return sockjsTransport.connect.calls.count() === 1;
+        }, "connect on SockJS to be called", 500);
+
+        sockjsTransport.state = "open";
+        sockjsTransport.emit("open");
+        sockjsTransport.emit("message", {
+          data: JSON.stringify({
+            event: "pusher:connection_established",
+            data: {
+              socket_id: "123.456",
+              activity_timeout: 120
+            }
+          })
+        });
+
+        await waitsFor(function() {
+          return wsTransport.close.calls.count() === 1;
+        }, "close on WS to be called", 500);
+
+        var timer;
+        // this caused a connection to be retried after 1s
+        wsTransport.emit("closed", {
+          code: 1000,
+          wasClean: true,
+          reason: "clean"
+        });
+        timer = new OneOffTimer(2000, function() {});
+
+        await waitsFor(function() {
+          return !timer.isRunning();
+        }, "timer to be called", 2500);
+
+        expect(sockjsTransport.close).not.toHaveBeenCalled();
+      });
+    }
+  });
+}

package/spec/javascripts/integration/core/pusher_spec/index.js

@@ -0,0 +1,68 @@
+var Pusher = require('pusher_integration');
+var TestEnv = require('testenv');
+
+if (TestEnv === "web") {
+  window.Pusher = Pusher;
+  var DependencyLoader = require('dom/dependency_loader').default;
+  var DependenciesReceivers = require('dom/dependencies').DependenciesReceivers;
+  var Dependencies = require('dom/dependencies').Dependencies;
+}
+
+var Integration = require("integration");
+var util = require("core/util").default;
+var Timer = require("core/utils/timers").OneOffTimer;
+var Collections = require('core/utils/collections');
+var Defaults = require('core/defaults').default;
+var Runtime = require('runtime').default;
+var integrationTestBuilder = require('./test_builder')
+
+module.exports = function(testConfigs) {
+  Integration.describe("Pusher", function() {
+    // Integration tests in Jasmine need to have setup and teardown phases as
+    // separate specs to make sure we share connections between actual specs.
+    // This way we can also make sure connections are closed even when tests fail.
+    //
+    // Ideally, we'd have a separate connection per spec, but this introduces
+    // significant delays and triggers security mechanisms in some browsers.
+
+    var _VERSION;
+    var _authTransport;
+    var _authEndpoint;
+    var _Dependencies;
+
+    it("should prepare the global config", function() {
+      // TODO fix how versions work in unit tests
+      _VERSION = Defaults.VERSION;
+      _authTransport = Defaults.authTransport;
+      _authEndpoint = Defaults.authEndpoint;
+      _Dependencies = Dependencies;
+
+      Defaults.VERSION = "8.8.8";
+      Defaults.authTransport = (TestEnv === 'web') ? 'jsonp' : 'ajax';
+      Defaults.authEndpoint = Integration.API_URL + "/auth";
+
+      if (TestEnv === "web") {
+        Dependencies = new DependencyLoader({
+          cdn_http: Integration.JS_HOST,
+          cdn_https: Integration.JS_HOST,
+          version: Defaults.VERSION,
+          suffix: "",
+          receivers: DependenciesReceivers
+        });
+      }
+    });
+
+    for (testConfig of testConfigs) {
+      integrationTestBuilder.build(testConfig)
+    }
+
+
+    it("should restore the global config", function() {
+      Dependencies = _Dependencies;
+      Defaults.authEndpoint = _authEndpoint;
+      Defaults.authTransport = _authTransport;
+      Defaults.VERSION = _VERSION;
+    });
+  });
+}
+