Suppose I have a code like this:

defmodule Spy do
  @analytics Application.compile_env!(:spy, :analytics)

  def create_article(params) do
    case insert_article(params) do
      {:ok, article} ->
        @analytics.record(:article_created, article)
        if params.published, do: @analytics.record(:article_published, article)
      
      {:error, error} -> {:error, error}
    end
  end

  defp insert_article(params) do
    id = :rand.uniform(1000)
    {:ok, Map.put(params, :id, id)}
  end
end

A typical tests for it would look like this:

defmodule SpyTest do
  use ExUnit.Case
  import Hammox

  defmock(AnalyticsMock, for: Analytics)

  test "old approach: not published" do
    expect(AnalyticsMock, :record, fn :article_created, payload ->
      assert payload.title == "Test"
      :ok
    end)

    Spy.create_article(%{title: "Test", published: false})
  end

  test "old approach: published" do
    expect(AnalyticsMock, :record, fn :article_created, payload ->
      assert payload.title == "Test"
      :ok
    end)

    expect(AnalyticsMock, :record, fn :article_published, payload ->
      assert payload.title == "Test"
      :ok
    end)

    Spy.create_article(%{title: "Test", published: true})
  end
end

While this of course works, it provides a couple disadvantages in my opinion:

• You don’t follow “arrange-act-assert”, as you actually assert at the beginning
• In case of testing for publish, you have to add both expectations in a single test case, otherwise you’d get an error.

As a result, I’ve been thinking about bending Hammox to my will a bit and force it to act more like a spy, where I record the interactions somehow and assert about them in the end. Of course, it should ideally work with async tests.

I came up with something like this:

defmodule SpyTest do
  use ExUnit.Case
  import Hammox

  defmock(AnalyticsMock, for: Analytics)

  defmodule AnalyticsStub do
    @behaviour Analytics
    def record(event, payload) do
      send(self(), {:analytics, event, payload})
    end
  end

  describe "new approach" do
    setup do
      stub_with(AnalyticsMock, AnalyticsStub)
      :ok
    end

    test "not published" do
      Spy.create_article(%{title: "Test", published: false})
      assert_received({:analytics, :article_created, payload})
      assert payload.id > 0
    end

    test "published - record creation" do
      Spy.create_article(%{title: "Test", published: true})
      assert_received({:analytics, :article_created, _})
    end

    test "published - record publish" do
      Spy.create_article(%{title: "Test", published: true})
      assert_received({:analytics, :article_published, _})
    end
  end
end

To me it reads much better and I wonder: is someone using an approach like this already? Or maybe there’s a different tool for that? If not, could it be a terrible idea for some reason I don’t yet see?

It might need some setup to ensure the process inbox is empty before running the test, but it is doable and aside from that?