The way to run a block of SnapHspecM tests within an hspec test suite. This takes both the top level handler (usually `route routes`, where routes are all the routes for your site) and the site initializer (often named app), and a block of tests. A test suite can have multiple calls to snap, though each one will cause the site initializer to run, which is often a slow operation (and will slow down test suites).

This allows you to change the default handler you are running requests against within a block. This is most likely useful for setting request state (for example, logging a user in).

This performs a similar operation to modifySite but in the context of SnapHspecM (which is needed if you need to eval, produce values, and hand them somewhere else (so they can't be created within f).

Evaluate a Handler action after each test.

Evaluate a Handler action before each test.

The result of making requests against your application. Most assertions act against these types (for example, should200, shouldHaveSelector, etc).

The main monad that tests run inside of. This allows both access to the application (via requests and eval) and to running assertions (like should404 or shouldHaveText).

Factory instances allow you to easily generate test data.

Essentially, you specify a default way of constructing a data type, and allow certain parts of it to be modified (via the fields data structure).

An example follows:

data Foo = Foo Int
newtype FooFields = FooFields (IO Int)
instance Factory App Foo FooFields where
  fields = FooFields randomIO
  save f = liftIO f >>= saveFoo . Foo1

main = do create id :: SnapHspecM App Foo
          create (const $ FooFields (return 1)) :: SnapHspecM App Foo

Runs a DELETE request

Runs a GET request.

Runs a GET request, with a set of parameters.

Creates a new POST request, with a set of parameters.

Creates a new POST request with a given JSON value as the request body.

Creates a new PUT request, with a set of parameters, with a default type of "application/x-www-form-urlencoded"

Creates a new PUT request with a configurable MIME/type

A helper to construct parameters.

Restricts a response to matches for a given CSS selector. Does nothing to non-Html responses.

Runs an arbitrary stateful action from your application.

Asserts that a given stateful action will produce a specific different result after an action has been run.

Asserts that two values are equal.

Asserts that two values are not equal.

Asserts that the value is True.

Asserts that the value is not True (otherwise known as False).

Asserts that the response is a success (either Html, or Other with status 200).

Asserts that the response is not a normal 200.

Asserts that the response is a NotFound.

Asserts that the response is not a NotFound.

Asserts that the response is a redirect.

Asserts that the response is not a redirect.

Asserts that the response is a redirect, and thet the url it redirects to starts with the given path.

Asserts that the response is not a redirect to a given path. Note that it can still be a redirect for this assertion to succeed, the path it redirects to just can't start with the given path.

Assert that a response (which should be Html) has a given selector.

Assert that a response (which should be Html) doesn't have a given selector.

Asserts that the response (which should be Html) contains the given text.

Asserts that the response (which should be Html) does not contain the given text.

A data type for tests against forms.

Tests against digestive-functors forms.

Internal state used to share site initialization across tests, and to propogate failures. Understanding it is completely unnecessary to use the library.

The fields it contains, in order, are:

Result
Main handler
Startup state
Startup state
Session state
Before handler (runs before each eval)
After handler (runs after each eval).

Records a test Success or Fail. Only the first Fail will be recorded (and will cause the whole block to Fail).

Runs a request (built with helpers from Snap.Test), resulting in a response.

Runs a request against a given handler (often the whole site), with the given state. Returns any triggered exception, or the response.

Evaluates a given handler with the given state. Returns any triggered exception, or the value produced.