exception_notification 4.3.0 → 4.5.0

data/test/exception_notifier/modules/formatter_test.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'timecop'
+
+class FormatterTest < ActiveSupport::TestCase
+  setup do
+    @exception = RuntimeError.new('test')
+    Timecop.freeze('2018-12-09 12:07:16 UTC')
+  end
+
+  teardown do
+    Timecop.return
+  end
+
+  #
+  # #title
+  #
+  test 'title returns correct content' do
+    formatter = ExceptionNotifier::Formatter.new(@exception)
+
+    title = if defined?(::Rails) && ::Rails.respond_to?(:env)
+              '⚠️ Error occurred in test ⚠️'
+            else
+              '⚠️ Error occurred ⚠️'
+            end
+
+    assert_equal title, formatter.title
+  end
+
+  #
+  # #subtitle
+  #
+  test 'subtitle without accumulated error' do
+    formatter = ExceptionNotifier::Formatter.new(@exception)
+    assert_equal 'A *RuntimeError* occurred.', formatter.subtitle
+  end
+
+  test 'subtitle with accumulated error' do
+    formatter = ExceptionNotifier::Formatter.new(@exception, accumulated_errors_count: 3)
+    assert_equal '3 *RuntimeError* occurred.', formatter.subtitle
+  end
+
+  test 'subtitle with controller' do
+    env = Rack::MockRequest.env_for(
+      '/', 'action_controller.instance' => test_controller
+    )
+
+    formatter = ExceptionNotifier::Formatter.new(@exception, env: env)
+    assert_equal 'A *RuntimeError* occurred in *home#index*.', formatter.subtitle
+  end
+
+  #
+  # #app_name
+  #
+  test 'app_name defaults to Rails app name' do
+    formatter = ExceptionNotifier::Formatter.new(@exception)
+
+    if defined?(::Rails) && ::Rails.respond_to?(:application)
+      assert_equal 'dummy', formatter.app_name
+    else
+      assert_nil formatter.app_name
+    end
+  end
+
+  test 'app_name can be overwritten using options' do
+    formatter = ExceptionNotifier::Formatter.new(@exception, app_name: 'test')
+    assert_equal 'test', formatter.app_name
+  end
+
+  #
+  # #request_message
+  #
+  test 'request_message when env set' do
+    text = [
+      '```',
+      '* url : http://test.address/?id=foo',
+      '* http_method : GET',
+      '* ip_address : 127.0.0.1',
+      '* parameters : {"id"=>"foo"}',
+      '* timestamp : 2018-12-09 12:07:16 UTC',
+      '```'
+    ].join("\n")
+
+    env = Rack::MockRequest.env_for(
+      '/',
+      'HTTP_HOST' => 'test.address',
+      'REMOTE_ADDR' => '127.0.0.1',
+      params: { id: 'foo' }
+    )
+
+    formatter = ExceptionNotifier::Formatter.new(@exception, env: env)
+    assert_equal text, formatter.request_message
+  end
+
+  test 'request_message when env not set' do
+    formatter = ExceptionNotifier::Formatter.new(@exception)
+    assert_nil formatter.request_message
+  end
+
+  #
+  # #backtrace_message
+  #
+  test 'backtrace_message when backtrace set' do
+    text = [
+      '```',
+      "* app/controllers/my_controller.rb:53:in `my_controller_params'",
+      "* app/controllers/my_controller.rb:34:in `update'",
+      '```'
+    ].join("\n")
+
+    @exception.set_backtrace([
+                               "app/controllers/my_controller.rb:53:in `my_controller_params'",
+                               "app/controllers/my_controller.rb:34:in `update'"
+                             ])
+
+    formatter = ExceptionNotifier::Formatter.new(@exception)
+    assert_equal text, formatter.backtrace_message
+  end
+
+  test 'backtrace_message when no backtrace' do
+    formatter = ExceptionNotifier::Formatter.new(@exception)
+    assert_nil formatter.backtrace_message
+  end
+
+  #
+  # #controller_and_action
+  #
+  test 'correct controller_and_action if controller is present' do
+    env = Rack::MockRequest.env_for(
+      '/', 'action_controller.instance' => test_controller
+    )
+
+    formatter = ExceptionNotifier::Formatter.new(@exception, env: env)
+    assert_equal 'home#index', formatter.controller_and_action
+  end
+
+  test 'controller_and_action is nil if no controller' do
+    env = Rack::MockRequest.env_for('/')
+
+    formatter = ExceptionNotifier::Formatter.new(@exception, env: env)
+    assert_nil formatter.controller_and_action
+  end
+
+  def test_controller
+    controller = mock('controller')
+    controller.stubs(:action_name).returns('index')
+    controller.stubs(:controller_name).returns('home')
+
+    controller
+  end
+end

data/test/exception_notifier/sidekiq_test.rb

@@ -1,38 +1,30 @@
-require "test_helper"
+# frozen_string_literal: true
+
+require 'test_helper'
 
 # To allow sidekiq error handlers to be registered, sidekiq must be in
 # "server mode". This mode is triggered by loading sidekiq/cli. Note this
 # has to be loaded before exception_notification/sidekiq.
-require "sidekiq/cli"
+require 'sidekiq/cli'
+require 'sidekiq/testing'
 
-require "exception_notification/sidekiq"
+require 'exception_notification/sidekiq'
 
 class MockSidekiqServer
   include ::Sidekiq::ExceptionHandler
 end
 
 class SidekiqTest < ActiveSupport::TestCase
-  setup do
-    @_original_sidekiq_logger = Sidekiq::Logging.logger
-
-    # Silence sidekiq warning to stdout
-    Sidekiq::Logging.logger = nil
-  end
-
-  test "should call notify_exception when sidekiq raises an error" do
+  test 'should call notify_exception when sidekiq raises an error' do
     server = MockSidekiqServer.new
-    message = Hash.new
+    message = {}
     exception = RuntimeError.new
 
     ExceptionNotifier.expects(:notify_exception).with(
       exception,
-      :data => { :sidekiq => message }
+      data: { sidekiq: message }
     )
 
     server.handle_exception(exception, message)
   end
-
-  teardown do
-    Sidekiq::Logging.logger = @_original_sidekiq_logger
-  end
 end

data/test/exception_notifier/slack_notifier_test.rb

@@ -1,18 +1,20 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 require 'slack-notifier'
 
 class SlackNotifierTest < ActiveSupport::TestCase
-
   def setup
     @exception = fake_exception
     @exception.stubs(:backtrace).returns(fake_backtrace)
     @exception.stubs(:message).returns('exception message')
+    ExceptionNotifier::SlackNotifier.any_instance.stubs(:clean_backtrace).returns(fake_cleaned_backtrace)
     Socket.stubs(:gethostname).returns('example.com')
   end
 
-  test "should send a slack notification if properly configured" do
+  test 'should send a slack notification if properly configured' do
     options = {
-      webhook_url: "http://slack.webhook.url"
+      webhook_url: 'http://slack.webhook.url'
     }
 
     Slack::Notifier.any_instance.expects(:ping).with('', fake_notification)
@@ -21,9 +23,9 @@ class SlackNotifierTest < ActiveSupport::TestCase
     slack_notifier.call(@exception)
   end
 
-  test "should send a slack notification without backtrace info if properly configured" do
+  test 'should send a slack notification without backtrace info if properly configured' do
     options = {
-      webhook_url: "http://slack.webhook.url"
+      webhook_url: 'http://slack.webhook.url'
     }
 
     Slack::Notifier.any_instance.expects(:ping).with('', fake_notification(fake_exception_without_backtrace))
@@ -32,10 +34,10 @@ class SlackNotifierTest < ActiveSupport::TestCase
     slack_notifier.call(fake_exception_without_backtrace)
   end
 
-  test "should send the notification to the specified channel" do
+  test 'should send the notification to the specified channel' do
     options = {
-      webhook_url: "http://slack.webhook.url",
-      channel: "channel"
+      webhook_url: 'http://slack.webhook.url',
+      channel: 'channel'
     }
 
     Slack::Notifier.any_instance.expects(:ping).with('', fake_notification)
@@ -47,10 +49,10 @@ class SlackNotifierTest < ActiveSupport::TestCase
     assert_equal channel, options[:channel]
   end
 
-  test "should send the notification to the specified username" do
+  test 'should send the notification to the specified username' do
     options = {
-      webhook_url: "http://slack.webhook.url",
-      username: "username"
+      webhook_url: 'http://slack.webhook.url',
+      username: 'username'
     }
 
     Slack::Notifier.any_instance.expects(:ping).with('', fake_notification)
@@ -62,9 +64,9 @@ class SlackNotifierTest < ActiveSupport::TestCase
     assert_equal username, options[:username]
   end
 
-  test "should send the notification with specific backtrace lines" do
+  test 'should send the notification with specific backtrace lines' do
     options = {
-      webhook_url: "http://slack.webhook.url",
+      webhook_url: 'http://slack.webhook.url',
       backtrace_lines: 1
     }
 
@@ -74,10 +76,10 @@ class SlackNotifierTest < ActiveSupport::TestCase
     slack_notifier.call(@exception)
   end
 
-  test "should send the notification with additional fields" do
-    field = {title: "Branch", value: "master", short: true}
+  test 'should send the notification with additional fields' do
+    field = { title: 'Branch', value: 'master', short: true }
     options = {
-      webhook_url: "http://slack.webhook.url",
+      webhook_url: 'http://slack.webhook.url',
       additional_fields: [field]
     }
 
@@ -90,17 +92,17 @@ class SlackNotifierTest < ActiveSupport::TestCase
     assert_equal additional_fields, options[:additional_fields]
   end
 
-  test "should pass the additional parameters to Slack::Notifier.ping" do
+  test 'should pass the additional parameters to Slack::Notifier.ping' do
     options = {
-      webhook_url: "http://slack.webhook.url",
-      username: "test",
-      custom_hook: "hook",
+      webhook_url: 'http://slack.webhook.url',
+      username: 'test',
+      custom_hook: 'hook',
       additional_parameters: {
-        icon_url: "icon",
+        icon_url: 'icon'
       }
     }
 
-    Slack::Notifier.any_instance.expects(:ping).with('', options[:additional_parameters].merge(fake_notification) )
+    Slack::Notifier.any_instance.expects(:ping).with('', options[:additional_parameters].merge(fake_notification))
 
     slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
     slack_notifier.call(@exception)
@@ -115,55 +117,57 @@ class SlackNotifierTest < ActiveSupport::TestCase
     assert_nil slack_notifier.call(@exception)
   end
 
-  test "should pass along environment data" do
+  test 'should pass along environment data' do
     options = {
-      webhook_url: "http://slack.webhook.url",
-      ignore_data_if: lambda {|k,v|
-        "#{k}" == 'key_to_be_ignored' || v.is_a?(Hash)
+      webhook_url: 'http://slack.webhook.url',
+      ignore_data_if: lambda { |k, v|
+        k.to_s == 'key_to_be_ignored' || v.is_a?(Hash)
       }
     }
 
     notification_options = {
       env: {
-        'exception_notifier.exception_data' => {foo: 'bar', john: 'doe'}
+        'exception_notifier.exception_data' => { foo: 'bar', john: 'doe' }
       },
       data: {
-        'user_id'           => 5,
+        'user_id' => 5,
         'key_to_be_ignored' => 'whatever',
-        'ignore_as_well'    => {what: 'ever'}
+        'ignore_as_well' => { what: 'ever' }
       }
     }
 
     expected_data_string = "foo: bar\njohn: doe\nuser_id: 5"
 
-    Slack::Notifier.any_instance.expects(:ping).with('', fake_notification(@exception, notification_options, expected_data_string))
+    Slack::Notifier.any_instance
+                   .expects(:ping)
+                   .with('', fake_notification(@exception, notification_options, expected_data_string))
     slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
     slack_notifier.call(@exception, notification_options)
   end
 
-  test "should call pre/post_callback proc if specified" do
+  test 'should call pre/post_callback proc if specified' do
     post_callback_called = 0
     options = {
-      webhook_url: "http://slack.webhook.url",
-      username: "test",
-      custom_hook: "hook",
-      :pre_callback => proc { |opts, notifier, backtrace, message, message_opts|
-        (message_opts[:attachments] = []) << { text: "#{backtrace.join("\n")}", color: 'danger' }
+      webhook_url: 'http://slack.webhook.url',
+      username: 'test',
+      custom_hook: 'hook',
+      pre_callback: proc { |_opts, _notifier, backtrace, _message, message_opts|
+        (message_opts[:attachments] = []) << { text: backtrace.join("\n").to_s, color: 'danger' }
       },
-      :post_callback => proc { |opts, notifier, backtrace, message, message_opts|
+      post_callback: proc { |_opts, _notifier, _backtrace, _message, _message_opts|
         post_callback_called = 1
       },
       additional_parameters: {
-        icon_url: "icon",
+        icon_url: 'icon'
       }
     }
 
     Slack::Notifier.any_instance.expects(:ping).with('',
-                                                     {:icon_url => 'icon',
-                                                      :attachments => [
-                                                        {:text => fake_backtrace.join("\n"),
-                                                         :color => 'danger'}
-                                                     ]})
+                                                     icon_url: 'icon',
+                                                     attachments: [{
+                                                       text: fake_backtrace.join("\n"),
+                                                       color: 'danger'
+                                                     }])
 
     slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
     slack_notifier.call(@exception)
@@ -173,11 +177,9 @@ class SlackNotifierTest < ActiveSupport::TestCase
   private
 
   def fake_exception
-    begin
-      5/0
-    rescue Exception => e
-      e
-    end
+    5 / 0
+  rescue StandardError => e
+    e
   end
 
   def fake_exception_without_backtrace
@@ -186,17 +188,19 @@ class SlackNotifierTest < ActiveSupport::TestCase
 
   def fake_backtrace
     [
-      "backtrace line 1",
-      "backtrace line 2",
-      "backtrace line 3",
-      "backtrace line 4",
-      "backtrace line 5",
-      "backtrace line 6",
+      'backtrace line 1', 'backtrace line 2', 'backtrace line 3',
+      'backtrace line 4', 'backtrace line 5', 'backtrace line 6'
     ]
   end
 
-  def fake_notification(exception = @exception, notification_options = {}, data_string = nil, expected_backtrace_lines = 10, additional_fields = [])
-    exception_name = "*#{exception.class.to_s =~ /^[aeiou]/i ? 'An' : 'A'}* `#{exception.class.to_s}`"
+  def fake_cleaned_backtrace
+    fake_backtrace[2..-1]
+  end
+
+  def fake_notification(exception = @exception, notification_options = {},
+                        data_string = nil, expected_backtrace_lines = 10, additional_fields = [])
+
+    exception_name = "*#{exception.class.to_s =~ /^[aeiou]/i ? 'An' : 'A'}* `#{exception.class}`"
     if notification_options[:env].nil?
       text = "#{exception_name} *occured in background*"
     else
@@ -211,16 +215,15 @@ class SlackNotifierTest < ActiveSupport::TestCase
 
     text += "\n"
 
-    fields = [ { title: 'Exception', value: exception.message} ]
-    fields.push({ title: 'Hostname', value: 'example.com' })
+    fields = [{ title: 'Exception', value: exception.message }]
+    fields.push(title: 'Hostname', value: 'example.com')
     if exception.backtrace
-      formatted_backtrace = "```#{exception.backtrace.first(expected_backtrace_lines).join("\n")}```"
-      fields.push({ title: 'Backtrace', value: formatted_backtrace })
+      formatted_backtrace = "```#{fake_cleaned_backtrace.first(expected_backtrace_lines).join("\n")}```"
+      fields.push(title: 'Backtrace', value: formatted_backtrace)
     end
-    fields.push({ title: 'Data', value: "```#{data_string}```" }) if data_string
+    fields.push(title: 'Data', value: "```#{data_string}```") if data_string
     additional_fields.each { |f| fields.push(f) }
 
-    { attachments: [ color: 'danger', text: text, fields: fields, mrkdwn_in: %w(text fields) ] }
+    { attachments: [color: 'danger', text: text, fields: fields, mrkdwn_in: %w[text fields]] }
   end
-
 end

data/test/exception_notifier/sns_notifier_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 require 'aws-sdk-sns'
 
@@ -12,7 +14,7 @@ class SnsNotifierTest < ActiveSupport::TestCase
       secret_access_key: 'my-secret_access_key',
       region: 'us-east',
       topic_arn: 'topicARN',
-      sns_prefix: '[App Exception]',
+      sns_prefix: '[App Exception]'
     }
     Socket.stubs(:gethostname).returns('example.com')
   end
@@ -60,53 +62,103 @@ class SnsNotifierTest < ActiveSupport::TestCase
 
   test 'should send a sns notification in background' do
     Aws::SNS::Client.any_instance.expects(:publish).with(
-      {
-      topic_arn: "topicARN",
-      message: "3 MyException occured in background\n"\
-               "Exception: undefined method 'method=' for Empty\n"\
-               "Hostname: example.com\n"\
-               "Backtrace:\n#{fake_backtrace.join("\n")}\n",
-      subject: "[App Exception] - 3 MyException occurred"
-    })
+      topic_arn: 'topicARN',
+      message: "3 MyException occured in background\n" \
+             "Exception: undefined method 'method=' for Empty\n" \
+             "Hostname: example.com\n" \
+             "Data: {}\n" \
+             "Backtrace:\n#{fake_backtrace.join("\n")}\n",
+      subject: '[App Exception] - 3 MyException occurred'
+    )
 
     sns_notifier = ExceptionNotifier::SnsNotifier.new(@options)
-    sns_notifier.call(@exception, { accumulated_errors_count: 3 })
+    sns_notifier.call(@exception, accumulated_errors_count: 3)
   end
 
   test 'should send a sns notification with controller#action information' do
-    ExamplesController.any_instance.stubs(:action_name).returns('index')
+    controller = mock('controller')
+    controller.stubs(:action_name).returns('index')
+    controller.stubs(:controller_name).returns('examples')
 
     Aws::SNS::Client.any_instance.expects(:publish).with(
-      {
-      topic_arn: "topicARN",
-      message: "A MyException occurred while GET </examples> "\
-               "was processed by examples#index\n"\
-               "Exception: undefined method 'method=' for Empty\n"\
-               "Hostname: example.com\n"\
-               "Backtrace:\n#{fake_backtrace.join("\n")}\n",
-      subject: "[App Exception] - A MyException occurred"
-    })
+      topic_arn: 'topicARN',
+      message: 'A MyException occurred while GET </examples> ' \
+             "was processed by examples#index\n" \
+             "Exception: undefined method 'method=' for Empty\n" \
+             "Hostname: example.com\n" \
+             "Data: {}\n" \
+             "Backtrace:\n#{fake_backtrace.join("\n")}\n",
+      subject: '[App Exception] - A MyException occurred'
+    )
 
     sns_notifier = ExceptionNotifier::SnsNotifier.new(@options)
     sns_notifier.call(@exception,
-      env: {
-        'REQUEST_METHOD' => 'GET',
-        'REQUEST_URI' => '/examples',
-        'action_controller.instance' => ExamplesController.new
-      }
+                      env: {
+                        'REQUEST_METHOD' => 'GET',
+                        'REQUEST_URI' => '/examples',
+                        'action_controller.instance' => controller
+                      })
+  end
+
+  test 'should put data from env["exception_notifier.exception_data"] into text' do
+    controller = mock('controller')
+    controller.stubs(:action_name).returns('index')
+    controller.stubs(:controller_name).returns('examples')
+
+    Aws::SNS::Client.any_instance.expects(:publish).with(
+      topic_arn: 'topicARN',
+      message: 'A MyException occurred while GET </examples> ' \
+             "was processed by examples#index\n" \
+             "Exception: undefined method 'method=' for Empty\n" \
+             "Hostname: example.com\n" \
+             "Data: {:current_user=>12}\n" \
+             "Backtrace:\n#{fake_backtrace.join("\n")}\n",
+      subject: '[App Exception] - A MyException occurred'
     )
+
+    sns_notifier = ExceptionNotifier::SnsNotifier.new(@options)
+    sns_notifier.call(@exception,
+                      env: {
+                        'REQUEST_METHOD' => 'GET',
+                        'REQUEST_URI' => '/examples',
+                        'action_controller.instance' => controller,
+                        'exception_notifier.exception_data' => { current_user: 12 }
+                      })
   end
+  test 'should put optional data into text' do
+    controller = mock('controller')
+    controller.stubs(:action_name).returns('index')
+    controller.stubs(:controller_name).returns('examples')
 
-  private
+    Aws::SNS::Client.any_instance.expects(:publish).with(
+      topic_arn: 'topicARN',
+      message: 'A MyException occurred while GET </examples> ' \
+             "was processed by examples#index\n" \
+             "Exception: undefined method 'method=' for Empty\n" \
+             "Hostname: example.com\n" \
+             "Data: {:current_user=>12}\n" \
+             "Backtrace:\n#{fake_backtrace.join("\n")}\n",
+      subject: '[App Exception] - A MyException occurred'
+    )
 
-  class ExamplesController < ActionController::Base; end
+    sns_notifier = ExceptionNotifier::SnsNotifier.new(@options)
+    sns_notifier.call(@exception,
+                      env: {
+                        'REQUEST_METHOD' => 'GET',
+                        'REQUEST_URI' => '/examples',
+                        'action_controller.instance' => controller
+                      },
+                      data: {
+                        current_user: 12
+                      })
+  end
+
+  private
 
   def fake_exception
-    begin
-      1 / 0
-    rescue Exception => e
-      e
-    end
+    1 / 0
+  rescue StandardError => e
+    e
   end
 
   def fake_exception_without_backtrace