pusher-js 7.0.6 → 7.2.0

package/index.d.ts

@@ -1,8 +1,13 @@
 export {
-  Authorizer,
+  DeprecatedAuthOptions,
+  ChannelAuthorizerGenerator,
+} from './types/src/core/auth/deprecated_channel_authorizer';
+export {
   AuthOptions,
-  AuthorizerGenerator,
-  AuthorizerCallback,
+  ChannelAuthorizationHandler,
+  UserAuthenticationHandler,
+  ChannelAuthorizationCallback,
+  UserAuthenticationCallback,
 } from './types/src/core/auth/options';
 export { Options } from './types/src/core/options'
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pusher-js",
-  "version": "7.0.6",
+  "version": "7.2.0",
   "description": "Pusher Channels JavaScript library for browsers, React Native, NodeJS and web workers",
   "main": "dist/node/pusher.js",
   "browser": "dist/web/pusher.js",
@@ -45,7 +45,7 @@
     "karma-chrome-launcher": "^3.1.0",
     "karma-firefox-launcher": "^2.1.1",
     "karma-jasmine": "^4.0.1",
-    "karma-jasmine-web-worker": "^0.1.2",
+    "karma-jasmine-web-worker": "git+https://git@github.com/pusher/karma-jasmine-web-worker.git#jasmine_3",
     "karma-opera-launcher": "^1.0.0",
     "karma-safari-launcher": "^1.0.0",
     "karma-spec-reporter": "0.0.32",

package/spec/config/karma/config.worker.js

@@ -26,6 +26,9 @@ module.exports = function(config, suite) {
     'src/runtimes',
     'spec/javascripts/helpers'
   ]
+  config.webpack.resolve.alias = {
+    'dom/dependencies': 'worker/mock-dom-dependencies',
+  }
   config.webpack.externals.testenv = "'worker'";
   return config;
 }

package/spec/config/karma/integration.js

@@ -10,8 +10,10 @@ if (process.env.CI) {
 if (process.env.WORKER === 'true') {
   config = require('./config.worker')(config, 'integration');
   config.webpack.resolve.alias = {
-    pusher_integration: 'core/pusher',
-    integration: 'node/integration'
+    pusher_integration: 'core/pusher.js',
+    integration: 'node/integration',
+    'dom/dependencies': 'worker/mock-dom-dependencies',
+    'dom/dependency_loader': 'worker/mock-dom-dependencies',
   };
   if (process.env.CI) config.browsers = ['bs_chrome_74'];
 }

package/spec/javascripts/helpers/mocks.js

@@ -112,6 +112,47 @@ var Mocks = {
     return transport;
   },
 
+  getWorkingTransport: function() {
+    var transport = new EventsDispatcher();
+
+    transport.handlesActivityChecks = jasmine
+      .createSpy('handlesActivityChecks')
+      .and.returnValue(false);
+    transport.supportsPing = jasmine
+      .createSpy('supportsPing')
+      .and.returnValue(false);
+    transport.initialize = jasmine
+      .createSpy('initialize')
+      .and.callFake(function() {
+        transport.state = 'initializing';
+        transport.emit('initializing');
+        setTimeout(() => {
+          transport.state = 'initialized';
+          transport.emit('initialized');
+        }, 0);
+      });
+    transport.connect = jasmine.createSpy('connect').and.callFake(function() {
+      transport.state = 'open';
+      transport.emit('open');
+      setTimeout(() => {
+        transport.emit('message', {
+          data: JSON.stringify({
+            event: 'pusher:connection_established',
+            data: {
+              socket_id: '123.456',
+              activity_timeout: 120
+            }
+          })
+        });
+      }, 0);
+    });
+    transport.send = jasmine.createSpy('send').and.returnValue(true);
+    transport.ping = jasmine.createSpy('ping');
+    transport.close = jasmine.createSpy('close');
+    transport.state = undefined;
+    return transport;
+  },
+
   getTransportManager: function(alive) {
     return {
       isAlive: jasmine.createSpy("isAlive").and.returnValue(alive !== false),
@@ -228,14 +269,6 @@ var Mocks = {
     return channel;
   },
 
-  getAuthorizer: function() {
-    var authorizer = {};
-    authorizer._callback = null;
-    authorizer.authorize = jasmine.createSpy("authorize").and.callFake(function(_, callback) {
-      authorizer._callback = callback;
-    });
-    return authorizer;
-  }
 };
 
 module.exports = Mocks;

package/spec/javascripts/helpers/worker/mock-dom-dependencies.js

@@ -0,0 +1 @@
+exports.Dependencies = {}

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

@@ -141,5 +141,13 @@ module.exports = function(testConfigs) {
     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/timeout_configuration_spec.js

@@ -23,6 +23,7 @@ module.exports = function() {
     var pusher;
 
     beforeEach(function() {
+      jasmine.clock().uninstall();
       jasmine.clock().install();
 
       spyOn(Network, "isOnline").and.returnValue(true);

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

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

package/spec/javascripts/unit/core/channels/channel_spec.js

@@ -170,6 +170,31 @@ describe("Channel", function() {
       });
     });
 
+    describe('on pusher_internal:subscription_count', function() {
+      it('should emit pusher:subscription_count', function() {
+        const testEvent = {
+          event: 'pusher_internal:subscription_count',
+          data: { subscription_count: 101 }
+        };
+
+        var callback = jasmine.createSpy('callback');
+        channel.bind('pusher:subscription_count', callback);
+
+        channel.handleEvent(testEvent);
+
+        expect(callback).toHaveBeenCalledWith(testEvent.data);
+      });
+
+      it('should set #subscriptionCount', function() {
+        channel.handleEvent({
+          event: 'pusher_internal:subscription_count',
+          data: { subscription_count: 101 }
+        });
+
+        expect(channel.subscriptionCount).toEqual(101);
+      });
+    });
+
     describe("on other events", function() {
       it("should emit the event", function() {
         var callback = jasmine.createSpy("callback");

package/spec/javascripts/unit/core/channels/encrypted_channel_spec.js

@@ -1,7 +1,6 @@
 const Errors = require("core/errors");
 const Logger = require('core/logger').default;
 const EncryptedChannel = require("core/channels/encrypted_channel").default;
-const Factory = require("core/utils/factory").default;
 const Mocks = require("mocks");
 const nacl = require("tweetnacl");
 const utf8 = require("@stablelib/utf8");
@@ -10,8 +9,7 @@ const base64 = require("@stablelib/base64");
 describe("EncryptedChannel", function() {
   var pusher;
   var channel;
-  var authorizer;
-  var factorySpy;
+  var channelAuthorizer;
   const secretUTF8 = "It Must Be Thirty Two Characters";
   const secretBytes = utf8.encode(secretUTF8);
   const secretBase64 = base64.encode(secretBytes);
@@ -25,10 +23,9 @@ describe("EncryptedChannel", function() {
   };
 
   beforeEach(function() {
-    pusher = Mocks.getPusher({ foo: "bar" });
+    channelAuthorizer = jasmine.createSpy("channelAuthorizer").and.callFake(function(params, callback) {})
+    pusher = Mocks.getPusher({ channelAuthorizer: channelAuthorizer });
     channel = new EncryptedChannel("private-encrypted-test", pusher, nacl);
-    authorizer = Mocks.getAuthorizer();
-    factorySpy = spyOn(Factory, "createAuthorizer").and.returnValue(authorizer);
   });
 
   describe("after construction", function() {
@@ -46,36 +43,38 @@ describe("EncryptedChannel", function() {
   });
 
   describe("#authorize", function() {
-    it("should create and call an authorizer", function() {
-      channel.authorize("1.23", function() {});
-      expect(Factory.createAuthorizer.calls.count()).toEqual(1);
-      expect(Factory.createAuthorizer).toHaveBeenCalledWith(channel, {
-        foo: "bar"
-      });
+    it("should call channelAuthorizer", function() {
+      const callback = function(){}
+      channel.authorize("1.23", callback);
+      expect(channelAuthorizer.calls.count()).toEqual(1);
+      expect(channelAuthorizer).toHaveBeenCalledWith(
+        { socketId: "1.23", channelName: "private-encrypted-test" }, jasmine.any(Function));
     });
 
-    it("should call back with only authorization data", function() {
-      let callback = jasmine.createSpy("callback");
+    it("should call the callback if an authorizaiton error is encountered", function() {
+      const callback = jasmine.createSpy("callback")
       channel.authorize("1.23", callback);
-      expect(callback).not.toHaveBeenCalled();
-      authorizer._callback(false, {
-        shared_secret: secretBase64,
-        foo: "bar"
-      });
-      expect(callback).toHaveBeenCalledWith(null, { foo: "bar" });
+      expect(channelAuthorizer.calls.count()).toEqual(1);
+      expect(channelAuthorizer).toHaveBeenCalledWith(
+        { socketId: "1.23", channelName: "private-encrypted-test" }, jasmine.any(Function));
+      const encryptedChannelCallback = channelAuthorizer.calls.mostRecent().args[1];
+      
+      encryptedChannelCallback("error", {})
+      expect(callback).toHaveBeenCalledWith("error", {})
     });
 
-    it("should callback an error if no shared_secret included in auth data", function() {
-      let callback = jasmine.createSpy("callback");
+    it("should fail if AuthData doens't have a shared_secret", function() {
+      const callback = jasmine.createSpy("callback")
       channel.authorize("1.23", callback);
-      authorizer._callback(null, {
-        foo: "bar"
-      });
-      // For some reason comparing the Error types doesn't work properly in
-      // Safari on Mojave. Manually check the arguments.
+      expect(channelAuthorizer.calls.count()).toEqual(1);
+      expect(channelAuthorizer).toHaveBeenCalledWith(
+        { socketId: "1.23", channelName: "private-encrypted-test" }, jasmine.any(Function));
+      const encryptedChannelCallback = channelAuthorizer.calls.mostRecent().args[1];
+      
+      encryptedChannelCallback(null, {})
+      
       expect(callback.calls.count()).toEqual(1)
       let args = callback.calls.first().args;
-
       expect(args.length).toEqual(2)
       expect(args[0]).toEqual(jasmine.any(Error))
       expect(args[0].message).toEqual(
@@ -83,27 +82,22 @@ describe("EncryptedChannel", function() {
       );
       expect(args[1]).toEqual(null);
     });
-
-    describe("with custom authorizer", function() {
-      beforeEach(function() {
-        pusher = Mocks.getPusher({
-          authorizer: function(channel, options) {
-            return authorizer;
-          }
-        });
-        channel = new EncryptedChannel("private-test-custom-auth", pusher, nacl);
-        factorySpy.and.callThrough();
-      });
-
-      it("should call the authorizer", function() {
-        let callback = jasmine.createSpy("callback");
-        channel.authorize("1.23", callback);
-        authorizer._callback(false, {
-          shared_secret: secretBase64,
-          foo: "bar"
-        });
-        expect(callback).toHaveBeenCalledWith(null, { foo: "bar" });
-      });
+    
+    it("should succeed if AuthData has a shared_secret", function() {
+      const callback = jasmine.createSpy("callback")
+      channel.authorize("1.23", callback);
+      expect(channelAuthorizer.calls.count()).toEqual(1);
+      expect(channelAuthorizer).toHaveBeenCalledWith(
+        { socketId: "1.23", channelName: "private-encrypted-test" }, jasmine.any(Function));
+      const encryptedChannelCallback = channelAuthorizer.calls.mostRecent().args[1];
+      
+      encryptedChannelCallback(null, {
+        shared_secret: secretBase64,
+        foo: 'bar',
+      })
+      expect(callback).toHaveBeenCalledWith(null, {
+        foo: 'bar',
+      })
     });
   });
 
@@ -213,14 +207,14 @@ describe("EncryptedChannel", function() {
 
     describe("on other events", function() {
       beforeEach(function() {
-        // in order to decrypt encrypted events, we need to get a shared secret
-        // from the authorizer.
-        let callback = function() {};
-        channel.authorize("1.23", callback);
-        authorizer._callback(false, {
-          shared_secret: secretBase64,
-          foo: "bar"
+        channelAuthorizer.and.callFake(function(params, callback) {
+          callback(null, {
+            shared_secret: secretBase64,
+            foo: 'bar',
+          });
         });
+        
+        channel.authorize("1.23", function (){});
       });
       it("should decrypt the event payload and emit the event", function() {
         let payload = { test: "payload" };
@@ -281,10 +275,20 @@ describe("EncryptedChannel", function() {
         };
 
         beforeEach(function() {
+          // Channel has already been authorized with the old secret
+          channel.authorize("1.23", function (){});
+
           pusher.connection = {
             socket_id: "9.37"
           };
-          authorizer._callback = null
+
+          // Next call to authorize will use the new secret
+          channelAuthorizer.and.callFake(function(params, callback) {
+            callback(null, {
+              shared_secret: newSecretBase64,
+              foo: 'bar',
+            });
+          });
         });
 
         it("should request new key from authorizer and decrypt event", function() {
@@ -299,10 +303,6 @@ describe("EncryptedChannel", function() {
             event: "something",
             data: encryptedPayload
           });
-          authorizer._callback(false, {
-            shared_secret: newSecretBase64,
-            foo: "bar"
-          });
           expect(boundCallback).toHaveBeenCalledWith(payload);
         });
         it("should log a warning if it fails to decrypt event after requesting a new key from the auth endpoint", function() {
@@ -315,10 +315,6 @@ describe("EncryptedChannel", function() {
             event: "something",
             data: encryptedPayload
           });
-          authorizer._callback(false, {
-            shared_secret: newSecretBase64,
-            foo: "bar"
-          });
           expect(Logger.error).toHaveBeenCalledWith(
             "Failed to decrypt event with new key. Dropping encrypted event"
           );
@@ -330,11 +326,13 @@ describe("EncryptedChannel", function() {
             ciphertext: newTestEncrypt(payload)
           };
           spyOn(Logger, "error");
+          channelAuthorizer.and.callFake(function(params, callback) {
+            callback(true, "ERROR");
+          });
           channel.handleEvent({
             event: "something",
             data: encryptedPayload
           });
-          authorizer._callback(true, "ERROR");
           expect(Logger.error).toHaveBeenCalledWith(
             "Failed to make a request to the authEndpoint: ERROR. Unable to fetch new key, so dropping encrypted event"
           );

package/spec/javascripts/unit/core/channels/presence_channel_spec.js

@@ -1,7 +1,6 @@
 var PresenceChannel = require('core/channels/presence_channel').default;
 var Channel = require('core/channels/channel').default;
 var Members = require('core/channels/members').default;
-var Authorizer = require('core/auth/pusher_authorizer').default;
 var Errors = require('core/errors');
 var Factory = require('core/utils/factory').default;
 var Mocks = require("mocks");
@@ -9,9 +8,11 @@ var Mocks = require("mocks");
 describe("PresenceChannel", function() {
   var pusher;
   var channel;
+  var channelAuthorizer;
 
   beforeEach(function() {
-    pusher = Mocks.getPusher({ foo: "bar" });
+    channelAuthorizer = jasmine.createSpy("channelAuthorizer")
+    pusher = Mocks.getPusher({ channelAuthorizer: channelAuthorizer });
     channel = new PresenceChannel("presence-test", pusher);
   });
 
@@ -46,46 +47,57 @@ describe("PresenceChannel", function() {
   });
 
   describe("#authorize", function() {
-    var authorizer;
-
-    beforeEach(function() {
-      authorizer = Mocks.getAuthorizer();
-      spyOn(Factory, "createAuthorizer").and.returnValue(authorizer);
+    
+    it("should call channelAuthorizer", function() {
+      const callback = function(){}
+      channel.authorize("1.23", callback);
+      expect(channelAuthorizer.calls.count()).toEqual(1);
+      expect(channelAuthorizer).toHaveBeenCalledWith(
+        { socketId: "1.23", channelName: "presence-test" }, jasmine.any(Function));
     });
 
-    it("should create and call an authorizer", function() {
-      channel.authorize("1.23", function() {});
-      expect(Factory.createAuthorizer.calls.count()).toEqual(1);
-      expect(Factory.createAuthorizer).toHaveBeenCalledWith(
-        channel,
-        { foo: "bar" }
-      );
+    it("should call the callback if an authorizaiton error is encountered", function() {
+      const callback = jasmine.createSpy("callback")
+      channel.authorize("1.23", callback);
+      expect(channelAuthorizer.calls.count()).toEqual(1);
+      expect(channelAuthorizer).toHaveBeenCalledWith(
+        { socketId: "1.23", channelName: "presence-test" }, jasmine.any(Function));
+      const presenceChannelCallback = channelAuthorizer.calls.mostRecent().args[1];
+      
+      presenceChannelCallback("error", {})
+      expect(callback).toHaveBeenCalledWith("error", {})
     });
 
-    it("should call back on success with authorization data", function() {
-      var callback = jasmine.createSpy("callback");
+    it("should call the callback with error if auth data doesn't have channel_data", function() {
+      const callback = jasmine.createSpy("callback")
       channel.authorize("1.23", callback);
-
-      expect(callback).not.toHaveBeenCalled();
-      authorizer._callback(false, {
-        foo: "bar",
-        channel_data: JSON.stringify({ user_id: "U" })
-      });
-
-      expect(callback).toHaveBeenCalledWith(false, {
-        foo: "bar",
-        channel_data: JSON.stringify({ user_id: "U" })
-      });
+      expect(channelAuthorizer.calls.count()).toEqual(1);
+      expect(channelAuthorizer).toHaveBeenCalledWith(
+        { socketId: "1.23", channelName: "presence-test" }, jasmine.any(Function));
+      const presenceChannelCallback = channelAuthorizer.calls.mostRecent().args[1];
+      
+      presenceChannelCallback(null, {
+        foo: 'bar'
+      })
+      expect(callback).toHaveBeenCalledWith("Invalid auth response")
     });
 
-    it("should call back on failure", function() {
-      var callback = jasmine.createSpy("callback");
+    it("should call the callback with auth data", function() {
+      const callback = jasmine.createSpy("callback")
       channel.authorize("1.23", callback);
-
-      authorizer._callback("error!");
-
-      expect(callback).toHaveBeenCalledWith("error!", undefined);
+      expect(channelAuthorizer.calls.count()).toEqual(1);
+      expect(channelAuthorizer).toHaveBeenCalledWith(
+        { socketId: "1.23", channelName: "presence-test" }, jasmine.any(Function));
+      const presenceChannelCallback = channelAuthorizer.calls.mostRecent().args[1];
+      
+      const authdata = {
+        channel_data: "{\"user_id\":\"123\"}",
+        foo: 'bar'
+      };
+      presenceChannelCallback(null, authdata)
+      expect(callback).toHaveBeenCalledWith(null, authdata)
     });
+
   });
 
   describe("#trigger", function() {
@@ -114,16 +126,14 @@ describe("PresenceChannel", function() {
   });
 
   describe("after authorizing", function() {
-    var authorizer;
-
     beforeEach(function() {
-      authorizer = Mocks.getAuthorizer();
-      spyOn(Factory, "createAuthorizer").and.returnValue(authorizer);
-      channel.authorize("1.23", function() {});
-      authorizer._callback(false, {
-        foo: "bar",
-        channel_data: JSON.stringify({ user_id: "U" })
+      channelAuthorizer.and.callFake(function(params, callback) {
+        callback(null, {
+          foo: "bar",
+          channel_data: JSON.stringify({ user_id: "U" })
+        });
       });
+      channel.authorize("1.23", function() {});
     });
 
     describe("#handleEvent", function() {

package/spec/javascripts/unit/core/channels/private_channel_spec.js

@@ -1,16 +1,15 @@
-var Authorizer = require('core/auth/pusher_authorizer').default;
 var Errors = require('core/errors');
 var PrivateChannel = require('core/channels/private_channel').default;
-var Factory = require('core/utils/factory').default;
 var Mocks = require("mocks");
 
 describe("PrivateChannel", function() {
   var pusher;
   var channel;
-  var factorySpy;
+  var channelAuthorizer;
 
   beforeEach(function() {
-    pusher = Mocks.getPusher({ foo: "bar" });
+    channelAuthorizer = jasmine.createSpy("channelAuthorizer")
+    pusher = Mocks.getPusher({ channelAuthorizer: channelAuthorizer });
     channel = new PrivateChannel("private-test", pusher);
   });
 
@@ -29,49 +28,12 @@ describe("PrivateChannel", function() {
   });
 
   describe("#authorize", function() {
-    var authorizer;
-
-    beforeEach(function() {
-      authorizer = Mocks.getAuthorizer();
-      factorySpy = spyOn(Factory, "createAuthorizer").and.returnValue(authorizer);
-    });
-
-    it("should create and call an authorizer", function() {
-      channel.authorize("1.23", function() {});
-      expect(Factory.createAuthorizer.calls.count()).toEqual(1);
-      expect(Factory.createAuthorizer).toHaveBeenCalledWith(
-        channel,
-        { foo: "bar" }
-      );
-    });
-
-    it("should call back with authorization data", function() {
-      var callback = jasmine.createSpy("callback");
+    it("should call channelAuthorizer", function() {
+      const callback = function(){}
       channel.authorize("1.23", callback);
-
-      expect(callback).not.toHaveBeenCalled();
-      authorizer._callback(false, { foo: "bar" });
-
-      expect(callback).toHaveBeenCalledWith(false, { foo: "bar" });
-    });
-
-    describe('with custom authorizer', function() {
-      beforeEach(function() {
-        pusher = Mocks.getPusher({
-          authorizer: function(channel, options) {
-            return authorizer;
-          }
-        });
-        channel = new PrivateChannel("private-test-custom-auth", pusher);
-        factorySpy.and.callThrough();
-      });
-
-      it("should call the authorizer", function() {
-        var callback = jasmine.createSpy("callback");
-        channel.authorize("1.23", callback);
-        authorizer._callback(false, { foo: "bar" });
-        expect(callback).toHaveBeenCalledWith(false, { foo: "bar" });
-      });
+      expect(channelAuthorizer.calls.count()).toEqual(1);
+      expect(channelAuthorizer).toHaveBeenCalledWith(
+        { socketId: "1.23", channelName: "private-test" }, callback);
     });
   });