Run a test suite using the given site.

If your site contains any resources that need to be set up, you probably want to be using one of the following functions instead.

Example usage with a minimal yesod App:

{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings     #-}
{-# LANGUAGE QuasiQuotes           #-}
{-# LANGUAGE TemplateHaskell       #-}
{-# LANGUAGE TypeFamilies          #-}

module Minimal where

import Yesod
import Test.Syd

data App = App -- | Empty App type

mkYesod "App" [parseRoutes|
    / HomeR GET
|]

instance Yesod App

getHomeR :: Handler Html
getHomeR = "Hello, world!"

main :: IO ()
main = Yesod.warp 3000 App

testMain :: IO ()
testMain = sydTest spec

spec :: Spec
spec = yesodSpec App $ do
  it "returns 200 on the homepage" $ do
    get HomeR
    statusIs 200

This function exists for backward compatibility with yesod-test.

Run a test suite using the given site generator.

If your site contains any resources that you will want to have set up beforhand, you will probably want to use yesodSpecWithSiteGeneratorAndArgument or yesodSpecWithSiteSupplierWith instead.

Example usage with a yesod App that contains a secret key that is generated at startup but not used during tests:

data Key = Key -- The implementation of the actual key is omitted here for brevity.
genKey :: IO Key
genKey = pure Key

data App = App { appSecretKey :: Key }

genApp :: IO App
genApp = App <$> genKey

main :: IO ()
main = sydTest spec

spec :: Spec
spec = yesodSpecWithSiteGenerator genApp $ do
  it "returns 200 on the homepage" $ do
    get HomeR
    statusIs 200

This function exists for backward compatibility with yesod-test.

Run a test suite using the given site generator which uses an inner resource.

If your site contains any resources that you need to set up using a withX function, you will want to use yesodSpecWithSiteSupplier instead.

This function exists for backward compatibility with yesod-test.

Using a function that supplies a site, run a test suite.

Example usage with a yesod App that contains an sqlite database connection. See 'sydtest-persistent-sqlite'.

import Test.Syd.Persistent.Sqlite

data App = App { appConnectionPool :: ConnectionPool }

main :: IO ()
main = sydTest spec

appSupplier :: (App -> IO r) -> IO r
appSupplier func =
  withConnectionPool myMigration $ \pool ->
    func $ App { appConnectionPool = pool}

spec :: Spec
spec = yesodSpecWithSiteSupplier appSupplier $ do
  it "returns 200 on the homepage" $ do
    get HomeR
    statusIs 200

Using a function that supplies a site, based on an inner resource, run a test suite.

Using a function that supplies a site, using a SetupFunc

This function assumed that you've already set up the Manager beforehand using something like managerSpec.

Using a function that supplies a site, using a SetupFunc.

This function assumed that you've already set up the Manager beforehand using something like managerSpec.

Run an end-to-end yesod test suite against a remote server at the given URI.

If you would like to write tests that can be run against both a local and a remote instance of your site, you can use the following type:

mySpec :: (Yesod site, RedirectUrl site (Route App)) => YesodSpec site
mySpec = do
  it "responds 200 OK to GET HomeR" $ do
    get HomeR
    statusIs 200

Like yesodE2ESpec, but doesn't set up the Manager for you.

If you are running the end-to-end test against a server that uses https://, make sure to use a TLS-enabled Manager.

You can do this using beforeAll newTlsManager.

A dummy type that is an instance of Yesod, with as a phantom type, the app that it represents.

That is to say, E2E site is an instance of Yesod that pretends to be a site. You can treat it as a site in end-to-end tests, except that you cannot use the site value because there is none in there.

See localToE2EClient

Turn an end-to-end yesod test suite into a local yesod test suite by treating a local instance as remote.

Turn a local 'YesodClient site' into a remote 'YesodClient (E2E site)'.

For backward compatibility with yesod-test

A client environment to call a Yesod app.

The state that is maintained throughout a YesodClientM

A monad to call a Yesod app.

This has access to a 'YesodClient site'.

Run a YesodClientM site using a YesodClient site

For backward compatibility

Define a test in the YesodClientM site monad instead of IO.

The YesodClientM site () type is a member of IsTest, so yit is defined as it. This function is only here for backward compatibility.

yit = it

For compatibility with yesod-test

ydescribe = describe

Make a GET request for the given route

it "returns 200 on the home route" $ do
  get HomeR
  statusIs 200

Make a POST request for the given route

it "returns 200 on the start processing route" $ do
  post StartProcessingR
  statusIs 200

Follow a redirect, if the last response was a redirect.

(We consider a request a redirect if the status is 301, 302, 303, 307 or 308, and the Location header is set.)

 it "redirects home" $ do
   get RedirectHomeR
   statusIs 303
   locationShouldBe HomeR
   _ <- followRedirect
   statusIs 200

Perform the request that is built by the given RequestBuilder.

it "returns 200 on this post request" $ do
  request $ do
    setUrl StartProcessingR
    setMethod "POST"
    addPostParam "key" "value"
  statusIs 200

Set the url of the RequestBuilder to the given route.

Set the method of the RequestBuilder.

Add the given request header to the RequestBuilder.

Add the given GET parameter to the RequestBuilder.

Add the given POST parameter to the RequestBuilder.

Set the request body of the RequestBuilder.

Note that this invalidates any of the other post parameters that may have been set.

Perform a request using an arbitrary method for the given route.

Perform the given request as-is.

Note that this function does not check whether you are making a request to the site under test. You could make a request to https://example.com if you wanted.

A request builder monad that allows you to monadically build a request using runRequestBuilder.

This request builder has access to the entire YesodClientM underneath. This includes the Site under test, as well as cookies etc.

See YesodClientM for more details.

Run a RequestBuilder to make the Request that it defines.

Look up the CSRF token from the only form data and add it to the request header

Look up the CSRF token from the given form data and add it to the request header

Look up the CSRF token from the cookie with name defaultCsrfCookieName and add it to the request header with name defaultCsrfHeaderName.

Looks up the CSRF token stored in the cookie with the given name and adds it to the given request header.

Get the status of the most recently received response.

Get the status of the most recently received response, and assert that it already exists.

Get the most recently sent request.

Get the most recently sent request.

Get the most recently received response.

Get the most recently received response, and assert that it already exists.

Get the Location header of most recently received response.

Get the Location header of most recently received response, and assert that it is a valid Route.

Get the most recently sent request and the response to it.

Get the most recently sent request and the response to it, and assert that they already exist.

Assert the status of the most recently received response.

it "returns 200 on the home route" $ do
  get HomeR
  statusShouldBe 200

Assert the redirect location of the most recently received response.

it "redirects to the overview on the home route" $ do
  get HomeR
  statusIs 301
  locationShouldBe OverviewR

Assert the last response has the given text.

The check is performed using the response body in full text form without any html parsing.

Synonym of statusShouldBe for compatibility with yesod-test