Bump nimble_ownership dep to make testing better (#700)

Author: whatyouhide

lib/sentry/test.ex

@@ -64,6 +64,8 @@ defmodule Sentry.Test do
   @spec maybe_collect(Sentry.Event.t()) :: :collected | :not_collecting
   def maybe_collect(%Sentry.Event{} = event) do
     if Sentry.Config.test_mode?() do
+      ensure_ownership_server_started()
+
       case NimbleOwnership.fetch_owner(@server, callers(), @key) do
         {:ok, owner_pid} ->
           result =
@@ -102,24 +104,77 @@ defmodule Sentry.Test do
 
       setup :start_collecting_sentry_reports
 
+  For a more flexible way to start collecting events, see `start_collecting/1`.
   """
   @doc since: "10.2.0"
   @spec start_collecting_sentry_reports(map()) :: :ok
   def start_collecting_sentry_reports(_context \\ %{}) do
+    start_collecting()
+  end
+
+  @doc """
+  Starts collecting events.
+
+  This function starts collecting events reported from the given (*owner*) process. If you want to
+  allow other processes to report events, you need to *allow* them to report events back
+  to the owner process. See `allow/2` for more information on allowances. If the owner
+  process is already *allowed by another process*, this function raises an error.
+
+  ## Options
+
+    * `:owner` - the PID of the owner process that will collect the events. Defaults to `self/0`.
+
+    * `:cleanup` - a boolean that controls whether collected resources around the owner process
+      should be cleaned up when the owner process exits. Defaults to `true`. If `false`, you'll
+      need to manually call `cleanup/1` to clean up the resources.
+
+  ## Examples
+
+  The `:cleanup` option can be used to implement expectation-based tests, akin to something
+  like [`Mox.expect/4`](https://hexdocs.pm/mox/1.1.0/Mox.html#expect/4).
+
+      test "implementing an expectation-based test workflow" do
+        test_pid = self()
+
+        Test.start_collecting(owner: test_pid, cleanup: false)
+
+        on_exit(fn ->
+          assert [%Event{} = event] = Test.pop_sentry_reports(test_pid)
+          assert event.message.formatted == "Oops"
+          assert :ok = Test.cleanup(test_pid)
+        end)
+
+        assert {:ok, ""} = Sentry.capture_message("Oops")
+      end
+
+  """
+  @doc since: "10.2.0"
+  @spec start_collecting(keyword()) :: :ok
+  def start_collecting(options \\ []) when is_list(options) do
+    owner_pid = Keyword.get(options, :owner, self())
+    cleanup? = Keyword.get(options, :cleanup, true)
+
+    callers =
+      if owner_pid == self() do
+        callers()
+      else
+        [owner_pid]
+      end
+
     # Make sure the ownership server is started (this is idempotent).
     ensure_ownership_server_started()
 
-    case NimbleOwnership.fetch_owner(@server, callers(), @key) do
+    case NimbleOwnership.fetch_owner(@server, callers, @key) do
       # No-op
-      {tag, owner_pid} when tag in [:ok, :shared_owner] and owner_pid == self() ->
+      {tag, ^owner_pid} when tag in [:ok, :shared_owner] ->
         :ok
 
-      {:shared_owner, _pid} ->
+      {:shared_owner, _other_pid} ->
         raise ArgumentError,
               "Sentry.Test is in global mode and is already collecting reported events"
 
-      {:ok, another_pid} ->
-        raise ArgumentError, "already collecting reported events from #{inspect(another_pid)}"
+      {:ok, other_pid} ->
+        raise ArgumentError, "already collecting reported events from #{inspect(other_pid)}"
 
       :error ->
         :ok
@@ -130,9 +185,25 @@ defmodule Sentry.Test do
         {:ignored, events || []}
       end)
 
+    if not cleanup? do
+      :ok = NimbleOwnership.set_owner_to_manual_cleanup(@server, owner_pid)
+    end
+
     :ok
   end
 
+  @doc """
+  Cleans up test resources associated with `owner_pid`.
+
+  See the `:cleanup` option in `start_collecting/1` and the corresponding
+  example for more information.
+  """
+  @doc since: "10.2.0"
+  @spec cleanup(pid()) :: :ok
+  def cleanup(owner_pid) when is_pid(owner_pid) do
+    :ok = NimbleOwnership.cleanup_owner(@server, owner_pid)
+  end
+
   @doc """
   Allows `pid_to_allow` to collect events back to the root process via `owner_pid`.
 
@@ -180,17 +251,22 @@ defmodule Sentry.Test do
 
   """
   @doc since: "10.2.0"
-  @spec pop_sentry_reports() :: [Sentry.Event.t()]
-  def pop_sentry_reports do
+  @spec pop_sentry_reports(pid()) :: [Sentry.Event.t()]
+  def pop_sentry_reports(owner_pid \\ self()) when is_pid(owner_pid) do
     result =
-      NimbleOwnership.get_and_update(@server, self(), @key, fn
-        nil -> {:not_collecting, []}
-        events when is_list(events) -> {events, []}
-      end)
+      try do
+        NimbleOwnership.get_and_update(@server, owner_pid, @key, fn
+          nil -> {:not_collecting, []}
+          events when is_list(events) -> {events, []}
+        end)
+      catch
+        :exit, {:noproc, _} ->
+          raise ArgumentError, "not collecting reported events from #{inspect(owner_pid)}"
+      end
 
     case result do
       {:ok, :not_collecting} ->
-        raise ArgumentError, "not collecting reported events from #{inspect(self())}"
+        raise ArgumentError, "not collecting reported events from #{inspect(owner_pid)}"
 
       {:ok, events} ->
         events
@@ -203,7 +279,7 @@ defmodule Sentry.Test do
   ## Helpers
 
   defp ensure_ownership_server_started do
-    case NimbleOwnership.start_link(name: @server) do
+    case Supervisor.start_child(Sentry.Supervisor, NimbleOwnership.child_spec(name: @server)) do
       {:ok, pid} ->
         pid
 

mix.exs

@@ -82,7 +82,7 @@ defmodule Sentry.Mixfile do
   defp deps do
     [
       {:nimble_options, "~> 1.0"},
-      {:nimble_ownership, "~> 0.2.0"},
+      {:nimble_ownership, "~> 0.3.0"},
 
       # Optional dependencies
       {:hackney, "~> 1.8", optional: true},

mix.lock

@@ -25,7 +25,7 @@
   "mime": {:hex, :mime, "1.5.0", "203ef35ef3389aae6d361918bf3f952fa17a09e8e43b5aa592b93eba05d0fb8d", [:mix], [], "hexpm", "55a94c0f552249fc1a3dd9cd2d3ab9de9d3c89b559c2bd01121f824834f24746"},
   "mimerl": {:hex, :mimerl, "1.2.0", "67e2d3f571088d5cfd3e550c383094b47159f3eee8ffa08e64106cdf5e981be3", [:rebar3], [], "hexpm", "f278585650aa581986264638ebf698f8bb19df297f66ad91b18910dfc6e19323"},
   "nimble_options": {:hex, :nimble_options, "1.0.2", "92098a74df0072ff37d0c12ace58574d26880e522c22801437151a159392270e", [:mix], [], "hexpm", "fd12a8db2021036ce12a309f26f564ec367373265b53e25403f0ee697380f1b8"},
-  "nimble_ownership": {:hex, :nimble_ownership, "0.2.1", "3e44c72ebe8dd213db4e13aff4090aaa331d158e72ce1891d02e0ffb05a1eb2d", [:mix], [], "hexpm", "bf38d2ef4fb990521a4ecf112843063c1f58a5c602484af4c7977324042badee"},
+  "nimble_ownership": {:hex, :nimble_ownership, "0.3.0", "29514f8779b26f50f9c07109677c98c0cc0b8025e89f82964dafa9cf7d657ec0", [:mix], [], "hexpm", "76c605106bc1e60f5b028b20203a1e0c90b4350b08e4b8a33f68bb50dcb6e837"},
   "nimble_parsec": {:hex, :nimble_parsec, "1.3.1", "2c54013ecf170e249e9291ed0a62e5832f70a476c61da16f6aac6dca0189f2af", [:mix], [], "hexpm", "2682e3c0b2eb58d90c6375fc0cc30bc7be06f365bf72608804fb9cffa5e1b167"},
   "oban": {:hex, :oban, "2.17.6", "bac1dacd836edbf6a200ddd880db10faa2d39bb2e550ec6d19b3eb9c43852c2a", [:mix], [{:ecto_sql, "~> 3.10", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:ecto_sqlite3, "~> 0.9", [hex: :ecto_sqlite3, repo: "hexpm", optional: true]}, {:jason, "~> 1.1", [hex: :jason, repo: "hexpm", optional: false]}, {:postgrex, "~> 0.16", [hex: :postgrex, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "623f3554212e9a776e015156c47f076d66c7b74115ac47a7d3acba0294e65acb"},
   "parse_trans": {:hex, :parse_trans, "3.3.1", "16328ab840cc09919bd10dab29e431da3af9e9e7e7e6f0089dd5a2d2820011d8", [:rebar3], [], "hexpm", "07cd9577885f56362d414e8c4c4e6bdf10d43a8767abb92d24cbe8b24c54888b"},

test/sentry/test_test.exs

@@ -1,5 +1,5 @@
 defmodule Sentry.TestTest do
-  use ExUnit.Case, async: true
+  use ExUnit.Case, async: false
 
   import Sentry.TestHelpers
 
@@ -174,4 +174,18 @@ defmodule Sentry.TestTest do
     assert [%Event{} = event] = Test.pop_sentry_reports()
     assert event.message.formatted == "Oops from parent process"
   end
+
+  test "implementing an expectation-based test workflow" do
+    test_pid = self()
+
+    Test.start_collecting(owner: test_pid, cleanup: false)
+
+    on_exit(fn ->
+      assert [%Event{} = event] = Test.pop_sentry_reports(test_pid)
+      assert event.message.formatted == "Oops"
+      assert :ok = Test.cleanup(test_pid)
+    end)
+
+    assert {:ok, ""} = Sentry.capture_message("Oops")
+  end
 end