Add support for integration testing about swoosh HOT 20 CLOSED

defmodule Webapp.Mailer.TestAdapter do
  use Swoosh.Adapter

  def deliver(email, _config) do
    send(test_process(), {:email, email})
    {:ok, %{}}
  end

  defp test_process do
    Application.get_env(:swoosh, :shared_test_process) || self()
  end
end

# in your config/test.exs
config :webapp, Webapp.Mailer, adapter: Webapp.Mailer.TestAdapter

setup do
   Application.put_env(:swoosh, :shared_test_process, self())
   :ok
end

# and somewhere in your assertions, something like
assert_email_sent(subject: subject, to: recipients)

# or 
receive do
  {:email, email} ->
    # assert other email fiels
    # _i.e. Mailgun: at the time of this writting there are no `assert_equal` support to `assert_email_sent` 
    # with `:provider_options` to assert email contains correct `recipient-variables` 
    assert email.subject == subject
    assert email.to == recipients
    assert email.provider_options == %{recipient_vars: recipient_vars}
after
  1_000 ->
    raise "No updates email delivered"
end

defmodule MyApp.SwooshAdapter.Test do
  use Swoosh.Adapter
  use GenServer

  def start_link do
    GenServer.start_link(__MODULE__, [], name: __MODULE__)
  end

  def subscribe do
    GenServer.call(__MODULE__, {:subscribe, self()})
  end

  def deliver(email, _config) do
    GenServer.call(__MODULE__, {:deliver, email})
  end


  # SERVER
  def handle_call({:subscribe, pid}, _from, listeners) do
    {:reply, :ok, [pid | listeners]}
  end

  def handle_call({:deliver, email}, _from, listeners) do
    send_to_listeners(listeners, {:email, email})
    {:reply, :ok, listeners}
  end

  defp send_to_listeners(listeners, message) do
    for listener <- listeners do
      send listener, message
    end
  end
end

defmodule BlahBlah.TestHelpers.BlahBlahEmails do
  alias BlahBlah.Mailer.AdapterMock, as: MailerMock
  
  # for multi-process high-level tests
  def allow_processes_to_send_mails(%{pids: pids})
  when is_list(pids) do
    pids |> Enum.each(fn pid ->
      :ok = allow_process_to_send_mails(%{pid: pid})
    end)
    :ok
  end

  # for single-process high-level tests
  def allow_process_to_send_mails(%{pid: pid}) do
    test_pid = self()
    MailerMock
    |> Mox.allow(test_pid, pid)
    |> Mox.stub(:validate_config, fn _ -> :ok end)
    |> Mox.stub(:deliver, fn email, _config ->
      # NOTE: self() here will not be the process of test.
      # This is why we need the test_pid that's set up outside.
      send(test_pid, {:email, email})

      {:ok, %{}}
    end)

    :ok
  end
end

defmodule BlahBlah.Mailer.ValidateConfigAdapterBehaviour do
  @callback validate_config(any()) :: :ok
end

Mox.defmock(BlahBlah.Mailer.AdapterMock,
  for: [Swoosh.Adapter, BlahBlah.Mailer.ValidateConfigAdapterBehaviour])

Application.put_env(:admin, BlahBlah.Mailer,
  adapter: BlahBlah.Mailer.AdapterMock)

defmodule BlahBlah.SomeMultiProcessTest do
  ...
  import Mox
  import BlahBlah.TestHelpers.BlahBlahEmails
  import Swoosh.TestAssertions
  ...
  setup [ 
    ... set up processes under tests and such ...
    :verify_on_exit!
  ]
  ...
  test "something", %{pid_a: pid_a, pid_b: pid_b, ...} do
     ...
     allow_process_to_send_mails(%{pids: [pid_a, pid_b, ...]})
     
     # or
     allow_process_to_send_mails(%{pid: pid_a})
     allow_process_to_send_mails(%{pid: pid_b})
     ...
     do actual test here
     ...
     assert_email_sent BlahBlah.Emails.whatever()
     assert_email_sent BlahBlah.Emails.another()
     ...
  end
  ...
end

...

Elixir.BlahBlah.Mailer.AdapterMock: [                                                   
  {:def, [context: Mox, import: Kernel],                                             
   [                                                                                 
     {:__mock_for__, [context: Mox], Mox},                                           
     [do: [Swoosh.Adapter, BlahBlah.Mailer.ValidateConfigAdapterBehaviour]]             
   ]},                                                                               
  {{:., [], [Swoosh.Adapter, :module_info]}, [], [:module]},                         
  {{:., [], [BlahBlah.Mailer.ValidateConfigAdapterBehaviour, :module_info]}, [],        
   [:module]},                                                                       
  {:def, [context: Mox, import: Kernel],                                             
   [                                                                                 
     {:validate_dependency, [context: Mox], []},                                     
     [                                                                               
       do: {{:., [], [{:__aliases__, [alias: false], [:Mox]}, :__dispatch__]},       
        [], [{:__MODULE__, [], Mox}, :validate_dependency, 0, []]}                   
     ]                                                                               
   ]},                                                                               
  {:def, [context: Mox, import: Kernel],                                             
   [                                                                                 
     {:validate_config, [context: Mox], [{:arg1, [], Elixir}]},                      
     [                                                                               
       do: {{:., [], [{:__aliases__, [alias: false], [:Mox]}, :__dispatch__]},       
        [],                                                                          
        [{:__MODULE__, [], Mox}, :validate_config, 1, [{:arg1, [], Elixir}]]}        
     ]                                                                               
   ]},                                                                               
  {:def, [context: Mox, import: Kernel],                                             
   [                                                                                 
     {:deliver, [context: Mox], [{:arg1, [], Elixir}, {:arg2, [], Elixir}]},         
     [                                                                               
       do: {{:., [], [{:__aliases__, [alias: false], [:Mox]}, :__dispatch__]},       
        [],                                                                          
        [                                                                            
          {:__MODULE__, [], Mox},                                                    
          :deliver,                                                                  
          2,                                                                         
          [{:arg1, [], Elixir}, {:arg2, [], Elixir}]                                 
        ]}                                                                           
     ]                                                                               
   ]},                                                                               
  {:def, [context: Mox, import: Kernel],
   [
     {:validate_config, [context: Mox], [{:arg1, [], Elixir}]},
     [
       do: {{:., [], [{:__aliases__, [alias: false], [:Mox]}, :__dispatch__]},
        [],
        [{:__MODULE__, [], Mox}, :validate_config, 1, [{:arg1, [], Elixir}]]}
     ]
   ]}
]

...

defmodule BlahBlah.Mailer.ValidateConfigAdapterBehaviour do
  @callback validate_config(any()) :: :ok
end

Mox.defmock(BlahBlah.Mailer.AdapterMock,
  for: [Swoosh.Adapter, BlahBlah.Mailer.ValidateConfigAdapterBehaviour])

Mox.defmock(BlahBlah.Mailer.AdapterMock,
  for: [Swoosh.Adapter])