Coder-Spirit / ts-insistent

import { expect } from 'chai'

import { CustomError } from 'ts-custom-error'

import { InsistPolicy, insist } from '../src/insist'

import { mockSetTimeout, restoreSetTimeout } from './mocks'

// We'll use some Bluebird features for our tests

import Bluebird from 'bluebird'

// Custom Errors

class RecoverableError extends CustomError {}

class ProblematicError extends CustomError {}

class WaitForItError extends CustomError {

  constructor(message: string, public retryAfter: number) {

    super(message)

  }

}

describe('When the passed function does not fail', function() {

  it('`insist` behaves as the passed regular function', async function() {

    const testFn = () => 42

    const result = await insist(testFn)

    expect(result).to.equal(42)

  })

  it('`insist` behaves as the passed async function', async function() {

    const testFn = async () => 42

    const result = await insist(testFn)

    expect(result).to.equal(42)

  })

})

describe('When the passed function does fail', function() {

  it("`insist` retries for fn failures, and succeeds if fn doesn't fail too many times", async function() {

    let failuresCounter = 0

    const testFn = async () => {

      if (failuresCounter < 3) {

        failuresCounter += 1

        throw new Error('Fake Error')

      }

      return 42

    }

    const result = await insist(testFn, {

      // These two parameters are needed to make the tests fast

      retryInterval: 0,

      intervalIncrements: 0,

      maxRetries: 3,

      insistPolicy: InsistPolicy.RETRY,

    })

    expect(result).to.equal(42)

  })

  it('`insist` raises if the number of retries exceeds the configured threshold', async function() {

    let failuresCounter = 0

    const testFn = async () => {

      if (failuresCounter < 5) {

        failuresCounter += 1

        throw new Error('Fake Error')

      }

      return 42

    }

    try {

      await insist(testFn, {

        // These two parameters are needed to make the tests fast

        retryInterval: 0,

        intervalIncrements: 0,

        maxRetries: 3,

        insistPolicy: InsistPolicy.RETRY,

      })

      expect.fail('The code should not reach this point')

    } catch (e) {

      expect(e).to.be.instanceOf(Error)

      expect(e.message).to.equal('Fake Error')

    }

  })

  it('`insist` raises if the policy is THROW and the error is not in alwaysRetryOn', async function() {

    let failureToggle = false

    const testFn = async () => {

      if (!failureToggle) {

        failureToggle = true

        throw new ProblematicError('Problematic Error')

      }

      return 42

    }

    try {

      await insist(testFn, {

        alwaysRetryOn: [RecoverableError],

        insistPolicy: InsistPolicy.THROW,

      })

      expect.fail('The code should not reach this point')

    } catch (e) {

      expect(e).to.be.instanceOf(ProblematicError)

      expect(e.message).to.equal('Problematic Error')

    }

  })

  it('`insist` retries & succeeds if the policy is THROW & error is in alwaysRetryOn', async function() {

    let failureToggle = false

    const testFn = async () => {

      if (!failureToggle) {

        failureToggle = true

        throw new RecoverableError('Recoverable Error')

      }

      return 42

    }

    const result = await insist(testFn, {

      // These two parameters are needed to make the tests fast

      retryInterval: 0,

      intervalIncrements: 0,

      alwaysRetryOn: [RecoverableError],

      insistPolicy: InsistPolicy.THROW,

    })

    expect(result).to.be.equal(42)

  })

  it('`insist` does not retry, and throws, if error is in alwaysThrowOn', async function() {

    let failureToggle = false

    const testFn = async () => {

      if (!failureToggle) {

        failureToggle = true

        throw new ProblematicError('Problematic Error')

      }

      return 42

    }

    try {

      await insist(testFn, {

        alwaysThrowOn: [ProblematicError],

        insistPolicy: InsistPolicy.RETRY,

      })

      expect.fail('The code should not reach this point')

    } catch (e) {

      expect(e).to.be.instanceOf(ProblematicError)

      expect(e.message).to.equal('Problematic Error')

    }

  })

  it('`insist` retries if errorClassifiers tells to do so', async function() {

    let failureToggle = false

    const testFn = async () => {

      if (!failureToggle) {

        failureToggle = true

        throw new RecoverableError('Recoverable Error')

      }

      return 42

    }

    const result = await insist(testFn, {

      // These two parameters are needed to make the tests fast

      retryInterval: 0,

      intervalIncrements: 0,

      insistPolicy: InsistPolicy.THROW,

      // We use errorClassifier instead of relying on alwaysRetryOn

      errorClassifier: (e: Error) => {

        return e instanceof RecoverableError ? InsistPolicy.RETRY : null

      },

    })

    expect(result).to.be.equal(42)

  })

  it('`insist` does not retry, and throws, if errorClassifiers tells to do so', async function() {

    let failureToggle = false

    const testFn = async () => {

      if (!failureToggle) {

        failureToggle = true

        throw new ProblematicError('Problematic Error')

      }

      return 42

    }

    try {

      await insist(testFn, {

        insistPolicy: InsistPolicy.RETRY,

        // We use errorClassifier instead of relying on alwaysThrowOn

        errorClassifier: (e: Error) => {

          return e instanceof ProblematicError ? InsistPolicy.THROW : null

        },

      })

      expect.fail('The code should not reach this point')

    } catch (e) {

      expect(e).to.be.instanceOf(ProblematicError)

      expect(e.message).to.equal('Problematic Error')

    }

  })

  it('`insist` is able to set the time between retries dynamically, based on the thrown error', async function() {

    const MAGIC_TIME_WAIT = 5432

    let failureToggle = false

    const testFn = async () => {

      if (!failureToggle) {

        failureToggle = true

        throw new WaitForItError('Recoverable Error', MAGIC_TIME_WAIT)

      }

      return 42

    }

    const timeMockState = mockSetTimeout(MAGIC_TIME_WAIT)

    const resultPromise = insist(testFn, {

      // These two parameters are needed to make the tests fast

      retryInterval: 0,

      intervalIncrements: 0,

      insistPolicy: InsistPolicy.THROW,

      // We use errorClassifier instead of relying on alwaysRetryOn

      errorClassifier: (e: Error, setRetryAfter) => {

        if (e instanceof WaitForItError) {

          setRetryAfter(e.retryAfter)

          return InsistPolicy.RETRY

        }

        return null

      },

    })

    expect((resultPromise as Bluebird<number>).isFulfilled()).to.be.false

    // Our dirty way to "advance time"

    while (timeMockState.numTimeoutCalls < 1) {

      await (async () => null)()

    }

    timeMockState.pendingCallback(...timeMockState.pendingCallbackArgs)

    restoreSetTimeout()

    expect(await resultPromise).to.be.equal(42)

    expect(timeMockState.passedTimeout).to.equal(MAGIC_TIME_WAIT) // We check that insist "waited" for 5.432s

    expect(timeMockState.numTimeoutCalls).to.equal(1) // And that we only called setTimeOut once

  })

})