refa(tests): simplify oban integration test

Author: solnic

test_integrations/phoenix_app/test/phoenix_app/oban_test.exs

@@ -3,17 +3,15 @@ defmodule Sentry.Integrations.Phoenix.ObanTest do
   use Oban.Testing, repo: PhoenixApp.Repo
 
   import ExUnit.CaptureLog
+  import Sentry.Test.Assertions
   import Sentry.TestHelpers
 
   require OpenTelemetry.Tracer
 
   alias Sentry.Integrations.Oban.ErrorReporter
 
   setup do
-    %{bypass: bypass} = setup_bypass(traces_sample_rate: 1.0)
-    ref = setup_bypass_envelope_collector(bypass)
-
-    %{bypass: bypass, ref: ref}
+    Sentry.Test.setup_sentry(collect_envelopes: true, traces_sample_rate: 1.0)
   end
 
   defmodule TestWorker do
@@ -47,43 +45,29 @@ defmodule Sentry.Integrations.Phoenix.ObanTest do
     end
   end
 
-  test "captures Oban worker execution as transaction", %{ref: ref} do
+  test "captures Oban worker execution as transaction" do
     :ok = perform_job(TestWorker, %{test: "args"})
 
-    envelopes = collect_envelopes(ref, 1)
-    transactions = extract_transactions(envelopes)
-    assert length(transactions) == 1
-
-    [tx] = transactions
+    tx =
+      assert_sentry_report(:transaction,
+        transaction: "Sentry.Integrations.Phoenix.ObanTest.TestWorker",
+        transaction_info: %{source: :custom}
+      )
 
-    assert tx["transaction"] == "Sentry.Integrations.Phoenix.ObanTest.TestWorker"
-    assert tx["transaction_info"] == %{"source" => "custom"}
+    trace = tx.contexts.trace
+    assert trace.origin == "opentelemetry_oban"
+    assert trace.op == "queue.process"
+    assert trace.description == "Sentry.Integrations.Phoenix.ObanTest.TestWorker"
+    assert trace.data["oban.job.job_id"]
+    assert trace.data["messaging.destination.name"] == "default"
+    assert trace.data["oban.job.attempt"] == 1
 
-    trace = tx["contexts"]["trace"]
-    assert trace["origin"] == "opentelemetry_oban"
-    assert trace["op"] == "queue.process"
-    assert trace["description"] == "Sentry.Integrations.Phoenix.ObanTest.TestWorker"
-    assert trace["data"]["oban.job.job_id"]
-    assert trace["data"]["messaging.destination.name"] == "default"
-    assert trace["data"]["oban.job.attempt"] == 1
-
-    assert tx["spans"] == []
+    assert tx.spans == []
   end
 
-  test "captures Oban worker with trace links", %{bypass: bypass} do
+  test "captures Oban worker with trace links", %{ref: ref} do
     # This test verifies that when an Oban job is inserted within an active trace,
     # the consumer span has links back to the producer span.
-    test_pid = self()
-
-    Bypass.stub(bypass, "POST", "/api/1/envelope/", fn conn ->
-      {:ok, body, conn} = Plug.Conn.read_body(conn)
-
-      for {headers, body_json} <- decode_envelope!(body) do
-        send(test_pid, {headers["type"], body_json})
-      end
-
-      Plug.Conn.send_resp(conn, 200, ~s<{"id": "340"}>)
-    end)
 
     # Insert within an active span so trace context is propagated into job metadata
     OpenTelemetry.Tracer.with_span "test.request" do
@@ -96,9 +80,8 @@ defmodule Sentry.Integrations.Phoenix.ObanTest do
     # Drain the queue to execute the job
     Oban.drain_queue(queue: :default)
 
-    # Multiple transactions are sent (test.request, DB queries, Oban consumer),
-    # so we need to find the Oban consumer transaction specifically
-    oban_tx = receive_oban_transaction()
+    transactions = collect_sentry_transactions(ref, 100, timeout: 500)
+    oban_tx = find_sentry_report!(transactions, contexts: %{trace: %{origin: "opentelemetry_oban"}})
 
     trace = oban_tx["contexts"]["trace"]
     assert trace["op"] == "queue.process"
@@ -116,70 +99,34 @@ defmodule Sentry.Integrations.Phoenix.ObanTest do
     end
   end
 
-  test "captures Oban worker with child spans", %{ref: ref} do
+  test "captures Oban worker with child spans" do
     :ok = perform_job(WorkerWithDatabaseQuery, %{})
 
-    envelopes = collect_envelopes(ref, 1)
-    transactions = extract_transactions(envelopes)
-    assert length(transactions) == 1
-
-    [tx] = transactions
-
-    assert tx["transaction"] ==
-             "Sentry.Integrations.Phoenix.ObanTest.WorkerWithDatabaseQuery"
-
-    # Should have child spans from the database query
-    assert length(tx["spans"]) > 0
+    tx =
+      assert_sentry_report(:transaction,
+        transaction: "Sentry.Integrations.Phoenix.ObanTest.WorkerWithDatabaseQuery"
+      )
 
-    # Verify at least one db span exists
-    assert Enum.any?(tx["spans"], fn span ->
-             span["op"] == "db"
-           end)
-  end
+    assert length(tx.spans) > 0
 
-  defp receive_oban_transaction do
-    receive do
-      {"transaction", tx} ->
-        if tx["contexts"]["trace"]["origin"] == "opentelemetry_oban" do
-          tx
-        else
-          receive_oban_transaction()
-        end
-    after
-      2000 -> flunk("expected an Oban consumer transaction")
-    end
+    assert Enum.any?(tx.spans, fn span -> span.op == "db" end)
   end
 
   describe "should_report_error_callback config" do
-    setup %{bypass: bypass} do
+    setup do
       :telemetry.detach(ErrorReporter)
 
-      ref = setup_bypass_envelope_collector(bypass, type: "event")
-
       on_exit(fn ->
         _ = :telemetry.detach(ErrorReporter)
         ErrorReporter.attach([])
       end)
 
-        %{ref: ref}
-      end
+      :ok
+    end
 
-    test "skips error reporting when callback returns false", %{bypass: bypass, ref: ref} do
+    test "skips error reporting when callback returns false" do
       test_pid = self()
 
-      # Allow transaction envelopes through but assert no error events are sent
-      Bypass.stub(bypass, "POST", "/api/1/envelope/", fn conn ->
-        {:ok, body, conn} = Plug.Conn.read_body(conn)
-        items = decode_envelope!(body)
-
-        for {headers, _body} <- items do
-          assert headers["type"] != "event",
-                 "Should not send error events when callback returns false"
-        end
-
-        Plug.Conn.send_resp(conn, 200, ~s<{"id": "340"}>)
-      end)
-
       ErrorReporter.attach(
         should_report_error_callback: fn worker, job ->
           send(test_pid, {:callback_invoked, worker, job})
@@ -199,11 +146,10 @@ defmodule Sentry.Integrations.Phoenix.ObanTest do
       assert %Oban.Job{} = received_job
       assert received_job.args == %{"should_fail" => true}
 
-      envelopes = collect_envelopes(ref, 10, timeout: 500)
-      assert extract_events(envelopes) == []
+      assert [] == Sentry.Test.pop_sentry_reports()
     end
 
-    test "reports error when callback returns true", %{ref: ref} do
+    test "reports error when callback returns true" do
       test_pid = self()
 
       ErrorReporter.attach(
@@ -222,18 +168,16 @@ defmodule Sentry.Integrations.Phoenix.ObanTest do
 
       assert_receive {:callback_invoked, _worker, _job}
 
-      envelopes = collect_envelopes(ref, 10, timeout: 500)
-      events = extract_events(envelopes)
-      assert [event] = events
-
-      assert [%{"type" => "RuntimeError", "value" => "intentional failure for testing"} | _] =
-               event["exception"]
+      event =
+        find_sentry_report!(Sentry.Test.pop_sentry_reports(),
+          tags: %{oban_worker: "Sentry.Integrations.Phoenix.ObanTest.FailingWorker"}
+        )
 
-      assert event["tags"]["oban_worker"] ==
-               "Sentry.Integrations.Phoenix.ObanTest.FailingWorker"
+      assert [%Sentry.Interfaces.Exception{type: "RuntimeError", value: "intentional failure for testing"} | _] =
+               event.exception
     end
 
-    test "callback receives worker module and full job struct", %{ref: ref} do
+    test "callback receives worker module and full job struct" do
       test_pid = self()
 
       ErrorReporter.attach(
@@ -262,27 +206,11 @@ defmodule Sentry.Integrations.Phoenix.ObanTest do
       assert job.max_attempts == 3
       assert is_integer(job.attempt)
       assert is_integer(job.id)
-
-      # Drain envelopes to avoid Bypass errors
-      collect_envelopes(ref, 10, timeout: 500)
     end
 
-    test "callback can make decisions based on attempt number", %{bypass: bypass, ref: ref} do
+    test "callback can make decisions based on attempt number" do
       test_pid = self()
 
-      # Allow transaction envelopes through but assert no error events are sent
-      Bypass.stub(bypass, "POST", "/api/1/envelope/", fn conn ->
-        {:ok, body, conn} = Plug.Conn.read_body(conn)
-        items = decode_envelope!(body)
-
-        for {headers, _body} <- items do
-          assert headers["type"] != "event",
-                 "Should not send error events when callback returns false"
-        end
-
-        Plug.Conn.send_resp(conn, 200, ~s<{"id": "340"}>)
-      end)
-
       ErrorReporter.attach(
         should_report_error_callback: fn _worker, job ->
           should_report = job.attempt >= job.max_attempts
@@ -303,11 +231,10 @@ defmodule Sentry.Integrations.Phoenix.ObanTest do
       assert max_attempts == 3
       assert should_report == false
 
-      envelopes = collect_envelopes(ref, 10, timeout: 500)
-      assert extract_events(envelopes) == []
+      assert [] == Sentry.Test.pop_sentry_reports()
     end
 
-    test "handles callback errors gracefully and defaults to reporting", %{ref: ref} do
+    test "handles callback errors gracefully and defaults to reporting" do
       log =
         capture_log(fn ->
           ErrorReporter.attach(
@@ -328,15 +255,16 @@ defmodule Sentry.Integrations.Phoenix.ObanTest do
       assert log =~ "FailingWorker"
       assert log =~ "callback crashed!"
 
-      envelopes = collect_envelopes(ref, 10, timeout: 500)
-      events = extract_events(envelopes)
-      assert [event] = events
+      event =
+        find_sentry_report!(Sentry.Test.pop_sentry_reports(),
+          tags: %{oban_worker: "Sentry.Integrations.Phoenix.ObanTest.FailingWorker"}
+        )
 
-      assert [%{"type" => "RuntimeError", "value" => "intentional failure for testing"} | _] =
-               event["exception"]
+      assert [%Sentry.Interfaces.Exception{type: "RuntimeError", value: "intentional failure for testing"} | _] =
+               event.exception
     end
 
-    test "reports error when no callback is configured", %{ref: ref} do
+    test "reports error when no callback is configured" do
       ErrorReporter.attach([])
 
       {:ok, _job} =
@@ -346,30 +274,18 @@ defmodule Sentry.Integrations.Phoenix.ObanTest do
 
       Oban.drain_queue(queue: :default)
 
-      envelopes = collect_envelopes(ref, 10, timeout: 500)
-      events = extract_events(envelopes)
-      assert [event] = events
+      event =
+        find_sentry_report!(Sentry.Test.pop_sentry_reports(),
+          tags: %{oban_worker: "Sentry.Integrations.Phoenix.ObanTest.FailingWorker"}
+        )
 
-      assert [%{"type" => "RuntimeError", "value" => "intentional failure for testing"} | _] =
-               event["exception"]
+      assert [%Sentry.Interfaces.Exception{type: "RuntimeError", value: "intentional failure for testing"} | _] =
+               event.exception
     end
 
-    test "callback can filter based on worker type", %{bypass: bypass, ref: ref} do
+    test "callback can filter based on worker type" do
       test_pid = self()
 
-      # Allow transaction envelopes through but assert no error events are sent
-      Bypass.stub(bypass, "POST", "/api/1/envelope/", fn conn ->
-        {:ok, body, conn} = Plug.Conn.read_body(conn)
-        items = decode_envelope!(body)
-
-        for {headers, _body} <- items do
-          assert headers["type"] != "event",
-                 "Should not send error events when callback returns false"
-        end
-
-        Plug.Conn.send_resp(conn, 200, ~s<{"id": "340"}>)
-      end)
-
       ErrorReporter.attach(
         should_report_error_callback: fn worker, _job ->
           should_report = worker != FailingWorker
@@ -387,11 +303,10 @@ defmodule Sentry.Integrations.Phoenix.ObanTest do
 
       assert_receive {:worker_check, FailingWorker, false}
 
-      envelopes = collect_envelopes(ref, 10, timeout: 500)
-      assert extract_events(envelopes) == []
+      assert [] == Sentry.Test.pop_sentry_reports()
     end
 
-    test "callback receives nil and logs warning for non-existent worker module", %{ref: ref} do
+    test "callback receives nil and logs warning for non-existent worker module" do
       test_pid = self()
 
       log =
@@ -432,10 +347,12 @@ defmodule Sentry.Integrations.Phoenix.ObanTest do
       assert worker == nil
       assert received_job.worker == "NonExistent.Worker.Module"
 
-      envelopes = collect_envelopes(ref, 1)
-      events = extract_events(envelopes)
-      assert [event] = events
-      assert event["tags"]["oban_worker"] == "NonExistent.Worker.Module"
+      event =
+        assert_sentry_report(:event,
+          tags: %{oban_worker: "NonExistent.Worker.Module"}
+        )
+
+      assert event.tags[:oban_worker] == "NonExistent.Worker.Module"
     end
   end