Assert a list of patterns ignoring order

You could find some inspiration here:
https://github.com/devonestes/assertions/blob/8b353fd941baee8b71181d4e8722c587a5aede87/lib/assertions.ex#L264

just make it take a list of maps to match agains your values.

They are? That’s surprising. Are you not using microsecond precision of inserted_at and updated_at?

It might sound dump, but if your data has no fixed order, then do not use assertions, which require order. Enum.find can do that for example. Testing for the length of lists can also make sure you‘re not missing records or have additional ones.

Well with insert_all setting timestamps is up to you cause ecto doesnt do it. So we pass the same value in every record. I don’t know what happens if you generate it at the db level… I guess another solution is to artificially stagger them in code on insert. Thanks for the prompt.

And we do use microsecond precision. Is that enough to GUARANTEE each map created in a loop has uniq timestamp?

If I were you I’d just not use a hardcoded single value – that’s a meaningless optimization and I can’t believe this would account for anything more than 0.01% performance improvement.

I’d just use DateTime.utc_now() on each record – but it’s fine to have a single identical value for inserted_at and updated_at – and then inspect the data myself.

IMO dynamically setting up each field as the record gets inserted should be quite enough at the microsecond precision level.

You could add a new column just for the purposes of sorting in tests. I’ll sometimes add a sequence column named seq just for this.

Here is a macro (with tests) that matches all elements in the collection matches exactly one pattern in the list:

defmodule ListAssertions do
  defmacro assert_unordered(patterns, expression) when is_list(patterns) do
    clauses =
      patterns
      |> Enum.with_index()
      |> Enum.flat_map(fn {pattern, index} ->
        quote do
          unquote(pattern) -> unquote(index)
        end
      end)

    clauses =
      clauses ++
        quote do
          _ -> :not_found
        end

    quote do
      ListAssertions.__assert_unordered__(
        unquote(Macro.escape(patterns)),
        unquote(expression),
        fn x -> case x, do: unquote(clauses) end
      )
    end
  end

  def __assert_unordered__(patterns, enum, fun) do
    result =
      Enum.reduce(enum, %{}, fn item, acc ->
        case fun.(item) do
          :not_found ->
            raise ArgumentError,
                  "#{inspect(item)} does not match any pattern: #{Macro.to_string(patterns)}"

          index when is_map_key(acc, index) ->
            raise ArgumentError,
                  "both #{inspect(item)} and #{inspect(acc[index])} match pattern: " <>
                    Macro.to_string(Enum.fetch!(patterns, index))

          index when is_integer(index) ->
            Map.put(acc, index, item)
        end
      end)

    if map_size(result) == length(patterns) do
      :ok
    else
      raise ArgumentError,
            "expected enumerable to have #{length(patterns)} entries, got: #{map_size(result)}"
    end
  end
end

ExUnit.start()

defmodule ListAssertionsTest do
  use ExUnit.Case, async: true

  import ListAssertions

  test "all match" do
    assert_unordered([:foo, :bar, :baz], [:foo, :baz, :bar])
    assert_unordered([{:ok, _}, {:error, _}], [{:error, :bad}, {:ok, :good}])
  end

  test "duplicates" do
    assert_unordered([{:ok, _}, {:error, _}], [{:error, :bad}, {:ok, :good}, {:ok, :bad}])
  end

  test "too few" do
    assert_unordered([{:ok, _}, {:error, _}], [{:error, :bad}])
  end

  test "unknown" do
    assert_unordered([{:ok, _}, {:error, _}], [:what])
  end
end

Better error messages that integrate nicely with ExUnit are left as an exercise to the reader.

Works like a frickin’ charm. This seems generally useful. Do you want me to improve messages (like you said) and offer PR to add to ExUnit.Assertions?

At the moment I don’t think it is ExUnit.Assertions material but I will keep an eye open for more use cases!