@cendarsoss/pusher-js 8.4.11

package/spec/javascripts/unit/core/strategies/best_connected_ever_strategy_spec.js

@@ -0,0 +1,104 @@
+var Mocks = require("mocks");
+var BestConnectedEverStrategy = require('core/strategies/best_connected_ever_strategy').default;
+
+describe("BestConnectedEverStrategy", function() {
+  beforeEach(function() {
+    this.substrategies = Mocks.getStrategies([true, true, true]);
+    this.strategy = new BestConnectedEverStrategy(this.substrategies);
+
+    this.callback = jasmine.createSpy();
+  });
+
+  describe("on connect", function() {
+    beforeEach(function() {
+      this.strategy.connect(0, this.callback);
+    });
+
+    it("should call connect on all substrategies", function() {
+      expect(this.substrategies[0].connect).toHaveBeenCalled();
+      expect(this.substrategies[1].connect).toHaveBeenCalled();
+      expect(this.substrategies[2].connect).toHaveBeenCalled();
+    });
+
+    describe("after establishing a connection", function() {
+      var transport1;
+      beforeEach(function() {
+        transport1 = Mocks.getTransport();
+        transport1.priority = 7;
+        this.substrategies[0]._callback(null, { transport: transport1 });
+      });
+
+      it("should call back with first successful transport", function() {
+        expect(this.callback).toHaveBeenCalledWith(null, {
+          transport: transport1
+        });
+        expect(this.callback.calls.count()).toEqual(1);
+      });
+
+      it("should force min priorities on all substrategies", function() {
+        expect(this.substrategies[0]._forceMinPriority).toHaveBeenCalledWith(7);
+        expect(this.substrategies[1]._forceMinPriority).toHaveBeenCalledWith(7);
+        expect(this.substrategies[2]._forceMinPriority).toHaveBeenCalledWith(7);
+      });
+
+      it("should call back again if another substrategy succeeds", function() {
+        var transport2 = Mocks.getTransport();
+        transport2.priority = 19;
+
+        this.substrategies[2]._callback(null, { transport: transport2 });
+
+        expect(this.callback).toHaveBeenCalledWith(null, {
+          transport: transport2
+        });
+        expect(this.callback.calls.count()).toEqual(2);
+      });
+    });
+
+    describe("on substrategy errors", function() {
+      it("should pass an error after all substrategies failed", function() {
+        this.substrategies[1]._callback(true);
+        expect(this.callback).not.toHaveBeenCalled();
+        this.substrategies[0]._callback(true);
+        expect(this.callback).not.toHaveBeenCalled();
+        this.substrategies[2]._callback(true);
+        expect(this.callback).toHaveBeenCalledWith(true);
+      });
+
+      it("should not pass errors after one substrategy succeeded", function() {
+        var transport = Mocks.getTransport();
+        this.substrategies[0]._callback(null, { transport: transport });
+        expect(this.callback.calls.count()).toEqual(1);
+
+        this.substrategies[1]._callback(true);
+        expect(this.callback.calls.count()).toEqual(1);
+        this.substrategies[2]._callback(true);
+        expect(this.callback.calls.count()).toEqual(1);
+      });
+    });
+  });
+
+  describe("on abort", function() {
+    it("should abort non-failed substrategies", function() {
+      var runner = this.strategy.connect(0, this.callback);
+      var transport = Mocks.getTransport();
+
+      this.substrategies[1]._callback(true);
+      this.substrategies[2]._callback(null, { transport: transport });
+      runner.abort();
+
+      expect(this.substrategies[0]._abort).toHaveBeenCalled();
+      expect(this.substrategies[1]._abort).not.toHaveBeenCalled();
+      expect(this.substrategies[2]._abort).toHaveBeenCalled();
+    });
+  });
+
+  describe("on forceMinPriority", function() {
+    it("should force the priority on all substrategies", function() {
+      var runner = this.strategy.connect(0, this.callback);
+      runner.forceMinPriority(991);
+      expect(this.substrategies[0]._forceMinPriority).toHaveBeenCalledWith(991);
+      expect(this.substrategies[1]._forceMinPriority).toHaveBeenCalledWith(991);
+      expect(this.substrategies[2]._forceMinPriority).toHaveBeenCalledWith(991);
+    });
+  });
+});

package/spec/javascripts/unit/core/strategies/delayed_strategy_spec.js

@@ -0,0 +1,95 @@
+var Mocks = require("mocks");
+var DelayedStrategy = require('core/strategies/delayed_strategy').default;
+
+describe("DelayedStrategy", function() {
+  beforeEach(function() {
+    this.substrategy = Mocks.getStrategy(true);
+    this.strategy = new DelayedStrategy(this.substrategy, { delay: 0 });
+    this.callback = jasmine.createSpy();
+
+    jasmine.clock().uninstall();
+    jasmine.clock().install();
+  });
+
+  afterEach(function() {
+    jasmine.clock().uninstall();
+  });
+
+  describe("after calling isSupported", function() {
+    it("should return true if substrategy is supported", function() {
+      var substrategy = Mocks.getStrategy(true);
+      var strategy = new DelayedStrategy(substrategy, {});
+      expect(strategy.isSupported()).toBe(true);
+    });
+
+    it("should return false if substrategy is not supported", function() {
+      var substrategy = Mocks.getStrategy(false);
+      var strategy = new DelayedStrategy(substrategy, {});
+      expect(strategy.isSupported()).toBe(false);
+    });
+  });
+
+  describe("on connect", function() {
+    it("should connect to substrategy after a delay", function() {
+      var strategy = new DelayedStrategy(this.substrategy, {
+        delay: 100
+      });
+
+      strategy.connect(0, this.callback);
+
+      expect(this.substrategy.connect).not.toHaveBeenCalled();
+      jasmine.clock().tick(99);
+      expect(this.substrategy.connect).not.toHaveBeenCalled();
+      jasmine.clock().tick(1);
+      expect(this.substrategy.connect).toHaveBeenCalled();
+
+      var handshake = {};
+      this.substrategy._callback(null, handshake);
+
+      expect(this.callback).toHaveBeenCalledWith(null, handshake);
+    });
+
+    it("should pass an error when substrategy fails", function() {
+      this.strategy.connect(0, this.callback);
+      jasmine.clock().tick(0);
+      this.substrategy._callback(true);
+
+      expect(this.callback).toHaveBeenCalledWith(true);
+    });
+  });
+
+  describe("on abort", function() {
+    it("should abort substrategy when connecting", function() {
+      var runner = this.strategy.connect(0);
+      jasmine.clock().tick(0);
+      runner.abort();
+      expect(this.substrategy._abort).toHaveBeenCalled();
+    });
+
+    it("should clear the timer and not abort substrategy when waiting", function() {
+      var run = this.strategy.connect(0);
+      expect(this.substrategy.connect).not.toHaveBeenCalled();
+      run.abort();
+      jasmine.clock().tick(10000);
+      expect(this.substrategy._abort).not.toHaveBeenCalled();
+      expect(this.substrategy.connect).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("on forceMinPriority", function() {
+    it("should force the priority while waiting", function() {
+      var runner = this.strategy.connect(0, this.callback);
+      runner.forceMinPriority(5);
+      jasmine.clock().tick(0);
+      expect(this.substrategy.connect)
+        .toHaveBeenCalledWith(5, jasmine.any(Function));
+    });
+
+    it("should force the priority while connecting", function() {
+      var runner = this.strategy.connect(0, this.callback);
+      jasmine.clock().tick(0);
+      runner.forceMinPriority(5);
+      expect(this.substrategy._forceMinPriority).toHaveBeenCalledWith(5);
+    });
+  });
+});

package/spec/javascripts/unit/core/strategies/first_connected_strategy_spec.js

@@ -0,0 +1,68 @@
+var Mocks = require("mocks");
+var FirstConnectedStrategy = require('core/strategies/first_connected_strategy').default;
+
+describe("FirstConnectedStrategy", function() {
+  var substrategy;
+  var callback;
+  var strategy;
+
+  beforeEach(function() {
+    substrategy = Mocks.getStrategy(true);
+    strategy = new FirstConnectedStrategy(substrategy);
+    state = {};
+
+    callback = jasmine.createSpy();
+  });
+
+  describe("after calling isSupported", function() {
+    it("should return true when the substrategy is supported", function() {
+      var substrategy = Mocks.getStrategy(true);
+      var strategy = new FirstConnectedStrategy(substrategy);
+      expect(strategy.isSupported()).toBe(true);
+    });
+
+    it("should return false when the substrategy is not supported", function() {
+      var substrategy = Mocks.getStrategy(false);
+      var strategy = new FirstConnectedStrategy(substrategy);
+      expect(strategy.isSupported()).toBe(false);
+    });
+  });
+
+  describe("on connect", function() {
+    it("should succeed on first connection and abort the substrategy", function() {
+      strategy.connect(0, callback);
+
+      expect(substrategy.connect)
+        .toHaveBeenCalledWith(0, jasmine.any(Function));
+
+      var handshake = {};
+      substrategy._callback(null, handshake);
+
+      expect(callback).toHaveBeenCalledWith(null, handshake);
+      expect(substrategy._abort).toHaveBeenCalled();
+    });
+
+    it("should pass an error when the substrategy fails", function() {
+      strategy.connect(0, callback);
+
+      substrategy._callback(true);
+      expect(callback).toHaveBeenCalledWith(true, undefined);
+    });
+  });
+
+  describe("on abort", function() {
+    it("should abort the substrategy", function() {
+      var runner = strategy.connect(0);
+      runner.abort();
+      expect(substrategy._abort).toHaveBeenCalled();
+    });
+  });
+
+  describe("on forceMinPriority", function() {
+    it("should force the priority on the substrategy", function() {
+      var runner = strategy.connect(0, this.callback);
+      runner.forceMinPriority(5);
+      expect(substrategy._forceMinPriority).toHaveBeenCalledWith(5);
+    });
+  });
+});

package/spec/javascripts/unit/core/strategies/if_strategy_spec.js

@@ -0,0 +1,165 @@
+var Mocks = require("mocks");
+
+var IfStrategy = require('core/strategies/if_strategy').default;
+
+describe("IfStrategy", function() {
+  var test, trueBranch, falseBranch;
+  var callback;
+
+  beforeEach(function() {
+    trueBranch = Mocks.getStrategy(true);
+    falseBranch = Mocks.getStrategy(true);
+    callback = jasmine.createSpy();
+  });
+
+  describe("when the test is true", function() {
+    var strategy;
+
+    beforeEach(function() {
+      test = function() { return true; };
+      strategy = new IfStrategy(test, trueBranch, falseBranch);
+    });
+
+    describe("#isSupported", function() {
+      it("should return true if the 'true' branch is supported", function() {
+        trueBranch = Mocks.getStrategy(true);
+        falseBranch = Mocks.getStrategy(false);
+        var strategy = new IfStrategy(
+          test, trueBranch, falseBranch
+        );
+        expect(strategy.isSupported()).toBe(true);
+      });
+
+      it("should return false if the 'true' branch is not supported", function() {
+        trueBranch = Mocks.getStrategy(false);
+        falseBranch = Mocks.getStrategy(true);
+        var strategy = new IfStrategy(
+          test, trueBranch, falseBranch
+        );
+        expect(strategy.isSupported()).toBe(false);
+      });
+    });
+
+    describe("#connect", function() {
+      beforeEach(function() {
+        strategy.connect(0, callback);
+      });
+
+      it("should connect using the 'true' branch", function() {
+        expect(trueBranch.connect).toHaveBeenCalled();
+        expect(falseBranch.connect).not.toHaveBeenCalled();
+      });
+
+      it("should connect with correct priority using the 'true' branch", function() {
+        strategy.connect(5, callback);
+        expect(trueBranch.connect)
+          .toHaveBeenCalledWith(5, jasmine.any(Function));
+      });
+
+      it("should call back with a connection after the 'true' branch succeeds", function() {
+        var handshake = {};
+        trueBranch._callback(null, handshake);
+        expect(callback).toHaveBeenCalledWith(null, handshake);
+      });
+
+      it("should call back with an error when the 'true' branch fails", function() {
+        trueBranch._callback("boom");
+        expect(callback).toHaveBeenCalledWith("boom");
+      });
+    });
+
+    describe("with a runner returned from #connect", function() {
+      var runner;
+
+      beforeEach(function() {
+        runner = strategy.connect(0, callback);
+      });
+
+      it("should abort the attempt from the 'true' branch", function() {
+        runner.abort();
+        expect(trueBranch._abort).toHaveBeenCalled();
+      });
+
+      it("should force priority on the attempt from the 'true' branch", function() {
+        runner.forceMinPriority(42);
+        expect(trueBranch._forceMinPriority).toHaveBeenCalledWith(42);
+      });
+    });
+  });
+
+  describe("when the test is false", function() {
+    var strategy;
+
+    beforeEach(function() {
+      test = function() { return false; };
+      strategy = new IfStrategy(test, trueBranch, falseBranch);
+    });
+
+    describe("after calling isSupported", function() {
+      it("should return true if the 'false' branch is supported", function() {
+        trueBranch = Mocks.getStrategy(false);
+        falseBranch = Mocks.getStrategy(true);
+        var strategy = new IfStrategy(
+          test, trueBranch, falseBranch
+        );
+        expect(strategy.isSupported()).toBe(true);
+      });
+
+      it("should return false if the 'false' branch is not supported", function() {
+        trueBranch = Mocks.getStrategy(true);
+        falseBranch = Mocks.getStrategy(false);
+        var strategy = new IfStrategy(
+          test, trueBranch, falseBranch
+        );
+        expect(strategy.isSupported()).toBe(false);
+      });
+    });
+
+    describe("#connect", function() {
+      it("should connect using the 'false' branch", function() {
+        strategy.connect(0, callback);
+        expect(falseBranch.connect).toHaveBeenCalled();
+        expect(trueBranch.connect).not.toHaveBeenCalled();
+      });
+
+      it("should connect with correct priority using the 'false' branch", function() {
+        strategy.connect(111, callback);
+        expect(falseBranch.connect)
+          .toHaveBeenCalledWith(111, jasmine.any(Function));
+      });
+
+      it("should call back with a connection after the 'false' branch succeeds", function() {
+        strategy.connect(0, callback);
+
+        var handshake = {};
+        falseBranch._callback(null, handshake);
+        expect(callback).toHaveBeenCalledWith(null, handshake);
+      });
+
+      it("should call back with an error when the 'false' branch fails", function() {
+        strategy.connect(0, callback);
+
+        falseBranch._callback("boom");
+        expect(callback).toHaveBeenCalledWith("boom");
+      });
+    });
+
+    describe("with a runner returned from #connect", function() {
+      var runner;
+
+      beforeEach(function() {
+        runner = strategy.connect(0, callback);
+      });
+
+      it("should abort the attempt from the 'false' branch", function() {
+        runner.abort();
+        expect(falseBranch._abort).toHaveBeenCalled();
+      });
+
+      it("should force priority on the attempt from the 'false' branch", function() {
+        runner.forceMinPriority(42);
+        expect(falseBranch._forceMinPriority).toHaveBeenCalledWith(42);
+      });
+    });
+  });
+});

package/spec/javascripts/unit/core/strategies/sequential_strategy_spec.js

@@ -0,0 +1,213 @@
+var Mocks = require("mocks");
+var SequentialStrategy = require('core/strategies/sequential_strategy').default;
+
+describe("SequentialStrategy", function() {
+  beforeEach(function() {
+    this.callback = jasmine.createSpy();
+    this.substrategies = Mocks.getStrategies([true, true]);
+    this.strategy = new SequentialStrategy(this.substrategies, {});
+
+    jasmine.clock().uninstall();
+    jasmine.clock().install();
+  });
+
+  afterEach(function() {
+    jasmine.clock().uninstall();
+  });
+
+  describe("after calling isSupported", function() {
+    it("should return true when one of substrategies is supported", function() {
+      var substrategies = Mocks.getStrategies([false, true]);
+      var strategy = new SequentialStrategy(substrategies, {});
+      expect(strategy.isSupported()).toBe(true);
+    });
+
+    it("should return false when none of substrategies are supported", function() {
+      var substrategies = Mocks.getStrategies([false, false]);
+      var strategy = new SequentialStrategy(substrategies, {});
+      expect(strategy.isSupported()).toBe(false);
+    });
+  });
+
+  describe("on connect", function() {
+    it("should finish on first successful substrategy", function() {
+      this.strategy.connect(0, this.callback);
+
+      expect(this.substrategies[0].connect).toHaveBeenCalled();
+      expect(this.substrategies[1].connect).not.toHaveBeenCalled();
+
+      var handshake = {};
+      this.substrategies[0]._callback(null, handshake);
+
+      expect(this.callback).toHaveBeenCalledWith(null, handshake);
+      expect(this.substrategies[0]._abort).not.toHaveBeenCalled();
+      expect(this.substrategies[1].connect).not.toHaveBeenCalled();
+    });
+
+    it("should fail after trying all supported substrategies", function() {
+      this.strategy.connect(0, this.callback);
+
+      expect(this.substrategies[0].connect).toHaveBeenCalled();
+      expect(this.substrategies[1].connect).not.toHaveBeenCalled();
+
+      this.substrategies[0]._callback(true);
+      expect(this.substrategies[1].connect).toHaveBeenCalled();
+
+      this.substrategies[1]._callback(true);
+      expect(this.substrategies[1]._abort).not.toHaveBeenCalled();
+      expect(this.callback).toHaveBeenCalledWith(true);
+      expect(this.callback.calls.count()).toEqual(1);
+    });
+
+    it("should support looping", function() {
+      var strategy = new SequentialStrategy(this.substrategies, {
+        loop: true
+      });
+      var runner = strategy.connect(0, this.callback);
+
+      expect(this.substrategies[0].connect.calls.count()).toEqual(1);
+      expect(this.substrategies[1].connect.calls.count()).toEqual(0);
+
+      this.substrategies[0]._callback(true);
+
+      expect(this.substrategies[0].connect.calls.count()).toEqual(1);
+      expect(this.substrategies[1].connect.calls.count()).toEqual(1);
+
+      this.substrategies[1]._callback(true);
+
+      expect(this.substrategies[0].connect.calls.count()).toEqual(2);
+      expect(this.substrategies[1].connect.calls.count()).toEqual(1);
+
+      runner.abort();
+      expect(this.substrategies[0]._abort).toHaveBeenCalled();
+    });
+  });
+
+  describe("on abort", function() {
+    it("should send abort to first tried substrategy", function() {
+      var runner = this.strategy.connect(0, this.callback);
+
+      expect(this.substrategies[0].connect).toHaveBeenCalled();
+      expect(this.substrategies[1].connect).not.toHaveBeenCalled();
+
+      runner.abort();
+
+      expect(this.substrategies[0]._abort).toHaveBeenCalled();
+      expect(this.substrategies[1].connect).not.toHaveBeenCalled();
+    });
+
+    it("should send abort to second tried substrategy", function() {
+      var runner = this.strategy.connect(0, this.callback);
+
+      this.substrategies[0]._callback(true);
+      expect(this.substrategies[1].connect).toHaveBeenCalled();
+
+      runner.abort();
+      expect(this.substrategies[1]._abort).toHaveBeenCalled();
+    });
+
+    it("should stop retrying with timeouts", function() {
+      var strategy = new SequentialStrategy(this.substrategies, {
+        timeout: 100
+      });
+      var runner = strategy.connect(0, this.callback);
+
+      expect(this.substrategies[0].connect).toHaveBeenCalled();
+      expect(this.substrategies[1].connect).not.toHaveBeenCalled();
+
+      runner.abort();
+      jasmine.clock().tick(100);
+      expect(this.substrategies[1].connect).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("on error", function() {
+    it("should wait for the timeout before calling back", function() {
+      var substrategy = Mocks.getStrategy(true);
+      var strategy = new SequentialStrategy([substrategy], {
+        timeout: 100
+      });
+
+      strategy.connect(0, this.callback);
+      substrategy._callback(true);
+
+      jasmine.clock().tick(99);
+      expect(this.callback).not.toHaveBeenCalled();
+      jasmine.clock().tick(1);
+      expect(this.callback).toHaveBeenCalled();
+    });
+
+    it("should not wait for the timeout before calling back if failFast is on", function() {
+      var substrategy = Mocks.getStrategy(true);
+      var strategy = new SequentialStrategy([substrategy], {
+        timeout: 100,
+        failFast: true
+      });
+
+      strategy.connect(0, this.callback);
+      substrategy._callback(true);
+      expect(this.callback).toHaveBeenCalled();
+    });
+  });
+
+  describe("on timeout", function() {
+    it("should try substrategies with exponential timeouts", function() {
+      var substrategies = Mocks.getStrategies(
+        [true, true, true, true, true]
+      );
+      var strategy = new SequentialStrategy(substrategies, {
+        timeout: 100,
+        timeoutLimit: 400
+      });
+
+      strategy.connect(0, this.callback);
+
+      expect(substrategies[0].connect).toHaveBeenCalled();
+      expect(substrategies[1].connect).not.toHaveBeenCalled();
+
+      jasmine.clock().tick(99);
+      expect(substrategies[1].connect).not.toHaveBeenCalled();
+
+      jasmine.clock().tick(1);
+      expect(substrategies[1].connect).toHaveBeenCalled();
+      expect(substrategies[2].connect).not.toHaveBeenCalled();
+
+      jasmine.clock().tick(199);
+      expect(substrategies[2].connect).not.toHaveBeenCalled();
+
+      jasmine.clock().tick(1);
+      expect(substrategies[2].connect).toHaveBeenCalled();
+      expect(substrategies[3].connect).not.toHaveBeenCalled();
+
+      jasmine.clock().tick(399);
+      expect(substrategies[3].connect).not.toHaveBeenCalled();
+
+      jasmine.clock().tick(1);
+      expect(substrategies[3].connect).toHaveBeenCalled();
+      expect(substrategies[4].connect).not.toHaveBeenCalled();
+
+      jasmine.clock().tick(399);
+      expect(substrategies[4].connect).not.toHaveBeenCalled();
+
+      jasmine.clock().tick(1);
+      expect(substrategies[4].connect).toHaveBeenCalled();
+    });
+  });
+
+  describe("on forceMinPriority", function() {
+    it("should force the priority on the running substrategy", function() {
+      var runner = this.strategy.connect(0, this.callback);
+      runner.forceMinPriority(5);
+      expect(this.substrategies[0]._forceMinPriority).toHaveBeenCalledWith(5);
+    });
+
+    it("should keep connecting with the new priority", function() {
+      var runner = this.strategy.connect(0, this.callback);
+      runner.forceMinPriority(5);
+
+      this.substrategies[0]._callback(true);
+      expect(this.substrategies[1].connect)
+        .toHaveBeenCalledWith(5, jasmine.any(Function));
+    });
+  });
+});