chore(sync-service): Fix flakey Publisher tests (#2851)

These tests can occasionally fail with:

```
 Assertion failed, no matching message after 5000ms
     The process mailbox is empty.
     code: assert_receive :publish_finished
```

The race condition occurs if the TestSubscriber receives the
`:finish_processing_message` message before it receives the publisher
call, in which case it swallows the message since `handle_info` is not
implemented on TestSubscriber. A GenServer would log that a message had
been received and not handled, but as `use GenServer` was omitted from
the TestSubscriber the message was swallowed silently.

This PR:
- Adds `use GenServer` to the TestSubscriber as this is best practice
(the race condition would have been obvious had it been included in the
first place)
- Waits for `:message_received` from each of the subscribers before
sending `:finish_processing_message`. This eliminates the race
condition.
- Renames `event` to `message` for consistency  

Credit to ChatGPT which worked out what the race condition was. It's
solution was terrible, but the hard part was knowing what the race
condition was, so that was super helpful.

Author: robacourt

packages/sync-service/test/electric/publisher_test.exs

@@ -5,6 +5,8 @@ defmodule Electric.PublisherTest do
   alias Electric.PublisherTest.TestSubscriber
 
   defmodule TestSubscriber do
+    use GenServer
+
     def start_link(on_message) do
       GenServer.start_link(__MODULE__, on_message)
     end
@@ -32,38 +34,47 @@ defmodule Electric.PublisherTest do
     end
 
     test "does not return until all subscibers have processed the message" do
-      on_event = fn :test_message ->
+      pid = self()
+
+      on_message = fn :test_message ->
+        send(pid, :message_received)
+
         receive do
-          :finish_processing_event -> :ok
+          :finish_processing_message -> :ok
         end
       end
 
-      {:ok, sub1} = TestSubscriber.start_link(on_event)
-      {:ok, sub2} = TestSubscriber.start_link(on_event)
-
-      pid = self()
+      {:ok, sub1} = TestSubscriber.start_link(on_message)
+      {:ok, sub2} = TestSubscriber.start_link(on_message)
 
       Task.async(fn ->
         Publisher.publish([sub1, sub2], :test_message)
         send(pid, :publish_finished)
       end)
 
+      assert_receive :message_received
+      assert_receive :message_received
+
       refute_receive :publish_finished, 10
-      send(sub2, :finish_processing_event)
+      send(sub2, :finish_processing_message)
       refute_receive :publish_finished, 10
-      send(sub1, :finish_processing_event)
-      assert_receive :publish_finished, 5000
+      send(sub1, :finish_processing_message)
+      assert_receive :publish_finished
     end
 
     test "does not return until all subscibers have processed the message or died" do
-      on_event = fn :test_message ->
+      pid = self()
+
+      on_message = fn :test_message ->
+        send(pid, :message_received)
+
         receive do
-          :finish_processing_event -> :ok
+          :finish_processing_message -> :ok
         end
       end
 
-      {:ok, sub1} = TestSubscriber.start_link(on_event)
-      {:ok, sub2} = TestSubscriber.start_link(on_event)
+      {:ok, sub1} = TestSubscriber.start_link(on_message)
+      {:ok, sub2} = TestSubscriber.start_link(on_message)
 
       pid = self()
 
@@ -72,12 +83,15 @@ defmodule Electric.PublisherTest do
         send(pid, :publish_finished)
       end)
 
+      assert_receive :message_received
+      assert_receive :message_received
+
       refute_receive :publish_finished, 10
       Process.unlink(sub2)
       Process.exit(sub2, :kill)
       refute_receive :publish_finished, 10
-      send(sub1, :finish_processing_event)
-      assert_receive :publish_finished, 5000
+      send(sub1, :finish_processing_message)
+      assert_receive :publish_finished
     end
   end
 end