Clean up docs and tests for "mix sentry.send_test_event" (#610)

Author: whatyouhide

lib/mix/tasks/sentry.send_test_event.ex

@@ -2,79 +2,88 @@ defmodule Mix.Tasks.Sentry.SendTestEvent do
   use Mix.Task
   alias Sentry.Config
 
-  @shortdoc "Attempts to send a test event to check Sentry configuration"
+  @shortdoc "Attempts to send a test event to check the Sentry configuration"
+
   @moduledoc """
-  Send test even to check if Sentry configuration is correct.
+  Send test event to check if Sentry configuration is correct.
+
+  ## Options
+
+    * `--no-compile` - does not compile, even if files require compilation.
+
   """
 
-  def run(args) do
+  @impl true
+  def run(args) when is_list(args) do
     unless "--no-compile" in args do
       Mix.Task.run("compile", args)
     end
 
-    Application.ensure_all_started(:sentry)
+    case Application.ensure_all_started(:sentry) do
+      {:ok, _apps} ->
+        :ok
+
+      {:error, reason} ->
+        Mix.raise("Failed to start the :sentry application:\n\n#{inspect(reason)}")
+    end
 
-    Sentry.Transport.get_dsn()
-    |> print_environment_info()
+    included_environments =
+      case Application.fetch_env(:sentry, :included_environments) do
+        {:ok, envs} when is_list(envs) or envs == :all ->
+          envs
+
+        :error ->
+          Mix.raise("""
+          The :included_environments application configuration option is not configured for the \
+          :sentry application.
+          """)
+      end
+
+    print_environment_info(Sentry.Transport.get_dsn(), included_environments)
+
+    env_name = to_string(Config.environment_name())
 
-    maybe_send_event()
+    if included_environments == :all or env_name in included_environments do
+      send_event()
+    else
+      Mix.shell().info([
+        :yellow,
+        "#{inspect(env_name)} is not in #{inspect(included_environments)} so no test event will be sent"
+      ])
+    end
   end
 
-  defp print_environment_info({endpoint, public_key, secret_key}) do
+  defp print_environment_info({endpoint, public_key, secret_key}, included_environments) do
     Mix.shell().info("Client configuration:")
     Mix.shell().info("server: #{endpoint}")
     Mix.shell().info("public_key: #{public_key}")
     Mix.shell().info("secret_key: #{secret_key}")
-    Mix.shell().info("included_environments: #{inspect(included_environments())}")
+    Mix.shell().info("included_environments: #{inspect(included_environments)}")
     Mix.shell().info("current environment_name: #{inspect(to_string(Config.environment_name()))}")
     Mix.shell().info("hackney_opts: #{inspect(Config.hackney_opts())}\n")
   end
 
-  defp included_environments do
-    case Application.fetch_env(:sentry, :included_environments) do
-      {:ok, envs} when is_list(envs) or envs == :all ->
-        envs
-
-      _ ->
-        Mix.raise(
-          "Sentry included_environments is not configured in :sentry, :included_environments"
-        )
-    end
-  end
+  defp send_event do
+    Mix.shell().info("Sending test event...")
 
-  defp maybe_send_event do
-    env_name = to_string(Config.environment_name())
-    included_envs = included_environments()
+    exception = %RuntimeError{message: "Testing sending Sentry event"}
+    {:current_stacktrace, stacktrace} = Process.info(self(), :current_stacktrace)
 
-    if included_envs == :all or env_name in included_envs do
-      Mix.shell().info("Sending test event...")
+    case Sentry.capture_exception(exception, result: :sync, stacktrace: stacktrace) do
+      {:ok, id} ->
+        Mix.shell().info([:green, :bright, "Test event sent", :reset, "\nEvent ID: #{id}"])
 
-      {:current_stacktrace, stacktrace} = Process.info(self(), :current_stacktrace)
+      {:error, reason} ->
+        Mix.raise("Error sending event:\n\n#{inspect(reason)}")
 
-      result =
-        "Testing sending Sentry event"
-        |> RuntimeError.exception()
-        |> Sentry.capture_exception(result: :sync, stacktrace: stacktrace)
+      :excluded ->
+        Mix.shell().info("No test event was sent because the event was excluded by a filter")
 
-      case result do
-        {:ok, id} ->
-          Mix.shell().info("Test event sent!  Event ID: #{id}")
-
-        {:error, reason} ->
-          Mix.shell().info("Error sending event: #{inspect(reason)}")
-
-        :excluded ->
-          Mix.shell().info("No test event was sent because the event was excluded by a filter")
-
-        :unsampled ->
-          Mix.shell().info(
-            "No test event was sent because the event was excluded according to the sample_rate"
-          )
-      end
-    else
-      Mix.shell().info(
-        "#{inspect(env_name)} is not in #{inspect(included_envs)} so no test event will be sent"
-      )
+      :unsampled ->
+        Mix.shell().info("""
+        No test event was sent because the event was excluded according to the :sample_rate \
+        configuration option.
+        """)
     end
   end
 end

test/mix/sentry.send_test_event_test.exs

@@ -1,25 +1,28 @@
 defmodule Mix.Tasks.Sentry.SendTestEventTest do
   use ExUnit.Case
+
   import ExUnit.CaptureIO
-  import ExUnit.CaptureLog
   import Sentry.TestEnvironmentHelper
 
   test "prints if environment_name is not in included_environments" do
     modify_env(:sentry, dsn: "http://public:secret@localhost:43/1", included_environments: [])
 
-    assert capture_io(fn ->
-             Mix.Tasks.Sentry.SendTestEvent.run([])
-           end) == """
+    output =
+      capture_io(fn ->
+        Mix.Tasks.Sentry.SendTestEvent.run([])
+      end)
+
+    assert output =~ """
            Client configuration:
            server: http://localhost:43/api/1/envelope/
            public_key: public
            secret_key: secret
            included_environments: []
            current environment_name: "test"
            hackney_opts: [recv_timeout: 50]
-
-           "test" is not in [] so no test event will be sent
            """
+
+    assert output =~ ~s("test" is not in [] so no test event will be sent)
   end
 
   test "sends event successfully when configured to" do
@@ -39,22 +42,27 @@ defmodule Mix.Tasks.Sentry.SendTestEventTest do
       included_environments: :all
     )
 
-    assert capture_io(fn ->
-             Mix.Tasks.Sentry.SendTestEvent.run([])
-           end) == """
+    output =
+      capture_io(fn ->
+        Mix.Tasks.Sentry.SendTestEvent.run([])
+      end)
+
+    assert output =~ """
            Client configuration:
            server: http://localhost:#{bypass.port}/api/1/envelope/
            public_key: public
            secret_key: secret
            included_environments: :all
            current environment_name: "test"
            hackney_opts: [recv_timeout: 50]
-
-           Sending test event...
-           Test event sent!  Event ID: 340
            """
+
+    assert output =~ "Sending test event..."
+    assert output =~ "Test event sent"
+    assert output =~ "Event ID: 340"
   end
 
+  @tag :capture_log
   test "handles error when Sentry server is failing" do
     bypass = Bypass.open()
 
@@ -68,21 +76,8 @@ defmodule Mix.Tasks.Sentry.SendTestEventTest do
       request_retries: []
     )
 
-    assert capture_log(fn ->
-             assert capture_io(fn ->
-                      Mix.Tasks.Sentry.SendTestEvent.run([])
-                    end) == """
-                    Client configuration:
-                    server: http://localhost:#{bypass.port}/api/1/envelope/
-                    public_key: public
-                    secret_key: secret
-                    included_environments: ["test"]
-                    current environment_name: "test"
-                    hackney_opts: [recv_timeout: 50]
-
-                    Sending test event...
-                    Error sending event: {:request_failure, "Received 500 from Sentry server: "}
-                    """
-           end) =~ "Failed to send Sentry event"
+    assert_raise Mix.Error, ~r/Error sending event/, fn ->
+      capture_io(fn -> Mix.Tasks.Sentry.SendTestEvent.run([]) end)
+    end
   end
 end