sydtest-0.4.0.0: A modern testing framework for Haskell with good defaults and advanced testing features.
Safe HaskellNone
LanguageHaskell2010

Test.Syd.Def.AroundAll

Description

This module defines all the functions you will use to define your test suite.

Synopsis

Documentation

beforeAll Source #

Arguments

:: IO outer

The function to run (once), beforehand, to produce the outer resource.

-> TestDefM (outer ': otherOuters) inner result 
-> TestDefM otherOuters inner result 

Run a custom action before all spec items in a group, to set up an outer resource a.

beforeAll_ Source #

Arguments

:: IO ()

The function to run (once), beforehand.

-> TestDefM outers inner result 
-> TestDefM outers inner result 

Run a custom action before all spec items in a group without setting up any outer resources.

beforeAllWith Source #

Arguments

:: (previousOuter -> IO newOuter)

The function to run (once), beforehand, to produce a new outer resource while using a previous outer resource

-> TestDefM (newOuter ': (previousOuter ': otherOuters)) inner result 
-> TestDefM (previousOuter ': otherOuters) inner result 

Run a custom action before all spec items in a group, to set up an outer resource b by using the outer resource a.

afterAll Source #

Arguments

:: (outer -> IO ())

The function to run (once), afterwards, using the outer resource.

-> TestDefM (outer ': otherOuters) inner result 
-> TestDefM (outer ': otherOuters) inner result 

Run a custom action after all spec items, using the outer resource a.

afterAll' Source #

Arguments

:: (HList outers -> IO ())

The function to run (once), afterwards, using all outer resources.

-> TestDefM outers inner result 
-> TestDefM outers inner result 

Run a custom action after all spec items, using all the outer resources.

afterAll_ Source #

Arguments

:: IO ()

The function to run (once), afterwards.

-> TestDefM outers inner result 
-> TestDefM outers inner result 

Run a custom action after all spec items without using any outer resources.

aroundAll Source #

Arguments

:: ((outer -> IO ()) -> IO ())

The function that provides the outer resource (once), around the tests.

-> TestDefM (outer ': otherOuters) inner result 
-> TestDefM otherOuters inner result 

Run a custom action before and/or after all spec items in group, to provide access to a resource a.

See the FOOTGUN note in the docs for around_.

aroundAll_ Source #

Arguments

:: (IO () -> IO ())

The function that wraps running the tests.

-> TestDefM outers inner result 
-> TestDefM outers inner result 

Run a custom action before and/or after all spec items in a group without accessing any resources.

FOOTGUN

Expand

This combinator gives the programmer a lot of power. In fact, it gives the programmer enough power to break the test framework. Indeed, you can provide a wrapper function that just _doesn't_ run the function like this:

spec :: Spec
spec = do
   let don'tDo :: IO () -> IO ()
       don'tDo _ = pure ()
   aroundAll_ don'tDo $ do
     it "should pass" True

During execution, you'll then get an error like this:

thread blocked indefinitely in an MVar operation

The same problem exists when using around_.

Something even more pernicious goes wrong when you run the given action more than once like this:

spec :: Spec
spec = do
   let doTwice :: IO () -> IO ()
       doTwice f = f >> f
   aroundAll_ doTwice $ do
     it "should pass" True

In this case, the test will "just work", but it will be executed twice even if the output reports that it only passed once.

Note: If you're interested in fixing this, talk to me, but only after GHC has gotten impredicative types because that will likely be a requirement.

aroundAllWith Source #

Arguments

:: forall newOuter oldOuter otherOuters inner result. ((newOuter -> IO ()) -> oldOuter -> IO ())

The function that provides the new outer resource (once), using the old outer resource.

-> TestDefM (newOuter ': (oldOuter ': otherOuters)) inner result 
-> TestDefM (oldOuter ': otherOuters) inner result 

Run a custom action before and/or after all spec items in a group to provide access to a resource a while using a resource b

See the FOOTGUN note in the docs for around_.

wrapRWST Source #

Arguments

:: (TestForest outers1 inner1 -> TestTree outers2 inner2)

The wrapper node

-> TestDefM outers1 inner1 result 
-> TestDefM outers2 inner2 result 

Declare a node in the spec def forest