Mark any test as flaky.

If this test is not successful, it will be retried according to the supplied RetryPolicyM IO. See Control.Retry for documentation on how to specify a RetryPolicyM IO.

For example, you can retry test cases from tasty-hunit like so:

import Test.Tasty.HUnit ( testCase ) -- from tasty-hunit

myFlakyTest :: TestTree
myFlakyTest = flakyTest (limitRetries 5 <> constantDelay 1000) $ testCase "some test case" $ do ...

To dynamically retry based on the result of a test, see flakyTestWithRetryAction instead.

Mark any test as flaky. Like flakyTest, but allows for overriding retry policies based on test results. Also see RetryAction.

For example, if you only want to retry a test if the error message contains "some error message":

import Test.Tasty.HUnit ( testCase ) -- from tasty-hunit
import Data.List ( isInfixOf )

myFlakyTest :: TestTree
myFlakyTest 
    = flakyTestWithRetryAction 
             retryAction 
             (constantDelay 1000)
                 $ testCase "some test case" $ do ...
    where
        retryAction :: RetryStatus -> Result -> IO RetryAction
        retryAction _ result
            | "some error message" `isInfixOf` show result = pure ConsultPolicy
            | otherwise = pure DontRetry

Since: 0.1.2.0

Implement a constant delay with unlimited retries.

Grow delay exponentially each iteration. Each delay will increase by a factor of two.

FullJitter exponential backoff as explained in AWS Architecture Blog article.

http://www.awsarchitectureblog.com/2015/03/backoff.html

temp = min(cap, base * 2 ** attempt)

sleep = temp / 2 + random_between(0, temp / 2)

Implement Fibonacci backoff.

Retry immediately, but only up to n times.

Add an upperbound to a policy such that once the given time-delay amount *per try* has been reached or exceeded, the policy will stop retrying and fail. If you need to stop retrying once *cumulative* delay reaches a time-delay amount, use limitRetriesByCumulativeDelay

Add an upperbound to a policy such that once the cumulative delay over all retries has reached or exceeded the given limit, the policy will stop retrying and fail.

Set a time-upperbound for any delays that may be directed by the given policy. This function does not terminate the retrying. The policy `capDelay maxDelay (exponentialBackoff n)` will never stop retrying. It will reach a state where it retries forever with a delay of maxDelay between each one. To get termination you need to use one of the limitRetries function variants.