@automattic/vip 4.1.5 → 4.1.8

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

@@ -1,1169 +0,0 @@
-'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
-  };
-}