chvanikoff

How to assert some process received some message?

Hi, I’m in need to test that some process (in my particular case, it’s a Phoenix channel) receives some message from another process (via handle_info). Unfortunately, I didn’t found anything suitable in stdlib and wonder if there’s a common approach for doing this, or maybe I missed something in stdlib? As of now I see 2 ways of testing this: mocking receiver process and watching it’s message queue, but both of the approaches don’t seem to be clear and correct way of doing this.

8 comments

#message-passing #processes #testing

1 9824 8

2023-06-11 15:52:05 UTC

First Post!

gregvaughn

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

Post #1

Most Liked

josevalim

Creator of Elixir

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

Post #4

rvirding

Creator of Erlang

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.

Post #3

josevalim

Creator of Elixir

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.

Post #7

Last Post!

mushu8

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

Post #8