View Source Moar.Assertions (Moar v1.7.0)

ExUnit assertions.

Link to this section Summary

Functions

Asserts that the left and right values are equal. Returns the left value unless the assertion fails, or unless the :returning option is used.

Asserts that datetime is within recency of now (in UTC), returning datetime if the assertion succeeeds.

Asserts that a pre-condition and a post-condition are true after performing an action.

Link to this section Types

@type assert_eq_opts() ::
  {:ignore_order, boolean()}
  | {:returning, any()}
  | {:within, number() | {number(), Moar.Duration.time_unit()}}

Link to this section Functions

Link to this function

assert_eq(left, right, opts \\ [])

View Source
@spec assert_eq(left :: any(), right :: any(), opts :: [assert_eq_opts()]) :: any()

Asserts that the left and right values are equal. Returns the left value unless the assertion fails, or unless the :returning option is used.

Uses assert left == right under the hood.

Style note: the authors prefer to use assert in most cases, using assert_eq only when the extra options are helpful or when they want to make assertions in a pipeline.

Options:

  • ignore_order: boolean - if the left and right values are lists, ignores the order when checking equality.
  • returning: value - returns value if the assertion passes, rather than returning the left value.
  • within: delta - asserts that the left and right values are within delta of each other.
  • within: {delta, time_unit} - like within: delta but performs time comparisons in the specified time_unit. See Moar.Duration for more about time units. If left and right are strings, they are parsed as ISO8601 dates.

examples

Examples

iex> import Moar.Assertions

iex> %{a: 1} |> Map.put(:b, 2) |> assert_eq(%{a: 1, b: 2})
%{a: 1, b: 2}

iex> map = %{a: 1, b: 2}
iex> map |> Map.get(:a) |> assert_eq(1, returning: map)
%{a: 1, b: 2}

iex> assert_eq(4/28, 0.14, within: 0.01)
0.14285714285714285

iex> inserted_at = ~U[2022-01-02 03:00:00Z]
iex> updated_at = ~U[2022-01-02 03:04:00Z]
iex> assert_eq(inserted_at, updated_at, within: {10, :minute})
~U[2022-01-02 03:00:00Z]

iex> inserted_at = "2022-01-02T03:00:00Z"
iex> updated_at = "2022-01-02T03:04:00Z"
iex> assert_eq(inserted_at, updated_at, within: {10, :minute})
"2022-01-02T03:00:00Z"
Link to this function

assert_recent(datetime, recency \\ {10, :second})

View Source
@spec assert_recent(DateTime.t() | NaiveDateTime.t() | binary(), Moar.Duration.t()) ::
  DateTime.t() | NaiveDateTime.t() | binary()

Asserts that datetime is within recency of now (in UTC), returning datetime if the assertion succeeeds.

Uses assert_eq(datetime, now, within: recency) under the hood.

five_seconds_ago = Moar.DateTime.add(DateTime.utc_now(), {-5, :second})
assert_recent five_seconds_ago
Link to this macro

assert_that(command, list)

View Source (macro)
@spec assert_that(any(), [{:changes, any()} | {:from, any()} | {:to, any()}, ...]) ::
  {:__block__, [], [...]}

Asserts that a pre-condition and a post-condition are true after performing an action.

examples

Examples

{:ok, agent} = Agent.start(fn -> 0 end)

assert_that(Agent.update(agent, fn s -> s + 1 end),
  changes: Agent.get(agent, fn s -> s end),
  from: 0,
  to: 1
)