pusher-js 7.0.6 → 7.2.0

package/spec/javascripts/unit/core/strategies/cached_strategy_spec.js

@@ -5,6 +5,7 @@ var Util = require('core/util').default;
 
 describe("CachedStrategy", function() {
   beforeEach(function() {
+    jasmine.clock().uninstall();
     jasmine.clock().install();
   });
 

package/spec/javascripts/unit/core/strategies/delayed_strategy_spec.js

@@ -7,6 +7,7 @@ describe("DelayedStrategy", function() {
     this.strategy = new DelayedStrategy(this.substrategy, { delay: 0 });
     this.callback = jasmine.createSpy();
 
+    jasmine.clock().uninstall();
     jasmine.clock().install();
   });
 

package/spec/javascripts/unit/core/strategies/sequential_strategy_spec.js

@@ -7,6 +7,7 @@ describe("SequentialStrategy", function() {
     this.substrategies = Mocks.getStrategies([true, true]);
     this.strategy = new SequentialStrategy(this.substrategies, {});
 
+    jasmine.clock().uninstall();
     jasmine.clock().install();
   });
 

package/spec/javascripts/unit/core/strategies/transport_strategy_spec.js

@@ -43,6 +43,7 @@ describe("TransportStrategy", function() {
 
   describe("#connect", function() {
     beforeEach(() => {
+      jasmine.clock().uninstall();
       jasmine.clock().install();
     });
 

package/spec/javascripts/unit/core/transports/assistant_to_the_transport_manager_spec.js

@@ -7,6 +7,7 @@ describe("AssistantToTheTransportManager", function() {
   var manager;
 
   beforeEach(function() {
+    jasmine.clock().uninstall();
     jasmine.clock().install();
     spyOn(Util, "now").and.returnValue(1);
 

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

@@ -0,0 +1,295 @@
+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 (User)", function () {
+
+  describe("#signin", function () {
+    var pusher;
+    beforeEach(function () {
+      pusher = new Pusher("foo");
+      spyOn(pusher.config, "userAuthenticator");
+      spyOn(pusher, "send_event");
+      pusher.connection.state = "connected";
+      pusher.connection.socket_id = "1.23";
+    });
+
+    it("should not call userAuthenticator if the connection is not connected", function () {
+      pusher.connection.state = "connecting";
+      pusher.signin();
+      expect(pusher.config.userAuthenticator).not.toHaveBeenCalled();
+    });
+
+
+    it("should fail if userAuthenticator fails", function () {
+      pusher.config.userAuthenticator.and.callFake(function (params, callback) {
+        callback("this error", {});
+      });
+      spyOn(Logger, "warn");
+      pusher.signin();
+      expect(pusher.config.userAuthenticator).toHaveBeenCalledWith(
+        { socketId: "1.23" },
+        jasmine.any(Function)
+      );
+      expect(Logger.warn).toHaveBeenCalledWith(
+        "Error during signin: this error"
+      );
+    });
+
+    it("should send pusher:signin event", function () {
+      pusher.config.userAuthenticator.and.callFake(function (params, callback) {
+        callback(null, {
+          auth: "auth",
+          user_data: JSON.stringify({ id: "1" }),
+          foo: "bar"
+        });
+      });
+      spyOn(Logger, "warn");
+      pusher.signin();
+      expect(pusher.config.userAuthenticator).toHaveBeenCalledWith(
+        { socketId: "1.23" },
+        jasmine.any(Function)
+      );
+      expect(pusher.send_event).toHaveBeenCalledWith("pusher:signin", {
+        auth: "auth",
+        user_data: JSON.stringify({ id: "1" })
+      });
+    });
+
+    it("should signin when the connection becomes connected", function () {
+      pusher.connection.state = "connecting";
+      pusher.signin();
+      expect(pusher.config.userAuthenticator).not.toHaveBeenCalled();
+
+      pusher.config.userAuthenticator.and.callFake(function (params, callback) {
+        callback(null, {
+          auth: "auth",
+          user_data: JSON.stringify({ id: "1" }),
+          foo: "bar"
+        });
+      });
+
+      pusher.connection.state = "connected";
+      pusher.connection.emit('connected');
+
+      expect(pusher.config.userAuthenticator).toHaveBeenCalledWith(
+        { socketId: "1.23" },
+        jasmine.any(Function)
+      );
+      expect(pusher.send_event).toHaveBeenCalledWith("pusher:signin", {
+        auth: "auth",
+        user_data: JSON.stringify({ id: "1" })
+      });
+    });
+
+    it("should re-signin when the connection reconnects!", function () {
+      pusher.config.userAuthenticator.and.callFake(function (params, callback) {
+        callback(null, {
+          auth: "auth",
+          user_data: JSON.stringify({ id: "1" }),
+          foo: "bar"
+        });
+      });
+
+      pusher.signin();
+      expect(pusher.config.userAuthenticator).toHaveBeenCalledWith(
+        { socketId: "1.23" },
+        jasmine.any(Function)
+      );
+      expect(pusher.send_event).toHaveBeenCalledWith("pusher:signin", {
+        auth: "auth",
+        user_data: JSON.stringify({ id: "1" })
+      });
+      pusher.send_event.calls.reset()
+      pusher.config.userAuthenticator.calls.reset()
+
+      pusher.connection.state == "disconnected";
+      pusher.connection.emit("disconnected");
+      pusher.connection.state == "connecting";
+      pusher.connection.emit("connecting");
+      pusher.connection.state == "connected";
+      pusher.connection.emit("connected");
+
+      expect(pusher.config.userAuthenticator).toHaveBeenCalledWith(
+        { socketId: "1.23" },
+        jasmine.any(Function)
+      );
+      expect(pusher.send_event).toHaveBeenCalledWith("pusher:signin", {
+        auth: "auth",
+        user_data: JSON.stringify({ id: "1" })
+      });
+    });
+
+    it("should not signin when the connection is connected if signin() was never called", function () {
+      pusher.connection.state = "connected";
+      pusher.connection.emit('connected');
+      expect(pusher.config.userAuthenticator).not.toHaveBeenCalled();
+    })
+
+  });
+
+
+  describe('pusher:signin_success', function () {
+    var pusher;
+    var transport;
+
+    beforeEach(async function () {
+      spyOn(Network, 'isOnline').and.returnValue(true);
+      spyOn(Runtime, 'getLocalStorage').and.returnValue({});
+
+      var Transports = Runtime.Transports;
+      function createConnection() {
+        transport = Mocks.getWorkingTransport();
+        return transport;
+      }
+      spyOn(Transports.xhr_polling, 'createConnection').and.callFake(
+        createConnection
+      );
+      spyOn(Transports.xhr_polling, 'isSupported').and.returnValue(true);
+      pusher = new Pusher('foobar', {
+        enabledTransports: ['xhr_polling']
+      });
+      pusher.connect();
+      await waitsFor(
+        function () {
+          return pusher.connection.state === 'connected';
+        },
+        'pusher.connection.state to be connected',
+        500
+      );
+    });
+
+    it('should process pusher:signin_success', async function () {
+      transport.emit('message', {
+        data: JSON.stringify({
+          event: 'pusher:signin_success',
+          data: {
+            user_data: JSON.stringify({ id: '1', name: 'test' })
+          }
+        })
+      });
+
+      expect(pusher.user.user_data).toEqual({ id: '1', name: 'test' });
+      expect(pusher.user.serverToUserChannel.subscriptionPending).toBe(true);
+    });
+
+    it('should log warning if user_data is not JSON', async function () {
+      spyOn(Logger, 'error');
+      transport.emit('message', {
+        data: JSON.stringify({
+          event: 'pusher:signin_success',
+          data: {
+            user_data: "I'm not JSON"
+          }
+        })
+      });
+      expect(Logger.error).toHaveBeenCalledWith(
+        "Failed parsing user data after signin: I'm not JSON"
+      );
+      expect(pusher.user.user_data).toEqual(null);
+    });
+
+    it('should bind to servetToUser channel events after sign in', async function () {
+      const fooCallback = jasmine.createSpy('fooCallback');
+      const barCallback = jasmine.createSpy('barCallback');
+      pusher.user.bind('foo', fooCallback);
+      pusher.user.bind('bar', barCallback);
+
+      // Send events on channel without being signed in
+      transport.emit('message', {
+        data: JSON.stringify({
+          channel: '#server-to-user-1',
+          event: 'foo',
+          data: { 'something': 'another' }
+        })
+      });
+
+      expect(fooCallback).not.toHaveBeenCalled();
+      expect(barCallback).not.toHaveBeenCalled();
+
+      // Sign in successfully
+      transport.emit('message', {
+        data: JSON.stringify({
+          event: 'pusher:signin_success',
+          data: {
+            user_data: JSON.stringify({ id: '1', name: 'test' })
+          }
+        })
+      });
+      transport.emit('message', {
+        data: JSON.stringify({
+          channel: '#server-to-user-1',
+          event: 'pusher_internal:subscription_succeeded',
+          data: {}
+        })
+      });
+      await waitsFor(
+        function () {
+          return pusher.user.serverToUserChannel.subscribed === true;
+        },
+        'pusher.user.serverToUserChannel.subscribed to be true',
+        500
+      );
+
+      // Send events on channel
+      transport.emit('message', {
+        data: JSON.stringify({
+          channel: '#server-to-user-1',
+          event: 'foo',
+          data: { 'something': 'another' }
+        })
+      });
+
+      expect(fooCallback).toHaveBeenCalledWith({ 'something': 'another' });
+      expect(barCallback).not.toHaveBeenCalled();
+    });
+
+
+    it('should cleanup the signed in state when disconnected', async function () {
+      // Sign in successfully
+      transport.emit('message', {
+        data: JSON.stringify({
+          event: 'pusher:signin_success',
+          data: {
+            user_data: JSON.stringify({ id: '1', name: 'test' })
+          }
+        })
+      });
+      transport.emit('message', {
+        data: JSON.stringify({
+          channel: '#server-to-user-1',
+          event: 'pusher_internal:subscription_succeeded',
+          data: {}
+        })
+      });
+      await waitsFor(
+        function () {
+          return pusher.user.serverToUserChannel.subscribed === true;
+        },
+        'pusher.user.serverToUserChannel.subscribed to be true',
+        500
+      );
+      expect(pusher.user.user_data).toEqual({ id: '1', name: 'test' });
+      expect(pusher.user.serverToUserChannel.subscribed).toBe(true);
+
+      // Disconnect
+      pusher.connection.emit('disconnected');
+
+      expect(pusher.user.user_data).toEqual(null);
+      expect(pusher.user.serverToUserChannel).toEqual(null);
+    });
+  });
+
+});

package/spec/javascripts/unit/core/utils/periodic_timer_spec.js

@@ -6,6 +6,7 @@ describe("PeriodicTimer", function() {
   var timer;
 
   beforeEach(function() {
+    jasmine.clock().uninstall();
     jasmine.clock().install();
 
     callback = jasmine.createSpy("callback");
@@ -62,10 +63,12 @@ describe("PeriodicTimer", function() {
 
     it("should stop callback from being called even if clearInterval is broken", function() {
       // IE has some edge-case with clearInterval not working, let's simulate it
-      spyOn(global, "clearInterval");
+      let _clearInterval = global.clearInterval;
+      spyOn(global, "clearInterval").and.callThrough();
       timer.ensureAborted();
       jasmine.clock().tick(1000);
       expect(callback).not.toHaveBeenCalled();
+      global.clearInterval = _clearInterval;
     });
   });
 });

package/spec/javascripts/unit/core/utils/timers_spec.js

@@ -19,6 +19,7 @@ describe("timers", function() {
 
     afterEach(function() {
       timer.ensureAborted();
+      jasmine.clock().uninstall();
     });
 
     it("should execute the callback with the specified delay", function() {
@@ -65,10 +66,12 @@ describe("timers", function() {
 
       it("should stop callback from being called even if clearTimeout is broken", function() {
         // IE has some edge-case with clearTimeout not working, let's simulate it
+        let _clearTimeout = global.clearTimeout;
         spyOn(global, "clearTimeout");
         timer.ensureAborted();
         jasmine.clock().tick(1000);
         expect(callback).not.toHaveBeenCalled();
+        global.clearTimeout = _clearTimeout;
       });
     });
   });
@@ -87,6 +90,7 @@ describe("timers", function() {
 
     afterEach(function() {
       timer.ensureAborted();
+      jasmine.clock().uninstall();
     });
 
     it("should execute the callback with the specified delay", function() {
@@ -145,10 +149,12 @@ describe("timers", function() {
 
       it("should stop callback from being called even if clearTimeout is broken", function() {
         // IE has some edge-case with clearTimeout not working, let's simulate it
+        let _clearTimeout = global.clearTimeout;
         spyOn(global, "clearTimeout");
         timer.ensureAborted();
         jasmine.clock().tick(1000);
         expect(callback).not.toHaveBeenCalled();
+        global.clearTimeout = _clearTimeout;
       });
     });
   });

package/spec/javascripts/unit/core/utils/url_store_spec.js

@@ -4,7 +4,7 @@ describe('url_store', function(){
   describe('buildLogSuffix', function(){
     it('should build a log suffix for known keys', function(){
       var suffix = url_store.buildLogSuffix('authenticationEndpoint');
-      expect(suffix).toEqual('See: https://pusher.com/docs/authenticating_users');
+      expect(suffix).toEqual('See: https://pusher.com/docs/channels/server_api/authenticating_users');
     });
     it('should return a blank suffix for unknown keys', function(){
       var suffix = url_store.buildLogSuffix('somethingUnknown');

package/spec/javascripts/unit/core_with_runtime/auth/channel_authorizer_spec.js

@@ -0,0 +1,55 @@
+var Runtime = require('runtime').default;
+var ChannelAuthorizer = require('core/auth/channel_authorizer').default;
+
+describe("ChannelAuthorizer", function() {
+
+  describe("initialization", function(){
+    it("should throw an error if the specified transport is unrecognized", function(){
+      const authOptions = {
+        transport: "bad-transport",
+      };
+      expect(function(){
+        ChannelAuthorizer(authOptions)
+      }).toThrow("'bad-transport' is not a recognized auth transport");
+    });
+  });
+
+  describe("channel AuthHandler", function(){
+    let _getAuthorizers;
+
+    beforeAll(function() {
+      _getAuthorizers = Runtime.getAuthorizers;
+    });
+
+    afterAll(function() {
+      Runtime.getAuthorizers = _getAuthorizers;
+    });
+
+    it("should call the specified transport authorizer", function(){
+      const authOptions = {
+        transport: "ajax",
+        endpoint: "http://example.com/auth",
+        params: { foo: "bar" },
+        headers: { "X-Foo": "my-bar" }
+      };
+      channelAuthorizer = ChannelAuthorizer(authOptions);
+
+      transportAuthorizer = jasmine.createSpy("ajax")
+      Runtime.getAuthorizers = jasmine.createSpy("getAuthorizers").and.returnValue({
+        ajax: transportAuthorizer
+      });
+
+      const params = { socketId: '1.23', channelName: 'private-test' };
+      const callback = function(){};
+      const query = 'socket_id=1.23&channel_name=private-test&foo=bar';
+      channelAuthorizer(params, callback);
+      expect(Runtime.getAuthorizers.calls.count()).toEqual(1);
+      expect(transportAuthorizer).toHaveBeenCalledWith(
+        Runtime,
+        query,
+        authOptions,
+        'channel-authorization',
+        callback);
+    });
+  });
+});

package/spec/javascripts/unit/core_with_runtime/auth/deprecated_channel_authorizer_spec.js

@@ -0,0 +1,48 @@
+var ChannelAuthorizerProxy = require('core/auth/deprecated_channel_authorizer').ChannelAuthorizerProxy;
+
+describe("ChannelAuthorizerProxy", function() {
+
+  describe("initialization", function(){
+    it("should call the deprecated authorizer properly", function(){
+      const channel = {};
+      const pusher = {
+        channel: jasmine.createSpy('channel').and.returnValue(channel)
+      }
+      
+      const authOptions = {
+        transport: "bad-transport",
+        endpoint: "http://example.com/auth",
+        params: { foo: "bar" },
+        headers: { "X-Foo": "my-bar" }
+      };
+      const deprecatedAuthorizerParams = {
+        authTransport: "bad-transport",
+        authEndpoint: "http://example.com/auth",
+        auth: {
+          params: { foo: "bar" },
+          headers: { "X-Foo": "my-bar" }
+        }
+      }
+      const deprecatedAuthorizer = {
+        authorize:jasmine.createSpy('deprecatedAuthorizer')
+      };
+      const deprecatedAuthorizerGenerator = jasmine.createSpy("deprecatedAuthorizerGenerator").and.returnValue(deprecatedAuthorizer);
+
+      channelAuthorizer = ChannelAuthorizerProxy(pusher, authOptions, deprecatedAuthorizerGenerator)
+      
+      const params = { socketId: "1.23", channelName: "private-test-channel"};
+      const callback = function() {};
+      channelAuthorizer(params, callback);
+
+      expect(pusher.channel.calls.count()).toEqual(1);
+      expect(pusher.channel).toHaveBeenCalledWith('private-test-channel');
+
+      expect(deprecatedAuthorizerGenerator.calls.count()).toEqual(1);
+      expect(deprecatedAuthorizerGenerator).toHaveBeenCalledWith(channel, deprecatedAuthorizerParams);
+
+      expect(deprecatedAuthorizer.authorize.calls.count()).toEqual(1);
+      expect(deprecatedAuthorizer.authorize).toHaveBeenCalledWith("1.23", callback);
+    });
+  });
+
+});

package/spec/javascripts/unit/core_with_runtime/auth/user_authorizer_spec.js

@@ -0,0 +1,52 @@
+var Runtime = require('runtime').default;
+var UserAuthenticator = require('core/auth/user_authenticator').default;
+
+describe("UserAuthenticator", function() {
+
+  describe("initialization", function(){
+    it("should throw an error if the specified transport is unrecognized", function(){
+      const userAuthentication = {
+        transport: "bad-transport",
+      };
+      expect(function(){
+        UserAuthenticator(userAuthentication)
+      }).toThrow("'bad-transport' is not a recognized auth transport");
+    });
+  });
+
+  describe("user AuthHandler", function(){
+    let _getAuthorizers;
+
+    beforeAll(function() {
+      _getAuthorizers = Runtime.getAuthorizers;
+    });
+
+    afterAll(function() {
+      Runtime.getAuthorizers = _getAuthorizers;
+    });
+
+    it("should call the specified transport authorizer", function(){
+      const userAuthentication = {
+        transport: "ajax",
+      };
+      userAuthenticator = UserAuthenticator(userAuthentication);
+
+      transportAuthorizer = jasmine.createSpy("ajax")
+      Runtime.getAuthorizers = jasmine.createSpy("getAuthorizers").and.returnValue({
+        ajax: transportAuthorizer
+      });
+
+      const params = { socketId: '1.23' };
+      const callback = function(){};
+      const query = 'socket_id=1.23';
+      userAuthenticator(params, callback);
+      expect(Runtime.getAuthorizers.calls.count()).toEqual(1);
+      expect(transportAuthorizer).toHaveBeenCalledWith(
+        Runtime,
+        query,
+        userAuthentication,
+        'user-authentication',
+        callback);
+    });
+  });
+});

package/spec/javascripts/unit/core_with_runtime/readme.md

@@ -0,0 +1,5 @@
+# core with runtime
+
+This directory contains unit tests for core features that requires access to a `Runtime`. These tests will be included in the unit tests for each runtime and the proper runtime will be loaded before calling those tests.
+
+In order for this to work, this directory `core_with_runtime` need to be included in `unit/index.node.js` and similar files after the proper runtime directory is included (ex. `unit/node`)

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

@@ -6,3 +6,6 @@ nodeTestsContext.keys().forEach(nodeTestsContext);
 
 var nodeTestsContext = require.context("./node", true, /_spec$/);
 nodeTestsContext.keys().forEach(nodeTestsContext)
+
+var coreWithRuntimeTestsContext = require.context("./core_with_runtime", true, /_spec$/);
+coreWithRuntimeTestsContext.keys().forEach(coreWithRuntimeTestsContext)

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

@@ -7,3 +7,6 @@ sharedTestsContext.keys().forEach(sharedTestsContext);
 
 var nodeTestsContext = require.context("./web", true, /_spec$/);
 nodeTestsContext.keys().forEach(nodeTestsContext);
+
+var coreWithRuntimeTestsContext = require.context("./core_with_runtime", true, /_spec$/);
+coreWithRuntimeTestsContext.keys().forEach(coreWithRuntimeTestsContext)

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

@@ -6,3 +6,6 @@ nodeTestsContext.keys().forEach(nodeTestsContext);
 
 var nodeTestsContext = require.context("./worker", true, /_spec$/);
 nodeTestsContext.keys().forEach(nodeTestsContext);
+
+var coreWithRuntimeTestsContext = require.context("./core_with_runtime", true, /_spec$/);
+coreWithRuntimeTestsContext.keys().forEach(coreWithRuntimeTestsContext)

package/spec/javascripts/unit/web/pusher_authorizer_spec.js

@@ -1,4 +1,4 @@
-var Authorizer = require('core/auth/pusher_authorizer').default;
+var ChannelAuthorizer = require('core/auth/channel_authorizer').default;
 var Logger = require('core/logger');
 var Mocks = require('mocks');
 var Util = require('core/util').default;
@@ -6,17 +6,13 @@ var Factory = require('core/utils/factory').default;
 var Logger = require('core/logger').default;
 var Runtime = require('runtime').default;
 
-describe("JSONP Authorizer", function() {
-  it("should raise a warning if headers are passed", function() {
-    var headers = { "foo": "bar", "n": 42 };
-    var authorizer = new Authorizer(
-      { name: "chan" },
-      { authTransport: "jsonp",
-        auth: {
-          headers: headers
-        }
-      }
-    );
+describe('JSONP Authorizer', function() {
+  it('should raise a warning if headers are passed', function() {
+    var headers = { foo: 'bar', n: 42 };
+    var channelAuthorizer = ChannelAuthorizer({
+      transport: 'jsonp',
+      headers: headers
+    })
 
     var document = Mocks.getDocument();
     var script = Mocks.getDocumentElement();
@@ -25,13 +21,16 @@ describe("JSONP Authorizer", function() {
     document.createElement.and.returnValue(script);
     document.getElementsByTagName.and.returnValue([]);
     document.documentElement = documentElement;
-    spyOn(Runtime, "getDocument").and.returnValue(document);
+    spyOn(Runtime, 'getDocument').and.returnValue(document);
 
-    spyOn(Logger, "warn");
-    authorizer.authorize("1.23", function() {});
+    spyOn(Logger, 'warn');
+    channelAuthorizer({
+      socketId: '1.23',
+      channelName: 'chan',
+    }, function() {})
 
     expect(Logger.warn).toHaveBeenCalledWith(
-      "To send headers with the auth request, you must use AJAX, rather than JSONP."
+      'To send headers with the channel-authorization request, you must use AJAX, rather than JSONP.'
     );
   });
 });

package/spec/javascripts/unit/web/transports/hosts_and_ports_spec.js

@@ -31,6 +31,7 @@ describe("Host/Port Configuration", function() {
 
   afterEach(function() {
     pusher.disconnect();
+    jasmine.clock().uninstall();
   });
 
   describe("SockJS", function() {