pusher-js 7.0.2 → 7.0.6

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

@@ -1,42 +1,41 @@
-var TestEnv = require('testenv');
-var Pusher = require('pusher_integration');
+const TestEnv = require('testenv');
+const Pusher = require('pusher_integration');
 
 if (TestEnv === "web") window.Pusher = Pusher;
 
-var Integration = require("integration");
-var Mocks = require("mocks");
-var Network = require('net_info').Network;
-var Timer = require("core/utils/timers").OneOffTimer;
-var util = require("core/util").default;
-var Runtime = require('runtime').default;
-var transports = Runtime.Transports;
-var Timer = require('core/utils/timers').OneOffTimer;
+const Integration = require('integration');
+const Mocks = require("mocks");
+const Network = require('net_info').Network;
+const OneOffTimer = require('core/utils/timers').OneOffTimer;
+const Runtime = require('runtime').default;
+const transports = Runtime.Transports;
+const waitsFor = require('../../helpers/waitsFor')
 
 module.exports = function() {
   Integration.describe("Falling back", function() {
     var pusher;
 
     beforeEach(function() {
-      spyOn(Network, "isOnline").andReturn(true);
+      spyOn(Network, "isOnline").and.returnValue(true);
 
-      spyOn(transports.ws, "isSupported").andReturn(false);
-      spyOn(transports.xhr_streaming, "isSupported").andReturn(false);
-      spyOn(transports.xhr_polling, "isSupported").andReturn(false);
+      spyOn(transports.ws, "isSupported").and.returnValue(false);
+      spyOn(transports.xhr_streaming, "isSupported").and.returnValue(false);
+      spyOn(transports.xhr_polling, "isSupported").and.returnValue(false);
 
       if (TestEnv === "web") {
-        spyOn(transports.sockjs, "isSupported").andReturn(false);
-        spyOn(transports.xdr_streaming, "isSupported").andReturn(false);
-        spyOn(transports.xdr_polling, "isSupported").andReturn(false);
+        spyOn(transports.sockjs, "isSupported").and.returnValue(false);
+        spyOn(transports.xdr_streaming, "isSupported").and.returnValue(false);
+        spyOn(transports.xdr_polling, "isSupported").and.returnValue(false);
       }
 
-      spyOn(Runtime, "getLocalStorage").andReturn({});
+      spyOn(Runtime, "getLocalStorage").and.returnValue({});
     });
 
     afterEach(function() {
       pusher.disconnect();
     });
 
-    it("should disable WebSockets after two broken connections", function() {
+    it("should disable WebSockets after two broken connections", async function() {
       var transport;
 
       function createConnection() {
@@ -44,75 +43,75 @@ module.exports = function() {
         return transport;
       }
 
-      transports.ws.isSupported.andReturn(true);
-      spyOn(transports.ws, "createConnection").andCallFake(createConnection);
+      transports.ws.isSupported.and.returnValue(true);
+      spyOn(transports.ws, "createConnection").and.callFake(createConnection);
 
       var timer;
-      runs(function() {
-        pusher = new Pusher("foobar");
-        pusher.connect();
-      });
-      waitsFor(function() {
-        return transports.ws.createConnection.calls.length === 1;
+
+      pusher = new Pusher("foobar");
+      pusher.connect();
+
+      await waitsFor(function() {
+        return transports.ws.createConnection.calls.count() === 1;
       }, "WS connection to be created", 500);
-      runs(function() {
-        transport.state = "initialized";
-        transport.emit("initialized");
-      });
-      waitsFor(function() {
-        return transport.connect.calls.length === 1;
+
+      transport.state = "initialized";
+      transport.emit("initialized");
+
+      await waitsFor(function() {
+        return transport.connect.calls.count() === 1;
       }, "connect to be called", 500);
-      runs(function() {
-        transport.state = "open";
-        transport.emit("open");
-
-        var timer = new Timer(100, function() {
-          transport.emit("closed", {
-            code: 1006,
-            reason: "KABOOM!",
-            wasClean: false
-          });
+
+      transport.state = "open";
+      transport.emit("open");
+
+      var timer = new OneOffTimer(100, function() {
+        transport.emit("closed", {
+          code: 1006,
+          reason: "KABOOM!",
+          wasClean: false
         });
       });
-      waitsFor(function() {
-        return transports.ws.createConnection.calls.length === 2;
+
+      await waitsFor(function() {
+        return transports.ws.createConnection.calls.count() === 2;
       }, "WS connection to be created", 1500);
-      runs(function() {
-        transport.state = "initialized";
-        transport.emit("initialized");
-      });
-      waitsFor(function() {
-        return transport.connect.calls.length === 1;
+
+      transport.state = "initialized";
+      transport.emit("initialized");
+
+      await waitsFor(function() {
+        return transport.connect.calls.count() === 1;
       }, "connect to be called", 500);
-      runs(function() {
-        transport.state = "open";
-        transport.emit("open");
-
-        timer = new Timer(100, function() {
-          transport.emit("closed", {
-            code: 1006,
-            reason: "KABOOM! AGAIN!",
-            wasClean: false
-          });
+
+      transport.state = "open";
+      transport.emit("open");
+
+      timer = new OneOffTimer(100, function() {
+        transport.emit("closed", {
+          code: 1006,
+          reason: "KABOOM! AGAIN!",
+          wasClean: false
         });
       });
-      waitsFor(function() {
+
+
+      await waitsFor(function() {
         return !timer.isRunning();
       }, "the transport to close", 200);
-      runs(function() {
-        timer = new Timer(500, function() {});
-      });
-      waitsFor(function() {
+
+      timer = new OneOffTimer(500, function() {});
+
+      await waitsFor(function() {
         return !timer.isRunning();
       }, "a while", 600);
-      runs(function() {
-        expect(transports.ws.createConnection.calls.length).toEqual(2);
-        pusher.disconnect();
-      });
+
+      expect(transports.ws.createConnection.calls.count()).toEqual(2);
+      pusher.disconnect();
     });
 
     if (TestEnv === "web") {
-      it("should not close established SockJS connection when WebSocket is stuck in handshake", function() {
+      it("should not close established SockJS connection when WebSocket is stuck in handshake", async function() {
         var wsTransport, sockjsTransport;
 
         function createWSConnection() {
@@ -124,74 +123,72 @@ module.exports = function() {
           return sockjsTransport;
         }
 
-        transports.ws.isSupported.andReturn(true);
-        transports.sockjs.isSupported.andReturn(true);
-        spyOn(transports.ws, "createConnection").andCallFake(createWSConnection);
-        spyOn(transports.sockjs, "createConnection").andCallFake(createSockJSConnection);
+        transports.ws.isSupported.and.returnValue(true);
+        transports.sockjs.isSupported.and.returnValue(true);
+        spyOn(transports.ws, "createConnection").and.callFake(createWSConnection);
+        spyOn(transports.sockjs, "createConnection").and.callFake(createSockJSConnection);
 
-        runs(function() {
-          // use TLS connection, to force sockjs to be the primary fallback
-          pusher = new Pusher("foobar", { forceTLS: true });
-          pusher.connect();
-        });
-        waitsFor(function() {
-          return transports.ws.createConnection.calls.length === 1;
+
+        // use TLS connection, to force sockjs to be the primary fallback
+        pusher = new Pusher("foobar", { forceTLS: true });
+        pusher.connect();
+
+        await waitsFor(function() {
+          return transports.ws.createConnection.calls.count() === 1;
         }, "WS connection to be created", 500);
-        runs(function() {
-          wsTransport.state = "initialized";
-          wsTransport.emit("initialized");
-        });
-        waitsFor(function() {
-          return wsTransport.connect.calls.length === 1;
+
+        wsTransport.state = "initialized";
+        wsTransport.emit("initialized");
+
+        await waitsFor(function() {
+          return wsTransport.connect.calls.count() === 1;
         }, "connect on WS to be called", 500);
-        runs(function() {
-          wsTransport.state = "open";
-          wsTransport.emit("open");
-          // start handshake, but don't do anything
-        });
-        waitsFor(function() {
-          return transports.sockjs.createConnection.calls.length === 1;
+
+        wsTransport.state = "open";
+        wsTransport.emit("open");
+        // start handshake, but don't do anything
+
+        await waitsFor(function() {
+          return transports.sockjs.createConnection.calls.count() === 1;
         }, "SockJS connection to be created", 3000);
-        runs(function() {
-          sockjsTransport.state = "initialized";
-          sockjsTransport.emit("initialized");
-        });
-        waitsFor(function() {
-          return sockjsTransport.connect.calls.length === 1;
+
+        sockjsTransport.state = "initialized";
+        sockjsTransport.emit("initialized");
+
+        await waitsFor(function() {
+          return sockjsTransport.connect.calls.count() === 1;
         }, "connect on SockJS to be called", 500);
-        runs(function() {
-          sockjsTransport.state = "open";
-          sockjsTransport.emit("open");
-          sockjsTransport.emit("message", {
-            data: JSON.stringify({
-              event: "pusher:connection_established",
-              data: {
-                socket_id: "123.456",
-                activity_timeout: 120
-              }
-            })
-          });
+
+        sockjsTransport.state = "open";
+        sockjsTransport.emit("open");
+        sockjsTransport.emit("message", {
+          data: JSON.stringify({
+            event: "pusher:connection_established",
+            data: {
+              socket_id: "123.456",
+              activity_timeout: 120
+            }
+          })
         });
-        waitsFor(function() {
-          return wsTransport.close.calls.length === 1;
+
+        await waitsFor(function() {
+          return wsTransport.close.calls.count() === 1;
         }, "close on WS to be called", 500);
 
         var timer;
-        runs(function() {
-          // this caused a connection to be retried after 1s
-          wsTransport.emit("closed", {
-            code: 1000,
-            wasClean: true,
-            reason: "clean"
-          });
-          timer = new Timer(2000, function() {});
+        // this caused a connection to be retried after 1s
+        wsTransport.emit("closed", {
+          code: 1000,
+          wasClean: true,
+          reason: "clean"
         });
-        waitsFor(function() {
+        timer = new OneOffTimer(2000, function() {});
+
+        await waitsFor(function() {
           return !timer.isRunning();
         }, "timer to be called", 2500);
-        runs(function() {
-          expect(sockjsTransport.close).not.toHaveBeenCalled();
-        });
+
+        expect(sockjsTransport.close).not.toHaveBeenCalled();
       });
     }
   });