Elixir GenServer를 순수 함수로 테스트하는 법

defmodule MyApp.Counter.Core do
  @enforce_keys [:value, :max]
  defstruct [:value, :max]

  @type t :: %__MODULE__{value: non_neg_integer(), max: non_neg_integer()}

  @type command ::
          {:audit, map()}
          | {:reply, term()}

  @spec new(keyword()) :: t()
  def new(opts) do
    max = Keyword.fetch!(opts, :max)
    %__MODULE__{value: 0, max: max}
  end

  @spec inc(t(), non_neg_integer()) :: {:ok, t(), [command()]} | {:error, term()}
  def inc(%__MODULE__{} = state, n) when is_integer(n) and n >= 0 do
    new_value = state.value + n

    if new_value <= state.max do
      new_state = %{state | value: new_value}

      commands = [
        {:audit, %{event: "inc", by: n, value: new_value}},
        {:reply, {:ok, new_value}}
      ]

      {:ok, new_state, commands}
    else
      {:error, :max_exceeded}
    end
  end
end

defmodule MyApp.Counter.Server do
  use GenServer

  alias MyApp.Counter.Core

  def start_link(opts) do
    GenServer.start_link(__MODULE__, opts, name: Keyword.get(opts, :name))
  end

  def inc(server, n), do: GenServer.call(server, {:inc, n})

  @impl true
  def init(opts) do
    {:ok, Core.new(opts)}
  end

  @impl true
  def handle_call({:inc, n}, _from, state) do
    case Core.inc(state, n) do
      {:ok, new_state, commands} ->
        {reply, _effects} = run_commands(commands)
        {:reply, reply, new_state}

      {:error, reason} ->
        {:reply, {:error, reason}, state}
    end
  end

  defp run_commands(commands) do
    reply =
      commands
      |> Enum.find_value(fn
        {:reply, value} -> value
        _ -> nil
      end)

    effects =
      commands
      |> Enum.filter(&match?({:audit, _}, &1))
      |> Enum.map(fn {:audit, payload} ->
        # 실제 서비스라면 Logger, Telemetry, DB insert 등이 될 수 있음
        send(self(), {:audit_emitted, payload})
        :ok
      end)

    {reply, effects}
  end
end

defmodule MyApp.Counter.CoreTest do
  use ExUnit.Case, async: true

  alias MyApp.Counter.Core

  test "inc increases value and emits audit command" do
    state = Core.new(max: 10)

    assert {:ok, new_state, commands} = Core.inc(state, 3)
    assert new_state.value == 3

    assert {:audit, %{event: "inc", by: 3, value: 3}} in commands
    assert {:reply, {:ok, 3}} in commands
  end

  test "inc rejects when max exceeded" do
    state = Core.new(max: 5)

    assert {:error, :max_exceeded} = Core.inc(state, 6)
  end

  test "inc with 0 is allowed" do
    state = Core.new(max: 5)

    assert {:ok, new_state, commands} = Core.inc(state, 0)
    assert new_state.value == 0
    assert {:reply, {:ok, 0}} in commands
  end
end

defmodule MyApp.Counter.ServerTest do
  use ExUnit.Case, async: true

  alias MyApp.Counter.Server

  test "server delegates to core and replies" do
    {:ok, pid} = Server.start_link(max: 10)

    assert {:ok, 2} = Server.inc(pid, 2)
    assert {:ok, 5} = Server.inc(pid, 3)
  end

  test "server emits audit side-effect (example)" do
    {:ok, pid} = Server.start_link(max: 10)

    assert {:ok, 1} = Server.inc(pid, 1)

    # 예제에서는 run_commands/1이 self()로 send하므로
    # 테스트 프로세스에서 받으려면 구조를 조금 바꿔야 함.
    # 실무에서는 audit를 별도 모듈로 분리하고 Mox로 검증하는 편이 일반적.
    assert is_pid(pid)
  end
end

defmodule MyApp.Audit do
  @callback emit(map()) :: :ok | {:error, term()}
end

defmodule MyApp.Audit.LoggerImpl do
  @behaviour MyApp.Audit

  require Logger

  @impl true
  def emit(payload) do
    Logger.info("audit=" <> inspect(payload))
    :ok
  end
end

defmodule MyApp.Counter.Server do
  use GenServer
  alias MyApp.Counter.Core

  def start_link(opts) do
    GenServer.start_link(__MODULE__, opts, name: Keyword.get(opts, :name))
  end

  def inc(server, n), do: GenServer.call(server, {:inc, n})

  @impl true
  def init(opts) do
    audit_impl = Keyword.get(opts, :audit, MyApp.Audit.LoggerImpl)
    {:ok, %{core: Core.new(opts), audit: audit_impl}}
  end

  @impl true
  def handle_call({:inc, n}, _from, %{core: core, audit: audit} = state) do
    case Core.inc(core, n) do
      {:ok, new_core, commands} ->
        reply = run_commands(commands, audit)
        {:reply, reply, %{state | core: new_core}}

      {:error, reason} ->
        {:reply, {:error, reason}, state}
    end
  end

  defp run_commands(commands, audit) do
    Enum.each(commands, fn
      {:audit, payload} ->
        _ = audit.emit(payload)
        :ok

      _ ->
        :ok
    end)

    Enum.find_value(commands, fn
      {:reply, value} -> value
      _ -> nil
    end)
  end
end

# test/test_helper.exs
ExUnit.start()
Mox.defmock(MyApp.AuditMock, for: MyApp.Audit)

defmodule MyApp.Counter.ServerAuditTest do
  use ExUnit.Case, async: true
  import Mox

  alias MyApp.Counter.Server

  setup :verify_on_exit!

  test "server calls audit implementation" do
    expect(MyApp.AuditMock, :emit, fn payload ->
      assert payload.event == "inc"
      assert payload.by == 2
      assert payload.value == 2
      :ok
    end)

    {:ok, pid} = Server.start_link(max: 10, audit: MyApp.AuditMock)
    assert {:ok, 2} = Server.inc(pid, 2)
  end
end

@type command ::
        {:reply, term()}
        | {:audit, map()}
        | {:schedule_after, non_neg_integer(), term()}