TrackerReplicaEventTests: Wipe registry before each test

test/tracker_replica_event_test.exs

@@ -15,6 +15,7 @@ defmodule Swarm.TrackerReplicaEventTests do
  end
 
  setup do
+ :ets.delete_all_objects(:swarm_registry)
  {:ok, pid} = MyApp.WorkerSup.register()
  meta = %{mfa: {MyApp.WorkerSup, :register, []}}
  name = :rand.uniform()
@@ -23,38 +24,59 @@ defmodule Swarm.TrackerReplicaEventTests do
  [name: name, pid: pid, meta: meta, lclock: lclock, rclock: rclock]
  end
 
- test "handle_replica_event :track should add registration", %{name: name, pid: pid, meta: meta, rclock: rclock} do
+ test "handle_replica_event :track should add registration", %{
+ name: name,
+ pid: pid,
+ meta: meta,
+ rclock: rclock
+ } do
  send_replica_event(rclock, {:track, name, pid, meta})
 
  assert ^pid = Registry.whereis(name)
  assert Enum.member?(Registry.all(), {name, pid})
  assert entry(name: _, pid: ^pid, ref: ref, meta: ^meta, clock: _) = Registry.get_by_name(name)
  assert [entry(name: ^name, pid: _, ref: _, meta: _, clock: _)] = Registry.get_by_pid(pid)
- assert entry(name: _, pid: _, ref: ^ref, meta: _, clock: _) = Registry.get_by_pid_and_name(pid, name)
+
+ assert entry(name: _, pid: _, ref: ^ref, meta: _, clock: _) =
+ Registry.get_by_pid_and_name(pid, name)
+
  assert entry(name: _, pid: ^pid, ref: _, meta: _, clock: _) = Registry.get_by_ref(ref)
- assert [entry(name: _, pid: ^pid, ref: _, meta: _, clock: _)] = Registry.get_by_meta(:mfa, {MyApp.WorkerSup, :register, []})
- assert [entry(name: _, pid: ^pid, ref: _, meta: _, clock: _)] = :ets.lookup(:swarm_registry, name)
+
+ assert [entry(name: _, pid: ^pid, ref: _, meta: _, clock: _)] =
+ Registry.get_by_meta(:mfa, {MyApp.WorkerSup, :register, []})
+
+ assert [entry(name: _, pid: ^pid, ref: _, meta: _, clock: _)] =
+ :ets.lookup(:swarm_registry, name)
  end
 
- test "handle_replica_event :track with existing registration should ignore the event", %{name: name, pid: pid, meta: meta, lclock: lclock, rclock: rclock} do
+ test "handle_replica_event :track with existing registration should ignore the event", %{
+ name: name,
+ pid: pid,
+ meta: meta,
+ lclock: lclock,
+ rclock: rclock
+ } do
  send_replica_event(lclock, {:track, name, pid, meta})
 
  send_replica_event(rclock, {:track, name, pid, meta})
 
  assert entry(name: _, pid: ^pid, ref: _, meta: _, clock: _) = Registry.get_by_name(name)
  end
 
- test "handle_replica_event :track with conflicting metadata and remote clock dominates should update the metadata", %{name: name, pid: pid, meta: meta, lclock: lclock, rclock: rclock} do
+ test "handle_replica_event :track with conflicting metadata and remote clock dominates should update the metadata",
+ %{name: name, pid: pid, meta: meta, lclock: lclock, rclock: rclock} do
  send_replica_event(lclock, {:track, name, pid, meta})
 
  rclock = Clock.event(rclock)
  remote_meta = %{other: "meta"}
  send_replica_event(rclock, {:track, name, pid, remote_meta})
 
- assert entry(name: _, pid: ^pid, ref: _, meta: ^remote_meta, clock: _) = Registry.get_by_name(name)
+ assert entry(name: _, pid: ^pid, ref: _, meta: ^remote_meta, clock: _) =
+ Registry.get_by_name(name)
  end
 
- test "handle_replica_event :track with conflicting metadata and local clock dominates should keep the metadata", %{name: name, pid: pid, meta: meta, lclock: lclock, rclock: rclock} do
+ test "handle_replica_event :track with conflicting metadata and local clock dominates should keep the metadata",
+ %{name: name, pid: pid, meta: meta, lclock: lclock, rclock: rclock} do
  lclock = Clock.event(lclock)
  send_replica_event(lclock, {:track, name, pid, meta})
 
@@ -64,29 +86,39 @@ defmodule Swarm.TrackerReplicaEventTests do
  assert entry(name: _, pid: ^pid, ref: _, meta: ^meta, clock: _) = Registry.get_by_name(name)
  end
 
- test "handle_replica_event :track with conflicting pid and remote clock dominates should kill the locally registered pid", %{name: name, pid: pid, meta: meta, lclock: lclock, rclock: rclock} do
+ test "handle_replica_event :track with conflicting pid and remote clock dominates should kill the locally registered pid",
+ %{name: name, pid: pid, meta: meta, lclock: lclock, rclock: rclock} do
  send_replica_event(lclock, {:track, name, pid, meta})
 
  rclock = Clock.event(rclock)
  {:ok, other_pid} = MyApp.WorkerSup.register()
  send_replica_event(rclock, {:track, name, other_pid, meta})
 
- assert entry(name: _, pid: ^other_pid, ref: _, meta: ^meta, clock: _) = Registry.get_by_name(name)
- refute Process.alive? pid
+ assert entry(name: _, pid: ^other_pid, ref: _, meta: ^meta, clock: _) =
+ Registry.get_by_name(name)
+
+ refute Process.alive?(pid)
  end
 
- test "handle_replica_event :track with conflicting pid and local clock dominates should ignore the event", %{name: name, pid: pid, meta: meta, lclock: lclock, rclock: rclock} do
+ test "handle_replica_event :track with conflicting pid and local clock dominates should ignore the event",
+ %{name: name, pid: pid, meta: meta, lclock: lclock, rclock: rclock} do
  lclock = Clock.event(lclock)
  send_replica_event(lclock, {:track, name, pid, meta})
 
  {:ok, other_pid} = MyApp.WorkerSup.register()
  send_replica_event(rclock, {:track, name, other_pid, meta})
 
  assert entry(name: _, pid: ^pid, ref: _, meta: ^meta, clock: _) = Registry.get_by_name(name)
- assert Process.alive? pid
+ assert Process.alive?(pid)
  end
 
- test "handle_replica_event :untrack when remote clock dominates should remove registration", %{name: name, pid: pid, meta: meta, lclock: lclock, rclock: rclock} do
+ test "handle_replica_event :untrack when remote clock dominates should remove registration", %{
+ name: name,
+ pid: pid,
+ meta: meta,
+ lclock: lclock,
+ rclock: rclock
+ } do
  send_replica_event(lclock, {:track, name, pid, meta})
 
  rclock = Clock.event(rclock)
@@ -95,7 +127,13 @@ defmodule Swarm.TrackerReplicaEventTests do
  assert :undefined = Registry.get_by_name(name)
  end
 
- test "handle_replica_event :untrack when local clock dominates should ignore event", %{name: name, pid: pid, meta: meta, lclock: lclock, rclock: rclock} do
+ test "handle_replica_event :untrack when local clock dominates should ignore event", %{
+ name: name,
+ pid: pid,
+ meta: meta,
+ lclock: lclock,
+ rclock: rclock
+ } do
  lclock = Clock.event(lclock)
  send_replica_event(lclock, {:track, name, pid, meta})
 
@@ -104,7 +142,13 @@ defmodule Swarm.TrackerReplicaEventTests do
  assert entry(name: _, pid: ^pid, ref: _, meta: ^meta, clock: _) = Registry.get_by_name(name)
  end
 
- test "handle_replica_event :untrack for unknown pid should ignore the event", %{name: name, pid: pid, meta: meta, lclock: lclock, rclock: rclock} do
+ test "handle_replica_event :untrack for unknown pid should ignore the event", %{
+ name: name,
+ pid: pid,
+ meta: meta,
+ lclock: lclock,
+ rclock: rclock
+ } do
  send_replica_event(lclock, {:track, name, pid, meta})
 
  {:ok, other_pid} = MyApp.WorkerSup.register()
@@ -113,7 +157,13 @@ defmodule Swarm.TrackerReplicaEventTests do
  assert entry(name: _, pid: ^pid, ref: _, meta: ^meta, clock: _) = Registry.get_by_name(name)
  end
 
- test "handle_replica_event :update_meta for unknown pid should ignore the event", %{name: name, pid: pid, meta: meta, lclock: lclock, rclock: rclock} do
+ test "handle_replica_event :update_meta for unknown pid should ignore the event", %{
+ name: name,
+ pid: pid,
+ meta: meta,
+ lclock: lclock,
+ rclock: rclock
+ } do
  send_replica_event(lclock, {:track, name, pid, meta})
 
  {:ok, other_pid} = MyApp.WorkerSup.register()
@@ -124,17 +174,30 @@ defmodule Swarm.TrackerReplicaEventTests do
  assert :undefined = Registry.get_by_pid(other_pid)
  end
 
- test "handle_replica_event :update_meta when remote dominates should update the registry", %{name: name, pid: pid, meta: meta, lclock: lclock, rclock: rclock} do
+ test "handle_replica_event :update_meta when remote dominates should update the registry", %{
+ name: name,
+ pid: pid,
+ meta: meta,
+ lclock: lclock,
+ rclock: rclock
+ } do
  send_replica_event(lclock, {:track, name, pid, meta})
 
  rclock = Clock.event(rclock)
  new_meta = %{other: "meta"}
  send_replica_event(rclock, {:update_meta, new_meta, pid})
 
- assert entry(name: _, pid: ^pid, ref: _, meta: ^new_meta, clock: _) = Registry.get_by_name(name)
+ assert entry(name: _, pid: ^pid, ref: _, meta: ^new_meta, clock: _) =
+ Registry.get_by_name(name)
  end
 
- test "handle_replica_event :update_meta when local dominates should ignore the event", %{name: name, pid: pid, meta: meta, lclock: lclock, rclock: rclock} do
+ test "handle_replica_event :update_meta when local dominates should ignore the event", %{
+ name: name,
+ pid: pid,
+ meta: meta,
+ lclock: lclock,
+ rclock: rclock
+ } do
  lclock = Clock.event(lclock)
  send_replica_event(lclock, {:track, name, pid, meta})
 
@@ -144,15 +207,23 @@ defmodule Swarm.TrackerReplicaEventTests do
  assert entry(name: _, pid: ^pid, ref: _, meta: ^meta, clock: _) = Registry.get_by_name(name)
  end
 
- test "handle_replica_event :update_meta when conflict should merge the meta data", %{name: name, pid: pid, meta: meta, lclock: lclock, rclock: rclock} do
+ test "handle_replica_event :update_meta when conflict should merge the meta data", %{
+ name: name,
+ pid: pid,
+ meta: meta,
+ lclock: lclock,
+ rclock: rclock
+ } do
  lclock = Clock.event(lclock)
  send_replica_event(lclock, {:track, name, pid, meta})
 
  rclock = Clock.event(rclock)
  new_meta = %{other: "meta"}
  send_replica_event(rclock, {:update_meta, new_meta, pid})
 
- assert entry(name: _, pid: ^pid, ref: _, meta: updated_meta, clock: _) = Registry.get_by_name(name)
+ assert entry(name: _, pid: ^pid, ref: _, meta: updated_meta, clock: _) =
+ Registry.get_by_name(name)
+
  assert updated_meta.mfa == {MyApp.WorkerSup, :register, []}
  assert updated_meta.other == "meta"
  end