Convert Connection to :gen_statem

Author: ftes

lib/phoenix_test/playwright/connection.ex

@@ -1,69 +1,47 @@
 defmodule PhoenixTest.Playwright.Connection do
   @moduledoc """
-  Stateful, `GenServer` based connection to a Playwright node.js server.
-  The connection is established via `PhoenixTest.Playwright.Port`.
+  Stateful, `:gen_statem` based connection to a Playwright node.js server.
+  The connection is established via `PhoenixTest.Playwright.PortServer`.
+
+  States:
+  - `:pending`: Initial state, waiting for Playwright initialization. Post calls are postponed.
+  - `:started`: Playwright is ready, all operations are processed normally.
 
   You won't usually have to use this module directly.
   `PhoenixTest.Playwright` uses this under the hood.
   """
-  use GenServer
+  @behaviour :gen_statem
 
   alias PhoenixTest.Playwright.Config
   alias PhoenixTest.Playwright.PortServer
 
   @timeout_grace_factor 1.5
   @min_genserver_timeout to_timeout(second: 1)
 
-  defstruct status: :pending,
-            awaiting_started: [],
-            initializers: %{},
+  defstruct initializers: %{},
             guid_subscribers: %{},
             posts_in_flight: %{}
 
   @name __MODULE__
 
+  @doc false
   def start_link do
-    GenServer.start_link(__MODULE__, :no_init_arg, name: @name, timeout: Config.global(:timeout))
+    :gen_statem.start_link({:local, @name}, __MODULE__, :no_init_arg, timeout: Config.global(:timeout))
   end
 
   @doc """
   Launch a browser and return its `guid`.
   """
   def launch_browser(type, opts) do
     ensure_started()
-
     types = initializer("Playwright")
     type_id = Map.fetch!(types, type).guid
-
-    timeout =
-      opts[:browser_launch_timeout] || opts[:timeout] || Config.global(:browser_launch_timeout)
-
-    params =
-      opts
-      |> Map.new()
-      |> Map.put(:timeout, timeout)
+    timeout = opts[:browser_launch_timeout] || opts[:timeout] || Config.global(:browser_launch_timeout)
+    params = opts |> Map.new() |> Map.put(:timeout, timeout)
 
     case post(guid: type_id, method: :launch, params: params) do
-      %{result: %{browser: %{guid: guid}}} ->
-        guid
-
-      %{error: %{error: %{name: "TimeoutError", stack: stack, message: message}}} ->
-        raise """
-        Timed out while launching the Playwright browser, #{String.capitalize("#{type}")}. #{message}
-
-        You may need to increase the :browser_launch_timeout option in config/test.exs:
-
-            config :phoenix_test,
-              playwright: [
-                browser_launch_timeout: 10_000,
-                # other Playwright options...
-              ],
-              # other phoenix_test options...
-
-        Playwright backtrace:
-
-        #{stack}
-        """
+      %{result: %{browser: %{guid: guid}}} -> guid
+      %{error: %{error: %{name: "TimeoutError"} = error}} -> raise launch_timeout_error_msg(type, error)
     end
   end
 
@@ -72,152 +50,140 @@ defmodule PhoenixTest.Playwright.Connection do
       nil -> start_link()
       pid -> {:ok, pid}
     end
-
-    GenServer.call(@name, :awaiting_started)
   end
 
   @doc """
   Subscribe to messages for a guid and its descendants.
   """
   def subscribe(pid \\ self(), guid) do
-    GenServer.cast(@name, {:subscribe, {pid, guid}})
+    :gen_statem.cast(@name, {:subscribe, pid, guid})
   end
 
-  @doc """
-  Handle a parsed message from the PortServer.
-  This is called by PortServer after parsing complete messages from the Port.
-  """
+  @doc false
   def handle_playwright_msg(msg) do
-    GenServer.cast(@name, {:playwright_msg, msg})
+    :gen_statem.cast(@name, {:msg, msg})
   end
 
   @doc """
   Post a message and await the response.
-  We wait for an additional grace period after the timeout that we pass to playwright.
+  Wait for an additional grace period after the playwright timeout.
   """
   def post(msg, timeout \\ nil) do
-    default = %{params: %{}, metadata: %{}}
-
     msg =
       msg
-      |> Enum.into(default)
+      |> Enum.into(%{params: %{}, metadata: %{}})
       |> update_in(~w(params timeout)a, &(&1 || timeout || Config.global(:timeout)))
+      |> Map.put_new_lazy(:id, fn -> System.unique_integer([:positive, :monotonic]) end)
 
     call_timeout = max(@min_genserver_timeout, round(msg.params.timeout * @timeout_grace_factor))
-    GenServer.call(@name, {:post, msg}, call_timeout)
+
+    :gen_statem.call(@name, {:post, msg}, call_timeout)
   end
 
   @doc """
   Get the initializer data for a channel.
   """
   def initializer(guid) do
-    GenServer.call(@name, {:initializer, guid})
+    :gen_statem.call(@name, {:initializer, guid})
   end
 
-  @impl GenServer
+  @impl :gen_statem
+  def callback_mode, do: :state_functions
+
+  @impl :gen_statem
   def init(:no_init_arg) do
-    {:ok, _} = PortServer.start_link(self())
+    {:ok, _port_server} = PortServer.start_link(self())
     msg = %{guid: "", params: %{sdk_language: :javascript}, method: :initialize, metadata: %{}}
     PortServer.post(msg)
 
-    {:ok, %__MODULE__{}}
+    {:ok, :pending, %__MODULE__{}}
   end
 
-  @impl GenServer
-  def handle_cast({:subscribe, {recipient, guid}}, state) do
-    subscribers = Map.update(state.guid_subscribers, guid, [recipient], &[recipient | &1])
-    {:noreply, %{state | guid_subscribers: subscribers}}
+  @doc false
+  def pending(:cast, {:msg, %{method: :__create__, params: %{guid: "Playwright"}} = msg}, data) do
+    {:next_state, :started, add_initializer(data, msg)}
   end
 
-  def handle_cast({:playwright_msg, msg}, state) do
-    state = handle_recv(msg, state)
-    {:noreply, state}
-  end
+  def pending(:cast, _msg, _data), do: {:keep_state_and_data, [:postpone]}
+  def pending({:call, _from}, _msg, _data), do: {:keep_state_and_data, [:postpone]}
 
-  @impl GenServer
-  def handle_call({:post, msg}, from, state) do
-    msg_id = fn -> System.unique_integer([:positive, :monotonic]) end
-    msg = msg |> Map.new() |> Map.put_new_lazy(:id, msg_id)
+  @doc false
+  def started({:call, from}, {:post, msg}, data) do
     PortServer.post(msg)
-
-    {:noreply, Map.update!(state, :posts_in_flight, &Map.put(&1, msg.id, from))}
-  end
-
-  def handle_call({:initializer, guid}, _from, state) do
-    {:reply, Map.get(state.initializers, guid), state}
+    {:keep_state, put_in(data.posts_in_flight[msg.id], from)}
   end
 
-  def handle_call(:awaiting_started, from, %{status: :pending} = state) do
-    {:noreply, Map.update!(state, :awaiting_started, &[from | &1])}
+  def started({:call, from}, {:initializer, guid}, data) do
+    {:keep_state_and_data, [{:reply, from, Map.fetch!(data.initializers, guid)}]}
   end
 
-  def handle_call(:awaiting_started, _from, %{status: :started} = state) do
-    {:reply, :ok, state}
+  def started(:cast, {:subscribe, recipient, guid}, data) do
+    {:keep_state, update_in(data.guid_subscribers[guid], &[recipient | &1 || []])}
   end
 
-  defp handle_recv(msg, state) do
-    state
-    |> log_js(msg)
-    |> add_initializer(msg)
-    |> handle_started(msg)
-    |> reply_in_flight(msg)
-    |> send_to_subscribers(msg)
-  end
-
-  defp log_js(state, %{method: :page_error} = msg) do
+  def started(:cast, {:msg, %{method: :page_error} = msg}, _data) do
     if module = Config.global(:js_logger) do
       module.log(:error, msg.params.error, msg)
     end
 
-    state
+    :keep_state_and_data
   end
 
-  defp log_js(state, %{method: :console} = msg) do
+  def started(:cast, {:msg, %{method: :console} = msg}, _data) do
     if module = Config.global(:js_logger) do
-      level =
-        case msg[:params][:type] do
-          "error" -> :error
-          "debug" -> :debug
-          _ -> :info
-        end
-
+      level = log_level_from_js(msg[:params][:type])
       module.log(level, msg.params.text, msg)
     end
 
-    state
+    :keep_state_and_data
   end
 
-  defp log_js(state, _), do: state
+  def started(:cast, {:msg, msg}, data) when is_map_key(data.posts_in_flight, msg.id) do
+    {from, posts_in_flight} = Map.pop(data.posts_in_flight, msg.id)
+    :gen_statem.reply(from, msg)
 
-  defp handle_started(state, %{method: :__create__, params: %{type: "Playwright"}}) do
-    for from <- state.awaiting_started, do: GenServer.reply(from, :ok)
-    %{state | status: :started, awaiting_started: :none}
+    {:keep_state, %{data | posts_in_flight: posts_in_flight}}
   end
 
-  defp handle_started(state, _), do: state
-
-  defp add_initializer(state, %{method: :__create__} = msg) do
-    Map.update!(state, :initializers, &Map.put(&1, msg.params.guid, msg.params.initializer))
+  def started(:cast, {:msg, msg}, data) do
+    {:keep_state, data |> add_initializer(msg) |> notify_subscribers(msg)}
   end
 
-  defp add_initializer(state, _), do: state
+  defp add_initializer(data, %{method: :__create__} = msg) do
+    put_in(data.initializers[msg.params.guid], msg.params.initializer)
+  end
 
-  defp reply_in_flight(%{posts_in_flight: in_flight} = state, msg) when is_map_key(in_flight, msg.id) do
-    {from, in_flight} = Map.pop(in_flight, msg.id)
-    GenServer.reply(from, msg)
+  defp add_initializer(data, _msg), do: data
 
-    %{state | posts_in_flight: in_flight}
+  defp notify_subscribers(data, msg) when is_map_key(data.guid_subscribers, msg.guid) do
+    for pid <- Map.fetch!(data.guid_subscribers, msg.guid), do: send(pid, {:playwright_msg, msg})
+    data
   end
 
-  defp reply_in_flight(state, _), do: state
+  defp notify_subscribers(data, _msg), do: data
 
-  defp send_to_subscribers(state, %{guid: guid} = msg) do
-    for pid <- Map.get(state.guid_subscribers, guid, []) do
-      send(pid, {:playwright, msg})
-    end
+  defp launch_timeout_error_msg(type, error) do
+    %{stack: stack, message: message} = error
+
+    """
+    Timed out while launching the Playwright browser, #{String.capitalize("#{type}")}. #{message}
+
+    You may need to increase the :browser_launch_timeout option in config/test.exs:
+
+        config :phoenix_test,
+          playwright: [
+            browser_launch_timeout: 10_000,
+            # other Playwright options...
+          ],
+          # other phoenix_test options...
+
+    Playwright backtrace:
 
-    state
+    #{stack}
+    """
   end
 
-  defp send_to_subscribers(state, _), do: state
+  defp log_level_from_js("error"), do: :error
+  defp log_level_from_js("debug"), do: :debug
+  defp log_level_from_js(_), do: :info
 end

lib/phoenix_test/playwright/event_listener.ex

@@ -39,7 +39,7 @@ defmodule PhoenixTest.Playwright.EventListener do
   end
 
   @impl GenServer
-  def handle_info({:playwright, event}, %__MODULE__{} = state) do
+  def handle_info({:playwright_msg, event}, %__MODULE__{} = state) do
     callback = List.first(state.callbacks)
     if state.filter.(event) and callback, do: callback.(event)
     {:noreply, state}

lib/phoenix_test/playwright/event_recorder.ex

@@ -27,7 +27,7 @@ defmodule PhoenixTest.Playwright.EventRecorder do
   end
 
   @impl GenServer
-  def handle_info({:playwright, event}, state) do
+  def handle_info({:playwright_msg, event}, state) do
     if state.filter.(event) do
       {:noreply, Map.update!(state, :events, &[event | &1])}
     else