fix(tests): accept nil as the DSN value again

Author: solnic

lib/sentry.ex

@@ -380,12 +380,6 @@ defmodule Sentry do
         ClientReport.Sender.record_discarded_events(:event_processor, [event])
         :ignored
 
-      !Config.dsn() ->
-        # We still validate options even if we're not sending the event. This aims at catching
-        # configuration issues during development instead of only when deploying to production.
-        _options = NimbleOptions.validate!(options, Options.send_event_schema())
-        :ignored
-
       included_envs == :all or to_string(Config.environment_name()) in included_envs ->
         Client.send_event(event, options)
 
@@ -399,12 +393,6 @@ defmodule Sentry do
     included_envs = Config.included_environments()
 
     cond do
-      !Config.dsn() ->
-        # We still validate options even if we're not sending the event. This aims at catching
-        # configuration issues during development instead of only when deploying to production.
-        _options = NimbleOptions.validate!(options, Options.send_event_schema())
-        :ignored
-
       included_envs == :all or to_string(Config.environment_name()) in included_envs ->
         Client.send_transaction(transaction, options)
 
@@ -458,13 +446,9 @@ defmodule Sentry do
   @spec capture_check_in(keyword()) ::
           {:ok, check_in_id :: String.t()} | :ignored | {:error, ClientError.t()}
   def capture_check_in(options) when is_list(options) do
-    if Config.dsn() do
-      options
-      |> CheckIn.new()
-      |> Client.send_check_in(options)
-    else
-      :ignored
-    end
+    options
+    |> CheckIn.new()
+    |> Client.send_check_in(options)
   end
 
   @doc ~S"""

lib/sentry/client.ex

@@ -27,30 +27,35 @@ defmodule Sentry.Client do
   @max_message_length 8_192
 
   @spec send_check_in(CheckIn.t(), keyword()) ::
-          {:ok, check_in_id :: String.t()} | {:error, ClientError.t()}
+          {:ok, check_in_id :: String.t()} | :ignored | {:error, ClientError.t()}
   def send_check_in(%CheckIn{} = check_in, opts) when is_list(opts) do
-    if Config.telemetry_processor_category?(:check_in) do
-      case TelemetryProcessor.add(check_in) do
-        {:ok, {:rate_limited, data_category}} ->
-          ClientReport.Sender.record_discarded_events(:ratelimit_backoff, data_category)
+    cond do
+      is_nil(Config.dsn()) ->
+        :ignored
 
-        :ok ->
-          :ok
-      end
+      Config.telemetry_processor_category?(:check_in) ->
+        case TelemetryProcessor.add(check_in) do
+          {:ok, {:rate_limited, data_category}} ->
+            ClientReport.Sender.record_discarded_events(:ratelimit_backoff, data_category)
 
-      {:ok, check_in.check_in_id}
-    else
-      client = Keyword.get_lazy(opts, :client, &Config.client/0)
+          :ok ->
+            :ok
+        end
 
-      # This is a "private" option, only really used in testing.
-      request_retries =
-        Keyword.get_lazy(opts, :request_retries, fn ->
-          Application.get_env(:sentry, :request_retries, Transport.default_retries())
-        end)
+        {:ok, check_in.check_in_id}
+
+      true ->
+        client = Keyword.get_lazy(opts, :client, &Config.client/0)
 
-      check_in
-      |> Envelope.from_check_in()
-      |> Transport.encode_and_post_envelope(client, request_retries)
+        # This is a "private" option, only really used in testing.
+        request_retries =
+          Keyword.get_lazy(opts, :request_retries, fn ->
+            Application.get_env(:sentry, :request_retries, Transport.default_retries())
+          end)
+
+        check_in
+        |> Envelope.from_check_in()
+        |> Transport.encode_and_post_envelope(client, request_retries)
     end
   end
 
@@ -59,6 +64,7 @@ defmodule Sentry.Client do
   @spec send_event(Event.t(), keyword()) ::
           {:ok, event_id :: String.t()}
           | {:error, ClientError.t()}
+          | :ignored
           | :unsampled
           | :excluded
   def send_event(%Event{} = event, opts) when is_list(opts) do
@@ -79,7 +85,8 @@ defmodule Sentry.Client do
     result =
       with {:ok, %Event{} = event} <- maybe_call_before_send(event, before_send),
            :ok <- sample_event(sample_rate),
-           :ok <- maybe_dedupe(event) do
+           :ok <- maybe_dedupe(event),
+           :ok <- ensure_dsn_configured() do
         send_result = encode_and_send(event, result_type, client, request_retries)
         _ignored = maybe_call_after_send(event, send_result, after_send_event)
         send_result
@@ -99,6 +106,9 @@ defmodule Sentry.Client do
       :excluded ->
         :excluded
 
+      :ignored ->
+        :ignored
+
       {:error, %ClientError{} = error} ->
         {:error, error}
     end
@@ -120,6 +130,7 @@ defmodule Sentry.Client do
   @spec send_transaction(Transaction.t(), keyword()) ::
           {:ok, transaction_id :: String.t()}
           | {:error, ClientError.t()}
+          | :ignored
           | :excluded
   def send_transaction(%Transaction{} = transaction, opts \\ []) do
     opts = NimbleOptions.validate!(opts, Options.send_transaction_schema())
@@ -134,16 +145,24 @@ defmodule Sentry.Client do
         Application.get_env(:sentry, :request_retries, Transport.default_retries())
       end)
 
-    with {:ok, %Transaction{} = transaction} <- maybe_call_before_send(transaction, before_send) do
+    with {:ok, %Transaction{} = transaction} <- maybe_call_before_send(transaction, before_send),
+         :ok <- ensure_dsn_configured() do
       send_result = encode_and_send(transaction, result_type, client, request_retries)
       _ignored = maybe_call_after_send(transaction, send_result, after_send_event)
       send_result
     else
       :excluded ->
         :excluded
+
+      :ignored ->
+        :ignored
     end
   end
 
+  defp ensure_dsn_configured do
+    if Config.dsn(), do: :ok, else: :ignored
+  end
+
   defp sample_event(sample_rate) do
     cond do
       sample_rate == 1 -> :ok

test/sentry_test.exs

@@ -136,6 +136,35 @@ defmodule SentryTest do
     assert :ignored = Sentry.send_event(event)
   end
 
+  describe "with test_mode: true and dsn: nil" do
+    setup do
+      put_test_config(dsn: nil)
+      :ok
+    end
+
+    test "capture_exception/2 still routes events to the test collector" do
+      assert :ignored = Sentry.capture_exception(%RuntimeError{message: "boom"})
+
+      assert [%Sentry.Event{} = event] = Sentry.Test.pop_sentry_reports()
+      assert [%Sentry.Interfaces.Exception{type: "RuntimeError", value: "boom"}] = event.exception
+    end
+
+    test "capture_message/2 still routes events to the test collector" do
+      assert :ignored = Sentry.capture_message("hello world")
+
+      assert [%Sentry.Event{} = event] = Sentry.Test.pop_sentry_reports()
+      assert event.message.formatted == "hello world"
+    end
+
+    test "send_transaction/2 still routes transactions to the test collector" do
+      transaction = create_transaction()
+
+      assert :ignored = Sentry.send_transaction(transaction)
+
+      assert [%Sentry.Transaction{}] = Sentry.Test.pop_sentry_transactions()
+    end
+  end
+
   describe "send_check_in/1" do
     test "posts a check-in with all the explicit arguments", %{bypass: bypass} do
       put_test_config(environment_name: "test", release: "1.3.2")