exception_notification 4.6.0 → 5.0.0

data/test/exception_notifier/modules/formatter_test.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require 'test_helper'
-require 'timecop'
+require "test_helper"
+require "timecop"
 
 class FormatterTest < ActiveSupport::TestCase
   setup do
-    @exception = RuntimeError.new('test')
-    Timecop.freeze('2018-12-09 12:07:16 UTC')
+    @exception = RuntimeError.new("test")
+    Timecop.freeze("2018-12-09 12:07:16 UTC")
   end
 
   teardown do
@@ -16,14 +16,14 @@ class FormatterTest < ActiveSupport::TestCase
   #
   # #title
   #
-  test 'title returns correct content' do
+  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
+      "⚠️ Error occurred in test ⚠️"
+    else
+      "⚠️ Error occurred ⚠️"
+    end
 
     assert_equal title, formatter.title
   end
@@ -31,69 +31,69 @@ class FormatterTest < ActiveSupport::TestCase
   #
   # #subtitle
   #
-  test 'subtitle without accumulated error' do
+  test "subtitle without accumulated error" do
     formatter = ExceptionNotifier::Formatter.new(@exception)
-    assert_equal 'A *RuntimeError* occurred.', formatter.subtitle
+    assert_equal "A *RuntimeError* occurred.", formatter.subtitle
   end
 
-  test 'subtitle with accumulated error' do
+  test "subtitle with accumulated error" do
     formatter = ExceptionNotifier::Formatter.new(@exception, accumulated_errors_count: 3)
-    assert_equal '3 *RuntimeError* occurred.', formatter.subtitle
+    assert_equal "3 *RuntimeError* occurred.", formatter.subtitle
   end
 
-  test 'subtitle with controller' do
+  test "subtitle with controller" do
     env = Rack::MockRequest.env_for(
-      '/', 'action_controller.instance' => test_controller
+      "/", "action_controller.instance" => test_controller
     )
 
     formatter = ExceptionNotifier::Formatter.new(@exception, env: env)
-    assert_equal 'A *RuntimeError* occurred in *home#index*.', formatter.subtitle
+    assert_equal "A *RuntimeError* occurred in *home#index*.", formatter.subtitle
   end
 
   #
   # #app_name
   #
-  test 'app_name defaults to Rails app name' do
+  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
+      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
+  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
+  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',
-      '```'
+      "```",
+      "* url : http://test.address/?id=foo",
+      "* http_method : GET",
+      "* ip_address : 127.0.0.1",
+      "* parameters : #{{"id" => "foo"}}", # standard:disable Lint/LiteralInInterpolation:
+      "* 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' }
+      "/",
+      "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
+  test "request_message when env not set" do
     formatter = ExceptionNotifier::Formatter.new(@exception)
     assert_nil formatter.request_message
   end
@@ -101,24 +101,24 @@ class FormatterTest < ActiveSupport::TestCase
   #
   # #backtrace_message
   #
-  test 'backtrace_message when backtrace set' do
+  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'"
-                             ])
+      "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
+  test "backtrace_message when no backtrace" do
     formatter = ExceptionNotifier::Formatter.new(@exception)
     assert_nil formatter.backtrace_message
   end
@@ -126,26 +126,28 @@ class FormatterTest < ActiveSupport::TestCase
   #
   # #controller_and_action
   #
-  test 'correct controller_and_action if controller is present' do
+  test "correct controller_and_action if controller is present" do
     env = Rack::MockRequest.env_for(
-      '/', 'action_controller.instance' => test_controller
+      "/", "action_controller.instance" => test_controller
     )
 
     formatter = ExceptionNotifier::Formatter.new(@exception, env: env)
-    assert_equal 'home#index', formatter.controller_and_action
+    assert_equal "home#index", formatter.controller_and_action
   end
 
-  test 'controller_and_action is nil if no controller' do
-    env = Rack::MockRequest.env_for('/')
+  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
 
+  private
+
   def test_controller
-    controller = mock('controller')
-    controller.stubs(:action_name).returns('index')
-    controller.stubs(:controller_name).returns('home')
+    controller = mock("controller")
+    controller.stubs(:action_name).returns("index")
+    controller.stubs(:controller_name).returns("home")
 
     controller
   end

data/test/exception_notifier/sidekiq_test.rb

@@ -1,33 +1,40 @@
 # frozen_string_literal: true
 
-require 'test_helper'
+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/testing'
+require "sidekiq/cli"
+require "sidekiq/testing"
 
-require 'exception_notification/sidekiq'
+require "exception_notification/sidekiq"
 
 class MockSidekiqServer
   include ::Sidekiq::Component
 
   def config
-    Sidekiq.default_configuration
+    @config ||= (Sidekiq.default_configuration.tap { |config| config.logger = Logger.new(nil) })
   end
 end
 
 class SidekiqTest < ActiveSupport::TestCase
-  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 = {}
     exception = RuntimeError.new
 
-    ExceptionNotifier.expects(:notify_exception).with(
-      exception,
-      data: { sidekiq: message }
-    )
+    if ::Sidekiq::VERSION < "7.1.5"
+      ExceptionNotifier.expects(:notify_exception).with(
+        exception,
+        data: {sidekiq: message}
+      )
+    else
+      ExceptionNotifier.expects(:notify_exception).with(
+        exception,
+        data: {sidekiq: {context: message, config: server.config}}
+      )
+    end
 
     server.handle_exception(exception, message)
   end

data/test/exception_notifier/slack_notifier_test.rb

@@ -1,46 +1,46 @@
 # frozen_string_literal: true
 
-require 'test_helper'
-require 'slack-notifier'
+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')
+    @exception.stubs(:message).returns("exception message")
     ExceptionNotifier::SlackNotifier.any_instance.stubs(:clean_backtrace).returns(fake_cleaned_backtrace)
-    Socket.stubs(:gethostname).returns('example.com')
+    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)
+    Slack::Notifier.any_instance.expects(:ping).with("", fake_notification)
 
     slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
     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))
+    Slack::Notifier.any_instance.expects(:ping).with("", fake_notification(fake_exception_without_backtrace))
 
     slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
     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)
+    Slack::Notifier.any_instance.expects(:ping).with("", fake_notification)
 
     slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
     slack_notifier.call(@exception)
@@ -49,13 +49,13 @@ 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)
+    Slack::Notifier.any_instance.expects(:ping).with("", fake_notification)
 
     slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
     slack_notifier.call(@exception)
@@ -64,26 +64,26 @@ 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
     }
 
-    Slack::Notifier.any_instance.expects(:ping).with('', fake_notification(@exception, {}, nil, 1))
+    Slack::Notifier.any_instance.expects(:ping).with("", fake_notification(@exception, {}, nil, 1))
 
     slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
     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]
     }
 
-    Slack::Notifier.any_instance.expects(:ping).with('', fake_notification(@exception, {}, nil, 10, [field]))
+    Slack::Notifier.any_instance.expects(:ping).with("", fake_notification(@exception, {}, nil, 10, [field]))
 
     slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
     slack_notifier.call(@exception)
@@ -92,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)
@@ -117,57 +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',
+      webhook_url: "http://slack.webhook.url",
       ignore_data_if: lambda { |k, v|
-        k.to_s == 'key_to_be_ignored' || v.is_a?(Hash)
+        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,
-        'key_to_be_ignored' => 'whatever',
-        'ignore_as_well' => { what: 'ever' }
+        "user_id" => 5,
+        "key_to_be_ignored" => "whatever",
+        "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))
+      .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',
+      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' }
+        (message_opts[:attachments] = []) << {text: backtrace.join("\n").to_s, color: "danger"}
       },
       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'
-                                                     }])
+    Slack::Notifier.any_instance.expects(:ping).with("",
+      {icon_url: "icon",
+       attachments: [{
+         text: fake_backtrace.join("\n"),
+         color: "danger"
+       }]})
 
     slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
     slack_notifier.call(@exception)
@@ -178,36 +178,35 @@ class SlackNotifierTest < ActiveSupport::TestCase
 
   def fake_exception
     5 / 0
-  rescue StandardError => e
+  rescue => e
     e
   end
 
   def fake_exception_without_backtrace
-    StandardError.new('my custom error')
+    StandardError.new("my custom error")
   end
 
   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_cleaned_backtrace
-    fake_backtrace[2..-1]
+    fake_backtrace[2..-1] # standard:disable Style/SlicingWithRange
   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}`"
+    data_string = nil, expected_backtrace_lines = 10, additional_fields = [])
+    exception_name = "*#{/^[aeiou]/i.match?(exception.class.to_s) ? "An" : "A"}* `#{exception.class}`"
     if notification_options[:env].nil?
       text = "#{exception_name} *occured in background*"
     else
       env = notification_options[:env]
 
-      kontroller = env['action_controller.instance']
-      request = "#{env['REQUEST_METHOD']} <#{env['REQUEST_URI']}>"
+      kontroller = env["action_controller.instance"]
+      request = "#{env["REQUEST_METHOD"]} <#{env["REQUEST_URI"]}>"
 
       text = "#{exception_name} *occurred while* `#{request}`"
       text += " *was processed by* `#{kontroller.controller_name}##{kontroller.action_name}`" if kontroller
@@ -215,15 +214,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 = "```#{fake_cleaned_backtrace.first(expected_backtrace_lines).join("\n")}```"
-      fields.push(title: 'Backtrace', value: formatted_backtrace)
+      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