Stability | stable |
---|---|
Safe Haskell | None |
Language | Haskell2010 |
Hspec is a testing framework for Haskell.
This is the library reference for Hspec. The User's Manual contains more in-depth documentation.
Synopsis
- type Spec = SpecWith ()
- type SpecWith a = SpecM a ()
- type family Arg e
- class Example e
- module Test.Hspec.Expectations
- it :: (HasCallStack, Example a) => String -> a -> SpecWith (Arg a)
- specify :: (HasCallStack, Example a) => String -> a -> SpecWith (Arg a)
- describe :: HasCallStack => String -> SpecWith a -> SpecWith a
- context :: HasCallStack => String -> SpecWith a -> SpecWith a
- example :: Expectation -> Expectation
- parallel :: SpecWith a -> SpecWith a
- runIO :: IO r -> SpecM a r
- pending :: HasCallStack => Expectation
- pendingWith :: HasCallStack => String -> Expectation
- xit :: (HasCallStack, Example a) => String -> a -> SpecWith (Arg a)
- xspecify :: (HasCallStack, Example a) => String -> a -> SpecWith (Arg a)
- xdescribe :: HasCallStack => String -> SpecWith a -> SpecWith a
- xcontext :: HasCallStack => String -> SpecWith a -> SpecWith a
- focus :: SpecWith a -> SpecWith a
- fit :: (HasCallStack, Example a) => String -> a -> SpecWith (Arg a)
- fspecify :: (HasCallStack, Example a) => String -> a -> SpecWith (Arg a)
- fdescribe :: HasCallStack => String -> SpecWith a -> SpecWith a
- fcontext :: HasCallStack => String -> SpecWith a -> SpecWith a
- type ActionWith a = a -> IO ()
- before :: IO a -> SpecWith a -> Spec
- before_ :: IO () -> SpecWith a -> SpecWith a
- beforeWith :: (b -> IO a) -> SpecWith a -> SpecWith b
- beforeAll :: IO a -> SpecWith a -> Spec
- beforeAll_ :: IO () -> SpecWith a -> SpecWith a
- beforeAllWith :: (b -> IO a) -> SpecWith a -> SpecWith b
- after :: ActionWith a -> SpecWith a -> SpecWith a
- after_ :: IO () -> SpecWith a -> SpecWith a
- afterAll :: HasCallStack => ActionWith a -> SpecWith a -> SpecWith a
- afterAll_ :: HasCallStack => IO () -> SpecWith a -> SpecWith a
- around :: (ActionWith a -> IO ()) -> SpecWith a -> Spec
- around_ :: (IO () -> IO ()) -> SpecWith a -> SpecWith a
- aroundWith :: (ActionWith a -> ActionWith b) -> SpecWith a -> SpecWith b
- aroundAll :: (ActionWith a -> IO ()) -> SpecWith a -> Spec
- aroundAllWith :: (ActionWith a -> ActionWith b) -> SpecWith a -> SpecWith b
- mapSubject :: (b -> a) -> SpecWith a -> SpecWith b
- ignoreSubject :: SpecWith () -> SpecWith a
- hspec :: Spec -> IO ()
Types
Instances
type Arg Bool | |
Defined in Test.Hspec.Core.Example | |
type Arg Property | |
Defined in Test.Hspec.Core.Example | |
type Arg Result | |
Defined in Test.Hspec.Core.Example | |
type Arg Expectation | |
Defined in Test.Hspec.Core.Example | |
type Arg (a -> Property) | |
Defined in Test.Hspec.Core.Example | |
type Arg (a -> Expectation) | |
Defined in Test.Hspec.Core.Example | |
type Arg (a -> Bool) | |
Defined in Test.Hspec.Core.Example | |
type Arg (a -> Result) | |
Defined in Test.Hspec.Core.Example |
A type class for examples
Instances
Setting expectations
module Test.Hspec.Expectations
Defining a spec
it :: (HasCallStack, Example a) => String -> a -> SpecWith (Arg a) #
The it
function creates a spec item.
A spec item consists of:
- a textual description of a desired behavior
- an example for that behavior
describe "absolute" $ do it "returns a positive number when given a negative number" $ absolute (-1) == 1
specify :: (HasCallStack, Example a) => String -> a -> SpecWith (Arg a) #
specify
is an alias for it
.
describe :: HasCallStack => String -> SpecWith a -> SpecWith a #
The describe
function combines a list of specs into a larger spec.
example :: Expectation -> Expectation Source #
example
is a type restricted version of id
. It can be used to get better
error messages on type mismatches.
Compare e.g.
it "exposes some behavior" $ example $ do putStrLn
with
it "exposes some behavior" $ do putStrLn
parallel :: SpecWith a -> SpecWith a #
parallel
marks all spec items of the given spec to be safe for parallel
evaluation.
Run an IO action while constructing the spec tree.
SpecM
is a monad to construct a spec tree, without executing any spec
items. runIO
allows you to run IO actions during this construction phase.
The IO action is always run when the spec tree is constructed (e.g. even
when --dry-run
is specified).
If you do not need the result of the IO action to construct the spec tree,
beforeAll
may be more suitable for your use case.
Pending spec items
During a test run a pending spec item is:
- not executed
- reported as "pending"
pending :: HasCallStack => Expectation #
pending
can be used to mark a spec item as pending.
If you want to textually specify a behavior but do not have an example yet, use this:
describe "fancyFormatter" $ do it "can format text in a way that everyone likes" $ pending
pendingWith :: HasCallStack => String -> Expectation #
pendingWith
is similar to pending
, but it takes an additional string
argument that can be used to specify the reason for why the spec item is pending.
xspecify :: (HasCallStack, Example a) => String -> a -> SpecWith (Arg a) #
xspecify
is an alias for xit
.
Focused spec items
During a test run, when a spec contains focused spec items, all other spec items are ignored.
fit :: (HasCallStack, Example a) => String -> a -> SpecWith (Arg a) #
fit
is an alias for fmap focus . it
fspecify :: (HasCallStack, Example a) => String -> a -> SpecWith (Arg a) #
fspecify
is an alias for fit
.
fdescribe :: HasCallStack => String -> SpecWith a -> SpecWith a #
fdescribe
is an alias for fmap focus . describe
Hooks
type ActionWith a = a -> IO () #
An IO
action that expects an argument of type a
beforeWith :: (b -> IO a) -> SpecWith a -> SpecWith b #
Run a custom action before every spec item.
beforeAll_ :: IO () -> SpecWith a -> SpecWith a #
Run a custom action before the first spec item.
beforeAllWith :: (b -> IO a) -> SpecWith a -> SpecWith b #
Run a custom action with an argument before the first spec item.
after :: ActionWith a -> SpecWith a -> SpecWith a #
Run a custom action after every spec item.
afterAll :: HasCallStack => ActionWith a -> SpecWith a -> SpecWith a #
Run a custom action after the last spec item.
afterAll_ :: HasCallStack => IO () -> SpecWith a -> SpecWith a #
Run a custom action after the last spec item.
around :: (ActionWith a -> IO ()) -> SpecWith a -> Spec #
Run a custom action before and/or after every spec item.
around_ :: (IO () -> IO ()) -> SpecWith a -> SpecWith a #
Run a custom action before and/or after every spec item.
aroundWith :: (ActionWith a -> ActionWith b) -> SpecWith a -> SpecWith b #
Run a custom action before and/or after every spec item.
aroundAllWith :: (ActionWith a -> ActionWith b) -> SpecWith a -> SpecWith b #
Wrap an action around the given spec. Changes the arg type inside.
mapSubject :: (b -> a) -> SpecWith a -> SpecWith b #
Modify the subject under test.
Note that this resembles a contravariant functor on the first type parameter
of SpecM
. This is because the subject is passed inwards, as an argument
to the spec item.
ignoreSubject :: SpecWith () -> SpecWith a #
Ignore the subject under test for a given spec.