pingerchips-js 1.0.1-a → 2.0.0

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

@@ -1,104 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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

@@ -1,165 +0,0 @@
-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

@@ -1,213 +0,0 @@
-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));
-    });
-  });
-});