Test.Hspec.Wai

A WAI test session that carries the Application under test and some client state.

An expectation in the WaiSession monad. Failing expectations are communicated through exceptions (similar to Expectation and Test.HUnit.Base.Assertion).

Perform a GET request to the application under test.

Perform a POST request to the application under test.

Perform a PUT request to the application under test.

Perform a PATCH request to the application under test.

Perform an OPTIONS request to the application under test.

Perform a DELETE request to the application under test.

Perform a request to the application under test, with specified HTTP method, request path, headers and body.

Set the expectation that a response matches a specified ResponseMatcher.

A ResponseMatcher matches a response if:

• the specified status matches the HTTP response status code

• the specified body (if any) matches the response body

• the response has all of the specified Header fields (the response may have arbitrary additional Header fields)

You can use ResponseMatcher's (broken) Num instance to match for a HTTP status code:

get "/" `shouldRespondWith` 200
-- matches if status is 200

You can use ResponseMatcher's IsString instance to match for a HTTP status 200 and a body:

get "/" `shouldRespondWith` "foo"
-- matches if body is "foo" and status is 200

If you want to match for a different HTTP status, you can use record update notation to specify matchStatus explicitly:

get "/" `shouldRespondWith` "foo" {matchStatus = 404}
-- matches if body is "foo" and status is 404

If you want to require a specific header field you can specify matchHeaders:

get "/" `shouldRespondWith` "foo" {matchHeaders = ["Content-Type" <:> "text/plain"]}
-- matches if body is "foo", status is 200 and there is a header field "Content-Type: text/plain"

Lift a computation from the IO monad. This allows us to run IO computations in any monadic stack, so long as it supports these kinds of operations (i.e. IO is the base monad for the stack).

Example

import Control.Monad.Trans.State -- from the "transformers" library

printState :: Show s => StateT s IO ()
printState = do
  state <- get
  liftIO $ print state

Had we omitted liftIO, we would have ended up with this error:

• Couldn't match type ‘IO’ with ‘StateT s IO’
 Expected type: StateT s IO ()
   Actual type: IO ()

The important part here is the mismatch between StateT s IO () and IO ().

Luckily, we know of a function that takes an IO a and returns an (m a): liftIO, enabling us to run the program and see the expected results:

> evalStateT printState "hello"
"hello"

> evalStateT printState 3
3

A lifted version of pending.

A lifted version of pendingWith.