pusher-js 7.0.6 → 7.2.0

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

@@ -46,13 +46,6 @@ describe('Config', function() {
       pongTimeout: 123,
       activityTimeout: 345,
       ignoreNullOrigin: true,
-      authorizer: () => {},
-      authTransport: 'some-auth-transport',
-      authEndpoint: '/pusher/spec/auth',
-      auth: {
-        params: { spec: 'param' },
-        headers: { spec: 'header' }
-      },
       wsHost: 'ws-spec.pusher.com',
       wsPort: 2020,
       wssPort: 2021,
@@ -68,6 +61,313 @@ describe('Config', function() {
     }
   });
 
+  describe('auth', function(){
+    let _getAuthorizers;
+    let transportAuthorizer;
+    let transportAuthorizer2;
+    let transportAuthorizerAjax;
+
+    beforeAll(function() {
+      _getAuthorizers = Runtime.getAuthorizers;
+    });
+
+    afterAll(function() {
+      Runtime.getAuthorizers = _getAuthorizers;
+    });
+
+    beforeEach(function() {
+      transportAuthorizer = jasmine.createSpy("some-auth-transport")
+      transportAuthorizer2 = jasmine.createSpy("some-auth-transport2")
+      transportAuthorizerAjax = jasmine.createSpy("ajax")
+      Runtime.getAuthorizers = jasmine.createSpy("getAuthorizers").and.returnValue({
+        'some-auth-transport': transportAuthorizer,
+        'some-auth-transport2': transportAuthorizer2,
+
+        // When we test channelAuthorizer, the userAuthenticator will be using
+        // the default ajax transport and vice versa.
+        'ajax': transportAuthorizerAjax,
+      });
+    });
+
+    it('should use deprecated auth options', function() {
+      let opts = {
+        authTransport: 'some-auth-transport',
+        authEndpoint: '/pusher/spec/auth',
+        auth: {
+          params: { foo: 'bar' },
+          headers: { spec: 'header' }
+        },
+      };
+      const pusher = {};
+      let config = Config.getConfig(opts, pusher);
+
+      let callback = function(){};
+      config.channelAuthorizer({
+        socketId: '1.23',
+        channelName: 'private-test',
+      }, callback);
+
+      authOptions = {
+        transport: 'some-auth-transport',
+        endpoint: '/pusher/spec/auth',
+        params: { foo: 'bar' },
+        headers: { spec: 'header' }
+      }
+      const query = 'socket_id=1.23&channel_name=private-test&foo=bar';
+      expect(transportAuthorizer.calls.count()).toEqual(1);
+      expect(transportAuthorizer).toHaveBeenCalledWith(
+        Runtime,
+        query,
+        authOptions,
+        "channel-authorization",
+        callback
+      );
+    })
+
+    it('should create ChannelAuthorizerProxy if authorizer is set', function() {
+      const authorizer = { authorize: jasmine.createSpy('authorize') };
+      const authorizerGenerator = jasmine.createSpy('authorizerGenerator').and.returnValue(authorizer);
+      let opts = {
+        authorizer: authorizerGenerator,
+        authTransport: 'some-auth-transport',
+        authEndpoint: '/pusher/spec/auth',
+        auth: {
+          params: { spec: 'param' },
+          headers: { spec: 'header' }
+        },
+      };
+      const channel = {name: 'private-test'};
+      const pusher = { channel: jasmine.createSpy('channel').and.returnValue(channel) };
+      let config = Config.getConfig(opts, pusher);
+
+      const callback = function(){};
+      config.channelAuthorizer({
+        socketId: '1.23',
+        channelName: 'private-test',
+      }, callback);
+      expect(authorizerGenerator).toHaveBeenCalledWith(channel, {
+        authTransport: 'some-auth-transport',
+        authEndpoint: '/pusher/spec/auth',
+        auth: {
+          params: { spec: 'param' },
+          headers: { spec: 'header' }
+        },
+      })
+      expect(authorizer.authorize).toHaveBeenCalledWith('1.23', callback);
+    });
+
+    it('should use channelAuthorization and override deprecated auth options', function() {
+      let opts = {
+        authTransport: 'some-auth-transport',
+        authEndpoint: '/pusher/spec/auth',
+        auth: {
+          params: { foo: 'bar' },
+          headers: { spec: 'header' }
+        },
+        channelAuthorization: {
+          transport: 'some-auth-transport2',
+          endpoint: '/pusher/spec/auth2',
+          params: { spec2: 'param2' },
+          headers: { spec2: 'header2' }
+        }
+      };
+      const pusher = {};
+      let config = Config.getConfig(opts, pusher);
+      let callback = function(){};
+      config.channelAuthorizer({
+        socketId: '1.23',
+        channelName: 'private-test',
+      }, callback);
+
+      console.log(config);
+      authOptions = {
+        transport: 'some-auth-transport2',
+        endpoint: '/pusher/spec/auth2',
+        params: { spec2: 'param2' },
+        headers: { spec2: 'header2' }
+      }
+      const query = 'socket_id=1.23&channel_name=private-test&spec2=param2';
+      expect(transportAuthorizer.calls.count()).toEqual(0);
+      expect(transportAuthorizer2.calls.count()).toEqual(1);
+      expect(transportAuthorizer2).toHaveBeenCalledWith(
+        Runtime,
+        query,
+        authOptions,
+        "channel-authorization",
+        callback
+      );
+    });
+
+    it('should use default transport when not provided in channelAuthorization', function() {
+      let opts = {
+        authEndpoint: '/pusher/spec/auth',
+        auth: {
+          params: { foo: 'bar' },
+          headers: { spec: 'header' }
+        },
+        channelAuthorization: {
+          endpoint: '/pusher/spec/auth2',
+          params: { spec2: 'param2' },
+          headers: { spec2: 'header2' }
+        }
+      };
+      const pusher = {};
+      let config = Config.getConfig(opts, pusher);
+      let callback = function(){};
+      config.channelAuthorizer({
+        socketId: '1.23',
+        channelName: 'private-test',
+      }, callback);
+
+      authOptions = {
+        transport: 'ajax',
+        endpoint: '/pusher/spec/auth2',
+        params: { spec2: 'param2' },
+        headers: { spec2: 'header2' }
+      }
+      const query = 'socket_id=1.23&channel_name=private-test&spec2=param2';
+      expect(transportAuthorizer.calls.count()).toEqual(0);
+      expect(transportAuthorizer2.calls.count()).toEqual(0);
+      expect(transportAuthorizerAjax.calls.count()).toEqual(1);
+      expect(transportAuthorizerAjax).toHaveBeenCalledWith(
+        Runtime,
+        query,
+        authOptions,
+        "channel-authorization",
+        callback
+      );
+    });
+
+
+    it('should use customerHandler inside channelAuthorization', function() {
+      const customHandler = jasmine.createSpy('customHandler');
+      let opts = {
+        channelAuthorization: {
+          transport: 'some-auth-transport',
+          endpoint: '/pusher/spec/auth',
+          params: { spec: 'param' },
+          headers: { spec: 'header' },
+          customHandler: customHandler
+        }
+      };
+
+      const pusher = {};
+      let config = Config.getConfig(opts, pusher);
+      expect(config.channelAuthorizer).toEqual(customHandler);
+    });
+
+    it('should have default options for user authentication', function() {
+      let opts = {};
+
+      const pusher = {};
+      let config = Config.getConfig(opts, pusher);
+      let callback = function(){};
+      config.userAuthenticator({
+        socketId: '1.23',
+      }, callback);
+
+      authOptions = {
+        transport: 'ajax',
+        endpoint: '/pusher/user-auth',
+      }
+      const query = 'socket_id=1.23';
+      expect(transportAuthorizerAjax.calls.count()).toEqual(1);
+      expect(transportAuthorizerAjax).toHaveBeenCalledWith(
+        Runtime,
+        query,
+        authOptions,
+        "user-authentication",
+        callback
+      );
+    });
+
+    it('should use userAuthentication options for user authentication', function() {
+      let opts = {
+        userAuthentication: {
+          transport: 'some-auth-transport',
+          endpoint: '/pusher/spec/auth',
+          params: { foo: 'bar' },
+          headers: { spec: 'header' }
+        }
+      };
+
+      const pusher = {};
+      let config = Config.getConfig(opts, pusher);
+      let callback = function(){};
+      config.userAuthenticator({
+        socketId: '1.23',
+      }, callback);
+
+      authOptions = {
+        transport: 'some-auth-transport',
+        endpoint: '/pusher/spec/auth',
+        params: { foo: 'bar' },
+        headers: { spec: 'header' }
+      }
+      const query = 'socket_id=1.23&foo=bar';
+      expect(transportAuthorizer.calls.count()).toEqual(1);
+      expect(transportAuthorizer).toHaveBeenCalledWith(
+        Runtime,
+        query,
+        authOptions,
+        "user-authentication",
+        callback
+      );
+    });
+
+    it('should use default transport when not provided in userAuthentication', function() {
+      let opts = {
+        userAuthentication: {
+          endpoint: '/pusher/spec/auth',
+          params: { foo: 'bar' },
+          headers: { spec: 'header' }
+        }
+      };
+
+      const pusher = {};
+      let config = Config.getConfig(opts, pusher);
+      let callback = function(){};
+      config.userAuthenticator({
+        socketId: '1.23',
+      }, callback);
+
+      authOptions = {
+        transport: 'ajax',
+        endpoint: '/pusher/spec/auth',
+        params: { foo: 'bar' },
+        headers: { spec: 'header' }
+      }
+      const query = 'socket_id=1.23&foo=bar';
+      expect(transportAuthorizer.calls.count()).toEqual(0);
+      expect(transportAuthorizer2.calls.count()).toEqual(0);
+      expect(transportAuthorizerAjax.calls.count()).toEqual(1);
+      expect(transportAuthorizerAjax).toHaveBeenCalledWith(
+        Runtime,
+        query,
+        authOptions,
+        "user-authentication",
+        callback
+      );
+    });
+
+    it('should use customHandler inside userAuthentication', function() {
+      const customHandler = jasmine.createSpy('customHandler');
+      let opts = {
+        userAuthentication: {
+          transport: 'some-auth-transport',
+          endpoint: '/pusher/spec/auth',
+          params: { spec: 'param' },
+          headers: { spec: 'header' },
+          customHandler: customHandler
+        }
+      };
+
+      const pusher = {};
+      let config = Config.getConfig(opts, pusher);
+      expect(config.userAuthenticator).toEqual(customHandler);
+    });
+  });
+
   describe('TLS', function() {
     it('should use TLS if forceTLS set', function() {
       let config = Config.getConfig({ forceTLS: true });

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

@@ -8,6 +8,7 @@ describe("ConnectionManager", function() {
   var managerOptions, manager;
 
   beforeAll(() => {
+    jasmine.clock().uninstall();
     jasmine.clock().install();
   });
 

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

@@ -15,6 +15,7 @@ describe("HTTP.Socket", function() {
 
   beforeEach(function() {
     HTTPFactory = require('runtime').default.HTTPFactory;
+    jasmine.clock().uninstall();
     jasmine.clock().install();
 
     spyOn(HTTPFactory, "createXHR").and.callFake(function(method, url) {

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

@@ -3,38 +3,34 @@ var Logger = require('core/logger').default;
 var global = Function("return this")();
 
 describe("Logger", function() {
-
-  var _nativeConsoleLog;
-  var _nativeConsoleWarn;
-  var _nativeConsoleError;
   var _consoleLogCalls;
   var _consoleWarnCalls;
   var _consoleErrorCalls;
 
+  var _nativeConsole;
+
   beforeEach(function() {
     _consoleLogCalls = [];
     _consoleWarnCalls = [];
     _consoleErrorCalls = [];
 
-    _nativeConsoleLog = global.console.log;
-    _nativeConsoleWarn = global.console.warn;
-    _nativeConsoleError = global.console.error;
-
-    global.console.log = function() {
-      _consoleLogCalls.push(arguments);
-    };
-    global.console.warn = function() {
-      _consoleWarnCalls.push(arguments);
-    };
-    global.console.error = function() {
-      _consoleErrorCalls.push(arguments);
-    };
+    _nativeConsole = global.console
+    global.console = {
+      log: function() {
+        _consoleLogCalls.push(arguments);
+      },
+      warn: function() {
+        _consoleWarnCalls.push(arguments);
+      },
+      error: function() {
+        _consoleErrorCalls.push(arguments);
+      },
+    }
+
   });
 
   afterEach(function() {
-    global.console.log = _nativeConsoleLog;
-    global.console.warn = _nativeConsoleWarn;
-    global.console.error = _nativeConsoleError;
+    global.console = _nativeConsole;
   });
 
   // logToConsole should be disabled by default
@@ -65,9 +61,14 @@ describe("Logger", function() {
   });
 
   describe("with logToConsole == true", function() {
+    var _defaultLogToConsole
     beforeEach(function() {
+      _defaultLogToConsole = Pusher.logToConsole;
       Pusher.logToConsole = true;
     })
+    afterEach(function() {
+      Pusher.logToConsole = _defaultLogToConsole;
+    })
 
     it("should log to the console", function() {
       Logger.debug("test", "this is a test");

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

@@ -1,14 +1,18 @@
-var TestEnv = require('testenv');
-var Util = require('core/util').default;
-var Collections = require('core/utils/collections');
-var Logger = require('core/logger').default;
-var Defaults = require('core/defaults').default;
-var DefaultConfig = require('core/config');
-var TimelineSender = require('core/timeline/timeline_sender').default;
-var Pusher = require('core/pusher').default;
-var Mocks = require('../../helpers/mocks');
-var Factory = require('core/utils/factory').default;
-var Runtime = require('runtime').default;
+var TestEnv = require("testenv");
+var Util = require("core/util").default;
+var Collections = require("core/utils/collections");
+var Logger = require("core/logger").default;
+var Defaults = require("core/defaults").default;
+var DefaultConfig = require("core/config");
+var TimelineSender = require("core/timeline/timeline_sender").default;
+var Pusher = require("core/pusher").default;
+var Mocks = require("../../helpers/mocks");
+var Factory = require("core/utils/factory").default;
+var Runtime = require("runtime").default;
+const transports = Runtime.Transports;
+const Network = require("net_info").Network;
+const waitsFor = require("../../helpers/waitsFor");
+var NetInfo = require("net_info").NetInfo;
 
 describe("Pusher", function() {
   var _isReady, _instances, _logToConsole;
@@ -20,9 +24,9 @@ describe("Pusher", function() {
       break;
     case "web":
       var timelineTransport = "jsonp";
-      break
+      break;
     default:
-      throw("Please specify the test environment as an external.")
+      throw "Please specify the test environment as an external.";
   }
 
   beforeEach(function() {
@@ -36,7 +40,11 @@ describe("Pusher", function() {
       return Mocks.getStrategy(true);
     });
 
-    spyOn(Factory, "createConnectionManager").and.callFake(function(key, options, config) {
+    spyOn(Factory, "createConnectionManager").and.callFake(function(
+      key,
+      options,
+      config
+    ) {
       var manager = Mocks.getConnectionManager();
       manager.key = key;
       manager.options = options;
@@ -64,11 +72,15 @@ describe("Pusher", function() {
 
   describe("app key validation", function() {
     it("should throw on a null key", function() {
-      expect(function() { new Pusher(null) }).toThrow("You must pass your app key when you instantiate Pusher.");
+      expect(function() {
+        new Pusher(null);
+      }).toThrow("You must pass your app key when you instantiate Pusher.");
     });
 
     it("should throw on an undefined key", function() {
-      expect(function() { new Pusher() }).toThrow("You must pass your app key when you instantiate Pusher.");
+      expect(function() {
+        new Pusher();
+      }).toThrow("You must pass your app key when you instantiate Pusher.");
     });
 
     it("should allow a hex key", function() {
@@ -85,8 +97,10 @@ describe("Pusher", function() {
 
     it("should not warn if no cluster is supplied if wsHost or httpHost are supplied", function() {
       spyOn(Logger, "warn");
-      var wsPusher = new Pusher("1234567890abcdef", { wsHost: 'example.com' });
-      var httpPusher = new Pusher("1234567890abcdef", { httpHost: 'example.com' });
+      var wsPusher = new Pusher("1234567890abcdef", { wsHost: "example.com" });
+      var httpPusher = new Pusher("1234567890abcdef", {
+        httpHost: "example.com"
+      });
       expect(Logger.warn).not.toHaveBeenCalled();
       expect(Logger.warn).not.toHaveBeenCalled();
     });
@@ -147,7 +161,7 @@ describe("Pusher", function() {
         expect(pusher.shouldUseTLS()).toBe(true);
       });
 
-      it("should be off when 'forceTLS' parameter is passed", function() {
+      it("should be off when forceTLS parameter is passed", function() {
         var pusher = new Pusher("foo", { forceTLS: false });
         expect(pusher.shouldUseTLS()).toBe(false);
       });
@@ -174,15 +188,15 @@ describe("Pusher", function() {
 
       it("should pass config and options to the strategy builder", function() {
         var config = DefaultConfig.getConfig({});
-        var options = { useTLS: true }
+        var options = { useTLS: true };
 
         var getStrategy = pusher.connection.options.getStrategy;
-        getStrategy(options)
+        getStrategy(options);
         expect(Runtime.getDefaultStrategy).toHaveBeenCalledWith(
           pusher.config,
           options,
-          jasmine.any(Function),
-        )
+          jasmine.any(Function)
+        );
       });
     });
 
@@ -236,6 +250,8 @@ describe("Pusher", function() {
   });
 
   describe("after connecting", function() {
+    var pusher;
+
     beforeEach(function() {
       pusher = new Pusher("foo");
       pusher.connect();
@@ -244,11 +260,10 @@ describe("Pusher", function() {
     });
 
     it("should subscribe to all channels", function() {
-      var pusher = new Pusher("foo");
-
+      pusher = new Pusher("foo");
       var subscribedChannels = {
-        "channel1": pusher.subscribe("channel1"),
-        "channel2": pusher.subscribe("channel2")
+        channel1: pusher.subscribe("channel1"),
+        channel2: pusher.subscribe("channel2")
       };
 
       expect(subscribedChannels.channel1.subscribe).not.toHaveBeenCalled();
@@ -265,7 +280,9 @@ describe("Pusher", function() {
     it("should send events via the connection manager", function() {
       pusher.send_event("event", { key: "value" }, "channel");
       expect(pusher.connection.send_event).toHaveBeenCalledWith(
-        "event", { key: "value" }, "channel"
+        "event",
+        { key: "value" },
+        "channel"
       );
     });
 
@@ -288,7 +305,7 @@ describe("Pusher", function() {
         pusher.subscribe("xxx");
 
         expect(channel.reinstateSubscription).toHaveBeenCalled();
-      })
+      });
     });
 
     describe("#unsubscribe", function() {
@@ -310,7 +327,7 @@ describe("Pusher", function() {
         expect(channel.unsubscribe).not.toHaveBeenCalled();
       });
 
-      it("should remove the channel from .channels if subscription is not pending", function () {
+      it("should remove the channel from .channels if subscription is not pending", function() {
         var channel = pusher.subscribe("yyy");
         expect(pusher.channel("yyy")).toBe(channel);
 
@@ -318,7 +335,7 @@ describe("Pusher", function() {
         expect(pusher.channel("yyy")).toBe(undefined);
       });
 
-      it("should delay unsubscription if the subscription is pending", function () {
+      it("should delay unsubscription if the subscription is pending", function() {
         var channel = pusher.subscribe("yyy");
         channel.subscriptionPending = true;
 
@@ -326,7 +343,7 @@ describe("Pusher", function() {
         expect(pusher.channel("yyy")).toBe(channel);
         expect(channel.unsubscribe).not.toHaveBeenCalled();
         expect(channel.cancelSubscription).toHaveBeenCalled();
-      })
+      });
     });
   });
 
@@ -348,7 +365,7 @@ describe("Pusher", function() {
       expect(channel.handleEvent).toHaveBeenCalledWith({
         channel: "chan",
         event: "event",
-        data: { key: "value" },
+        data: { key: "value" }
       });
     });
 
@@ -404,6 +421,12 @@ describe("Pusher", function() {
   });
 
   describe("#unbind", function() {
+    var pusher;
+
+    beforeEach(function() {
+      pusher = new Pusher("foo");
+    });
+
     it("should allow a globally bound callback to be removed", function() {
       var onEvent = jasmine.createSpy("onEvent");
       pusher.bind("event", onEvent);
@@ -418,6 +441,7 @@ describe("Pusher", function() {
     });
   });
 
+
   describe("#disconnect", function() {
     it("should call disconnect on connection manager", function() {
       var pusher = new Pusher("foo");
@@ -455,11 +479,11 @@ describe("Pusher", function() {
     var timelineSender;
 
     beforeEach(function() {
+      jasmine.clock().uninstall();
       jasmine.clock().install();
 
       timelineSender = Mocks.getTimelineSender();
       spyOn(Factory, "createTimelineSender").and.returnValue(timelineSender);
-
     });
 
     afterEach(function() {
@@ -470,17 +494,19 @@ describe("Pusher", function() {
       var pusher = new Pusher("foo", { enableStats: true });
       expect(Factory.createTimelineSender.calls.count()).toEqual(1);
       expect(Factory.createTimelineSender).toHaveBeenCalledWith(
-        pusher.timeline, { host: "stats.pusher.com", path: "/timeline/v2/" + timelineTransport }
+        pusher.timeline,
+        { host: "stats.pusher.com", path: "/timeline/v2/" + timelineTransport }
       );
     });
 
     it("should be sent to a hostname specified in constructor options", function() {
       var pusher = new Pusher("foo", {
         statsHost: "example.com",
-        enableStats: true,
+        enableStats: true
       });
       expect(Factory.createTimelineSender).toHaveBeenCalledWith(
-        pusher.timeline, { host: "example.com", path: "/timeline/v2/" + timelineTransport }
+        pusher.timeline,
+        { host: "example.com", path: "/timeline/v2/" + timelineTransport }
       );
     });
 
@@ -498,7 +524,8 @@ describe("Pusher", function() {
       pusher.connection.options.timeline.info({});
       expect(Factory.createTimelineSender.calls.count()).toEqual(1);
       expect(Factory.createTimelineSender).toHaveBeenCalledWith(
-        pusher.timeline, { host: "stats.pusher.com", path: "/timeline/v2/" + timelineTransport }
+        pusher.timeline,
+        { host: "stats.pusher.com", path: "/timeline/v2/" + timelineTransport }
       );
     });
 
@@ -508,7 +535,8 @@ describe("Pusher", function() {
       pusher.connection.options.timeline.info({});
       expect(Factory.createTimelineSender.calls.count()).toEqual(1);
       expect(Factory.createTimelineSender).toHaveBeenCalledWith(
-        pusher.timeline, { host: "stats.pusher.com", path: "/timeline/v2/" + timelineTransport }
+        pusher.timeline,
+        { host: "stats.pusher.com", path: "/timeline/v2/" + timelineTransport }
       );
     });
 

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

@@ -8,9 +8,11 @@ describe('PusherWithEncryption', function() {
     expect(Pusher.logToConsole).toEqual(true);
   });
   it('should pass log function to parent class', function() {
+    let _prevLog = PusherWithEncryption.log
     let logFn =  jasmine.createSpy('logFn');
     PusherWithEncryption.log = logFn
     let pusher = new PusherWithEncryption('key');
     expect(logFn).toHaveBeenCalled();
+    PusherWithEncryption.log = _prevLog
   });
 });