The result of a single test run: either a pass or a fail.

Passes if the arguments are equal.

Expect.equal 0 (List.length [])


-- Passes because (0 == 0) is True

Failures resemble code written in pipeline style, so you can tell which argument is which:

-- Fails because the expected value didn't split the space in "Betty Botter"
String.split " " "Betty Botter bought some butter"
    |> Expect.equal [ "Betty Botter", "bought", "some", "butter" ]


{-


[ "Betty", "Botter", "bought", "some", "butter" ]
╷
│ Expect.equal
╵
[ "Betty Botter", "bought", "some", "butter" ]


-}

Passes if the arguments are not equal.

-- Passes because (11 /= 100) is True
90 + 10
    |> Expect.notEqual 11




-- Fails because (100 /= 100) is False
90 + 10
    |> Expect.notEqual 100


{-


100
╷
│ Expect.notEqual
╵
100


-}

Passes if the second argument is less than the first.

Expect.lessThan 1 (List.length [])


-- Passes because (0 < 1) is True

Failures resemble code written in pipeline style, so you can tell which argument is which:

-- Fails because (0 < -1) is False
List.length []
    |> Expect.lessThan -1




{-


0
╷
│ Expect.lessThan
╵
-1


-}

Passes if the second argument is less than or equal to the first.

Expect.atMost 1 (List.length [])


-- Passes because (0 <= 1) is True

Failures resemble code written in pipeline style, so you can tell which argument is which:

-- Fails because (0 <= -3) is False
List.length []
    |> Expect.atMost -3


{-


0
╷
│ Expect.atMost
╵
-3


-}

Passes if the second argument is greater than the first.

Expect.greaterThan -2 List.length []


-- Passes because (0 > -2) is True

Failures resemble code written in pipeline style, so you can tell which argument is which:

-- Fails because (0 > 1) is False
List.length []
    |> Expect.greaterThan 1


{-


0
╷
│ Expect.greaterThan
╵
1


-}

Passes if the second argument is greater than or equal to the first.

Expect.atLeast -2 (List.length [])


-- Passes because (0 >= -2) is True

Failures resemble code written in pipeline style, so you can tell which argument is which:

-- Fails because (0 >= 3) is False
List.length []
    |> Expect.atLeast 3


{-


0
╷
│ Expect.atLeast
╵
3


-}

Passes if the argument is 'True', and otherwise fails with the given message.

Expect.true "Expected the list to be empty." (List.isEmpty [])


-- Passes because (List.isEmpty []) is True

Failures resemble code written in pipeline style, so you can tell which argument is which:

-- Fails because List.isEmpty returns False, but we expect True.
List.isEmpty [ 42 ]
    |> Expect.true "Expected the list to be empty."


{-


Expected the list to be empty.


-}

Passes if the argument is 'False', and otherwise fails with the given message.

Expect.false "Expected the list not to be empty." (List.isEmpty [ 42 ])


-- Passes because (List.isEmpty [ 42 ]) is False

Failures resemble code written in pipeline style, so you can tell which argument is which:

-- Fails because (List.isEmpty []) is True
List.isEmpty []
    |> Expect.false "Expected the list not to be empty."


{-


Expected the list not to be empty.


-}

Always passes.

import Json.Decode exposing (decodeString, int)
import Test exposing (test)
import Expect




test "Json.Decode.int can decode the number 42." <|
    \() ->
        case decodeString int "42" of
            Ok _ ->
                Expect.pass


            Err err ->
                Expect.fail err

Fails with the given message.

import Json.Decode exposing (decodeString, int)
import Test exposing (test)
import Expect




test "Json.Decode.int can decode the number 42." <|
    \() ->
        case decodeString int "42" of
            Ok _ ->
                Expect.pass


            Err err ->
                Expect.fail err

If the given expectation fails, replace its failure message with a custom one.

"something"
    |> Expect.equal "something else"
    |> Expect.onFail "thought those two strings would be the same"

Return Nothing if the given Expectation is a pass.

If it is a fail, return a record containing the failure message, along with the given inputs if it was a fuzz test. (If no inputs were involved, the record's given field will be "").

For example, if a fuzz test generates random integers, this might return { message = "it was supposed to be positive", given = "-1" }

getFailure (Expect.fail "this failed")
-- Just { message = "this failed", given = "" }


getFailure (Expect.pass)
-- Nothing