@cendarsoss/pusher-js 8.4.11

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

@@ -0,0 +1,303 @@
+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", {cluster: "mt1"});
+      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('state_change', {previous:'connecting', current:'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('state_change', {previous:'connected', current:'disconnected'});
+      pusher.connection.state == "connecting";
+      pusher.connection.emit('state_change', {previous:'disconnected', current:'connecting'});
+      pusher.connection.state == "connected";
+      pusher.connection.emit('state_change', {previous:'connecting', current:'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('state_change', {previous:'connecting', current:'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', {
+        cluster: "mt1",
+        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 () {
+      pusher.user._signinDoneResolve = jasmine.createSpy('signinDoneResolve');
+      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);
+      expect(pusher.user._signinDoneResolve).toHaveBeenCalled();
+    });
+
+    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
+      pusher.user._signinDoneResolve = jasmine.createSpy('signinDoneResolve');
+      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._signinDoneResolve).toHaveBeenCalled();
+
+      // 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
+      pusher.user._signinDoneResolve = jasmine.createSpy('signinDoneResolve');
+      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._signinDoneResolve).toHaveBeenCalled();
+
+      expect(pusher.user.user_data).toEqual({ id: '1', name: 'test' });
+      expect(pusher.user.serverToUserChannel.subscribed).toBe(true);
+
+      // Disconnect
+      pusher.connection.emit('state_change', {previous:'connected', current:'disconnected'});
+
+      expect(pusher.user.user_data).toEqual(null);
+      expect(pusher.user.serverToUserChannel).toEqual(null);
+    });
+  });
+
+});

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

@@ -0,0 +1,74 @@
+var Timers = require('core/utils/timers');
+var PeriodicTimer = Timers.PeriodicTimer;
+
+describe("PeriodicTimer", function() {
+  var callback;
+  var timer;
+
+  beforeEach(function() {
+    jasmine.clock().uninstall();
+    jasmine.clock().install();
+
+    callback = jasmine.createSpy("callback");
+    timer = new PeriodicTimer(123, callback);
+  });
+
+  afterEach(function() {
+    timer.ensureAborted();
+    jasmine.clock().uninstall();
+  });
+
+  it("should keep executing the callback with the specified interval", function() {
+    expect(callback.calls.count()).toEqual(0);
+    jasmine.clock().tick(122);
+    expect(callback.calls.count()).toEqual(0);
+    jasmine.clock().tick(1);
+    expect(callback.calls.count()).toEqual(1);
+
+    expect(callback.calls.count()).toEqual(1);
+    jasmine.clock().tick(122);
+    expect(callback.calls.count()).toEqual(1);
+    jasmine.clock().tick(1);
+    expect(callback.calls.count()).toEqual(2);
+  });
+
+  describe("#isRunning", function() {
+    it("should return true before first execution", function() {
+      jasmine.clock().tick(122);
+      expect(timer.isRunning()).toBe(true);
+    });
+
+    it("should return true after execution", function() {
+      jasmine.clock().tick(123);
+      expect(timer.isRunning()).toBe(true);
+    });
+
+    it("should return false after aborting", function() {
+      timer.ensureAborted();
+      expect(timer.isRunning()).toBe(false);
+    });
+  });
+
+  describe("#ensureAborted", function() {
+    it("should abort the timer before execution", function() {
+      timer.ensureAborted();
+      jasmine.clock().tick(1000000);
+      expect(callback).not.toHaveBeenCalled();
+    });
+
+    it("should play nice after first execution", function() {
+      jasmine.clock().tick(1000);
+      timer.ensureAborted();
+    });
+
+    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
+      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

@@ -0,0 +1,157 @@
+var timers = require('core/utils/timers');
+
+describe("timers", function() {
+  describe("Timer", function() {
+    var callback;
+    var timer;
+
+    beforeEach(function() {
+      jasmine.clock().uninstall();
+      jasmine.clock().install();
+
+      callback = jasmine.createSpy("callback");
+      timer = new timers.OneOffTimer(123, callback);
+    });
+
+    afterEach(function() {
+      timer.ensureAborted();
+      jasmine.clock().uninstall();
+    });
+
+    it("should execute the callback with the specified delay", function() {
+      expect(callback).not.toHaveBeenCalled();
+      jasmine.clock().tick(122);
+      expect(callback).not.toHaveBeenCalled();
+      jasmine.clock().tick(1);
+      expect(callback).toHaveBeenCalled();
+    });
+
+    it("should execute the callback exactly once", function() {
+      jasmine.clock().tick(1000);
+      expect(callback.calls.count()).toEqual(1);
+    });
+
+    describe("#isRunning", function() {
+      it("should return true before execution", function() {
+        jasmine.clock().tick(122);
+        expect(timer.isRunning()).toBe(true);
+      });
+
+      it("should return false after execution", function() {
+        jasmine.clock().tick(123);
+        expect(timer.isRunning()).toBe(false);
+      });
+
+      it("should return false after aborting", function() {
+        timer.ensureAborted();
+        expect(timer.isRunning()).toBe(false);
+      });
+    });
+
+    describe("#ensureAborted", function() {
+      it("should abort the timer before execution", function() {
+        timer.ensureAborted();
+        jasmine.clock().tick(1000);
+        expect(callback).not.toHaveBeenCalled();
+      });
+
+      it("should play nice after execution", function() {
+        jasmine.clock().tick(1000);
+        timer.ensureAborted();
+      });
+
+      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;
+      });
+    });
+  });
+
+  describe("PeriodicTimer", function() {
+    var callback;
+    var timer;
+
+    beforeEach(function() {
+      jasmine.clock().uninstall();
+      jasmine.clock().install();
+
+      callback = jasmine.createSpy("callback");
+      timer = new timers.PeriodicTimer(123, callback);
+    });
+
+    afterEach(function() {
+      timer.ensureAborted();
+      jasmine.clock().uninstall();
+    });
+
+    it("should execute the callback with the specified delay", function() {
+      expect(callback).not.toHaveBeenCalled();
+      jasmine.clock().tick(122);
+      expect(callback).not.toHaveBeenCalled();
+      jasmine.clock().tick(1);
+      expect(callback).toHaveBeenCalled();
+    });
+
+    it("should execute the callback periodically", function() {
+      jasmine.clock().tick(123);
+      expect(callback.calls.count()).toEqual(1);
+      jasmine.clock().tick(123);
+      expect(callback.calls.count()).toEqual(2);
+    });
+
+    describe("#isRunning", function() {
+      it("should return true before execution", function() {
+        jasmine.clock().tick(122);
+        expect(timer.isRunning()).toBe(true);
+      });
+
+      it("should return true after execution", function() {
+        jasmine.clock().tick(123);
+        expect(timer.isRunning()).toBe(true);
+      });
+
+      it("should return false after aborting", function() {
+        timer.ensureAborted();
+        expect(timer.isRunning()).toBe(false);
+      });
+    });
+
+    describe("#ensureAborted", function() {
+      it("should abort the timer before execution", function() {
+        timer.ensureAborted();
+        jasmine.clock().tick(1000);
+        expect(callback).not.toHaveBeenCalled();
+      });
+
+      it("should abort the timer after first execution", function() {
+        jasmine.clock().tick(123);
+        expect(callback.calls.count()).toEqual(1);
+        timer.ensureAborted();
+        jasmine.clock().tick(1000);
+        expect(callback.calls.count()).toEqual(1);
+      });
+
+      it("should be idempotent", function() {
+        timer.ensureAborted();
+        timer.ensureAborted();
+        jasmine.clock().tick(1000);
+        expect(callback).not.toHaveBeenCalled();
+      });
+
+      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

@@ -0,0 +1,14 @@
+var url_store = require('core/utils/url_store').default;
+
+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/channels/server_api/authenticating_users');
+    });
+    it('should return a blank suffix for unknown keys', function(){
+      var suffix = url_store.buildLogSuffix('somethingUnknown');
+      expect(suffix).toEqual('');
+    });
+  });
+});

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);
+      });
+    });
+  })
+});