@cendarsoss/pusher-js 8.4.11

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

@@ -0,0 +1,137 @@
+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",
+        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",
+        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);
+    });
+
+    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/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,128 @@
+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);
+    });
+
+    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);
+    });
+  });
+});

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

@@ -0,0 +1,11 @@
+var sharedTestsContext = require.context("./core", true, /_spec$/);
+sharedTestsContext.keys().forEach(sharedTestsContext);
+
+var nodeTestsContext = require.context("./isomorphic", true, /_spec$/);
+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

@@ -0,0 +1,12 @@
+// the webpack context API uses Object.keys and Array.prototype.forEach
+// both of which are unavailable in old versions of IE.
+require('../polyfills');
+
+var sharedTestsContext = require.context("./core", true, /_spec$/);
+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

@@ -0,0 +1,11 @@
+var sharedTestsContext = require.context("./core", true, /_spec$/);
+sharedTestsContext.keys().forEach(sharedTestsContext);
+
+var nodeTestsContext = require.context("./isomorphic", true, /_spec$/);
+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/isomorphic/transports/hosts_and_ports_spec.js

@@ -0,0 +1,82 @@
+var TestEnv = require('testenv');
+var Pusher = require('core/pusher').default;
+var NetInfo  = require('net_info').NetInfo;
+var Mocks = require('mocks');
+var Defaults = require('core/defaults').default;
+var version = Defaults.VERSION;
+var dependency_suffix = Defaults.dependency_suffix;
+var Runtime = require('runtime').default;
+
+describe("Host/Port Configuration", function() {
+  var transport;
+  var pusher;
+  var Transports;
+
+  beforeEach(function() {
+    spyOn(Runtime, 'getNetwork').and.callFake(function(){
+      var network = new NetInfo();
+      network.isOnline = jasmine.createSpy("isOnline")
+        .and.returnValue(true);
+      return network;
+    });
+    spyOn(Runtime, "getLocalStorage").and.returnValue({});
+  });
+
+  afterEach(function() {
+    try {
+      pusher.disconnect();
+    } catch (e) {
+      console.log(`Received an error when tried to disconnect. Error message: ${e}`);
+    }
+  });
+
+  describe("WebSockets", function() {
+    var _WebSocket;
+
+    beforeEach(function() {
+      spyOn(Runtime, 'createWebSocket').and.returnValue(Mocks.getTransport());
+
+      var Transports = Runtime.Transports;
+
+      spyOn(Transports.ws, "isSupported").and.returnValue(true);
+      spyOn(Transports.xhr_streaming, "isSupported").and.returnValue(false);
+      spyOn(Transports.xhr_polling, "isSupported").and.returnValue(false);
+    });
+
+    it("should connect to wss://ws-<cluster>.pusher.com:443 by default", function() {
+      pusher = new Pusher("foobar", {cluster: "mt1"});
+      pusher.connect();
+
+      expect(Runtime.createWebSocket).toHaveBeenCalledWith(
+        "wss://ws-mt1.pusher.com:443/app/foobar?protocol=7&client=js&version="+version+"&flash=false"
+      );
+    });
+
+    it("should connect to ws://ws-<cluster>.pusher.com:80 by default when forceTLS disabled", function() {
+      pusher = new Pusher("foobar", { cluster: "mt1", forceTLS: false });
+      pusher.connect();
+
+      expect(Runtime.createWebSocket).toHaveBeenCalledWith(
+        "ws://ws-mt1.pusher.com:80/app/foobar?protocol=7&client=js&version="+version+"&flash=false"
+      );
+    });
+
+    it("should connect using wsHost and wssPort when specified in options", function() {
+      pusher = new Pusher("foobar", { cluster: "mt1", wsHost: "example.com", wssPort: 1999 });
+      pusher.connect();
+
+      expect(Runtime.createWebSocket).toHaveBeenCalledWith(
+        "wss://example.com:1999/app/foobar?protocol=7&client=js&version="+version+"&flash=false"
+      );
+    });
+
+    it("should connect using wsHost and wsPort when specified in options and forceTLS disabled", function() {
+      pusher = new Pusher("foobar", { cluster: "mt1", wsHost: "example.org", wsPort: 4444, forceTLS: false });
+      pusher.connect();
+
+      expect(Runtime.createWebSocket).toHaveBeenCalledWith(
+        "ws://example.org:4444/app/foobar?protocol=7&client=js&version="+version+"&flash=false"
+      );
+    });
+  });
+});

package/spec/javascripts/unit/isomorphic/transports/transports_spec.js

@@ -0,0 +1,202 @@
+var Mocks = require("mocks");
+var Factory = require('core/utils/factory').default;
+var Collections = require('core/utils/collections');
+var HTTP = require('runtime').default.HTTPFactory;
+var Runtime = require('runtime').default;
+var VERSION = require('core/defaults').default.VERSION;
+var Transports = Runtime.Transports;
+
+describe("Transports", function() {
+  describe("ws", function() {
+    it("should generate correct non TLS URLs", function() {
+      var url = Transports.ws.hooks.urls.getInitial("foobar", {
+        useTLS: false,
+        hostNonTLS: "example.com:123"
+      });
+      expect(url).toEqual(
+        "ws://example.com:123/app/foobar?protocol=7&client=js&version=" + VERSION + "&flash=false"
+      );
+    });
+
+    it("should generate correct TLS URLs", function() {
+      var url = Transports.ws.hooks.urls.getInitial("foobar", {
+        useTLS: true,
+        hostTLS: "example.org:321"
+      });
+      expect(url).toEqual(
+        "wss://example.org:321/app/foobar?protocol=7&client=js&version=" + VERSION + "&flash=false"
+      );
+    });
+
+    it("should generate correct non TLS URLs with custom path prefix", function() {
+      var url = Transports.ws.hooks.urls.getInitial("foobar", {
+        useTLS: false,
+        hostNonTLS: "example.com:123",
+        httpPath: "/path"
+      });
+      expect(url).toEqual(
+        "ws://example.com:123/path/app/foobar?protocol=7&client=js&version=" + VERSION + "&flash=false"
+      );
+    });
+
+    it("should generate correct TLS URLs with custom path prefix", function() {
+      var url = Transports.ws.hooks.urls.getInitial("foobar", {
+        useTLS: true,
+        hostTLS: "example.org:321",
+        httpPath: "/path"
+      });
+      expect(url).toEqual(
+        "wss://example.org:321/path/app/foobar?protocol=7&client=js&version=" + VERSION + "&flash=false"
+      );
+    });
+
+    it("should not have a resource file", function() {
+      expect(Transports.ws.hooks.file).toBe(undefined);
+    });
+
+    it("should not expose the URL path generator", function() {
+      expect(Transports.ws.hooks.urls.getPath).toBe(undefined);
+    });
+
+    it("should not handle activity checks", function() {
+      expect(Transports.ws.hooks.handlesActivityChecks).toBe(false);
+    });
+
+    it("should not support ping", function() {
+      expect(Transports.ws.hooks.supportsPing).toBe(false);
+    });
+
+    it("should not have a beforeOpen hook", function() {
+      expect(Transports.ws.hooks.beforeOpen).toBe(undefined);
+    });
+
+    describe("isSupported hook", function() {
+      it("should return true", function() {
+        expect(Transports.ws.hooks.isSupported({})).toBe(true);
+      });
+    });
+
+    describe("getSocket hook", function() {
+      it("should return a new WebSocket object, if the class is present", function() {
+        var FakeWebSocket = function(url) {
+          this.url = url;
+        }
+        spyOn(Runtime, 'getWebSocketAPI').and.returnValue(FakeWebSocket);
+        var socket = Transports.ws.hooks.getSocket("testurl");
+        expect(Runtime.getWebSocketAPI.calls.count()).toEqual(1);
+        expect(socket).toEqual(jasmine.any(FakeWebSocket));
+        expect(socket.url).toEqual("testurl");
+      });
+    });
+  });
+
+  var XHR_TRANSPORTS = ["xhr_streaming", "xhr_polling"];
+  var STREAMING_TRANSPORTS = ["xhr_streaming"];
+  var POLLING_TRANSPORTS = ["xhr_polling"];
+
+  Collections.apply(XHR_TRANSPORTS, function(transport) {
+    describe(transport, function() {
+      it("should generate correct non TLS URLs with default path prefix", function() {
+        var url = Transports[transport].hooks.urls.getInitial("foobar", {
+          useTLS: false,
+          hostNonTLS: "example.com:8080"
+        });
+        expect(url).toEqual(
+          "http://example.com:8080/pusher/app/foobar?protocol=7&client=js&version=" + VERSION
+        );
+      });
+
+      it("should generate correct non TLS URLs with custom path prefix", function() {
+        var url = Transports[transport].hooks.urls.getInitial("foobar", {
+          useTLS: false,
+          hostNonTLS: "example.com:8080",
+          httpPath: "/a/b/c"
+        });
+        expect(url).toEqual(
+          "http://example.com:8080/a/b/c/app/foobar?protocol=7&client=js&version=" + VERSION
+        );
+      });
+
+      it("should generate correct TLS URLs with default path prefix", function() {
+        var url = Transports[transport].hooks.urls.getInitial("foobar", {
+          useTLS: true,
+          hostTLS: "example.org:4443"
+        });
+        expect(url).toEqual(
+          "https://example.org:4443/pusher/app/foobar?protocol=7&client=js&version=" + VERSION
+        );
+      });
+
+      it("should generate correct TLS URLs with custom path prefix", function() {
+        var url = Transports[transport].hooks.urls.getInitial("foobar", {
+          useTLS: true,
+          hostTLS: "example.org:4443",
+          httpPath: "/c/b/a"
+        });
+        expect(url).toEqual(
+          "https://example.org:4443/c/b/a/app/foobar?protocol=7&client=js&version=" + VERSION
+        );
+      });
+
+      it("should not expose the URL path generator", function() {
+        expect(Transports[transport].hooks.urls.getPath).toBe(undefined);
+      });
+
+      it("should not handle activity checks", function() {
+        expect(Transports[transport].hooks.handlesActivityChecks).toBe(false);
+      });
+
+      it("should support ping", function() {
+        expect(Transports[transport].hooks.supportsPing).toBe(true);
+      });
+
+      it("should not have a beforeOpen hook", function() {
+        expect(Transports[transport].hooks.beforeOpen).toBe(undefined);
+      });
+    });
+  });
+
+  Collections.apply(XHR_TRANSPORTS, function(transport) {
+    describe(transport, function() {
+      describe("isSupported hook", function() {
+        it("should return true", function(){
+          expect(Transports[transport].hooks.isSupported({})).toBe(true);
+        });
+      });
+    });
+  });
+
+  Collections.apply(STREAMING_TRANSPORTS, function(transport) {
+    describe(transport, function() {
+      describe("getSocket hook", function() {
+        it("should return a new streaming HTTPSocket object", function() {
+          spyOn(HTTP, "createStreamingSocket").and.callFake(function(url) {
+            return "streaming socket mock";
+          });
+
+          var socket = Transports[transport].hooks.getSocket("streamurl");
+          expect(HTTP.createStreamingSocket.calls.count()).toEqual(1);
+          expect(HTTP.createStreamingSocket).toHaveBeenCalledWith("streamurl");
+          expect(socket).toEqual("streaming socket mock");
+        });
+      });
+    });
+  });
+
+  Collections.apply(POLLING_TRANSPORTS, function(transport) {
+    describe(transport, function() {
+      describe("getSocket hook", function() {
+        it("should return a new polling HTTPSocket object", function() {
+          spyOn(HTTP, "createPollingSocket").and.callFake(function(url) {
+            return "polling socket mock";
+          });
+
+          var socket = Transports[transport].hooks.getSocket("streamurl");
+          expect(HTTP.createPollingSocket.calls.count()).toEqual(1);
+          expect(HTTP.createPollingSocket).toHaveBeenCalledWith("streamurl");
+          expect(socket).toEqual("polling socket mock");
+        });
+      });
+    });
+  });
+});