Test.Hspec.Lens

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

Types

type Spec = SpecWith ()

class Example e

A type class for examples

Minimal complete definition

evaluateExample

Instances

Example Bool

Example Property

Example Expectation

Example Result

Example (a -> Expectation)

Example (a -> Property)

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 @?=).

module Test.Hspec.Expectations.Lens

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
  putStrLn

with

it "exposes some behavior" $ do
  putStrLn

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" $
    pending

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.