messenger_test.exs

defmodule Zave.Commander.Messenger.Test do
  use ExUnit.Case, async: true
  @subject Zwave.Commander.Messenger

  defmodule TestCommandModule do
    defstruct [:initiator, :message]

    def initialize(initiator) do
      %__MODULE__{initiator: initiator}
    end

    def received(state, :expected_command) do
      {:ok, %{state | message: :expected_command}}
    end

    def received(state, :fin_command) do
      {:fin, %{state | message: :fin_command}}
    end

    def received(state, :error_command) do
      {:error, %{state | message: :error_command}}
    end

    def initiator(state) do
      state.initiator
    end
  end

  setup do
    Process.flag(:trap_exit, true)

    {:ok, pid} = @subject.start_link(TestCommandModule, self())

    on_exit fn ->
      Process.exit(pid, :normal)
    end

    {:ok, messenger: pid}
  end

  test "with no error",
  %{messenger: messenger} do
    send(messenger, {:received, :expected_command})

    {TestCommandModule, new_state} = :sys.get_state(messenger)

      assert %TestCommandModule{initiator: self(), message: :expected_command}== new_state
  end

  test "with final state",
  %{messenger: messenger} do
    send(messenger, {:received, :fin_command})
    assert_receive {:EXIT, ^messenger, :normal}
  end

  @tag :capture_log
  test "with error",
  %{messenger: messenger} do
    send(messenger, {:received, :error_command})
    assert_receive {:EXIT, ^messenger, :error}
  end

  test "with timeout delegates to the initiator",
  %{messenger: messenger} do
    timeout_message = make_ref()
    send(messenger, {:timeout, timeout_message})

    assert_receive {:timeout, ^timeout_message}
    assert_receive {:EXIT, ^messenger, :normal}
  end
end