Modulehedgehog-extras-0.10.1.0Haskell2010

Hedgehog.Extras.Test.Base

Synopsis

value propertyOnce
value workspace
value workspaceWithConfig
data WorkspacePolicy
value moduleWorkspace
value note
value note_
value noteM
value noteM_
value noteIO
value noteIO_
value noteShow
value noteShowPretty
value noteShowIO
value noteShowPrettyIO
value noteShowIO_
value noteShowPrettyIO_
value noteShowM
value noteShowPrettyM
value noteShowM_
value noteShowPrettyM_
value noteShow_
value noteShowPretty_
value noteEach
value noteEachPretty
value noteEachIO
value noteEachPrettyIO
value noteEachIO_
value noteEachPrettyIO_
value noteEachM
value noteEachPrettyM
value noteEachM_
value noteEachPrettyM_
value noteEach_
value noteEachPretty_
value noteTempFile
value headM
value indexM
value fromJustM
value nothingFail
value nothingFailM
value leftFail
value leftFailM
value onLeft
value onNothing
value jsonErrorFail
value jsonErrorFailM
value failWithCustom
value failMessage
value expectFailure
value expectFailureWith
value tryAssertion
value assertFailure
value assertFailure_
value assertByDeadlineM
value assertByDeadlineIO
value assertByDeadlineMFinally
value assertByDeadlineIOFinally
value assertWith
value assertWithM
value assertM
value assertIO
value assertWithinTolerance
value byDeadlineM
value byDeadlineIO
value byDurationM
value byDurationIO
value onFailure
type Integration
value release
value runFinallies
value retry
value retry'
class MonadBaseControl
value bracket
value bracket_

Packagehedgehog-extras-0.10.1.0
Exports76
LanguageHaskell2010
LicenceApache-2.0
SourceBase.hs

valuepropertyOnce :: HasCallStack => Integration () -> Property

Source#

Run a property with only one test. This is intended for allowing hedgehog to run unit tests.

valueworkspace

:: (HasCallStack, MonadCatch m, MonadBaseControl IO m, MonadResource m, MonadTest m, MonadAssertion m)
=> FilePath
-> FilePath -> m ()
-> m ()

Source#

Create a workspace directory which will exist for at least the duration of the supplied block.

The directory will have the supplied prefix but contain a generated random suffix to prevent interference between tests

The directory will be deleted if the block succeeds, but left behind if the block fails.

valueworkspaceWithConfig

:: (HasCallStack, MonadCatch m, MonadBaseControl IO m, MonadResource m, MonadTest m, MonadAssertion m)
=> WorkspacePolicy
Cleanup policy: PreserveWorkspace always preserves, CleanupOnSuccess deletes on success only
-> FilePath
-> (FilePath -> m ())
-> m ()

Source#

Create a workspace directory with explicit configuration for cleanup behavior.

The directory will have the supplied prefix but contain a generated random suffix to prevent interference between tests

The directory will be deleted if the block succeeds, but left behind if the block fails (unless policy is PreserveWorkspace, in which case it's always preserved).

datadata WorkspacePolicy

Source#

Policy for workspace directory cleanup behavior

Constructors

PreserveWorkspace
Always preserve workspace directories, even on success
CleanupOnSuccess
Clean up workspace directories only when tests succeed

Instances2Eq, Show

Eq WorkspacePolicyDefined in hedgehog-extras-0.10.1.0 · Hedgehog.Extras.Test.Base
Show WorkspacePolicyDefined in hedgehog-extras-0.10.1.0 · Hedgehog.Extras.Test.Base

valuemoduleWorkspace

:: (HasCallStack, MonadCatch m, MonadBaseControl IO m, MonadResource m, MonadTest m, MonadAssertion m)
=> String
-> FilePath -> m ()
-> m ()

Source#

Create a workspace directory which will exist for at least the duration of the supplied block.

The directory will have the prefix as "$prefixPath/$moduleName" but contain a generated random suffix to prevent interference between tests

The directory will be deleted if the block succeeds, but left behind if the block fails.

The prefix argument should not contain directory delimeters.

valuenote :: (MonadTest m, HasCallStack) => String -> m String

Source#

Annotate with the given string.

valuenote_ :: (MonadTest m, HasCallStack) => String -> m ()

Source#

Annotate the given string returning unit.

valuenoteM :: (MonadTest m, MonadCatch m, HasCallStack) => m String -> m String

Source#

Annotate the given string in a monadic context.

valuenoteM_ :: (MonadTest m, MonadCatch m, HasCallStack) => m String -> m ()

Source#

Annotate the given string in a monadic context returning unit.

valuenoteIO :: (MonadTest m, MonadIO m, HasCallStack) => IO String -> m String

Source#

Annotate the given string in IO.

valuenoteIO_ :: (MonadTest m, MonadIO m, HasCallStack) => IO String -> m ()

Source#

Annotate the given string in IO returning unit.

valuenoteShow :: (MonadTest m, HasCallStack, Show a) => a -> m a

Source#

Annotate the given value.

valuenoteShowPretty :: (MonadTest m, HasCallStack, Show a) => a -> m a

Source#

Annotate the given value, pretty printing it with indentation. Note that large data structures will take a significant amount of vertical screen space.

valuenoteShowIO :: (MonadTest m, MonadIO m, HasCallStack, Show a) => IO a -> m a

Source#

Annotate the given value in IO.

valuenoteShowPrettyIO

:: (MonadTest m, MonadIO m, HasCallStack, Show a)
=> IO a
-> m a

Source#

Annotate the given value in IO, pretty printing it with indentation. Note that large data structures will take a significant amount of vertical screen space.

valuenoteShowIO_

:: (MonadTest m, MonadIO m, HasCallStack, Show a)
=> IO a
-> m ()

Source#

Annotate the given value in IO returning unit.

valuenoteShowPrettyIO_

:: (MonadTest m, MonadIO m, HasCallStack, Show a)
=> IO a
-> m ()

Source#

Annotate the given value in IO returning unit, pretty printing it with indentation. Note that large data structures will take a significant amount of vertical screen space.

valuenoteShowM :: (MonadTest m, MonadCatch m, HasCallStack, Show a) => m a -> m a

Source#

Annotate the given value in a monadic context.

valuenoteShowPrettyM

:: (MonadTest m, MonadCatch m, HasCallStack, Show a)
=> m a
-> m a

Source#

Annotate the given value in a monadic context, pretty printing it with indentation. Note that large data structures will take a significant amount of vertical screen space.

valuenoteShowM_

:: (MonadTest m, MonadCatch m, HasCallStack, Show a)
=> m a
-> m ()

Source#

Annotate the given value in a monadic context returning unit.

valuenoteShowPrettyM_

:: (MonadTest m, MonadCatch m, HasCallStack, Show a)
=> m a
-> m ()

Source#

Annotate the given value in a monadic context returning unit, pretty printing it with indentation. Note that large data structures will take a significant amount of vertical screen space.

valuenoteShow_ :: (MonadTest m, HasCallStack, Show a) => a -> m ()

Source#

Annotate the given value returning unit.

valuenoteShowPretty_ :: (MonadTest m, HasCallStack, Show a) => a -> m ()

Source#

Annotate the given value returning unit, pretty printing it with indentation. Note that large data structures will take a significant amount of vertical screen space.

valuenoteEach

:: (MonadTest m, HasCallStack, Show a, Traversable f)
=> f a
-> m (f a)

Source#

Annotate the each value in the given traversable.

valuenoteEachPretty

:: (MonadTest m, HasCallStack, Show a, Traversable f)
=> f a
-> m (f a)

Source#

Annotate the each value in the given traversable, pretty printing it with indentation. Note that large data structures will take a significant amount of vertical screen space.

valuenoteEachIO

:: (MonadTest m, MonadIO m, HasCallStack, Show a, Traversable f)
=> IO (f a)
-> m (f a)

Source#

Annotate the each value in the given traversable in IO.

valuenoteEachPrettyIO

:: (MonadTest m, MonadIO m, HasCallStack, Show a, Traversable f)
=> IO (f a)
-> m (f a)

Source#

Annotate the each value in the given traversable in IO, pretty printing it with indentation. Note that large data structures will take a significant amount of vertical screen space.

valuenoteEachIO_

:: (MonadTest m, MonadIO m, HasCallStack, Show a, Traversable f)
=> IO (f a)
-> m ()

Source#

Annotate the each value in the given traversable in IO returning unit.

valuenoteEachPrettyIO_

:: (MonadTest m, MonadIO m, HasCallStack, Show a, Traversable f)
=> IO (f a)
-> m ()

Source#

Annotate the each value in the given traversable in IO returning unit, pretty printing it with indentation. Note that large data structures will take a significant amount of vertical screen space.

valuenoteEachM

:: (MonadTest m, HasCallStack, Show a, Traversable f)
=> m (f a)
-> m (f a)

Source#

Annotate the each value in the given traversable in a monadic context.

valuenoteEachPrettyM

:: (MonadTest m, HasCallStack, Show a, Traversable f)
=> m (f a)
-> m (f a)

Source#

Annotate the each value in the given traversable in a monadic context, pretty printing it with indentation. Note that large data structures will take a significant amount of vertical screen space.

valuenoteEachM_

:: (MonadTest m, HasCallStack, Show a, Traversable f)
=> m (f a)
-> m ()

Source#

Annotate the each value in the given traversable in a monadic context returning unit.

valuenoteEachPrettyM_

:: (MonadTest m, HasCallStack, Show a, Traversable f)
=> m (f a)
-> m ()

Source#

Annotate the each value in the given traversable in a monadic context returning unit, pretty printing it with indentation. Note that large data structures will take a significant amount of vertical screen space.

valuenoteEach_

:: (MonadTest m, HasCallStack, Show a, Traversable f)
=> f a
-> m ()

Source#

Annotate the each value in the given traversable returning unit.

valuenoteEachPretty_

:: (MonadTest m, HasCallStack, Show a, Traversable f)
=> f a
-> m ()

Source#

Annotate the each value in the given traversable returning unit, pretty printing it with indentation. Note that large data structures will take a significant amount of vertical screen space.

valuenoteTempFile

:: (MonadTest m, HasCallStack)
=> FilePath
-> FilePath
-> m FilePath

Source#

Return the test file path after annotating it relative to the project root directory

valueheadM :: (MonadTest m, HasCallStack) => [a] -> m a

valueindexM :: (MonadTest m, HasCallStack) => Int -> [a] -> m a

valuefromJustM :: (MonadTest m, HasCallStack) => Maybe a -> m a

Source#

Index into a list. On failure, a friendly message is included in the test report.

valuenothingFail :: (MonadTest m, HasCallStack) => Maybe a -> m a

Source#

Fail when the result is Nothing.

valuenothingFailM :: (MonadTest m, HasCallStack) => m (Maybe a) -> m a

Source#

Fail when the computed result is Nothing.

valueleftFail :: (MonadTest m, Show e, HasCallStack) => Either e a -> m a

Source#

Fail when the result is Left.

valueleftFailM :: (MonadTest m, Show e, HasCallStack) => m (Either e a) -> m a

Source#

Fail when the computed result is Left.

valueonLeft :: Monad m => (e -> m a) -> m (Either e a) -> m a

valueonNothing :: Monad m => m a -> m (Maybe a) -> m a

valuejsonErrorFail :: (MonadTest m, HasCallStack) => Result a -> m a

Source#

Fail when the result is Error.

valuejsonErrorFailM :: (MonadTest m, HasCallStack) => m (Result a) -> m a

Source#

Fail when the computed result is Error.

valuefailWithCustom :: MonadTest m => CallStack -> Maybe Diff -> String -> m a

Source#

Takes a CallStack so the error can be rendered at the appropriate call site.

valuefailMessage :: MonadTest m => CallStack -> String -> m a

Source#

Takes a CallStack so the error can be rendered at the appropriate call site.

valueexpectFailure

:: (MonadTest m, MonadIO m, HasCallStack)
=> TestT IO a
-> m ()

Source#

Invert the behavior of a property: success becomes failure and vice versa.

valueexpectFailureWith

:: (MonadTest m, MonadIO m, HasCallStack)
=> Failure -> m ()
-> TestT IO b
-> m ()

Source#

Invert the behavior of a property: success becomes failure and vice versa. This function behaves like expectFailure but it allows to check the failure is as expected. The function takes a Failure and should itself be a test that fails if the failure is not as expected.

valuetryAssertion :: MonadAssertion m => m a -> m (Either Failure a)

Source#

Attempt to run a function that may assert, returning either a failure or the result of the assertion.

valueassertFailure

:: (HasCallStack, Show a, MonadAssertion m, MonadTest m)
=> m a
-> m Failure

Source#

Run the given action and succeed if the action fails, but fail if it succeeds.

valueassertFailure_

:: (HasCallStack, Show a, MonadAssertion m, MonadTest m)
=> m a
-> m ()

Source#

Run the given action and succeed if the action fails, but fail if it succeeds.

valueassertByDeadlineM

:: (MonadTest m, MonadIO m, HasCallStack)
=> UTCTime
-> m Bool
-> m ()

Source#

Run the operation f once a second until it returns True or the deadline expires.

Expiration of the deadline results in an assertion failure

valueassertByDeadlineIO

:: (MonadTest m, MonadIO m, HasCallStack)
=> UTCTime
-> IO Bool
-> m ()

Source#

Run the operation f once a second until it returns True or the deadline expires.

Expiration of the deadline results in an assertion failure

valueassertByDeadlineMFinally

:: (MonadTest m, MonadIO m, HasCallStack)
=> UTCTime
-> m Bool
-> m ()
-> m ()

Source#

Run the operation f once a second until it returns True or the deadline expires.

The action g is run after expiration of the deadline, but before failure allowing for additional annotations to be presented.

Expiration of the deadline results in an assertion failure

valueassertByDeadlineIOFinally

:: (MonadTest m, MonadIO m, HasCallStack)
=> UTCTime
-> IO Bool
-> m ()
-> m ()

Source#

Run the operation f once a second until it returns True or the deadline expires.

The action g is run after expiration of the deadline, but before failure allowing for additional annotations to be presented.

Expiration of the deadline results in an assertion failure

valueassertWith

:: (MonadTest m, Show p, HasCallStack)
=> p
-> p -> Bool
-> m ()

Source#

Run the test function against the value. Report the value on the failure.

valueassertWithM

:: (MonadTest m, Show p, HasCallStack)
=> p
-> p -> m Bool
-> m ()

Source#

Run the test function against the value. Report the value on the failure.

valueassertM :: (MonadTest m, HasCallStack) => m Bool -> m ()

Source#

Run the monadic action f and assert the return value is True.

valueassertIO :: (MonadTest m, MonadIO m, HasCallStack) => IO Bool -> m ()

Source#

Run the IO action f and assert the return value is True.

valueassertWithinTolerance

:: (Show a, Ord a, Num a, HasCallStack, MonadTest m)
=> a
tested value v
-> a
expected value c
-> a
tolerance range r
-> m ()

Source#

Tests if |c - v| <= r

valuebyDeadlineM

:: (MonadAssertion m, MonadTest m, MonadIO m, HasCallStack)
=> NominalDiffTime
-> UTCTime
-> String
-> m a
-> m a

Source#

Run the operation f once per period until it returns True or the deadline expires.

Expiration of the deadline results in an assertion failure

valuebyDeadlineIO

:: (MonadAssertion m, MonadTest m, MonadIO m, HasCallStack)
=> NominalDiffTime
-> UTCTime
-> String
-> IO a
-> m a

Source#

Run the operation f once per period until it returns True or the deadline expires.

Expiration of the deadline results in an assertion failure

valuebyDurationM

:: (MonadAssertion m, MonadTest m, MonadIO m, HasCallStack)
=> NominalDiffTime
-> NominalDiffTime
-> String
-> m a
-> m a

Source#

Run the operation f once per period until it returns True or the duration expires.

Expiration of the duration results in an assertion failure

valuebyDurationIO

:: (MonadAssertion m, MonadTest m, MonadIO m, HasCallStack)
=> NominalDiffTime
-> NominalDiffTime
-> String
-> IO a
-> m a

Source#

Run the operation f once per period until it returns True or the duration expires.

Expiration of the duration results in an assertion failure

valueonFailure :: Integration () -> Integration ()

typetype Integration a = PropertyT (ReaderT IntegrationState (ResourceT IO)) a

valuerelease :: (MonadTest m, MonadIO m) => ReleaseKey -> m ()

Source#

Release the given release key.

valuerunFinallies :: Integration a -> Integration a

valueretry :: Int -> (Int -> Integration a) -> Integration a

valueretry' :: Int -> Integration a -> Integration a

classclass MonadBase b m => MonadBaseControl (b :: Type -> Type) (m :: Type -> Type) | m -> b where

Source#

Writing instances

The usual way to write a MonadBaseControl instance for a transformer stack over a base monad B is to write an instance MonadBaseControl B B for the base monad, and MonadTransControl T instances for every transformer T. Instances for MonadBaseControl are then simply implemented using ComposeSt, defaultLiftBaseWith, defaultRestoreM.

Instances25MonadBaseControl, …

MonadBaseControl STM STMDefined in monad-control-1.0.3.1 · Control.Monad.Trans.Control
MonadBaseControl Identity IdentityDefined in monad-control-1.0.3.1 · Control.Monad.Trans.Control
MonadBaseControl Maybe MaybeDefined in monad-control-1.0.3.1 · Control.Monad.Trans.Control
MonadBaseControl IO IODefined in monad-control-1.0.3.1 · Control.Monad.Trans.Control
MonadBaseControl IO UnitIODefined in hedgehog-extras-0.10.1.0 · Hedgehog.Extras.Test.Unit
MonadBaseControl [] []Defined in monad-control-1.0.3.1 · Control.Monad.Trans.Control
MonadBaseControl IO (ResourceT IO)Defined in hedgehog-extras-0.10.1.0 · Hedgehog.Extras.Internal.Orphans · orphan
MonadBaseControl b m => MonadBaseControl b (GenT m)Defined in hedgehog-1.7 · Hedgehog.Internal.Gen
MonadBaseControl b m => MonadBaseControl b (PropertyT m)Defined in hedgehog-1.7 · Hedgehog.Internal.Property
MonadBaseControl b m => MonadBaseControl b (TestT m)Defined in hedgehog-1.7 · Hedgehog.Internal.Property
MonadBaseControl b m => MonadBaseControl b (TreeT m)Defined in hedgehog-1.7 · Hedgehog.Internal.Tree
MonadBaseControl b m => MonadBaseControl b (MaybeT m)Defined in monad-control-1.0.3.1 · Control.Monad.Trans.Control
MonadBaseControl b m => MonadBaseControl b (ExceptT e m)Defined in monad-control-1.0.3.1 · Control.Monad.Trans.Control
MonadBaseControl b m => MonadBaseControl b (IdentityT m)Defined in monad-control-1.0.3.1 · Control.Monad.Trans.Control
MonadBaseControl b m => MonadBaseControl b (ReaderT r m)Defined in monad-control-1.0.3.1 · Control.Monad.Trans.Control
MonadBaseControl b m => MonadBaseControl b (StateT s m)Defined in monad-control-1.0.3.1 · Control.Monad.Trans.Control
MonadBaseControl b m => MonadBaseControl b (StateT s m)Defined in monad-control-1.0.3.1 · Control.Monad.Trans.Control
(Monoid w, MonadBaseControl b m) => MonadBaseControl b (WriterT w m)Defined in monad-control-1.0.3.1 · Control.Monad.Trans.Control
(Monoid w, MonadBaseControl b m) => MonadBaseControl b (WriterT w m)Defined in monad-control-1.0.3.1 · Control.Monad.Trans.Control
(Monoid w, MonadBaseControl b m) => MonadBaseControl b (RWST r w s m)Defined in monad-control-1.0.3.1 · Control.Monad.Trans.Control
(Monoid w, MonadBaseControl b m) => MonadBaseControl b (RWST r w s m)Defined in monad-control-1.0.3.1 · Control.Monad.Trans.Control
MonadBaseControl (ST s) (ST s)Defined in monad-control-1.0.3.1 · Control.Monad.Trans.Control
MonadBaseControl (Either e) (Either e)Defined in monad-control-1.0.3.1 · Control.Monad.Trans.Control
MonadBaseControl (ST s) (ST s)Defined in monad-control-1.0.3.1 · Control.Monad.Trans.Control
MonadBaseControl ((->) r) ((->) r)Defined in monad-control-1.0.3.1 · Control.Monad.Trans.Control

valuebracket

:: MonadBaseControl IO m
=> m a
computation to run first ("acquire resource")
-> (a -> m b)
computation to run last ("release resource")
-> (a -> m c)
computation to run in-between
-> m c

Source#

Generalized version of bracket.

Note:

When the "acquire" or "release" computations throw exceptions any monadic side effects in m will be discarded.
When the "in-between" computation throws an exception any monadic side effects in m produced by that computation will be discarded but the side effects of the "acquire" or "release" computations will be retained.
Also, any monadic side effects in m of the "release" computation will be discarded; it is run only for its side effects in IO.

Note that when your acquire and release computations are of type IO it will be more efficient to write:

liftBaseOp (bracket acquire release)

valuebracket_

:: MonadBaseControl IO m
=> m a
computation to run first ("acquire resource")
-> m b
computation to run last ("release resource")
-> m c
computation to run in-between
-> m c

Source#

Generalized version of bracket_.

Note any monadic side effects in m of both the "acquire" and "release" computations will be discarded. To keep the monadic side effects of the "acquire" computation, use bracket with constant functions instead.

Note that when your acquire and release computations are of type IO it will be more efficient to write:

liftBaseOp_ (bracket_ acquire release)