quran/node_modules/fetch-retry/test/unit/index.js

'use strict';
var fetchBuilder = require('../../');
var sinon = require('sinon');
var expect = require('expectations');

describe('fetchBuilder', function () {

  it('throws when fetch is not a function', function () {
    expect(function () {
      fetchBuilder();
    }).toThrow({
      name: 'ArgumentError',
      message: 'fetch must be a function'
    });
  });

  it('throws when default is not an object', function () {
    expect(function () {
      fetchBuilder(function () { }, 'this is a string, not an object');
    }).toThrow({
      name: 'ArgumentError',
      message: 'defaults must be an object'
    });
  });

  it('returns fetchRetry when provided valid constructor arguments', function () {
    expect(typeof fetchBuilder(function () { }, {retries: 1})).toBe('function');
  });
});

describe('fetch-retry', function () {

  var fetch;
  var fetchRetry;

  var deferred1;
  var deferred2;
  var deferred3;
  var deferred4;

  var thenCallback;
  var catchCallback;

  var clock;
  var delay;

  beforeEach(function () {
    delay = 1000;
    clock = sinon.useFakeTimers();
  });

  afterEach(function () {
    clock.restore();
  });

  beforeEach(function () {
    deferred1 = defer();
    deferred2 = defer();
    deferred3 = defer();
    deferred4 = defer();

    fetch = sinon.stub();
    fetch.onCall(0).returns(deferred1.promise);
    fetch.onCall(1).returns(deferred2.promise);
    fetch.onCall(2).returns(deferred3.promise);
    fetch.onCall(3).returns(deferred4.promise);

    fetchRetry = fetchBuilder(fetch);
  });

  describe('#input', function () {

    var expectedUrl = 'http://some-url.com';

    beforeEach(function () {
      fetchRetry(expectedUrl);
    });

    it('passes #input to fetch', function () {
      expect(fetch.getCall(0).args[0]).toBe(expectedUrl);
    });

  });

  describe('#init', function () {

    describe('when #init is provided', function () {

      var init;

      beforeEach(function () {
        init = {
          retries: 3,
          whatever: 'something'
        };

        fetchRetry('http://someUrl', init);
      });

      it('passes init to fetch', function () {
        expect(fetch.getCall(0).args[1]).toEqual(init);
      });

      describe('when #init.retryOn is not an array or function', () => {

        it('throws exception', () => {
          expect(function () {
            init.retryOn = 503;
            fetchRetry('http://someUrl', init);
          }).toThrow({
            name: 'ArgumentError',
            message: 'retryOn property expects an array or function'
          });
        });

      });

    });

    describe('when #init is undefined or null', function () {

      [undefined, null].forEach(function (testCase) {

        beforeEach(function () {
          fetchRetry('http://someUrl', testCase);
        });

        it('does not pass through init to fetch', function () {
          expect(fetch.getCall(0).args[1]).toEqual(undefined);
        });

      });

    });

  });

  describe('#init.retries', function () {

    describe('when #init.retries=3 (default)', function () {

      beforeEach(function () {
        thenCallback = sinon.spy();
        catchCallback = sinon.spy();

        fetchRetry('http://someurl')
          .then(thenCallback)
          .catch(catchCallback);
      });

      describe('when first call is a success', function () {

        beforeEach(function () {
          deferred1.resolve({ status: 200 });
        });

        describe('when resolved', function () {

          it('invokes the then callback', function () {
            expect(thenCallback.called).toBe(true);
          });

          it('calls fetch once', function () {
            expect(fetch.callCount).toBe(1);
          });

        });

      });

      describe('when first call is a failure', function () {

        beforeEach(function () {
          deferred1.reject();
        });

        describe('when second call is a success', function () {

          beforeEach(function () {
            clock.tick(delay);
            deferred2.resolve({ status: 200 });
          });

          describe('when resolved', function () {

            it('invokes the then callback', function () {
              expect(thenCallback.called).toBe(true);
            });

            it('calls fetch twice', function () {
              expect(fetch.callCount).toBe(2);
            });

          });

        });

        describe('when second call is a failure', function () {

          beforeEach(function () {
            deferred2.reject();
            clock.tick(delay);
          });

          describe('when third call is a success', function () {

            beforeEach(function () {
              deferred3.resolve({ status: 200 });
              clock.tick(delay);
            });

            describe('when resolved', function () {

              it('invokes the then callback', function () {
                expect(thenCallback.called).toBe(true);
              });

              it('calls fetch three times', function () {
                expect(fetch.callCount).toBe(3);
              });

            });

          });

          describe('when third call is a failure', function () {

            beforeEach(function () {
              deferred3.reject();
              clock.tick(delay);
            });

            describe('when fourth call is a success', function () {

              beforeEach(function () {
                deferred4.resolve({ status: 200 });
                clock.tick(delay);
              });

              describe('when resolved', function () {

                it('invokes the then callback', function () {
                  expect(thenCallback.called).toBe(true);
                });

                it('calls fetch four times', function () {
                  expect(fetch.callCount).toBe(4);
                });

              });

            });

            describe('when fourth call is a failure', function () {

              beforeEach(function () {
                deferred4.reject();
                clock.tick(delay);
              });

              describe('when rejected', function () {

                it('invokes the catch callback', function () {
                  expect(catchCallback.called).toBe(true);
                });

                it('does not call fetch again', function () {
                  expect(fetch.callCount).toBe(4);
                });

              });

            });

          });

        });

      });

    });

    describe('when #defaults.retries is not a a positive integer', () => {
      ['1', -1, 'not a number', null].forEach(invalidRetries => {
        it('throws error', () => {
          const expectedError = {
            name: 'ArgumentError',
            message: 'retries must be a positive integer'
          };
          expect(() => {
            var fetchRetryWithDefaults = fetchBuilder(fetch, {retries: invalidRetries});
            fetchRetryWithDefaults('http://someurl');
          }).toThrow(expectedError);
        });
      });
    });

    describe('when #defaults.retryDelay is not a a positive integer', () => {

      ['1', -1, 'not a number', null].forEach(invalidDelay => {

        it('throws error', () => {
          const expectedError = {
            name: 'ArgumentError',
            message: 'retryDelay must be a positive integer or a function returning a positive integer'
          };
          expect(() => {
            var fetchRetryWithDefaults = fetchBuilder(fetch, { retryDelay: invalidDelay });
            fetchRetryWithDefaults('http://someurl');
          }).toThrow(expectedError);
        });

      });

    });

    describe('when #defaults.retryDelay is a function', function () {

      var defaults;
      var retryDelay;

      beforeEach(function () {
        retryDelay = sinon.stub().returns(5000);
        defaults = {
          retryDelay: retryDelay
        };

        thenCallback = sinon.spy();

        var fetchRetryWithDefaults = fetchBuilder(fetch, defaults);
        fetchRetryWithDefaults('http://someUrl')
          .then(thenCallback);
      });
    });

    describe('when #defaults.retryOn is not an array or function', function () {

      var defaults = {};

      describe('when #defaults.retryOn is not an array or function', () => {

        it('throws exception', () => {
          expect(function () {
            defaults.retryOn = 503;
            var fetchRetryWithDefaults = fetchBuilder(fetch, defaults);
            fetchRetryWithDefaults('http://someUrl');
          }).toThrow({
            name: 'ArgumentError',
            message: 'retryOn property expects an array or function'
          });
        });

      });

    });

    describe('when #defaults.retries=0', function () {
      beforeEach(function () {
        thenCallback = sinon.spy();
        catchCallback = sinon.spy();

        var fetchRetryWithDefaults = fetchBuilder(fetch, {retries: 0});

        fetchRetryWithDefaults('http://someurl')
          .then(thenCallback)
          .catch(catchCallback);
      });

      describe('when first call is a failure', function () {
        beforeEach(function () {
          deferred1.reject();
        });

        describe('when rejected', function () {

          it('invokes the catch callback', function () {
            expect(catchCallback.called).toBe(true);
          });

          it('does not call fetch again', function () {
            expect(fetch.callCount).toBe(1);
          });
        });
      });
    });

    describe('when #init.retries=1', function () {

      beforeEach(function () {
        thenCallback = sinon.spy();
        catchCallback = sinon.spy();

        fetchRetry('http://someurl', { retries: 1 })
          .then(thenCallback)
          .catch(catchCallback);
      });

      describe('when first call is a success', function () {

        beforeEach(function () {
          deferred1.resolve({ status: 200 });
        });

        describe('when resolved', function () {

          it('invokes the then callback', function () {
            expect(thenCallback.called).toBe(true);
          });

          it('calls fetch once', function () {
            expect(fetch.callCount).toBe(1);
          });

        });

      });

      describe('when first call is a failure', function () {

        beforeEach(function () {
          deferred1.reject();
          clock.tick(delay);
        });

        describe('when second call is a success', function () {

          beforeEach(function () {
            deferred2.resolve({ status: 200 });
            clock.tick(delay);
          });

          describe('when resolved', function () {

            it('invokes the then callback', function () {
              expect(thenCallback.called).toBe(true);
            });

            it('calls fetch twice', function () {
              expect(fetch.callCount).toBe(2);
            });

          });

        });

        describe('when second call is a failure', function () {

          beforeEach(function () {
            deferred2.reject();
            clock.tick(delay);
          });

          describe('when rejected', function () {

            it('invokes the catch callback', function () {
              expect(catchCallback.called).toBe(true);
            });

            it('does not call fetch again', function () {
              expect(fetch.callCount).toBe(2);
            });

          });

        });

      });

    });

    describe('when #init.retries=0', function () {

      beforeEach(function () {
        thenCallback = sinon.spy();
        catchCallback = sinon.spy();

        fetchRetry('http://someurl', { retries: 0 })
          .then(thenCallback)
          .catch(catchCallback);
      });

      describe('when first call is a success', function () {

        beforeEach(function () {
          deferred1.resolve({ status: 200 });
        });

        describe('when resolved', function () {

          it('invokes the then callback', function () {
            expect(thenCallback.called).toBe(true);
          });

          it('calls fetch once', function () {
            expect(fetch.callCount).toBe(1);
          });

        });

      });

      describe('when first call is a failure', function () {

        beforeEach(function () {
          deferred1.reject();
        });

        describe('when rejected', () => {

          it('invokes the catch callback', function () {
            expect(catchCallback.called).toBe(true);
          });

        });

      });

    });

    describe('when #init.retries is not a a positive integer', () => {

      ['1', -1, 'not a number', null].forEach(invalidRetries => {

        it('throws error', () => {
          const expectedError = {
            name: 'ArgumentError',
            message: 'retries must be a positive integer'
          };
          expect(() => {
            fetchRetry('http://someurl', { retries: invalidRetries });
          }).toThrow(expectedError);
        });

      });

    });

  });

  describe('#init.retryDelay', function () {

    describe('when #init.retryDelay is a number', function () {

      var init;
      var retryDelay;

      beforeEach(function () {
        retryDelay = 5000;
        init = {
          retryDelay: retryDelay
        };

        thenCallback = sinon.spy();

        fetchRetry('http://someUrl', init)
          .then(thenCallback);
      });

      describe('when first call is unsuccessful', function () {

        beforeEach(function () {
          deferred1.reject();
        });

        describe('after specified time', function () {

          beforeEach(function () {
            clock.tick(retryDelay);
          });

          it('invokes fetch again', function () {
            expect(fetch.callCount).toBe(2);
          });

        });

        describe('after less than specified time', function () {

          beforeEach(function () {
            clock.tick(1000);
          });

          it('does not invoke fetch again', function () {
            expect(fetch.callCount).toBe(1);
          });

        });

      });

    });

    describe('when #init.retryDelay is 0', function () {

      var init;
      var retryDelay;

      beforeEach(function () {
        retryDelay = 0;
        init = {
          retryDelay: retryDelay
        };

        thenCallback = sinon.spy();

        fetchRetry('http://someUrl', init)
          .then(thenCallback);
      });

      describe('when first call is unsuccessful', function () {

        beforeEach(function () {
          deferred1.reject();
        });

        describe('after one event loop tick', function () {

          beforeEach(function () {
            clock.tick(0);
          });

          it('invokes fetch again', function () {
            expect(fetch.callCount).toBe(2);
          });

        });

      });

    });

    describe('when #init.retryDelay is not a a positive integer', () => {

      ['1', -1, 'not a number', null].forEach(invalidDelay => {

        it('throws error', () => {
          const expectedError = {
            name: 'ArgumentError',
            message: 'retryDelay must be a positive integer or a function returning a positive integer'
          };
          expect(() => {
            fetchRetry('http://someurl', { retryDelay: invalidDelay });
          }).toThrow(expectedError);
        });

      });

    });

    describe('when #init.retryDelay is a function', function () {

      var init;
      var retryDelay;

      beforeEach(function () {
        retryDelay = sinon.stub().returns(5000);
        init = {
          retryDelay: retryDelay
        };

        thenCallback = sinon.spy();

        fetchRetry('http://someUrl', init)
          .then(thenCallback);
      });

      describe('when first call is unsuccessful', function () {

        beforeEach(function () {
          deferred1.reject(new Error('first error'));
        });

        describe('when the second call is a success', function () {

          beforeEach(function () {
            deferred2.resolve({ status: 200 });
            clock.tick(5000);
          });

          it('invokes the retryDelay function', function () {
            expect(retryDelay.called).toBe(true);
            expect(retryDelay.lastCall.args[0]).toEqual(0);
            expect(retryDelay.lastCall.args[1].message).toEqual('first error');
          });


        });

        describe('when second call is a failure', function () {

          beforeEach(function () {
            deferred2.reject(new Error('second error'));
            clock.tick(5000);
          });

          describe('when the third call is a success', function () {

            beforeEach(function () {
              deferred3.resolve({ status: 200 });
              clock.tick(5000);
            });

            it('invokes the retryDelay function again', function () {
              expect(retryDelay.callCount).toBe(2);
              expect(retryDelay.lastCall.args[0]).toEqual(1);
              expect(retryDelay.lastCall.args[1].message).toEqual('second error');
            });

          });

        });

      });

    });

  });

  describe('#init.retryOn', () => {

    describe('when #init.retryOn is an array', () => {

      var init;
      var retryOn;

      beforeEach(function () {
        retryOn = [503, 404];
        init = {
          retryOn: retryOn
        };

        thenCallback = sinon.spy();
        catchCallback = sinon.spy();

        fetchRetry('http://someUrl', init)
          .then(thenCallback)
          .catch((catchCallback));
      });

      describe('when first fetch is resolved with status code specified in retryOn array', () => {

        beforeEach(() => {
          deferred1.resolve({ status: 503 });
        });

        describe('after specified delay', () => {

          beforeEach(() => {
            clock.tick(delay);
          });

          it('retries fetch', () => {
            expect(fetch.callCount).toBe(2);
          });

          describe('when second fetch resolves with a different status code', () => {

            beforeEach(() => {
              deferred2.resolve({ status: 200 });
            });

            describe('when resolved', () => {

              it('invokes the then callback', function () {
                expect(thenCallback.called).toBe(true);
              });

              it('has called fetch twice', function () {
                expect(fetch.callCount).toBe(2);
              });

            });

          });

        });

      });

    });

    describe('when #init.retryOn is a function', function () {

      var init;
      var retryOn;
      var fetchRetryChain;

      beforeEach(function () {
        retryOn = sinon.stub();
        init = {
          retryOn: retryOn
        };

        thenCallback = sinon.spy();
        catchCallback = sinon.spy();

        fetchRetryChain = fetchRetry('http://someUrl', init)
          .then(thenCallback)
          .catch((catchCallback));
      });

      describe('when first attempt is rejected due to network error', function () {

        describe('when #retryOn() returns true', () => {

          beforeEach(function () {
            retryOn.returns(true);
            deferred1.reject(new Error('first error'));
          });

          describe('when rejected', function () {

            it('invokes #retryOn function with an error', function () {
              expect(retryOn.called).toBe(true);
              expect(retryOn.lastCall.args.length).toBe(3);
              expect(retryOn.lastCall.args[0]).toBe(0);
              expect(retryOn.lastCall.args[1] instanceof Error).toBe(true);
              expect(retryOn.lastCall.args[2]).toBe(null);
            });

            describe('after specified time', function () {

              beforeEach(function () {
                clock.tick(delay);
              });

              it('invokes fetch again', function () {
                expect(fetch.callCount).toBe(2);
              });

              describe('when the second call is unsuccessful', function () {

                beforeEach(function () {
                  deferred2.reject(new Error('second error'));
                  clock.tick(delay);
                });

                describe('when rejected', function () {

                  it('invokes the #retryOn function twice', function () {
                    expect(retryOn.callCount).toBe(2);
                    expect(retryOn.lastCall.args[0]).toBe(1);
                  });

                });

              });

            });

          });

        });

        describe('when #retryOn() returns false', () => {

          beforeEach(function () {
            retryOn.returns(false);
            deferred1.reject(new Error('first error'));
          });

          describe('when rejected', function () {

            it('invokes #retryOn function with an error', function () {
              expect(retryOn.called).toBe(true);
              expect(retryOn.lastCall.args.length).toBe(3);
              expect(retryOn.lastCall.args[0]).toBe(0);
              expect(retryOn.lastCall.args[1] instanceof Error).toBe(true);
              expect(retryOn.lastCall.args[2]).toBe(null);
            });

            describe('after specified time', function () {

              beforeEach(function () {
                clock.tick(delay);
              });

              it('invokes the catch callback', function () {
                expect(catchCallback.called).toBe(true);
              });

              it('does not call fetch again', function () {
                expect(fetch.callCount).toBe(1);
              });

            });

          });

        });

      });

      describe('when first attempt is resolved', function () {

        describe('when #retryOn() returns true', () => {

          beforeEach(function () {
            retryOn.returns(true);
            deferred1.resolve({ status: 200 });
          });

          describe('after specified delay', () => {

            beforeEach(function () {
              clock.tick(delay);
            });

            it('calls fetch again', function () {
              expect(fetch.callCount).toBe(2);
            });

            describe('when second call is resolved', () => {

              beforeEach(function () {
                deferred2.resolve({ status: 200 });
                clock.tick(delay);
              });

              it('invokes the #retryOn function with the response', function () {
                expect(retryOn.called).toBe(true);
                expect(retryOn.lastCall.args.length).toBe(3);
                expect(retryOn.lastCall.args[0]).toBe(0);
                expect(retryOn.lastCall.args[1]).toBe(null);
                expect(retryOn.lastCall.args[2]).toEqual({ status: 200 });
              });

            });

          });

        });

        describe('when #retryOn() returns false', () => {

          beforeEach(function () {
            retryOn.returns(false);
            deferred1.resolve({ status: 502 });
          });

          describe('when resolved', () => {

            it('invokes the then callback', function () {
              expect(thenCallback.called).toBe(true);
            });

            it('calls fetch 1 time only', function () {
              expect(fetch.callCount).toBe(1);
            });

          });

        });

      });

      describe('when first attempt is resolved with Promise', function() {

        describe('when #retryOn() returns Promise with true resolve', () => {

          beforeEach(function() {
            retryOn.resolves(true);
            deferred1.resolve({ status: 200 });
          });

          describe('after specified delay', () => {

            beforeEach(function() {
              clock.tick(delay);
            });

            it('calls fetch again', function() {
              expect(fetch.callCount).toBe(2);
            });

            describe('when second call is resolved', () => {

              beforeEach(function() {
                deferred2.resolve({ status: 200 });
                clock.tick(delay);
              });

              it('invokes the #retryOn function with the response', function() {
                expect(retryOn.called).toBe(true);
                expect(retryOn.lastCall.args.length).toBe(3);
                expect(retryOn.lastCall.args[0]).toBe(0);
                expect(retryOn.lastCall.args[1]).toBe(null);
                expect(retryOn.lastCall.args[2]).toEqual({ status: 200 });
              });

            });

          });

        });

        describe('when #retryOn() returns Promise with false resolve', () => {

          beforeEach(function() {
            retryOn.resolves(false);
            deferred1.resolve({ status: 502 });
          });

          describe('when resolved', () => {

            it('invokes the then callback', function() {
              expect(thenCallback.called).toBe(true);
            });

            it('calls fetch 1 time only', function() {
              expect(fetch.callCount).toBe(1);
            });

          });

        });

        describe('when #retryOn() throws an error', () => {

          beforeEach(function() {
            retryOn.throws();
          });

          describe('when rejected', () => {

            beforeEach(function() {
              deferred1.reject();
            });

            it('retryOn called only once', () => {
              return fetchRetryChain.finally(() => {
                expect(retryOn.callCount).toBe(1);
              });
            });

            it('invokes the catch callback', function() {
              return fetchRetryChain.finally(() => {
                expect(catchCallback.called).toBe(true);
              });
            });

            it('called fetch', function() {
              expect(fetch.callCount).toBe(1);
            });

          });

          describe('when resolved', () => {

            beforeEach(function() {
              deferred1.resolve({ status: 200 });
            });

            it('retryOn called only once', () => {
              return fetchRetryChain.finally(() => {
                expect(retryOn.callCount).toBe(1);
              });
            });

            it('invokes the catch callback', function() {
              return fetchRetryChain.finally(() => {
                expect(catchCallback.called).toBe(true);
              });
            });

            it('called fetch', function() {
              expect(fetch.callCount).toBe(1);
            });

          });

        });

        describe('when #retryOn() returns a Promise that rejects', () => {

          beforeEach(function() {
            retryOn.rejects();
          });

          describe('when rejected', () => {

            beforeEach(function() {
              deferred1.reject();
            });

            it('retryOn called only once', () => {
              return fetchRetryChain.finally(() => {
                expect(retryOn.callCount).toBe(1);
              });
            });

            it('invokes the catch callback', function() {
              return fetchRetryChain.finally(() => {
                expect(catchCallback.called).toBe(true);
              });
            });

            it('called fetch', function() {
              expect(fetch.callCount).toBe(1);
            });

          });
          describe('when resolved', () => {

            beforeEach(function() {
              deferred1.resolve({ status: 200 });
            });

            it('retryOn called only once', () => {
              return fetchRetryChain.finally(() => {
                expect(retryOn.callCount).toBe(1);
              });
            });

            it('invokes the catch callback', function() {
              return fetchRetryChain.finally(() => {
                expect(catchCallback.called).toBe(true);
              });
            });

            it('called fetch', function() {
              expect(fetch.callCount).toBe(1);
            });

          });

        });

      });

    });

    describe('when #init.retryOn is not an array or function', function () {

      var init;

      describe('when #init.retryOn is not an array or function', () => {

        it('throws exception', () => {
          expect(function () {
            init.retryOn = 503;
            fetchRetry('http://someUrl', init);
          }).toThrow({
            name: 'ArgumentError',
            message: 'retryOn property expects an array or function'
          });
        });

      });

    });

  });

});

function defer() {
  var resolve, reject;
  // eslint-disable-next-line no-undef
  var promise = new Promise(function () {
    resolve = arguments[0];
    reject = arguments[1];
  });
  return {
    resolve: resolve,
    reject: reject,
    promise: promise
  };
}