adding src and test files

Author: samisayegh

.gitignore

@@ -0,0 +1,2 @@
+node_modules/
+dist/

package-lock.json

@@ -20,5 +20,11 @@
   "bugs": {
     "url": "https://github.com/coveo/exponential-backoff/issues"
   },
-  "homepage": "https://github.com/coveo/exponential-backoff#readme"
+  "homepage": "https://github.com/coveo/exponential-backoff#readme",
+  "devDependencies": {
+    "@types/jasmine": "^2.8.8",
+    "@types/node": "^10.5.1",
+    "jasmine": "^3.1.0",
+    "typescript": "^2.9.2"
+  }
 }

package.json

@@ -0,0 +1,145 @@
+import { backOff, IBackOffRequest, IBackOffOptions } from './backoff';
+
+export function BackOffTest() {
+  describe('BackOff', () => {
+    const mockSuccessResponse = { success: true };
+    const mockFailResponse = { success: false };
+    let backOffRequest: IBackOffRequest<{}>;
+    let backOffOptions: Partial<IBackOffOptions>;
+
+    function initBackOff() {
+      return backOff(backOffRequest, backOffOptions);
+    }
+
+    function promiseThatIsResolved() {
+      return () => Promise.resolve(mockSuccessResponse);
+    }
+
+    function promiseThatIsRejected() {
+      return () => Promise.reject(mockFailResponse);
+    }
+
+    beforeEach(() => {
+      backOffOptions = { startingDelay: 0 };
+      backOffRequest = { fn: promiseThatIsResolved() };
+    });
+
+    describe('when #backOffRequest.fn is a promise that resolves', () => {
+      it('returns the resolved value', done => {
+        const request = initBackOff();
+
+        request.then(response => {
+          expect(response).toBe(mockSuccessResponse);
+          done();
+        });
+      });
+
+      it('calls the #backOffRequest.fn only once', done => {
+        spyOn(backOffRequest, 'fn');
+        const request = initBackOff();
+
+        request.then(() => {
+          expect(backOffRequest.fn).toHaveBeenCalledTimes(1);
+          done();
+        });
+      });
+
+      it(`when the #backOffOptions.numOfAttempts is 0,
+      it overrides the value and calls the method only once`, done => {
+        backOffOptions.numOfAttempts = 0;
+        spyOn(backOffRequest, 'fn');
+
+        const request = initBackOff();
+
+        request.then(() => {
+          expect(backOffRequest.fn).toHaveBeenCalledTimes(1);
+          done();
+        });
+      });
+    });
+
+    describe('when #BackOffRequest.fn is a promise that is rejected', () => {
+      beforeEach(() => (backOffRequest.fn = promiseThatIsRejected()));
+
+      it('returns the rejected value', done => {
+        const request = initBackOff();
+        request.catch(err => {
+          expect(err).toBe(mockFailResponse);
+          done();
+        });
+      });
+
+      it('retries the request as many times as specified in #BackOffOptions.numOfAttempts', done => {
+        backOffOptions.numOfAttempts = 2;
+        spyOn(backOffRequest, 'fn').and.returnValue(Promise.reject(mockFailResponse));
+
+        const request = initBackOff();
+
+        request.catch(() => {
+          expect(backOffRequest.fn).toHaveBeenCalledTimes(backOffOptions.numOfAttempts as number);
+          done();
+        });
+      });
+
+      it(`when the #BackOffRequest.retry method is set to always return false,
+      it only calls #BackOffRequest.fn one time`, done => {
+        backOffRequest.retry = () => false;
+        backOffOptions.numOfAttempts = 2;
+        spyOn(backOffRequest, 'fn').and.returnValue(Promise.reject(mockFailResponse));
+
+        const request = initBackOff();
+
+        request.catch(() => {
+          expect(backOffRequest.fn).toHaveBeenCalledTimes(1);
+          done();
+        });
+      });
+    });
+
+    describe(`when calling #backOff with a function that throws an error the first time, and succeeds the second time`, () => {
+      beforeEach(() => {
+        spyOn(backOffRequest, 'fn').and.returnValues(Promise.reject(mockFailResponse), Promise.resolve(mockSuccessResponse));
+      });
+
+      it(`returns a successful response`, done => {
+        const request = initBackOff();
+
+        request.then(response => {
+          expect(response).toBe(mockSuccessResponse);
+          done();
+        });
+      });
+
+      it('calls the #BackOffRequest.fn method two times', done => {
+        const request = initBackOff();
+
+        request.then(() => {
+          expect(backOffRequest.fn).toHaveBeenCalledTimes(2);
+          done();
+        });
+      });
+
+      it(`when setting the #BackOffOption.timeMultiple to a value,
+      it applies a delay between the first and the second call`, done => {
+        const startingDelay = 100;
+        const timeMultiple = 3;
+        const totalExpectedDelay = startingDelay + timeMultiple * startingDelay;
+
+        backOffOptions.startingDelay = startingDelay;
+        backOffOptions.timeMultiple = timeMultiple;
+
+        const startTime = Date.now();
+        const request = initBackOff();
+
+        request.then(() => {
+          const endTime = Date.now();
+          const duration = endTime - startTime;
+          const roundedDuration = Math.round(duration / startingDelay) * startingDelay;
+
+          expect(roundedDuration).toBe(totalExpectedDelay);
+          done();
+        });
+      });
+    });
+  });
+}

src/backoff.spec.ts

@@ -0,0 +1,57 @@
+export interface IBackOffRequest<T> {
+  fn: () => Promise<T>;
+  retry?: (e, attemptNumber: number) => boolean;
+}
+
+export interface IBackOffOptions {
+  numOfAttempts: number;
+  timeMultiple: number;
+  startingDelay: number;
+}
+
+const defaultOptions: IBackOffOptions = {
+  numOfAttempts: 10,
+  timeMultiple: 2,
+  startingDelay: 100
+};
+
+export async function backOff<T>(request: IBackOffRequest<T>, options: Partial<IBackOffOptions> = {}): Promise<T> {
+  const sanitizedOptions = getSanitizedOptions(options);
+
+  let attemptNumber = 0;
+  let delay = sanitizedOptions.startingDelay;
+
+  while (attemptNumber < sanitizedOptions.numOfAttempts) {
+    try {
+      await delayBeforeExecuting(delay);
+      attemptNumber++;
+      return await request.fn();
+    } catch (e) {
+      const shouldRetry = request.retry ? request.retry(e, attemptNumber) : true;
+      const reachedRetryLimit = attemptNumber >= sanitizedOptions.numOfAttempts;
+
+      if (!shouldRetry || reachedRetryLimit) {
+        throw e;
+      }
+
+      delay *= sanitizedOptions.timeMultiple;
+    }
+  }
+
+  throw new Error('Something went wrong.');
+}
+
+function getSanitizedOptions(options: Partial<IBackOffOptions>) {
+  const sanitized: IBackOffOptions = { ...defaultOptions, ...options };
+  const numOfAttempts = sanitized.numOfAttempts;
+
+  if (numOfAttempts && numOfAttempts < 1) {
+    sanitized.numOfAttempts = 1;
+  }
+
+  return sanitized;
+}
+
+function delayBeforeExecuting(delay: number) {
+  return new Promise(resolve => setTimeout(resolve, delay));
+}

src/backoff.ts

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "outDir": "./dist/",
+    "sourceMap": true,
+    "strictNullChecks": true,
+    "module": "es6",
+    "target": "es5",
+    "lib": [
+      "es2015"
+    ]
+  },
+  "include": [
+    "./src/"
+  ]
+}