Asserts value is true, displaying the given message otherwise.

Examples

assert false, "it will never be true"

Asserts that value1 and value2 differ by no more than delta.

Examples

assert_in_delta 1.1, 1.5, 0.2
assert_in_delta 10, 15, 4

Asserts the exception is raised during function execution. Returns the rescued exception, fails otherwise.

Examples

assert_raise ArithmeticError, fn ->
  1 + "test"
end

Asserts the exception is raised during function execution with the expected message, which can be a Regex or an exact String. Returns the rescued exception, fails otherwise.

Examples

assert_raise ArithmeticError, "bad argument in arithmetic expression", fn ->
  1 + "test"
end

assert_raise RuntimeError, ~r/^Today's lucky number is 0.+!$/, fn ->
  raise "Today's lucky number is 0.4435846174457203!"
end

Fails with a message.

Examples

flunk "This should raise an error"

Asserts value is nil or false (that is, value is not truthy).

Examples

refute true, "This will obviously fail"

Asserts value1 and value2 are not within delta.

If you supply message, information about the values will automatically be appended to it.

Examples

refute_in_delta 1.1, 1.2, 0.2
refute_in_delta 10, 11, 2

Asserts its argument is a truthy value.

assert instrospects the underlying expression and provide good reporting whenever there is a failure. For example, if the expression uses the comparison operator, the message will show the values of the two sides. The assertion

assert 1+2+3+4 > 15

will fail with the message:

Assertion with > failed
code: 1+2+3+4 > 15
lhs:  10
rhs:  15

Similarly, if a match expression is given, it will report any failure in terms of that match. Given

assert [one] = [two]

you’ll see:

match (=) failed
code: [one] = [two]
rhs:  [2]

Keep in mind that assert does not change its semantics based on the expression. In other words, the expression is still required to return a truthy value. For example, the following will fail:

assert nil = some_function_that_returns_nil()

Even though the match works, assert still expects a truth value. In such cases, simply use Kernel.==/2 or Kernel.match?/2.

Asserts a message was or is going to be received.

Unlike assert_received, it has a default timeout of 100 milliseconds.

The expected argument is a pattern.

Examples

assert_receive :hello

Asserts against a larger timeout:

assert_receive :hello, 20_000

You can also match against specific patterns:

assert_receive {:hello, _}

x = 5
assert_receive {:count, ^x}

Asserts a message was received and is in the current process’ mailbox. Timeout is set to 0, so there is no waiting time.

The expected argument is a pattern.

Examples

send self, :hello
assert_received :hello

You can also match against specific patterns:

send self, {:hello, "world"}
assert_received {:hello, _}

Asserts expression will cause an error. Returns the error or fails otherwise.

Examples

assert catch_error(error 1) == 1

Asserts expression will exit. Returns the exit status/message or fails otherwise.

Examples

assert catch_exit(exit 1) == 1

Asserts expression will throw a value. Returns the thrown value or fails otherwise.

Examples

assert catch_throw(throw 1) == 1

A negative assertion, expects the expression to be false or nil.

Keep in mind that refute does not change the semantics of the given expression. In other words, the following will fail:

refute {:ok, _} = some_function_that_returns_error_tuple()

The code above will fail because the = operator always fails when the sides do not match and refute/2 does not change it.

The correct way to write the refutation above is to use Kernel.match?/2:

refute match? {:ok, _}, some_function_that_returns_error_tuple()

Examples

refute age < 0

Asserts message was not received (and won’t be received) within the timeout period.

The not_expected argument is a match pattern.

Examples

refute_receive :bye

Refute received with an explicit timeout:

refute_receive :bye, 1000

Asserts a message was not received (i.e. it is not in the current process mailbox). The not_expected argument must be a match pattern.

Timeout is set to 0, so there is no waiting time.

Examples

send self, :hello
refute_received :bye