Snap.Test.BDD

Types

type SnapTesting b a = StateT (Handler b b (), (Snaplet b, InitializerState b), OutputStream TestResult) IO a

The main type for this library, where b is your application state, often called App. This is a State monad on top of IO, where the State carries your application (or, more specifically, a top-level handler), and stream of test results to be reported as passing or failing.

data TestResult

TestResult is a a flattened tree structure that reflects the structure of your tests, and is the data that is passed to report generators.

Constructors

NameStart Text

NameEnd

TestPass (Sentiment Text)

TestFail (Sentiment Text)

TestError Text

Instances

Show TestResult

data Sentiment a

Tests have messages that are agnostic to whether the result should hold or should not hold. The sentiment is attached to them to indicate that positive/negative statement. This allows the same message to be used for tests asserted with should and shouldNot.

Constructors

Positive a

Negative a

Instances

Show a => Show (Sentiment a)

data TestResponse

A TestResponse is the result of making a request. Many predicates operate on these types of responses, and custom predicates can be written against them.

Constructors

Html Text

NotFound

Redirect Int Text

Other Int

Empty

data SnapTestingConfig

The configuration that is passed to the test runner, currently just a list of report generators, that are each passed a stream of results, and can do any side effecting thing with them.

Constructors

SnapTestingConfig

Fields

reportGenerators :: [InputStream TestResult -> IO ()]

Configuration

defaultConfig :: SnapTestingConfig

The default configuration just prints results to the console, using the consoleReport.

Running tests

runSnapTests

Arguments

:: SnapTestingConfig

Configuration for test runner

-> Handler b b ()

Site that requests are run against (often route routes, where routes are your sites routes).

-> SnapletInit b b

Site initializer

-> SnapTesting b ()

Block of tests

-> IO ()

Run a set of tests, putting the results through the specified report generators

consoleReport :: InputStream TestResult -> IO ()

Prints test results to the console. For example:

/auth/new_user
 success PASSED
 creates a new account PASSED

linuxDesktopReport :: InputStream TestResult -> IO ()

Sends the test results to desktop notifications on linux. Prints how many tests passed and failed.

Labeling

name

Arguments

:: Text

Name of block

-> SnapTesting b ()

Block of tests

-> SnapTesting b ()

Labels a block of tests with a descriptive name, to be used in report generation.

Applying Predicates

should :: SnapTesting b TestResult -> SnapTesting b ()

This takes a TestResult and writes it to the test log, so it is processed by the report generators.

shouldNot :: SnapTesting b TestResult -> SnapTesting b ()

This is similar to should, but it asserts that the test should fail, and inverts the corresponding message sentiment.

Helpers for running tests

css :: Applicative m => Text -> m CssSelector

Constructor for CSS selectors

val :: Applicative m => a -> m a

A constructor for pure values (this is just a synonym for pure from Applicative).

Getting Responses

get

Arguments

:: Text

The url to request.

-> SnapTesting b TestResponse

Runs a GET request

get'

Arguments

:: Text

The url to request.

-> Map ByteString [ByteString]

The parameters to send.

-> SnapTesting b TestResponse

Runs a GET request, with a set of parameters.

post

Arguments

:: Text

The url to request.

-> Map ByteString [ByteString]

The parameters to send.

-> SnapTesting b TestResponse

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

params

Arguments

:: [(ByteString, ByteString)]

Pairs of parameter and value.

-> Map ByteString [ByteString]

A helper to construct parameters.

Predicates on values

equal :: (Show a, Eq a) => a -> a -> TestResult

Checks that the handler evaluates to the given value.

beTrue :: Bool -> TestResult

Helper to bring the results of other tests into the test suite.

Predicates on Responses

succeed :: TestResponse -> TestResult

Checks that the given request results in a success (200) code.

notfound :: TestResponse -> TestResult

Checks that the given request results in a not found (404) code.

redirect :: TestResponse -> TestResult

Checks that the given request results in a redirect (3**) code.

redirectTo

Arguments

:: TestResponse

Request to run

-> Text

URL it should redirect to

-> TestResult

Checks that the given request results in a redirect to a specific url.

haveText :: TestResponse -> Text -> TestResult

Asserts that a response (which should be Html) has given text.

haveSelector :: TestResponse -> CssSelector -> TestResult

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

Stateful value tests

changes

Arguments

:: (Show a, Eq a)

=> (a -> a)

Change function

-> Handler b b a

Monadic value

-> SnapTesting b c

Test block to run.

-> SnapTesting b ()

Checks that the monadic value given changes by the function specified after the given test block is run.

For example, if you wanted to make sure that account creation was creating new accounts:

changes (+1) countAccounts (post "/auth/new_user" $ params
                            [ ("new_user.name", "Jane")
                            , ("new_user.email", "[e-mail]")
                            , ("new_user.password", "foobar")])

Stateful form tests

data FormExpectations a

A data type for tests against forms.

Constructors

Value a

The value the form should take (and should be valid)

ErrorPaths [Text]

The error paths that should be populated

form

Arguments

:: (Eq a, Show a)

=> FormExpectations a

If the form should succeed, Value a is what it should produce. If failing, ErrorPaths should be all the errors that are triggered.

-> Form Text (Handler b b) a

The form to run

-> Map Text Text

The parameters to pass

-> SnapTesting b ()

Test against digestive-functors forms.

Run actions after block

cleanup

Arguments

:: Handler b b ()

Action to run after tests

-> SnapTesting b ()

Tests to run

-> SnapTesting b ()

Runs an action after a block of tests, usually used to remove database state.

Evaluating arbitrary actions

eval

Arguments

:: Handler b b a

Action to evaluate

-> SnapTesting b a

Evaluate arbitrary actions

Create helpers

modifySite

Arguments

:: (Handler b b () -> Handler b b ())

Site modification function

-> SnapTesting b a

Tests to run

-> SnapTesting b a

Given a site to site function (like, generating a random user and logging in), run the given block of test with the modified state.

Integrate with QuickCheck

quickCheck :: Testable prop => prop -> SnapTesting b ()

Allows you to run a quickcheck test. All 100 test passing counts as a pass, any failure a failure. Currently the reporting is really bad (you don't see what the failing example is).