first test

Author: axdg

src/retrier.js

@@ -49,10 +49,11 @@ const createRetrierFn = function (fn, curve) {
 
     const recurse = function (resolve, reject) {
       return fn(...args).then(resolve).catch(function (err) {
-        let timeout = curve(err, ++attempt)
-        if (timeout < 0) return reject(err)
+        let timeout
+
         try {
-          if (err <= 0) return recurse(resolve, reject)
+          timeout = curve(err, ++attempt)
+          if (timeout <= 0) return recurse(resolve, reject)
           return setTimeout(recurse, timeout, resolve, reject)
         } catch (_err) {
           return reject(_err)
@@ -65,3 +66,4 @@ const createRetrierFn = function (fn, curve) {
 }
 
 module.exports.createRetrierFn = createRetrierFn
+module.exports.retry = createRetrierFn

test/retrier.js

@@ -1,12 +1,8 @@
 const test = require('ava')
-const {
-  createLinear,
-  createExponential,
-  createRetrierFn,
-} = require('../src/retrier')
+const { createRetrierFn } = require('../src/retrier')
 
 test('createRetrierFn - retries async errors with delay', async function (t) {
-  const sleep = x => new Promise(r => setTimeout(r, x))
+  const sleep = ms => new Promise(r => setTimeout(r, ms))
 
   /**
    * Given 'i', create function that will return a promise
@@ -22,146 +18,40 @@ test('createRetrierFn - retries async errors with delay', async function (t) {
         i--
         throw new Error(i)
       }
-      return true
-    }
-  }
-
-  // Will retry three times.
-  const succeeder = createRetrierFn(createFailer(2), () => 15, 3)
-  t.true(typeof succeeder === 'function')
-
-  const start = new Date().getTime()
-  const success = await succeeder()
-  t.true(success)
-  t.true(new Date().getTime() - start >= 30)
 
-  const failer = createRetrierFn(createFailer(4), 2)
-  t.true(typeof succeeder === 'function')
-
-  let failure
-  try {
-    failure = await failer()
-  } catch ({ message }) {
-    failure = +message // Coerce.
+      return i
+    }
   }
 
-  t.true(failure === 2)
-})
-
-test('createRetrierFn - retries sync errors', async function (t) {
-  const responses = [
-    new Error('fail'),
-    true,
-  ]
+  // NOTE: This serves as an example of a curve function.
+  const createCurve = function (limit, ms) {
+    const curve = function (err, count) {
+      if (count > limit) throw err
+      return ms
+    }
 
-  function failOnce() {
-    const response = responses.shift()
-    if (response instanceof Error) throw response
-    return response
+    return curve
   }
 
-  const fn = createRetrierFn(failOnce, 2)
-  t.true(await fn())
-})
-
-test('createRetrierFn - allows opt out of retries', async function (t) {
-  const shouldRetry = () => false
-  const responses = [
-    new Error('fail'),
-    true,
-  ]
+  const succeeder = createRetrierFn(createFailer(2), createCurve(3, 200))
+  t.true(typeof succeeder === 'function')
 
-  function failOnce() {
-    const response = responses.shift()
-    if (response instanceof Error) throw response
-    return response
-  }
+  const ts = new Date().getTime()
 
-  const fn = createRetrierFn(failOnce, 2, undefined, shouldRetry)
-  try {
-    await fn()
-    t.fail()
-  } catch (error) {
-    t.pass()
-  }
-})
+  const success = await succeeder()
+  t.true(success === 0)
+  t.true((new Date().getTime() - ts) >= 400)
 
-test('createRetrierFn - allows indefinite retries', async function (t) {
-  const responses = [
-    new Error('fail'),
-    new Error('fail'),
-    new Error('fail'),
-    new Error('fail'),
-    true,
-  ]
+  const failer = createRetrierFn(createFailer(5), createCurve(2, 200))
+  t.true(typeof failer === 'function')
 
-  function failMany() {
-    const response = responses.shift()
-    if (response instanceof Error) throw response
-    return response
-  }
+  let value
 
-  const fn = createRetrierFn(failMany, 0, 0)
   try {
-    await fn()
-    t.pass()
-  } catch (error) {
-    t.fail()
-  }
-})
-
-test('createRetrierFn - supports curves', async function (t) {
-  const sleep = x => new Promise(r => setTimeout(r, x))
-
-  const cache = []
-  const createFn = function () {
-    let failed = false
-
-    const fn = async function (value) {
-      await sleep(100)
-      cache.push(value)
-
-      if (!failed) {
-        failed = true
-        throw new Error('')
-      }
-
-      return value
-    }
-
-    return fn
-  }
-
-  let f = createFn()
-  let fn = createRetrierFn(f, 2)
-
-  t.true(await fn('x') === 'x')
-  t.true(cache.length === 2)
-
-  cache.length = 0
-  f = createFn()
-  fn = createRetrierFn(f, x => x, 2)
-
-  t.true(await fn('x') === 'x')
-  t.true(cache.length === 2)
-})
-
-test('createRetrierFn - and inbuilt curves', async function (t) {
-  const range = function* (len) {
-    let count = 0
-    while (count < len) {
-      yield count
-      count++
-    }
+    await failer()
+  } catch ({ message }) {
+    value = +message // Coerce.
   }
 
-  let fx = createLinear({ m: 2, b: 0 })
-  t.deepEqual([...range(4)].map(fx), [0, 2, 4, 6])
-
-  fx = createExponential({ a: 2, b: 1 }, 1)
-  t.deepEqual([...range(6)].map(fx), [1, 2, 4, 8, 16, 32])
-
-  fx = createExponential({ a: 2, b: 1 }, 1000)
-  t.deepEqual([...range(6)].map(fx), [1000, 2000, 4000, 8000, 16000, 32000])
+  t.true(value === 2)
 })
-