Elixir GenServer를 함수형 상태머신으로 리팩터링

defmodule Payments.Worker do
  use GenServer

  def start_link(opts), do: GenServer.start_link(__MODULE__, opts, name: via(opts[:id]))

  def authorize(id), do: GenServer.call(via(id), :authorize)

  @impl true
  def init(opts) do
    state = %{
      id: opts[:id],
      status: :idle,
      auth_ref: nil,
      timer_ref: nil,
      attempts: 0
    }

    {:ok, state}
  end

  @impl true
  def handle_call(:authorize, _from, %{status: :idle} = state) do
    # 외부 I/O
    {:ok, auth_ref} = Payments.Gateway.authorize(state.id)

    # 타이머 설정
    timer_ref = Process.send_after(self(), {:timeout, auth_ref}, 5_000)

    new_state = %{state | status: :authorizing, auth_ref: auth_ref, timer_ref: timer_ref}
    {:reply, :ok, new_state}
  end

  def handle_call(:authorize, _from, state) do
    {:reply, {:error, :invalid_state}, state}
  end

  @impl true
  def handle_info({:gateway_ok, auth_ref}, %{status: :authorizing, auth_ref: auth_ref} = state) do
    if state.timer_ref, do: Process.cancel_timer(state.timer_ref)
    {:noreply, %{state | status: :authorized, timer_ref: nil}}
  end

  def handle_info({:gateway_error, auth_ref, reason}, %{status: :authorizing, auth_ref: auth_ref} = state) do
    if state.timer_ref, do: Process.cancel_timer(state.timer_ref)
    {:noreply, %{state | status: {:failed, reason}, timer_ref: nil}}
  end

  def handle_info({:timeout, auth_ref}, %{status: :authorizing, auth_ref: auth_ref} = state) do
    {:noreply, %{state | status: :timed_out, timer_ref: nil}}
  end

  def handle_info(_msg, state), do: {:noreply, state}

  defp via(id), do: {:via, Registry, {Payments.Registry, id}}
end

defmodule Payments.Fsm do
  @moduledoc """
  결제 승인 워크플로우 상태머신.

  - 순수 함수만 포함한다.
  - 부수효과는 effect로 기술만 하고 실행하지 않는다.
  """

  defstruct [:id, status: :idle, auth_ref: nil, attempts: 0]

  @type status :: :idle | :authorizing | :authorized | :timed_out | {:failed, term()}
  @type t :: %__MODULE__{id: term(), status: status(), auth_ref: term() | nil, attempts: non_neg_integer()}

  @type event ::
          :authorize
          | {:gateway_ok, term()}
          | {:gateway_error, term(), term()}
          | {:timeout, term()}

  @type effect ::
          {:call_gateway_authorize, term()}
          | {:start_timer, term(), non_neg_integer()}
          | {:cancel_timer, term()}

  @spec step(t(), event()) :: {t(), [effect()]}
  def step(%__MODULE__{status: :idle} = s, :authorize) do
    s1 = %{s | status: :authorizing, attempts: s.attempts + 1}

    effects = [
      {:call_gateway_authorize, s.id}
      # auth_ref를 아직 모르므로 타이머는 authorize 결과를 받은 뒤 시작하도록 설계할 수도 있다.
    ]

    {s1, effects}
  end

  def step(%__MODULE__{status: :authorizing, auth_ref: auth_ref} = s, {:gateway_ok, auth_ref}) do
    s1 = %{s | status: :authorized}
    {s1, [{:cancel_timer, auth_ref}]}
  end

  def step(%__MODULE__{status: :authorizing, auth_ref: auth_ref} = s, {:gateway_error, auth_ref, reason}) do
    s1 = %{s | status: {:failed, reason}}
    {s1, [{:cancel_timer, auth_ref}]}
  end

  def step(%__MODULE__{status: :authorizing, auth_ref: auth_ref} = s, {:timeout, auth_ref}) do
    s1 = %{s | status: :timed_out}
    {s1, []}
  end

  # 알 수 없는 이벤트나 상태 불일치(out-of-order 포함)는 상태를 바꾸지 않는다.
  def step(s, _event), do: {s, []}

  @spec on_authorize_result(t(), {:ok, term()} | {:error, term()}) :: {t(), [effect()]}
  def on_authorize_result(%__MODULE__{status: :authorizing} = s, {:ok, auth_ref}) do
    s1 = %{s | auth_ref: auth_ref}
    {s1, [{:start_timer, auth_ref, 5_000}]}
  end

  def on_authorize_result(%__MODULE__{status: :authorizing} = s, {:error, reason}) do
    s1 = %{s | status: {:failed, reason}}
    {s1, []}
  end
end

defmodule Payments.Worker do
  use GenServer

  alias Payments.Fsm

  def start_link(opts), do: GenServer.start_link(__MODULE__, opts, name: via(opts[:id]))
  def authorize(id), do: GenServer.call(via(id), :authorize)

  @impl true
  def init(opts) do
    fsm = %Fsm{id: opts[:id]}

    runtime = %{
      timer_refs: %{} # auth_ref => timer_ref
    }

    {:ok, %{fsm: fsm, runtime: runtime}}
  end

  @impl true
  def handle_call(:authorize, _from, %{fsm: fsm} = state) do
    {fsm1, effects} = Fsm.step(fsm, :authorize)
    state1 = %{state | fsm: fsm1}

    {state2, _} = run_effects(state1, effects)
    {:reply, :ok, state2}
  end

  @impl true
  def handle_info({:authorize_result, result}, %{fsm: fsm} = state) do
    {fsm1, effects} = Fsm.on_authorize_result(fsm, result)
    state1 = %{state | fsm: fsm1}

    {state2, _} = run_effects(state1, effects)
    {:noreply, state2}
  end

  @impl true
  def handle_info({:gateway_ok, auth_ref}, %{fsm: fsm} = state) do
    {fsm1, effects} = Fsm.step(fsm, {:gateway_ok, auth_ref})
    state1 = %{state | fsm: fsm1}

    {state2, _} = run_effects(state1, effects)
    {:noreply, state2}
  end

  @impl true
  def handle_info({:gateway_error, auth_ref, reason}, %{fsm: fsm} = state) do
    {fsm1, effects} = Fsm.step(fsm, {:gateway_error, auth_ref, reason})
    state1 = %{state | fsm: fsm1}

    {state2, _} = run_effects(state1, effects)
    {:noreply, state2}
  end

  @impl true
  def handle_info({:timeout, auth_ref}, %{fsm: fsm} = state) do
    {fsm1, effects} = Fsm.step(fsm, {:timeout, auth_ref})
    state1 = %{state | fsm: fsm1}

    {state2, _} = run_effects(state1, effects)
    {:noreply, state2}
  end

  defp run_effects(state, effects) do
    Enum.reduce(effects, {state, []}, fn eff, {st, acc} ->
      {st2, out} = run_effect(st, eff)
      {st2, [out | acc]}
    end)
  end

  defp run_effect(state, {:call_gateway_authorize, id}) do
    # 실제 I/O는 여기서만
    result = Payments.Gateway.authorize(id)

    # 결과를 self 메시지로 되돌려 이벤트 흐름을 유지
    send(self(), {:authorize_result, result})

    {state, :ok}
  end

  defp run_effect(%{runtime: rt} = state, {:start_timer, auth_ref, ms}) do
    timer_ref = Process.send_after(self(), {:timeout, auth_ref}, ms)
    rt1 = put_in(rt.timer_refs[auth_ref], timer_ref)
    {%{state | runtime: rt1}, :ok}
  end

  defp run_effect(%{runtime: rt} = state, {:cancel_timer, auth_ref}) do
    case rt.timer_refs[auth_ref] do
      nil ->
        {state, :noop}

      timer_ref ->
        _ = Process.cancel_timer(timer_ref)
        rt1 = update_in(rt.timer_refs, &Map.delete(&1, auth_ref))
        {%{state | runtime: rt1}, :ok}
    end
  end

  defp via(id), do: {:via, Registry, {Payments.Registry, id}}
end

defmodule Payments.FsmTest do
  use ExUnit.Case, async: true

  alias Payments.Fsm

  test "idle에서 authorize하면 authorizing으로 전이하고 gateway 호출 effect를 만든다" do
    s0 = %Fsm{id: 1}

    {s1, effects} = Fsm.step(s0, :authorize)

    assert s1.status == :authorizing
    assert {:call_gateway_authorize, 1} in effects
  end

  test "authorizing에서 gateway_ok를 받으면 authorized로 전이하고 타이머 취소 effect를 만든다" do
    s0 = %Fsm{id: 1, status: :authorizing, auth_ref: :ref1}

    {s1, effects} = Fsm.step(s0, {:gateway_ok, :ref1})

    assert s1.status == :authorized
    assert {:cancel_timer, :ref1} in effects
  end

  test "상태 불일치 이벤트는 무시한다" do
    s0 = %Fsm{id: 1, status: :idle}

    {s1, effects} = Fsm.step(s0, {:gateway_ok, :ref1})

    assert s1 == s0
    assert effects == []
  end
end