@cendarsoss/pusher-js 8.4.11

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

@@ -0,0 +1,200 @@
+var Pusher = require('pusher_integration');
+var TestEnv = require('testenv');
+
+if (TestEnv === "web") window.Pusher = Pusher;
+
+var Integration = require("integration");
+var Mocks = require("mocks");
+var Network = require("net_info").Network;
+var util = require("core/util").default;
+var Runtime = require('runtime').default;
+var transports = Runtime.Transports;
+var Defaults = require('core/defaults').default;
+
+if (TestEnv == "web") {
+  var BASE_FALLBACK = "sockjs"
+} else {
+  var BASE_FALLBACK = "xhr_polling"
+}
+
+module.exports = function() {
+  Integration.describe("Timeout Configuration", function() {
+    var transport;
+    var pusher;
+
+    beforeEach(function() {
+      jasmine.clock().uninstall();
+      jasmine.clock().install();
+
+      spyOn(Network, "isOnline").and.returnValue(true);
+
+      spyOn(transports.ws, "isSupported").and.returnValue(true);
+      spyOn(transports[BASE_FALLBACK], "isSupported").and.returnValue(false);
+
+      spyOn(Runtime, "getLocalStorage").and.returnValue({});
+
+      spyOn(transports.ws, "createConnection").and.callFake(function() {
+        transport = Mocks.getTransport(true);
+        transport.supportsPing.and.returnValue(false);
+        return transport;
+      });
+    });
+
+    afterEach(function() {
+      pusher.disconnect();
+      jasmine.clock().uninstall();
+    });
+
+    it("should transition to unavailable after default timeout", function() {
+      var onUnavailable = jasmine.createSpy("onUnavailable");
+
+      pusher = new Pusher("foobar", {cluster: "mt1"});
+      pusher.connect();
+      pusher.connection.bind("unavailable", onUnavailable);
+
+      jasmine.clock().tick(Defaults.unavailableTimeout - 1);
+      expect(onUnavailable).not.toHaveBeenCalled();
+      jasmine.clock().tick(1);
+      expect(onUnavailable).toHaveBeenCalled();
+    });
+
+    it("should transition to unavailable after timeout passed as an option", function() {
+      var onUnavailable = jasmine.createSpy("onUnavailable");
+
+      pusher = new Pusher("foobar", { cluster: "mt1", unavailableTimeout: 2345 });
+      pusher.connect();
+      pusher.connection.bind("unavailable", onUnavailable);
+
+      jasmine.clock().tick(2344);
+      expect(onUnavailable).not.toHaveBeenCalled();
+      jasmine.clock().tick(1);
+      expect(onUnavailable).toHaveBeenCalled();
+    });
+
+    it("should obey the server's activity timeout and the default pong timeout", function() {
+      pusher = new Pusher("foobar", { cluster: "mt1" });
+      pusher.connect();
+
+      var firstTransport = transport;
+
+      firstTransport.state = "initialized";
+      firstTransport.emit("initialized");
+      firstTransport.state = "open";
+      firstTransport.emit("open");
+      firstTransport.emit("message", {
+        data: JSON.stringify({
+          event: "pusher:connection_established",
+          data: {
+            socket_id: "123.456",
+            activity_timeout: 12
+          }
+        })
+      });
+
+      expect(pusher.connection.state).toEqual("connected");
+      jasmine.clock().tick(12000 - 1);
+      expect(firstTransport.send).not.toHaveBeenCalled();
+      jasmine.clock().tick(1);
+      expect(firstTransport.send).toHaveBeenCalled();
+
+      jasmine.clock().tick(Defaults.pongTimeout - 1);
+      expect(firstTransport.close).not.toHaveBeenCalled();
+      jasmine.clock().tick(2);
+      expect(firstTransport.close).toHaveBeenCalled();
+    });
+
+    it("should obey the activity timeout from the handshake if it's lower than one specified in options", function() {
+      pusher = new Pusher("foobar", {
+        cluster: "mt1",
+        activityTimeout: 16000,
+        pongTimeout: 2222
+      });
+      pusher.connect();
+
+      var firstTransport = transport;
+
+      firstTransport.state = "initialized";
+      firstTransport.emit("initialized");
+      firstTransport.state = "open";
+      firstTransport.emit("open");
+      firstTransport.emit("message", {
+        data: JSON.stringify({
+          event: "pusher:connection_established",
+          data: {
+            socket_id: "123.456",
+            activity_timeout: 15
+          }
+        })
+      });
+
+      expect(pusher.connection.state).toEqual("connected");
+      jasmine.clock().tick(15000 - 1);
+      expect(firstTransport.send).not.toHaveBeenCalled();
+      jasmine.clock().tick(1);
+      expect(firstTransport.send).toHaveBeenCalled();
+    });
+
+    it("should obey the activity timeout specified in options if it's lower than one from the handshake", function() {
+      pusher = new Pusher("foobar", {
+        cluster: "mt1",
+        activityTimeout: 15555,
+        pongTimeout: 2222
+      });
+      pusher.connect();
+
+      var firstTransport = transport;
+
+      firstTransport.state = "initialized";
+      firstTransport.emit("initialized");
+      firstTransport.state = "open";
+      firstTransport.emit("open");
+      firstTransport.emit("message", {
+        data: JSON.stringify({
+          event: "pusher:connection_established",
+          data: {
+            socket_id: "123.456",
+            activity_timeout: 17
+          }
+        })
+      });
+
+      expect(pusher.connection.state).toEqual("connected");
+      jasmine.clock().tick(15555 - 1);
+      expect(firstTransport.send).not.toHaveBeenCalled();
+      jasmine.clock().tick(1);
+      expect(firstTransport.send).toHaveBeenCalled();
+    });
+
+    it("should obey the pong timeout passed in options", function() {
+      pusher = new Pusher("foobar", {
+        cluster: "mt1",
+        pongTimeout: 2222
+      });
+      pusher.connect();
+
+      var firstTransport = transport;
+
+      firstTransport.state = "initialized";
+      firstTransport.emit("initialized");
+      firstTransport.state = "open";
+      firstTransport.emit("open");
+      firstTransport.emit("message", {
+        data: JSON.stringify({
+          event: "pusher:connection_established",
+          data: {
+            socket_id: "123.456",
+            activity_timeout: 120
+          }
+        })
+      });
+
+      // first, send the ping
+      jasmine.clock().tick(120000);
+      // wait for the pong timeout
+      jasmine.clock().tick(2221);
+      expect(firstTransport.close).not.toHaveBeenCalled();
+      jasmine.clock().tick(2);
+      expect(firstTransport.close).toHaveBeenCalled();
+    });
+  });
+}

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

@@ -0,0 +1,103 @@
+var TestEnv = require('testenv');
+var Pusher = require('pusher_integration');
+if (TestEnv === "web") window.Pusher = Pusher;
+var Integration = require("integration");
+var Mocks = require("mocks");
+var Runtime = require('runtime').default;
+var Network = require("net_info").Network;
+var defineTransport = require('core/strategies/strategy_builder').defineTransport;
+var BestConnectedEverStrategy = require('core/strategies/best_connected_ever_strategy').default;
+var transports = Runtime.Transports;
+
+if (TestEnv == "web") {
+  var BASE_FALLBACK = "sockjs"
+} else {
+  var BASE_FALLBACK = "xhr_polling"
+}
+
+module.exports = function() {
+  Integration.describe("Transport lists", function() {
+    var _isReady = Pusher.isReady;
+
+    beforeEach(function() {
+      spyOn(transports.ws, "isSupported").and.returnValue(true);
+      spyOn(transports.xhr_streaming, "isSupported").and.returnValue(true);
+      spyOn(transports[BASE_FALLBACK], "isSupported").and.returnValue(true);
+
+      spyOn(transports.ws, "createConnection")
+        .and.callFake(Mocks.getTransport);
+      spyOn(transports.xhr_streaming, "createConnection")
+        .and.callFake(Mocks.getTransport);
+      spyOn(transports[BASE_FALLBACK], "createConnection")
+        .and.callFake(Mocks.getTransport);
+
+      spyOn(Runtime, "getDefaultStrategy").and.callFake(function(config) {
+        return new BestConnectedEverStrategy([
+          defineTransport(config, 'a', 'ws', 1, {}),
+          defineTransport(config, 'b', 'xhr_streaming', 2, {}),
+          defineTransport(config, 'c', BASE_FALLBACK, 3, {}),
+        ]);
+      });
+
+      spyOn(Network, "isOnline").and.returnValue(true);
+      Pusher.isReady = true;
+    });
+
+    afterEach(function() {
+      Pusher.isReady = _isReady;
+    });
+
+    it("should use all transports if the whitelist is not specified", function() {
+      var pusher = new Pusher("asdf", {cluster: "mt1"});
+      expect(transports.ws.createConnection).toHaveBeenCalled();
+      expect(transports.xhr_streaming.createConnection).toHaveBeenCalled();
+      expect(transports[BASE_FALLBACK].createConnection).toHaveBeenCalled();
+      pusher.disconnect();
+    });
+
+    it("should not use any transports if the whitelist is empty", function() {
+      var pusher = new Pusher("asdf", {
+        cluster: "mt1",
+        enabledTransports: []
+      });
+      expect(transports.ws.createConnection).not.toHaveBeenCalled();
+      expect(transports.xhr_streaming.createConnection).not.toHaveBeenCalled();
+      expect(transports[BASE_FALLBACK].createConnection).not.toHaveBeenCalled();
+      pusher.disconnect();
+    });
+
+    it("should use only transports from the whitelist", function() {
+      var pusher = new Pusher("asdf", {
+        cluster: "mt1",
+        enabledTransports: ["a", "c"]
+      });
+      expect(transports.ws.createConnection).toHaveBeenCalled();
+      expect(transports.xhr_streaming.createConnection).not.toHaveBeenCalled();
+      expect(transports[BASE_FALLBACK].createConnection).toHaveBeenCalled();
+      pusher.disconnect();
+    });
+
+    it("should not use transports from the blacklist", function() {
+      var pusher = new Pusher("asdf", {
+        cluster: "mt1",
+        disabledTransports: ["a", "b"]
+      });
+      expect(transports.ws.createConnection).not.toHaveBeenCalled();
+      expect(transports.xhr_streaming.createConnection).not.toHaveBeenCalled();
+      expect(transports[BASE_FALLBACK].createConnection).toHaveBeenCalled();
+      pusher.disconnect();
+    });
+
+    it("should not use transports from the blacklist, even if they are on the whitelist", function() {
+      var pusher = new Pusher("asdf", {
+        cluster: "mt1",
+        enabledTransports: ["b", "c"],
+        disabledTransports: ["b"]
+      });
+      expect(transports.ws.createConnection).not.toHaveBeenCalled();
+      expect(transports.xhr_streaming.createConnection).not.toHaveBeenCalled();
+      expect(transports[BASE_FALLBACK].createConnection).toHaveBeenCalled();
+      pusher.disconnect();
+    });
+  });
+}

package/spec/javascripts/integration/index.node.js

@@ -0,0 +1,12 @@
+var sharedTestsContext = require.context("./core", true, /_spec$/);
+var testConfigs = [{
+  transport: "ws",
+  forceTLS: true,
+},{
+  transport: "ws",
+  forceTLS: false,
+}];
+
+sharedTestsContext.keys().forEach((key) => {
+  sharedTestsContext(key)(testConfigs);
+})

package/spec/javascripts/integration/index.web.js

@@ -0,0 +1,63 @@
+// the webpack context API uses Object.keys and Array.prototype.forEach
+// both of which are unavailable in old versions of IE.
+require('../polyfills');
+
+// there are some circular dependencies and there are type errors when requiring
+// runtime before core/pusher
+require('core/pusher');
+
+var Runtime = require('runtime').default;
+var TestEnv = require('testenv');
+
+var testConfigs = getTestConfigs();
+
+// We can access this 'env var' here because there's a webpack.DefinePlugin
+// overwriting this value with whatever is set at compile time
+if (process.env.MINIMAL_INTEGRATION_TESTS) {
+  testConfigs = testConfigs.filter((config) => config.forceTLS && config.transport === "ws")
+}
+
+var sharedTestsContext = require.context("./core", true, /_spec$/);
+sharedTestsContext.keys().forEach((key) => {
+  sharedTestsContext(key)(testConfigs);
+});
+
+var webTestsContext = require.context("./web", true, /_spec$/);
+webTestsContext.keys().forEach(webTestsContext);
+
+function getTestConfigs() {
+  var testConfigs = [{
+    transport: "ws",
+    forceTLS: true,
+  },{
+    transport: "ws",
+    forceTLS: false,
+  }];
+
+  if (Runtime.isXHRSupported()) {
+    // CORS-compatible browsers
+    if (TestEnv !== "web" || !/Android 2\./i.test(navigator.userAgent)) {
+      testConfigs.push({ transport: "xhr_streaming", forceTLS: true})
+      testConfigs.push({ transport: "xhr_streaming", forceTLS: false})
+    }
+    testConfigs.push({transport: "xhr_polling", forceTLS: true})
+    testConfigs.push({transport: "xhr_polling", forceTLS: false})
+
+  } else if (Runtime.isXDRSupported(false)) {
+
+    testConfigs.push({transport: "xdr_streaming", forceTLS: true})
+    testConfigs.push({transport: "xdr_streaming", forceTLS: false})
+    testConfigs.push({transport: "xdr_polling", forceTLS: true})
+    testConfigs.push({transport: "xdr_polling", forceTLS: false})
+
+    // IE can fall back to SockJS if protocols don't match
+    // No SockJS TLS tests due to the way JS files are served
+    testConfigs.push({transport: "sockjs", forceTLS: false})
+
+  } else {
+    // Browsers using SockJS
+    testConfigs.push({ transport: "sockjs", forceTLS: true})
+    testConfigs.push({ transport: "sockjs", forceTLS: false})
+  }
+  return testConfigs
+}

package/spec/javascripts/integration/index.worker.js

@@ -0,0 +1,13 @@
+var sharedTestsContext = require.context("./core", true, /_spec$/);
+var testConfigs = [{
+  transport: "ws",
+  forceTLS: true,
+},{
+  transport: "ws",
+  forceTLS: false,
+}];
+
+
+sharedTestsContext.keys().forEach((key) => {
+  sharedTestsContext(key)(testConfigs);
+})

package/spec/javascripts/integration/web/dom/jsonp_spec.js

@@ -0,0 +1,97 @@
+const Pusher = require('pusher_integration');
+window.Pusher = Pusher;
+
+const Integration = require('integration');
+const JSONPRequest = require('dom/jsonp_request').default;
+const waitsFor = require('../../../helpers/waitsFor');
+
+Integration.describe("JSONP", function() {
+  it("should send a request and receive a correct response", async function() {
+    var callback = jasmine.createSpy();
+    var receiver = Pusher.ScriptReceivers.create(callback);
+    var url = Integration.API_URL + "/v2/jsonp/echo";
+    var request;
+
+    request = new JSONPRequest(url, {
+      "session": 2289545,
+      "features": ["ws", "sockjs"],
+      "version": "1.13.0",
+      "t0": 1355850357911,
+      "timeline": [
+        { t:    0, e: 2 },
+        { t:    2, e: 2, type: "ws" },
+        { t: 1001, e: 4, type: "ws" },
+        { t: 1001, e: 0, type: "sockjs" },
+        { t: 2000, e: 5 },
+        { t: 2158, e: 1, type: "sockjs" },
+        { t: 2378, e: 2, type: "sockjs" },
+        { t: 3892, e: 3, type: "sockjs" },
+        { t: 3892, e: 3 }
+      ]
+    });
+    request.send(receiver);
+
+    await waitsFor(function() {
+      return callback.calls.count() > 0;
+    }, "JSONP to respond", 5000);
+
+    expect(callback.calls.count()).toEqual(1);
+    expect(callback).toHaveBeenCalledWith(null, {
+      "session": 2289545,
+      "features": ["ws", "sockjs"],
+      "version": "1.13.0",
+      "t0": 1355850357911,
+      "timeline": [
+        { t:    0, e: 2 },
+        { t:    2, e: 2, type: "ws" },
+        { t: 1001, e: 4, type: "ws" },
+        { t: 1001, e: 0, type: "sockjs" },
+        { t: 2000, e: 5 },
+        { t: 2158, e: 1, type: "sockjs" },
+        { t: 2378, e: 2, type: "sockjs" },
+        { t: 3892, e: 3, type: "sockjs" },
+        { t: 3892, e: 3 }
+      ]
+    });
+
+    request.cleanup()
+  });
+
+  it("should call back without a result on 404 response", async function() {
+    var callback = jasmine.createSpy();
+    var receiver = Pusher.ScriptReceivers.create(callback);
+    var url = Integration.API_URL + "/jsonp/404";
+    var request;
+
+    request = new JSONPRequest(url, {});
+    request.send(receiver);
+
+    await waitsFor(function() {
+      return callback.calls.count() > 0;
+    }, "JSONP to respond", 5000);
+
+    expect(callback.calls.count()).toEqual(1);
+    expect(callback.calls.first().args[1]).toBe(undefined);
+
+    request.cleanup();
+  });
+
+  it("should call back without a result on 500 response", async function() {
+    var callback = jasmine.createSpy();
+    var receiver = Pusher.ScriptReceivers.create(callback);
+    var url = Integration.API_URL + "/jsonp/500";
+    var request;
+
+    request = new JSONPRequest(url, {});
+    request.send(receiver);
+
+    await waitsFor(function() {
+      return callback.calls.count() > 0;
+    }, "JSONP to respond", 5000);
+
+    expect(callback.calls.count()).toEqual(1);
+    expect(callback.calls.first().args[1]).toBe(undefined);
+
+    request.cleanup();
+  });
+});

package/spec/javascripts/integration/web/dom/script_request_spec.js

@@ -0,0 +1,90 @@
+const Pusher = require('pusher_integration');
+window.Pusher = Pusher;
+
+const Integration = require('integration');
+const ScriptRequest = require('dom/script_request').default;
+const waitsFor = require('../../../helpers/waitsFor');
+
+Integration.describe("ScriptRequest", function() {
+  var callback, receiver;
+  var query, url;
+  var request;
+  var ScriptReceivers;
+
+  beforeEach(function() {
+    callback = jasmine.createSpy();
+    receiver = Pusher.Integration.ScriptReceivers.create(callback);
+    query = "receiver=" + receiver.name + "&param=test";
+    url = Integration.API_URL + "/v2/script_request/echo?" + query;
+    request = new ScriptRequest(url);
+  });
+
+  afterEach(function(){
+    request.cleanup();
+  });
+
+  it("should send a request and receive a correct response", async function() {
+    request.send(receiver);
+
+    await waitsFor(function() {
+      return callback.calls.count() > 0;
+    }, "endpoint to respond", 5000);
+
+    expect(callback.calls.count()).toEqual(1);
+    expect(callback).toHaveBeenCalledWith(null, { param: "test" });
+  });
+
+  it("should allow cleaning up", async function() {
+    var callback = jasmine.createSpy();
+    var receiver = Pusher.Integration.ScriptReceivers.create(callback);
+    var query = "receiver=" + receiver.name;
+    var url = Integration.API_URL + "/v2/script_request/echo?" + query;
+
+    var request = new ScriptRequest(url);
+
+    expect(document.getElementById(receiver.id)).toBe(null);
+    expect(document.getElementById(receiver.id + "_error")).toBe(null);
+    request.send(receiver);
+    // we don't test for the _error tag, because it's Opera-specific
+    expect(document.getElementById(receiver.id)).not.toBe(null);
+
+    await waitsFor(function() {
+      return callback.calls.count() > 0;
+    }, "endpoint to respond", 5000);
+
+    expect(document.getElementById(receiver.id)).not.toBe(null);
+    request.cleanup();
+    expect(document.getElementById(receiver.id)).toBe(null);
+    expect(document.getElementById(receiver.id + "_error")).toBe(null);
+  });
+
+  it("should call back without result on a 404 response", async function() {
+    var url = Integration.API_URL + "/jsonp/404/" + receiver.number;
+    var request = new ScriptRequest(url);
+
+    request.send(receiver);
+
+    await waitsFor(function() {
+      return callback.calls.count() > 0;
+    }, "endpoint to respond", 5000);
+
+    expect(callback.calls.count()).toEqual(1);
+    expect(callback.calls.first().args[1]).toBe(undefined);
+    request.cleanup();
+  });
+
+  it("should call back without result on a 500 response", async function() {
+    var url = Integration.API_URL + "/jsonp/500/" + receiver.number;
+    var request = new ScriptRequest(url);
+
+    request.send(receiver);
+
+    await waitsFor(function() {
+      return callback.calls.count() > 0;
+    }, "endpoint to respond", 5000);
+
+    expect(callback.calls.count()).toEqual(1);
+    expect(callback.calls.first().args[1]).toBe(undefined);
+    request.cleanup();
+  });
+});

package/spec/javascripts/polyfills/index.js

@@ -0,0 +1,105 @@
+// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys
+if (!Object.keys) {
+  Object.keys = (function() {
+    'use strict';
+    var hasOwnProperty = Object.prototype.hasOwnProperty,
+        hasDontEnumBug = !({ toString: null }).propertyIsEnumerable('toString'),
+        dontEnums = [
+          'toString',
+          'toLocaleString',
+          'valueOf',
+          'hasOwnProperty',
+          'isPrototypeOf',
+          'propertyIsEnumerable',
+          'constructor'
+        ],
+        dontEnumsLength = dontEnums.length;
+
+    return function(obj) {
+      if (typeof obj !== 'object' && (typeof obj !== 'function' || obj === null)) {
+        throw new TypeError('Object.keys called on non-object');
+      }
+
+      var result = [], prop, i;
+
+      for (prop in obj) {
+        if (hasOwnProperty.call(obj, prop)) {
+          result.push(prop);
+        }
+      }
+
+      if (hasDontEnumBug) {
+        for (i = 0; i < dontEnumsLength; i++) {
+          if (hasOwnProperty.call(obj, dontEnums[i])) {
+            result.push(dontEnums[i]);
+          }
+        }
+      }
+      return result;
+    };
+  }());
+}
+
+// Production steps of ECMA-262, Edition 5, 15.4.4.18
+// Reference: http://es5.github.io/#x15.4.4.18
+if (!Array.prototype.forEach) {
+
+  Array.prototype.forEach = function(callback, thisArg) {
+
+    var T, k;
+
+    if (this == null) {
+      throw new TypeError(' this is null or not defined');
+    }
+
+    // 1. Let O be the result of calling toObject() passing the
+    // |this| value as the argument.
+    var O = Object(this);
+
+    // 2. Let lenValue be the result of calling the Get() internal
+    // method of O with the argument "length".
+    // 3. Let len be toUint32(lenValue).
+    var len = O.length >>> 0;
+
+    // 4. If isCallable(callback) is false, throw a TypeError
+    // exception. // See: http://es5.github.com/#x9.11
+    if (typeof callback !== "function") {
+      throw new TypeError(callback + ' is not a function');
+    }
+
+    // 5. If thisArg was supplied, let T be thisArg; else let
+    // T be undefined.
+    if (arguments.length > 1) {
+      T = thisArg;
+    }
+
+    // 6. Let k be 0
+    k = 0;
+
+    // 7. Repeat, while k < len
+    while (k < len) {
+
+      var kValue;
+
+      // a. Let Pk be ToString(k).
+      //    This is implicit for LHS operands of the in operator
+      // b. Let kPresent be the result of calling the HasProperty
+      //    internal method of O with argument Pk.
+      //    This step can be combined with c
+      // c. If kPresent is true, then
+      if (k in O) {
+
+        // i. Let kValue be the result of calling the Get internal
+        // method of O with argument Pk.
+        kValue = O[k];
+
+        // ii. Call the Call internal method of callback with T as
+        // the this value and argument list containing kValue, k, and O.
+        callback.call(T, kValue, k, O);
+      }
+      // d. Increase k by 1.
+      k++;
+    }
+    // 8. return undefined
+  };
+}