| Safe Haskell | None |
|---|
Test.Tasty.Ingredients
Description
This module contains the core definitions related to ingredients.
Ingredients themselves are provided by other modules (usually under
the Test.Tasty.Ingredients.* hierarchy).
- data Ingredient
- = TestReporter [OptionDescription] (OptionSet -> TestTree -> Maybe (StatusMap -> IO (Time -> IO Bool)))
- | TestManager [OptionDescription] (OptionSet -> TestTree -> Maybe (IO Bool))
- tryIngredients :: [Ingredient] -> OptionSet -> TestTree -> Maybe (IO Bool)
- ingredientOptions :: Ingredient -> [OptionDescription]
- ingredientsOptions :: [Ingredient] -> [OptionDescription]
- suiteOptions :: [Ingredient] -> TestTree -> [OptionDescription]
Documentation
data Ingredient Source
Ingredients make your test suite tasty.
Ingredients represent different actions that you can perform on your test suite. One obvious ingredient that you want to include is one that runs tests and reports the progress and results.
Another standard ingredient is one that simply prints the names of all tests.
Similar to test providers (see IsTest), every ingredient may specify
which options it cares about, so that those options are presented to
the user if the ingredient is included in the test suite.
An ingredient can choose, typically based on the OptionSet, whether to
run. That's what the Maybe is for. The first ingredient that agreed to
run does its work, and the remaining ingredients are ignored. Thus, the
order in which you arrange the ingredients may matter.
Usually, the ingredient which runs the tests is unconditional and thus should be placed last in the list. Other ingredients usually run only if explicitly requested via an option. Their relative order thus doesn't matter.
That's all you need to know from an (advanced) user perspective. Read on if you want to create a new ingredient.
There are two kinds of ingredients. TestReporter, if it agrees to run,
automatically launches tests execution.
TestManager is the second kind of ingredient. It is typically used for
test management purposes (such as listing the test names), although it
can also be used for running tests (but, unlike TestReporter, it has
to launch the tests manually). It is therefore more general than
TestReporter. TestReporter is provided just for convenience.
The function's result should indicate whether all the tests passed.
In the TestManager case, it's up to the ingredient author to decide
what the result should be. When no tests are run, the result should
probably be True. Sometimes, even if some tests run and fail, it still
makes sense to return True.
Constructors
| TestReporter [OptionDescription] (OptionSet -> TestTree -> Maybe (StatusMap -> IO (Time -> IO Bool))) | For the explanation on how the callback works, see the
documentation for |
| TestManager [OptionDescription] (OptionSet -> TestTree -> Maybe (IO Bool)) |
tryIngredients :: [Ingredient] -> OptionSet -> TestTree -> Maybe (IO Bool)Source
Run the first Ingredient that agrees to be run.
If no one accepts the task, return Nothing. This is usually a sign of
misconfiguration.
ingredientOptions :: Ingredient -> [OptionDescription]Source
Return the options which are relevant for the given ingredient.
Note that this isn't the same as simply pattern-matching on
Ingredient. E.g. options for a TestReporter automatically include
NumThreads.
ingredientsOptions :: [Ingredient] -> [OptionDescription]Source
Like ingredientOption, but folds over multiple ingredients.
suiteOptions :: [Ingredient] -> TestTree -> [OptionDescription]Source
All the options relevant for this test suite. This includes the options for the test tree and ingredients, and the core options.