Tests that a condition holds for a randomly generated Model after that specific Msg is applied.

The process is as follows:

1. get an initial Model (based on TestedApp)

2. stuff it and a list of random Msgs into update to get a random Model

3. create a Msg we will test

4. stuff it and the random Model into update to get the final Model

5. run your test function on the three values (random Model, tested Msg, final Model)

cancelReturnsMoney : Test
cancelReturnsMoney =
    msgTest "Cancelling returns all input money"
        app
        (Fuzz.constant Cancel)
    <|
        \_ _ finalModel -> finalModel.currentCoins |> Expect.equal 0

The test function's arguments are:

random Model (before the tested Msg) -> tested Msg -> final Model

Similar to msgTest, but only gets run when a precondition holds.

buyingAbovePriceVendsProduct : Test
buyingAbovePriceVendsProduct =
    msgTestWithPrecondition "Buying above price vends the product"
        app
        (Fuzz.constant Buy)
        (\model -> model.currentCoins >= model.productPrice)
    <|
        \_ _ finalModel ->
            finalModel.isProductVended
                |> Expect.true "Product should be vended after trying to buy with enough money"

The precondition acts on the "model before specific Msg" (see msgTest docs).

Tests that a property holds no matter what Msgs we applied.

priceConstant : Test
priceConstant =
    invariantTest "Price is constant"
        app
    <|
        \initModel _ finalModel ->
            finalModel.productPrice
                |> Expect.equal initModel.productPrice

The test function's arguments are:

init model -> random Msgs -> final model

All of these "architecture tests" are going to have something in common: Model, update function and Msgs.

Note that for some tests you can eg. make the Msg fuzzer prefer certain Msgs more if you need to test them more extensively.

The strategy for choosing an init model to which the Msgs will be applied.

Main applications can be of two types: those without Cmds and normal (Cmds present).

For custom update functions returning eg. triples etc., just use UpdateWithoutCmds with a function that returns just the model part of the result:

update : Msg -> Model -> {model : Model, cmd : Cmd Msg, outMsg : OutMsg}


UpdateWithoutCmds (\msg model -> update msg model |> .model)

Fuzz the model, always starting with initial Models and then doing consecutive update calls with fuzzed Msgs.

Guarantees the final model is reachable using your Msgs and thus "makes sense."