Update tests

Author: hhubert6

lib/live_debugger/services/garbage_collector/actions/garbage_collecting.ex

@@ -5,6 +5,7 @@ defmodule LiveDebugger.Services.GarbageCollector.Actions.GarbageCollecting do
 
   alias LiveDebugger.API.StatesStorage
   alias LiveDebugger.API.TracesStorage
+  alias LiveDebugger.Services.GarbageCollector.GenServers.GarbageCollector
 
   alias LiveDebugger.Bus
   alias LiveDebugger.Services.GarbageCollector.Events.TableTrimmed
@@ -14,7 +15,12 @@ defmodule LiveDebugger.Services.GarbageCollector.Actions.GarbageCollecting do
   @watched_table_size 50 * @megabyte_unit
   @non_watched_table_size 5 * @megabyte_unit
 
-  @spec garbage_collect_traces!(map(), MapSet.t(pid()), MapSet.t(pid())) :: MapSet.t(pid())
+  @doc """
+  Performs garbage collection on traces based on `to_remove`, `watched_pids`, and `alive_pids` sets.
+  Returns a set of PIDs marked for removal in next cycle.
+  """
+  @spec garbage_collect_traces!(GarbageCollector.state(), MapSet.t(pid()), MapSet.t(pid())) ::
+          to_remove :: MapSet.t(pid())
   def garbage_collect_traces!(%{to_remove: to_remove}, watched_pids, alive_pids) do
     TracesStorage.get_all_tables()
     |> Enum.map(fn {pid, table} ->
@@ -31,7 +37,12 @@ defmodule LiveDebugger.Services.GarbageCollector.Actions.GarbageCollecting do
     |> aggregate_results()
   end
 
-  @spec garbage_collect_states!(map(), MapSet.t(pid()), MapSet.t(pid())) :: MapSet.t(pid())
+  @doc """
+  Performs garbage collection on states based on `to_remove`, `watched_pids`, and `alive_pids` sets.
+  Returns a set of PIDs marked for removal in next cycle.
+  """
+  @spec garbage_collect_states!(GarbageCollector.state(), MapSet.t(pid()), MapSet.t(pid())) ::
+          to_remove :: MapSet.t(pid())
   def garbage_collect_states!(%{to_remove: to_remove}, watched_pids, alive_pids) do
     StatesStorage.get_all_states()
     |> Enum.map(fn {pid, _} ->

lib/live_debugger/services/garbage_collector/gen_servers/garbage_collector.ex

@@ -16,6 +16,11 @@ defmodule LiveDebugger.Services.GarbageCollector.GenServers.GarbageCollector do
 
   @garbage_collect_interval 2000
 
+  @type state :: %{
+          garbage_collection_enabled?: boolean(),
+          to_remove: MapSet.t(pid())
+        }
+
   def start_link(opts \\ []) do
     GenServer.start_link(__MODULE__, opts, name: __MODULE__)
   end
@@ -46,26 +51,20 @@ defmodule LiveDebugger.Services.GarbageCollector.GenServers.GarbageCollector do
   end
 
   # Handle messages related to ETS table transfers from TracesStorage
-  @impl true
   def handle_info({:"ETS-TRANSFER", _ref, _from, _}, state) do
     {:noreply, state}
   end
 
-  @impl true
   def handle_info(%UserChangedSettings{key: :garbage_collection, value: true}, state) do
     resume_garbage_collection()
     {:noreply, Map.put(state, :garbage_collection_enabled?, true)}
   end
 
-  @impl true
   def handle_info(%UserChangedSettings{key: :garbage_collection, value: false}, state) do
     {:noreply, Map.put(state, :garbage_collection_enabled?, false)}
   end
 
-  @impl true
-  def handle_info(_, state) do
-    {:noreply, state}
-  end
+  def handle_info(_, state), do: {:noreply, state}
 
   defp loop_garbage_collection() do
     Process.send_after(

test/services/garbage_collector/actions/garbage_collecting_test.exs

@@ -25,6 +25,7 @@ defmodule LiveDebugger.Services.GarbageCollector.Actions.GarbageCollectingTest d
       alive_pids = MapSet.new([pid2])
       table1 = make_ref()
       table2 = make_ref()
+      state = %{to_remove: MapSet.new()}
 
       max_table_size_watched = 50 * @megabyte_unit
       max_table_size_non_watched = 5 * @megabyte_unit
@@ -39,7 +40,8 @@ defmodule LiveDebugger.Services.GarbageCollector.Actions.GarbageCollectingTest d
       MockBus
       |> expect(:broadcast_event!, 2, fn %TableTrimmed{} -> :ok end)
 
-      assert true == GarbageCollectingActions.garbage_collect_traces!(watched_pids, alive_pids)
+      assert MapSet.new() ==
+               GarbageCollectingActions.garbage_collect_traces!(state, watched_pids, alive_pids)
     end
 
     test "does not collect garbage if max size not exceeded" do
@@ -49,6 +51,7 @@ defmodule LiveDebugger.Services.GarbageCollector.Actions.GarbageCollectingTest d
       alive_pids = MapSet.new([pid2])
       table1 = make_ref()
       table2 = make_ref()
+      state = %{to_remove: MapSet.new()}
 
       MockAPITracesStorage
       |> expect(:get_all_tables, fn -> [{pid1, table1}, {pid2, table2}] end)
@@ -59,44 +62,75 @@ defmodule LiveDebugger.Services.GarbageCollector.Actions.GarbageCollectingTest d
       MockBus
       |> deny(:broadcast_event!, 2)
 
-      assert false == GarbageCollectingActions.garbage_collect_traces!(watched_pids, alive_pids)
+      assert MapSet.new() ==
+               GarbageCollectingActions.garbage_collect_traces!(state, watched_pids, alive_pids)
     end
 
-    test "deletes table if not watched and no alive" do
+    test "marks for removal if not watched and not alive" do
       watched_pids = MapSet.new()
       alive_pids = MapSet.new()
       pid1 = :c.pid(0, 11, 0)
       table1 = make_ref()
+      state = %{to_remove: MapSet.new([])}
+
+      expect(MockAPITracesStorage, :get_all_tables, fn -> [{pid1, table1}] end)
+
+      assert MapSet.new([pid1]) ==
+               GarbageCollectingActions.garbage_collect_traces!(state, watched_pids, alive_pids)
+    end
+
+    test "deletes table if not watched, not alive and marked to remove" do
+      watched_pids = MapSet.new()
+      alive_pids = MapSet.new()
+      pid1 = :c.pid(0, 11, 0)
+      table1 = make_ref()
+      state = %{to_remove: MapSet.new([pid1])}
 
       expect(MockAPITracesStorage, :get_all_tables, fn -> [{pid1, table1}] end)
       expect(MockAPITracesStorage, :delete_table!, fn ^table1 -> :ok end)
       expect(MockBus, :broadcast_event!, fn %TableDeleted{} -> :ok end)
 
-      assert true == GarbageCollectingActions.garbage_collect_traces!(watched_pids, alive_pids)
+      assert MapSet.new() ==
+               GarbageCollectingActions.garbage_collect_traces!(state, watched_pids, alive_pids)
     end
   end
 
   describe "garbage_collect_states!/1" do
-    test "collects garbage for states if pids are not watched and not alive" do
+    test "marks for removal if not watched and not alive" do
       pid1 = :c.pid(0, 12, 0)
       watched_pids = MapSet.new([:c.pid(0, 11, 0)])
       alive_pids = MapSet.new([:c.pid(0, 13, 0)])
+      state = %{to_remove: MapSet.new()}
+
+      MockAPIStatesStorage
+      |> expect(:get_all_states, fn -> [{pid1, :some_state}] end)
+
+      assert MapSet.new([pid1]) ==
+               GarbageCollectingActions.garbage_collect_states!(state, watched_pids, alive_pids)
+    end
+
+    test "deletes states if not watched, not alive and marked for removal " do
+      pid1 = :c.pid(0, 12, 0)
+      watched_pids = MapSet.new([:c.pid(0, 11, 0)])
+      alive_pids = MapSet.new([:c.pid(0, 13, 0)])
+      state = %{to_remove: MapSet.new([pid1])}
 
       MockAPIStatesStorage
       |> expect(:get_all_states, fn -> [{pid1, :some_state}] end)
       |> expect(:delete!, fn ^pid1 -> :ok end)
 
-      MockBus
-      |> expect(:broadcast_event!, fn %TableTrimmed{} -> :ok end)
+      expect(MockBus, :broadcast_event!, fn %TableTrimmed{} -> :ok end)
 
-      assert true == GarbageCollectingActions.garbage_collect_states!(watched_pids, alive_pids)
+      assert MapSet.new() ==
+               GarbageCollectingActions.garbage_collect_states!(state, watched_pids, alive_pids)
     end
 
-    test "does not collect garbage for states if pids are watched or alive" do
+    test "do nothing if pids are watched or alive" do
       pid1 = :c.pid(0, 12, 0)
       pid2 = :c.pid(0, 13, 0)
       watched_pids = MapSet.new([pid1])
       alive_pids = MapSet.new([pid2])
+      state = %{to_remove: MapSet.new()}
 
       MockAPIStatesStorage
       |> expect(:get_all_states, fn -> [{pid1, :some_state}, {pid2, :some_other_state}] end)
@@ -105,7 +139,8 @@ defmodule LiveDebugger.Services.GarbageCollector.Actions.GarbageCollectingTest d
       MockBus
       |> deny(:broadcast_event!, 1)
 
-      assert false == GarbageCollectingActions.garbage_collect_states!(watched_pids, alive_pids)
+      assert MapSet.new() ==
+               GarbageCollectingActions.garbage_collect_states!(state, watched_pids, alive_pids)
     end
   end
 end