pingerchips-js 1.0.0 → 2.0.0

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

@@ -1,182 +0,0 @@
-var Errors = require('core/errors');
-var PrivateChannel = require('core/channels/private_channel').default;
-var Mocks = require("mocks");
-
-describe("PrivateChannel", function() {
-  var pusher;
-  var channel;
-  var channelAuthorizer;
-
-  beforeEach(function() {
-    channelAuthorizer = jasmine.createSpy("channelAuthorizer")
-    pusher = Mocks.getPusher({ channelAuthorizer: channelAuthorizer });
-    channel = new PrivateChannel("private-test", pusher);
-  });
-
-  describe("after construction", function() {
-    it("#subscribed should be false", function() {
-      expect(channel.subscribed).toEqual(false);
-    });
-
-    it("#subscriptionPending should be false", function() {
-      expect(channel.subscriptionPending).toEqual(false);
-    });
-
-    it("#subscriptionCancelled should be false", function() {
-      expect(channel.subscriptionCancelled).toEqual(false);
-    });
-  });
-
-  describe("#authorize", function() {
-    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-test" }, callback);
-    });
-  });
-
-  describe("#trigger", function() {
-    beforeEach(function() {
-      channel.subscribed = true;
-    });
-
-    it("should raise an exception if the event name does not start with client-", function() {
-      expect(() => channel.trigger('whatever', {})).toThrow(jasmine.any(Errors.BadEventName));
-    });
-
-    it("should call send_event on connection", function() {
-      channel.trigger("client-test", { k: "v" });
-      expect(pusher.send_event)
-        .toHaveBeenCalledWith("client-test", { k: "v" }, "private-test");
-    });
-
-    it("should return true if connection sent the event", function() {
-      pusher.send_event.and.returnValue(true);
-      expect(channel.trigger("client-test", {})).toBe(true);
-    });
-
-    it("should return false if connection didn't send the event", function() {
-      pusher.send_event.and.returnValue(false);
-      expect(channel.trigger("client-test", {})).toBe(false);
-    });
-  });
-
-  describe("#disconnect", function() {
-    it("should set subscribed to false", function() {
-      channel.handleEvent({
-        event: "pusher_internal:subscription_succeeded"
-      });
-      channel.disconnect();
-      expect(channel.subscribed).toEqual(false);
-    });
-  });
-
-  describe("#handleEvent", function() {
-    it("should not emit pusher_internal:* events", function() {
-      var callback = jasmine.createSpy("callback");
-      channel.bind("pusher_internal:test", callback);
-      channel.bind_global(callback);
-
-      channel.handleEvent({
-        event: "pusher_internal:test"
-      });
-
-      expect(callback).not.toHaveBeenCalled();
-    });
-
-    describe("on pusher_internal:subscription_succeeded", function() {
-      it("should emit pusher:subscription_succeeded", function() {
-        var callback = jasmine.createSpy("callback");
-        channel.bind("pusher:subscription_succeeded", callback);
-
-        channel.handleEvent({
-          event: "pusher_internal:subscription_succeeded",
-          data: "123"
-        });
-
-        expect(callback).toHaveBeenCalledWith("123");
-      });
-
-      it("should set #subscribed to true", function() {
-        channel.handleEvent({
-          event: "pusher_internal:subscription_succeeded",
-          data: "123"
-        });
-
-        expect(channel.subscribed).toEqual(true);
-      });
-
-      it("should set #subscriptionPending to false", function() {
-        channel.handleEvent({
-          event: "pusher_internal:subscription_succeeded",
-          data: "123"
-        });
-
-        expect(channel.subscriptionPending).toEqual(false);
-      });
-    });
-
-    describe("pusher_internal:subscription_succeeded but subscription cancelled", function() {
-      it("should not emit pusher:subscription_succeeded", function() {
-        var callback = jasmine.createSpy("callback");
-        channel.bind("pusher:subscription_succeeded", callback);
-
-        channel.cancelSubscription();
-        channel.handleEvent({
-          event: "pusher_internal:subscription_succeeded",
-          data: "123"
-        });
-
-        expect(callback).not.toHaveBeenCalled();
-      });
-
-      it("should set #subscribed to true", function() {
-        channel.cancelSubscription();
-        channel.handleEvent({
-          event: "pusher_internal:subscription_succeeded",
-          data: "123"
-        });
-
-        expect(channel.subscribed).toEqual(true);
-      });
-
-      it("should set #subscriptionPending to false", function() {
-        channel.cancelSubscription();
-        channel.handleEvent({
-          event: "pusher_internal:subscription_succeeded",
-          data: "123"
-        });
-
-        expect(channel.subscriptionPending).toEqual(false);
-      });
-
-      it("should call #pusher.unsubscribe", function() {
-        expect(pusher.unsubscribe).not.toHaveBeenCalled();
-
-        channel.cancelSubscription();
-        channel.handleEvent({
-          event: "pusher_internal:subscription_succeeded",
-          data: "123"
-        });
-
-        expect(pusher.unsubscribe).toHaveBeenCalledWith(channel.name);
-      });
-    });
-
-    describe("on other events", function() {
-      it("should emit the event", function() {
-        var callback = jasmine.createSpy("callback");
-        channel.bind("something", callback);
-
-        channel.handleEvent({
-          event: "something",
-          data: 9
-        });
-
-        expect(callback).toHaveBeenCalledWith(9, {});
-      });
-    });
-  });
-});

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

@@ -1,507 +0,0 @@
-var TestEnv = require('testenv');
-var Config = require('core/config');
-var Defaults = require('core/defaults').default;
-var Runtime = require('runtime').default;
-var nacl = require('tweetnacl')
-
-describe('Config', function() {
-  beforeEach(function() {
-    if (TestEnv === 'web') {
-      spyOn(Runtime, 'getDocument').and.returnValue({
-        location: {
-          protocol: 'http:'
-        }
-      });
-    }
-  });
-
-  it('should populate defaults', function() {
-    let config = Config.getConfig({});
-    for (let key in getStaticDefaultKeys()) {
-      expect(config[key]).toEqual(Defaults[key])
-    }
-  });
-
-  it('should disable stats by default', function() {
-    let config = Config.getConfig({});
-    expect(config.enableStats).toEqual(false)
-  });
-
-  it('should allow enabling of stats', function() {
-    let config = Config.getConfig({enableStats: true});
-    expect(config.enableStats).toEqual(true)
-  });
-
-  it('should honour deprecated disableStats option', function() {
-    let config = Config.getConfig({disableStats: true});
-    expect(config.enableStats).toEqual(false)
-
-    config = Config.getConfig({disableStats: false});
-    expect(config.enableStats).toEqual(true)
-  });
-
-
-  it('should override config with supplied options', function() {
-    let opts = {
-      pongTimeout: 123,
-      activityTimeout: 345,
-      ignoreNullOrigin: true,
-      wsHost: 'ws-spec.pusher.com',
-      wsPort: 2020,
-      wssPort: 2021,
-      httpHost: 'socksjs-spec.pusher.com',
-      httpPort: 1020,
-      httpsPort: 1021,
-      enableStats: true
-    };
-    let config = Config.getConfig(opts);
-    expect(config).toEqual(jasmine.objectContaining(opts));
-    for (let opt in opts) {
-      expect(config[opt]).toEqual(opts[opt]);
-    }
-  });
-
-  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 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',
-        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 customHandler 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 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: {
-          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 });
-      expect(config.useTLS).toEqual(true);
-    });
-    // deprecated
-    it('should use TLS if encrypted set', function() {
-      let config = Config.getConfig({ encrypted: true });
-      expect(config.useTLS).toEqual(true);
-    });
-    if (TestEnv === 'web') {
-      it('should use TLS when using https', function() {
-        Runtime.getDocument.and.returnValue({
-          location: {
-            protocol: 'https:'
-          }
-        });
-        let config = Config.getConfig({});
-        expect(config.useTLS).toEqual(true);
-      });
-    }
-  });
-
-  it('should not set nacl on config if no nacl provided', function() {
-    let config = Config.getConfig({});
-    expect('nacl' in config).toEqual(false)
-  });
-  it('should set nacl on config if nacl provided', function() {
-    let config = Config.getConfig({ nacl: nacl });
-    expect(config.nacl).toEqual(nacl);
-  });
-});
-function getStaticDefaultKeys() {
-  return [
-    'activityTimeout',
-    'authEndpoint',
-    'authTransport',
-    'cluster',
-    'httpPath',
-    'httpPort',
-    'httpsPort',
-    'pongTimeout',
-    'statsHost',
-    'unavailableTimeout',
-    'wsPath',
-    'wsPort',
-    'wssPort'
-  ]
-}