fix: Correct Registry.select match specification syntax

Fix incorrect string syntax for match variables in Registry.select calls.
Changed from string atoms (":$1", ":$2") to proper atom syntax (:"$1", :"$2")
throughout the codebase.

Changes:
- Fix list_session/0 Registry.select syntax and add guard to filter session entries
- Fix get_session_id/0 in both :process and :process_link macros
- Refactor list_sessions_by_module/1 to use Registry.lookup for cleaner implementation
- Add @impl annotations to handle_info/2 and terminate/2 in :process_link macro
- Update list_session/0 typespec to allow empty lists (fix Dialyzer warning)

Tests:
- Add comprehensive unit tests for list_session/0, list_sessions_by_module/1
- Add tests for session_info/0 and get_session_id/0 functionality
- Create TestProcessLink module for :process_link testing

All tests pass (75/75) with no warnings or linting errors.

Author: GSMLG-BOT

lib/phoenix/session_process.ex

@@ -351,10 +351,10 @@ defmodule Phoenix.SessionProcess do
 
       # Returns list of {session_id, pid} tuples, or empty list if no sessions exist
   """
-  @spec list_session :: [{binary(), pid()}, ...]
+  @spec list_session :: [{binary(), pid()}]
   def list_session do
     Registry.select(SessionRegistry, [
-      {{:":$1", :":$2", :_}, [], [{{:":$1", :":$2"}}]}
+      {{:"$1", :"$2", :_}, [{:is_binary, :"$1"}], [{{:"$1", :"$2"}}]}
     ])
   end
 
@@ -416,11 +416,14 @@ defmodule Phoenix.SessionProcess do
   """
   @spec list_sessions_by_module(module()) :: [binary()]
   def list_sessions_by_module(module) do
-    Registry.select(SessionRegistry, [
-      {{:"$1", :"$2", :"$_"}, [], [{{:"$1", :"$2", :"$_"}}]}
-    ])
-    |> Enum.filter(fn {_session_id, _pid, mod} -> mod == module end)
-    |> Enum.map(fn {session_id, _pid, _mod} -> session_id end)
+    list_session()
+    |> Enum.filter(fn {_session_id, pid} ->
+      case Registry.lookup(SessionRegistry, pid) do
+        [{_, ^module}] -> true
+        _ -> false
+      end
+    end)
+    |> Enum.map(fn {session_id, _pid} -> session_id end)
   end
 
   @doc """
@@ -529,7 +532,7 @@ defmodule Phoenix.SessionProcess do
         current_pid = self()
 
         Registry.select(unquote(SessionRegistry), [
-          {{:":$1", :":$2", :_}, [{:==, :":$2", current_pid}], [{{:":$1", :":$2"}}]}
+          {{:"$1", :"$2", :_}, [{:==, :"$2", current_pid}], [{{:"$1", :"$2"}}]}
         ])
         |> Enum.at(0)
         |> elem(0)
@@ -551,7 +554,7 @@ defmodule Phoenix.SessionProcess do
         current_pid = self()
 
         Registry.select(unquote(SessionRegistry), [
-          {{:":$1", :":$2", :_}, [{:==, :":$2", current_pid}], [{{:":$1", :":$2"}}]}
+          {{:"$1", :"$2", :_}, [{:==, :"$2", current_pid}], [{{:"$1", :"$2"}}]}
         ])
         |> Enum.at(0)
         |> elem(0)
@@ -565,6 +568,7 @@ defmodule Phoenix.SessionProcess do
         {:noreply, new_state}
       end
 
+      @impl true
       def handle_info({:DOWN, _ref, :process, pid, _reason}, state) do
         new_state =
           state
@@ -573,6 +577,7 @@ defmodule Phoenix.SessionProcess do
         {:noreply, new_state}
       end
 
+      @impl true
       def terminate(_reason, state) do
         state
         |> Map.get(:__live_view__, [])

test/phoenix/session_process_test.exs

@@ -54,4 +54,138 @@ defmodule Phoenix.SessionProcessTest do
     SessionProcess.cast(session_id, :add_one)
     assert SessionProcess.call(session_id, :get_value) == 1
   end
+
+  describe "list_session/0" do
+    test "returns list type" do
+      assert is_list(SessionProcess.list_session())
+    end
+
+    test "returns list of session_id and pid tuples" do
+      session_id1 = SessionId.generate_unique_session_id()
+      session_id2 = SessionId.generate_unique_session_id()
+
+      {:ok, pid1} = SessionProcess.start(session_id1, TestProcess, %{value: 1})
+      {:ok, pid2} = SessionProcess.start(session_id2, TestProcess, %{value: 2})
+
+      sessions = SessionProcess.list_session()
+      # Check that our created sessions are in the list
+      assert {session_id1, pid1} in sessions
+      assert {session_id2, pid2} in sessions
+
+      # Cleanup
+      SessionProcess.terminate(session_id1)
+      SessionProcess.terminate(session_id2)
+    end
+
+    test "removes session when terminated" do
+      session_id = SessionId.generate_unique_session_id()
+      {:ok, pid} = SessionProcess.start(session_id, TestProcess, %{value: 0})
+
+      # Check session exists in list
+      sessions_before = SessionProcess.list_session()
+      assert {session_id, pid} in sessions_before
+
+      # Terminate and verify it's removed
+      SessionProcess.terminate(session_id)
+      sessions_after = SessionProcess.list_session()
+      assert {session_id, pid} not in sessions_after
+    end
+  end
+
+  describe "list_sessions_by_module/1" do
+    test "returns list type" do
+      assert is_list(SessionProcess.list_sessions_by_module(TestProcess))
+    end
+
+    test "returns session IDs for specific module" do
+      session_id1 = SessionId.generate_unique_session_id()
+      session_id2 = SessionId.generate_unique_session_id()
+
+      {:ok, _pid1} = SessionProcess.start(session_id1, TestProcess, %{value: 1})
+      {:ok, _pid2} = SessionProcess.start(session_id2, TestProcess, %{value: 2})
+
+      sessions = SessionProcess.list_sessions_by_module(TestProcess)
+      # Check that our created sessions are in the list
+      assert session_id1 in sessions
+      assert session_id2 in sessions
+
+      # Cleanup
+      SessionProcess.terminate(session_id1)
+      SessionProcess.terminate(session_id2)
+    end
+
+    test "filters sessions by module correctly" do
+      session_id1 = SessionId.generate_unique_session_id()
+      session_id2 = SessionId.generate_unique_session_id()
+
+      {:ok, _pid1} = SessionProcess.start(session_id1, TestProcess, %{value: 1})
+      {:ok, _pid2} =
+        SessionProcess.start(session_id2, TestProcessLink, %{value: 2})
+
+      test_sessions = SessionProcess.list_sessions_by_module(TestProcess)
+      link_sessions = SessionProcess.list_sessions_by_module(TestProcessLink)
+
+      # Check that each session appears in the correct module list
+      assert session_id1 in test_sessions
+      assert session_id1 not in link_sessions
+      assert session_id2 in link_sessions
+      assert session_id2 not in test_sessions
+
+      # Cleanup
+      SessionProcess.terminate(session_id1)
+      SessionProcess.terminate(session_id2)
+    end
+  end
+
+  describe "session_info/0" do
+    test "returns map with count and modules keys" do
+      info = SessionProcess.session_info()
+      assert is_map(info)
+      assert Map.has_key?(info, :count)
+      assert Map.has_key?(info, :modules)
+      assert is_integer(info.count)
+      assert is_list(info.modules)
+    end
+
+    test "includes modules of active sessions" do
+      session_id1 = SessionId.generate_unique_session_id()
+      session_id2 = SessionId.generate_unique_session_id()
+
+      {:ok, _pid1} = SessionProcess.start(session_id1, TestProcess, %{value: 1})
+      {:ok, _pid2} =
+        SessionProcess.start(session_id2, TestProcessLink, %{value: 2})
+
+      info = SessionProcess.session_info()
+      # Check that both modules are in the list
+      assert TestProcess in info.modules
+      assert TestProcessLink in info.modules
+      # Check that count is at least 2 (could be more from other tests)
+      assert info.count >= 2
+
+      # Cleanup
+      SessionProcess.terminate(session_id1)
+      SessionProcess.terminate(session_id2)
+    end
+  end
+
+  describe "get_session_id/0 in :process macro" do
+    test "returns correct session_id from within session process" do
+      session_id = SessionId.generate_unique_session_id()
+      {:ok, _pid} = SessionProcess.start(session_id, TestProcess, %{value: 0})
+
+      # Call a function that uses get_session_id internally
+      result = SessionProcess.call(session_id, :get_my_session_id)
+      assert result == session_id
+    end
+  end
+
+  describe "get_session_id/0 in :process_link macro" do
+    test "returns correct session_id from within session process" do
+      session_id = SessionId.generate_unique_session_id()
+      {:ok, _pid} = SessionProcess.start(session_id, TestProcessLink, %{value: 0})
+
+      result = SessionProcess.call(session_id, :get_my_session_id)
+      assert result == session_id
+    end
+  end
 end

test/support/test_process.ex

@@ -21,6 +21,11 @@ defmodule TestProcess do
     {:reply, State.get(state.agent, :value), state}
   end
 
+  @impl true
+  def handle_call(:get_my_session_id, _from, state) do
+    {:reply, get_session_id(), state}
+  end
+
   @impl true
   def handle_cast(:add_one, state) do
     value = State.get(state.agent, :value)

test/support/test_process_link.ex

@@ -0,0 +1,35 @@
+defmodule TestProcessLink do
+  @moduledoc """
+  Test helper module for session process with LiveView link testing.
+
+  This module provides a session process implementation using the :process_link
+  option to verify LiveView monitoring functionality and get_session_id behavior.
+  """
+
+  use Phoenix.SessionProcess, :process_link
+
+  alias Phoenix.SessionProcess.State
+
+  @impl true
+  def init(init_arg \\ %{}) do
+    {:ok, agent} = State.start_link(init_arg)
+    {:ok, %{agent: agent}}
+  end
+
+  @impl true
+  def handle_call(:get_value, _from, state) do
+    {:reply, State.get(state.agent, :value), state}
+  end
+
+  @impl true
+  def handle_call(:get_my_session_id, _from, state) do
+    {:reply, get_session_id(), state}
+  end
+
+  @impl true
+  def handle_cast(:add_one, state) do
+    value = State.get(state.agent, :value)
+    State.put(state.agent, :value, value + 1)
+    {:noreply, state}
+  end
+end