hspec-expectations-lens-0.4.0: Hspec expectations for the lens stuff

Safe HaskellNone




Module is designed to be conveniently imported instead of Test.Hspec

It reexports Test.Hspec without expectations (except for shouldBe) and Test.Hspec.Expectations.Lens expectations



type Spec = SpecWith ()

class Example e

A type class for examples

Minimal complete definition


Setting expectations

shouldBe :: (Show a, Eq a) => a -> a -> Expectation infix 1

actual `shouldBe` expected sets the expectation that actual is equal to expected (this is just an alias for @?=).

Defining a spec

describe :: String -> SpecWith a -> SpecWith a

The describe function combines a list of specs into a larger spec.

context :: String -> SpecWith a -> SpecWith a

context is an alias for describe.

it :: 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

example :: Expectation -> Expectation

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


it "exposes some behavior" $ do

pending :: Expectation

pending can be used to indicate that an example is 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" $

pendingWith :: String -> Expectation

pendingWith is similar to pending, but it takes an additional string argument that can be used to specify the reason for why it's pending.

before :: IO a -> SpecWith a -> Spec

Run a custom action before every spec item.

after :: ActionWith a -> SpecWith a -> SpecWith a

Run a custom action after every spec item.

around :: (ActionWith a -> IO ()) -> SpecWith a -> Spec

Run a custom action before and/or after every spec item.

parallel :: SpecWith a -> SpecWith a

parallel marks all spec items of the given spec to be safe for parallel evaluation.

Running a spec

hspec :: Spec -> IO ()

Run given spec and write a report to stdout. Exit with exitFailure if at least one spec item fails.