How to assert some process received some message?

I know of 2 ways. The first, and the one I prefer, is for the test itself to send in the self pid to be the receiver of the message. Then you can use ExUnit’s assert_received. The other approach is to, only in test code, use :erlang.process.info

Unfortunately, I don’t see a way the first one would work for me - it would be pretty painful and require including tests logic into my app code itself. Second one is the one I think of, but as I already wrote, it doesn’t seem to be really good solution.

Three ways I know you can do this but neither are very straight forward:

• Use the tracing BIFs to trace messages sent to that process. You can then match on them to get the ones in which you are interested. AFAIK there is no elixir library which supports this so you need to use an erlang interface, for example :dbg.
• Trace calls to the handle_info/2 function in your module in the process in which you are interested.
• Use the erlang :sys module to install a special debug handler then turn on tracing with :sys.trace/2. More high level and OTPish, but I have never tested it.

The tracing always works but might be a bit tricky to set up. It also works very well if you want inspect running production systems. Not surprising as that is what the tracing was designed for.

for the trace BIFs. Here is an example from using it in Phoenix:

https://github.com/phoenixframework/phoenix/blob/a3834735543977c988e1cd0e78069076a464cf44/test/phoenix/code_reloader_test.exs#L31
https://github.com/phoenixframework/phoenix/blob/a3834735543977c988e1cd0e78069076a464cf44/test/phoenix/code_reloader_test.exs#L39

@rvirding @josevalim thanks, will try this approach now. I think it might be a good idea to do this as a part of ExUnit API

@josevalim maybe something like this could be put into ExUnit?

defmacro assert_process_receive(pid, message, fun) do
  quote do
    :erlang.trace(unquote(pid), true, [:receive])
    unquote(fun).()
    assert_receive({:trace, ^unquote(pid), :receive, message})
  end
end

I would prefer not. It must be used rarely and having it as part of the assertions may lead developers to write tests that rely on implementation details (did this process receive a message) instead of asserting on a particular behaviour from receiving that message.

For later reference, trace messages receive GenServer call methods :

test "call test" do
  pid = start_link_supervised!({MyGenServer})
  :erlang.trace(pid, true, [:receive])
  MyGenServer.that_sends_call() # implementation sends a call message {:call_mesage_name, 1}

  assert_receive {:trace, ^pid, :receive,
    {:"$gen_call", pid, {:call_mesage_name, parameter}}
  }
  assert parameter == 1

test "cast test" do
  pid = start_link_supervised!({MyGenServer})
  :erlang.trace(pid, true, [:receive])
  MyGenServer.that_sends_cast() # implementation sends a cast message {:cast_mesage_name, 1}

  assert_receive {:trace, ^pid, :receive,
    {:"$gen_cast", pid, {:cast_mesage_name, parameter}}
  }
  assert parameter == 1