pusher-js 7.4.1 → 7.6.0

package/integration_tests_server/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "integration_tests_auth_server",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "express": "^4.18.2",
+    "pusher": "^5.1.1-beta"
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pusher-js",
-  "version": "7.4.1",
+  "version": "7.6.0",
   "description": "Pusher Channels JavaScript library for browsers, React Native, NodeJS and web workers",
   "main": "dist/node/pusher.js",
   "browser": "dist/web/pusher.js",
@@ -38,9 +38,9 @@
     "faye-websocket": "^0.11.3",
     "fetch-mock": "git+https://git@github.com/jpatel531/fetch-mock.git",
     "isomorphic-fetch": "^3.0.0",
-    "jasmine": "^3.99.0",
+    "jasmine": "^4.5.0",
     "jasmine-spec-reporter": "^7.0.0",
-    "karma": "^6.4.0",
+    "karma": "^6.4.1",
     "karma-browserstack-launcher": "^1.6.0",
     "karma-chrome-launcher": "^3.1.0",
     "karma-firefox-launcher": "^2.1.1",
@@ -58,12 +58,13 @@
     "uglify-js": "^2.6.2",
     "webpack": "^4.46.0",
     "webpack-cli": "^3.3.12",
-    "webpack-dev-server": "^3.11.2",
+    "webpack-dev-server": "^4.11.1",
     "webpack-merge": "^5.8.0",
     "xmlhttprequest": "^1.8.0"
   },
   "dependencies": {
     "tweetnacl": "^1.0.3",
-    "@types/node": "^14.14.31"
+    "@types/node": "^14.14.31",
+    "@types/express-serve-static-core": "4.17.28"
   }
 }

package/spec/config/karma/config.common.js

@@ -32,7 +32,7 @@ module.exports = {
   autoWatch: true,
 
   browsers: browserList,
-  captureTimeout: 5e3,
+  captureTimeout: 10e3,
   browserNoActivityTimeout: 3e4,
   browserDisconnectTimeout: 3e4,
   browserDisconnectTolerance: 3,
@@ -48,4 +48,3 @@ module.exports = {
     }
   }
 };
-

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

@@ -3,8 +3,8 @@ var Runtime = require('runtime').default
 var Collections = require('core/utils/collections');
 var util = require('core/util').default;
 
-exports.API_URL = "http://pusher-js-integration-api.herokuapp.com";
-exports.API_EU_URL = "http://pusher-js-integration-api-eu.herokuapp.com";
+exports.API_URL = "http://localhost:3000";
+exports.API_EU_URL = "http://localhost:3001";
 
 exports.describe = function(name, body) {
   describe(name + " (integration)", body);

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

@@ -5,8 +5,8 @@ var Collections = require('core/utils/collections');
 var JSONPRequest = require('dom/jsonp_request').default;
 var ScriptReceivers = require('dom/script_receiver_factory').ScriptReceivers;
 
-exports.API_URL = "http://pusher-js-integration-api.herokuapp.com";
-exports.API_EU_URL = "http://pusher-js-integration-api-eu.herokuapp.com";
+exports.API_URL = "http://localhost:3000";
+exports.API_EU_URL = "http://localhost:3001";
 
 exports.describe = function(name, body) {
   if (navigator.userAgent.match(/phantomjs/i)) {

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

@@ -59,7 +59,7 @@ module.exports = function(testConfigs) {
         it("should open a connection to the 'eu' cluster", async function() {
           var authTransport = (TestEnv === "web") ? 'jsonp' : 'ajax';
 
-          pusher = new Pusher("4d31fbea7080e3b4bf6d", {
+          pusher = new Pusher("cb7d5e50f5669e5c9ae6", {
             authTransport: authTransport,
             authEndpoint: Integration.API_EU_URL + "/auth",
             cluster: "eu",

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

@@ -1,28 +1,11 @@
 const Pusher = require('pusher_integration');
 
 const Integration = require('integration');
-const OneOffTimer = require('core/utils/timers').OneOffTimer;
 const Collections = require('core/utils/collections');
 const Runtime = require('runtime').default;
 const TRANSPORTS = Runtime.Transports;
 const waitsFor = require('../../../helpers/waitsFor');
 
-// this is a slightly horrible function that allows easy placement of arbitrary
-// delays in jasmine async tests. e.g:
-// waitsFor(sleep(3000), "thing to happen", 3500)
-function sleep(time) {
-  var fn = function() {
-    var val = false;
-    setTimeout(function(){
-      val = true;
-    }, time)
-    return function() {
-      return val;
-    }
-  }
-  return fn();
-}
-
 function canRunTwoConnections(transport) {
   if (transport !== "sockjs") {
     return true;
@@ -38,6 +21,10 @@ function subscribe(pusher, channelName, callback) {
   return channel;
 }
 
+function delay(timeMs) {
+  return new Promise(resolve => setTimeout(resolve, timeMs));
+}
+
 function build(testConfig) {
   var forceTLS = testConfig.forceTLS;
   var transport = testConfig.transport;
@@ -67,11 +54,11 @@ function build(testConfig) {
 
     describe("setup", function() {
       it("should open connections", async function() {
-        pusher1 = new Pusher("7324d55a5eeb8f554761", {
+        pusher1 = new Pusher("c49a449b916bb4246729", {
           forceTLS: forceTLS,
         });
         if (canRunTwoConnections(transport)) {
-          pusher2 = new Pusher("7324d55a5eeb8f554761", {
+          pusher2 = new Pusher("c49a449b916bb4246729", {
             forceTLS: forceTLS,
           });
           await waitsFor(function() {
@@ -401,11 +388,7 @@ function buildClientEventsTests(getPusher1, getPusher2, prefix) {
 
     channel.bind(eventName, onEvent);
     pusher.send_event(eventName, {}, channelName);
-    timer = new OneOffTimer(3000, function() {});
-
-    await waitsFor(function() {
-      return !timer.isRunning();
-    }, "timer to finish", 3210);
+    await delay(5000);
 
     expect(onEvent).not.toHaveBeenCalled();
     pusher.unsubscribe(channelName);
@@ -470,12 +453,7 @@ function buildPublicChannelTests(getPusher, prefix) {
       event: eventName,
       data: {}
     });
-    timer = new OneOffTimer(3000, function() {});
-
-    await waitsFor(function() {
-      return !timer.isRunning();
-    }, "timer to finish", 3210);
-
+    await delay(5000);
     expect(received).toBe(null);
   });
 
@@ -519,11 +497,7 @@ function buildPublicChannelTests(getPusher, prefix) {
       event: eventName,
       data: {}
     });
-    timer = new OneOffTimer(3000, function() {});
-
-    await waitsFor(function() {
-      return !timer.isRunning();
-    }, "timer to finish", 10000);
+    await delay(5000);
 
     expect(channel.subscribed).toEqual(false);
     expect(received).toBe(null);
@@ -554,11 +528,7 @@ function buildPublicChannelTests(getPusher, prefix) {
       event: eventName,
       data: {}
     });
-    timer = new OneOffTimer(3000, function() {});
-
-    await waitsFor(function() {
-      return !timer.isRunning();
-    }, "timer to finish", 10000);
+    await delay(10000);
 
     expect(channel.subscribed).toEqual(true);
     expect(received).not.toBe(null);
@@ -627,7 +597,7 @@ function buildSubscriptionStateTests(getPusher, prefix) {
 
     // there is no easy way to know when an unsubscribe request has been
     // actioned by the server, so we just wait a while
-    await waitsFor(sleep(3000), "unsubscription to finish", 3500)
+    await delay(5000);
 
     expect(pusher.channel(channelName)).toBe(undefined);
   });
@@ -697,7 +667,7 @@ function buildSubscriptionStateTests(getPusher, prefix) {
 
     // there is no easy way to know when an unsubscribe request has been
     // actioned by the server, so we just wait a while
-    await waitsFor(sleep(3000), "unsubscription to finish", 3500)
+    await delay(5000);
     expect(pusher.channel(channelName)).toBe(undefined);
 
     pusher.subscribe(channelName)
@@ -735,7 +705,7 @@ function buildSubscriptionStateTests(getPusher, prefix) {
 
     // there is no easy way to know when an unsubscribe request has been
     // actioned by the server, so we just wait a while
-    await waitsFor(sleep(3000), "unsubscription to finish", 3500)
+    await delay(5000);
 
     expect(pusher.channel(channelName)).toBe(undefined);
   });

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

@@ -37,10 +37,10 @@ Integration.describe("JSONP", function() {
 
     expect(callback.calls.count()).toEqual(1);
     expect(callback).toHaveBeenCalledWith(null, {
-      "session": "2289545",
+      "session": 2289545,
       "features": ["ws", "sockjs"],
       "version": "1.13.0",
-      "t0": "1355850357911",
+      "t0": 1355850357911,
       "timeline": [
         { t:    0, e: 2 },
         { t:    2, e: 2, type: "ws" },

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

@@ -198,6 +198,54 @@ describe('Config', function() {
       );
     });
 
+    it('should use channelAuthorization with providers and override deprecated auth options', function() {
+      let headersProvider = () => { return { abc: '123'} };
+      let paramsProvider = () => { return { def: '456'} };
+      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' },
+          headersProvider,
+          paramsProvider
+        }
+      };
+      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' },
+        headersProvider,
+        paramsProvider
+      }
+      const query = 'socket_id=1.23&channel_name=private-test&spec2=param2&def=456';
+      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',
@@ -239,7 +287,7 @@ describe('Config', function() {
     });
 
 
-    it('should use customerHandler inside channelAuthorization', function() {
+    it('should use customHandler inside channelAuthorization', function() {
       const customHandler = jasmine.createSpy('customHandler');
       let opts = {
         channelAuthorization: {
@@ -287,7 +335,7 @@ describe('Config', function() {
           transport: 'some-auth-transport',
           endpoint: '/pusher/spec/auth',
           params: { foo: 'bar' },
-          headers: { spec: 'header' }
+          headers: { spec: 'header' },
         }
       };
 
@@ -302,7 +350,7 @@ describe('Config', function() {
         transport: 'some-auth-transport',
         endpoint: '/pusher/spec/auth',
         params: { foo: 'bar' },
-        headers: { spec: 'header' }
+        headers: { spec: 'header' },
       }
       const query = 'socket_id=1.23&foo=bar';
       expect(transportAuthorizer.calls.count()).toEqual(1);
@@ -315,6 +363,46 @@ describe('Config', function() {
       );
     });
 
+    it('should use userAuthentication options with providers for user authentication', function() {
+      let headersProvider = () => { return { abc: '123'} };
+      let paramsProvider = () => { return { def: '456'} };
+      let opts = {
+        userAuthentication: {
+          transport: 'some-auth-transport',
+          endpoint: '/pusher/spec/auth',
+          params: { foo: 'bar' },
+          headers: { spec: 'header' },
+          headersProvider,
+          paramsProvider
+        }
+      };
+
+      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' },
+        headersProvider,
+        paramsProvider
+      }
+      const query = 'socket_id=1.23&foo=bar&def=456';
+      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: {

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

@@ -13,7 +13,17 @@ describe("ConnectionManager", function() {
   });
 
   afterAll(() => {
-    jasmine.clock().uninstall();
+    try {
+      jasmine.clock().uninstall();
+    } catch (e) {
+      if (e instanceof TypeError) {
+        // Ignore
+        // It's a bug in jasmine AFAIK and all other attempts of working
+        // around it led to other issues
+      } else {
+        throw e;
+      }
+    }
   });
 
   beforeEach(function() {

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

@@ -163,12 +163,6 @@ describe("HTTPRequest", function() {
     });
   });
 
-  describe("on request end", function() {
-    beforeEach(function() {
-      request.start();
-    });
-  });
-
   describe("on page unload", function() {
     var unloader;
 

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

@@ -225,6 +225,11 @@ describe("TransportConnection", function() {
             expect(loadCallback).toHaveBeenCalledWith(false);
           });
         });
+      } else {
+        // Needed so that the describe block isn't empty
+        it("dummy test", function() {
+          expect(true).toBe(true);
+        })
       }
     });
   });

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

@@ -1,10 +1,6 @@
 var timers = require('core/utils/timers');
 
 describe("timers", function() {
-  afterEach(() => {
-    jasmine.clock().uninstall();
-  });
-
   describe("Timer", function() {
     var callback;
     var timer;

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

@@ -0,0 +1,48 @@
+var WatchlistFacade = require("core/watchlist").default;
+
+describe("WatchlistFacade", function () {
+  var connection;
+  var pusher;
+
+  beforeEach(function() {
+    connection = jasmine.createSpy('connection');
+    pusher = jasmine.createSpy('pusher');
+    pusher.connection = connection;
+
+    spyOn(pusher.connection, 'bind')
+  });
+
+  it('should bind to pusher_internal:user_presence events', function() {
+    new WatchlistFacade(pusher);
+    expect(connection.bind).toHaveBeenCalledWith('message', jasmine.any(Function));
+  });
+
+  describe('#handleEvent', function() {
+    var watchlistFacade;
+
+    beforeEach(function() {
+      watchlistFacade = new WatchlistFacade(pusher);
+    });
+
+    const watchlistEvents = [
+      { name: 'online', user_ids: ['1'] },
+      { name: 'offline', user_ids: ['2', '3', '4'] },
+      { name: 'subscribe', user_ids: ['5', '6'], channel_name: 'presence-chat' }
+    ];
+
+    it(`should emit ${watchlistEvents.length} events`, function() {
+      const pusherEvent = {
+        event: 'pusher_internal:watchlist_events',
+        data: { events: watchlistEvents }
+      };
+
+      spyOn(watchlistFacade, 'emit').and.callThrough();
+      watchlistFacade.handleEvent(pusherEvent);
+      
+      expect(watchlistFacade.emit).toHaveBeenCalledTimes(watchlistEvents.length)
+      watchlistEvents.forEach(function(event) {
+        expect(watchlistFacade.emit).toHaveBeenCalledWith(event.name, event);
+      });
+    });
+  })
+});

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

@@ -26,6 +26,32 @@ describe("ChannelAuthorizer", function() {
     });
 
     it("should call the specified transport authorizer", function(){
+      const authOptions = {
+        transport: "ajax",
+        endpoint: "http://example.com/auth",
+        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';
+      channelAuthorizer(params, callback);
+      expect(Runtime.getAuthorizers.calls.count()).toEqual(1);
+      expect(transportAuthorizer).toHaveBeenCalledWith(
+        Runtime,
+        query,
+        authOptions,
+        'channel-authorization',
+        callback);
+    });
+
+    it("should call the specified transport authorizer with params", function(){
       const authOptions = {
         transport: "ajax",
         endpoint: "http://example.com/auth",
@@ -51,5 +77,61 @@ describe("ChannelAuthorizer", function() {
         'channel-authorization',
         callback);
     });
+
+    it("should call the specified transport authorizer with paramsProvider", function(){
+      const authOptions = {
+        transport: "ajax",
+        endpoint: "http://example.com/auth",
+        paramsProvider: () => { return { abc: '123' }; },
+        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&abc=123';
+      channelAuthorizer(params, callback);
+      expect(Runtime.getAuthorizers.calls.count()).toEqual(1);
+      expect(transportAuthorizer).toHaveBeenCalledWith(
+        Runtime,
+        query,
+        authOptions,
+        'channel-authorization',
+        callback);
+    });
+
+
+    it("should call the specified transport authorizer with params and paramsProvider", function(){
+      const authOptions = {
+        transport: "ajax",
+        endpoint: "http://example.com/auth",
+        params: { foo: "bar" },
+        paramsProvider: () => { return { abc: '123' }; },
+        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&abc=123';
+      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/user_authorizer_spec.js

@@ -48,5 +48,81 @@ describe("UserAuthenticator", function() {
         'user-authentication',
         callback);
     });
+
+    it("should call the specified transport authorizer with params", function(){
+      const userAuthentication = {
+        transport: "ajax",
+        params: { abc: '123' }
+      };
+      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&abc=123';
+      userAuthenticator(params, callback);
+      expect(Runtime.getAuthorizers.calls.count()).toEqual(1);
+      expect(transportAuthorizer).toHaveBeenCalledWith(
+        Runtime,
+        query,
+        userAuthentication,
+        'user-authentication',
+        callback);
+    });
+
+    it("should call the specified transport authorizer with paramsProvider", function(){
+      const userAuthentication = {
+        transport: "ajax",
+        paramsProvider: () => { return { abc: '123' }; }
+      };
+      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&abc=123';
+      userAuthenticator(params, callback);
+      expect(Runtime.getAuthorizers.calls.count()).toEqual(1);
+      expect(transportAuthorizer).toHaveBeenCalledWith(
+        Runtime,
+        query,
+        userAuthentication,
+        'user-authentication',
+        callback);
+    });
+
+    it("should call the specified transport authorizer with params and paramsProvider", function(){
+      const userAuthentication = {
+        transport: "ajax",
+        params: { abc: '123' },
+        paramsProvider: () => { return { def: '456' }; }
+      };
+      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&abc=123&def=456';
+      userAuthenticator(params, callback);
+      expect(Runtime.getAuthorizers.calls.count()).toEqual(1);
+      expect(transportAuthorizer).toHaveBeenCalledWith(
+        Runtime,
+        query,
+        userAuthentication,
+        'user-authentication',
+        callback);
+    });
   });
 });