Compilation error when re-ordering `use Bamboo.Test`

I have a test file that tests some of the emails we send in our app. We had the following use lines:

use MyApp.DataCase, async: true
use Bamboo.Test

We then decided to introduce a credo rule where we order our uses and imports alphabetically. The test was working fine, but if we change the use order we get this error:

== Compilation error in file lib/my_app/event_test.exs ==
** (CompileError) lib/my_app/event_test.exs:2: undefined function setup/2 (there is no such import)
    (bamboo 2.2.0) expanding macro: Bamboo.Test.__using__/1
    lib/my_app/event_test.exs:2: MyApp.EventTest (module)
    (elixir 1.14.0) expanding macro: Kernel.use/1
    lib/my_app/event_test.exs:2: MyApp.EventTest (module)

I imagine that the problem might be something that I’m defining on my DataCase module so here are the contents of the file:

defmodule MyApp.DataCase do
  use ExUnit.CaseTemplate

  alias Ecto.Adapters.SQL.Sandbox
  alias Ecto.Changeset
  alias Ecto.Query
  alias MyApp.DataCase
  alias MyApp.Repo
  alias MyApp.Tracer

  require MyApp.Tracer

  using do
    quote do
      use MyApp.Tracer.TestTracingDecorator

      alias MyApp.Repo

      import Changeset
      import DataCase
      import Ecto
      import Hammox
      import Query

      @moduletag test_case_type: :datacase_test_case
      @decorate_all trace_test(service: :my_app, tags: [test_suite: __MODULE__, test_type: :data_case])
      setup :verify_on_exit!

  setup context do
    Tracer.strict_span "sandbox_checkout" do
      :ok = Sandbox.checkout(Repo)

      unless context[:async] do
        Sandbox.mode(Repo, {:shared, self()})

    # default stubs go here
    Tracer.strict_span "stubbing" do
      # stub datetime so we don't have to mock it everywhere
      Hammox.stub_with(DateTimeMock, MyApp.Utils.DateTime)
      # stub async so we don't have to mock it everywhere
      Hammox.stub(AsyncMock, :cast, fn _function, _opts -> :ok end)

      # this allows us to dynamically stub BankAccountStorageMock
      # by tagging the test with @moduledoc :mock_bank_account_storage
      unless context[:mock_bank_account_storage] do
        # stub BankAccountStorageMock so we don't have to mock it everywhere
        # this mock is only used for cache testing/verification
        Hammox.stub_with(BankAccountStorageMock, MyApp.BankAccount.Storage)

      unless context[:mock_earn_storage] do
        Hammox.stub_with(EarnStorageMock, MyApp.Earn.Storage)

      unless context[:mock_user_storage] do
        Hammox.stub_with(UserStorageMock, MyApp.User.Storage)


  @doc """
  A helper that transforms changeset errors into a map of messages.

      assert {:error, changeset} = Accounts.create_user(%{password: "short"})
      assert "password is too short" in errors_on(changeset).password
      assert %{password: ["password is too short"]} = errors_on(changeset)

  def errors_on(changeset) do
    Changeset.traverse_errors(changeset, fn {message, opts} ->
      Regex.replace(~r"%{(\w+)}", message, fn _error_msg, key ->
        opts |> Keyword.get(String.to_existing_atom(key), key) |> to_string()

This is a mistake for use, because order does matter. use injects code, and the sequence of the code injection is semantically significant. I would disable that credo rule and have it only apply to aliases and imports.

1 Like