exception_notification 4.6.0 → 5.0.0

data/test/exception_notifier/hipchat_notifier_test.rb

@@ -1,37 +1,37 @@
 # frozen_string_literal: true
 
-require 'test_helper'
-require 'rack'
-require 'hipchat'
+require "test_helper"
+require "rack"
+require "hipchat"
 
 class HipchatNotifierTest < ActiveSupport::TestCase
-  test 'should send hipchat notification if properly configured' do
+  test "should send hipchat notification if properly configured" do
     options = {
-      api_token: 'good_token',
-      room_name: 'room_name',
-      color: 'yellow'
+      api_token: "good_token",
+      room_name: "room_name",
+      color: "yellow"
     }
 
-    HipChat::Room.any_instance.expects(:send).with('Exception', fake_body, color: 'yellow')
+    HipChat::Room.any_instance.expects(:send).with("Exception", fake_body, {color: "yellow"})
 
     hipchat = ExceptionNotifier::HipchatNotifier.new(options)
     hipchat.call(fake_exception)
   end
 
-  test 'should call pre/post_callback if specified' do
+  test "should call pre/post_callback if specified" do
     pre_callback_called = 0
     post_callback_called = 0
     options = {
-      api_token: 'good_token',
-      room_name: 'room_name',
-      color: 'yellow',
+      api_token: "good_token",
+      room_name: "room_name",
+      color: "yellow",
       pre_callback: proc { |*| pre_callback_called += 1 },
       post_callback: proc { |*| post_callback_called += 1 }
     }
 
     HipChat::Room.any_instance
-                 .expects(:send)
-                 .with('Exception', fake_body, { color: 'yellow' }.merge(options.except(:api_token, :room_name)))
+      .expects(:send)
+      .with("Exception", fake_body, {color: "yellow"}.merge(options.except(:api_token, :room_name)))
 
     hipchat = ExceptionNotifier::HipchatNotifier.new(options)
     hipchat.call(fake_exception)
@@ -39,152 +39,154 @@ class HipchatNotifierTest < ActiveSupport::TestCase
     assert_equal(1, post_callback_called)
   end
 
-  test 'should send hipchat notification without backtrace info if properly configured' do
+  test "should send hipchat notification without backtrace info if properly configured" do
     options = {
-      api_token: 'good_token',
-      room_name: 'room_name',
-      color: 'yellow'
+      api_token: "good_token",
+      room_name: "room_name",
+      color: "yellow"
     }
 
-    HipChat::Room.any_instance.expects(:send).with('Exception', fake_body_without_backtrace, color: 'yellow')
+    HipChat::Room.any_instance.expects(:send).with("Exception", fake_body_without_backtrace, {color: "yellow"})
 
     hipchat = ExceptionNotifier::HipchatNotifier.new(options)
     hipchat.call(fake_exception_without_backtrace)
   end
 
-  test 'should allow custom from value if set' do
+  test "should allow custom from value if set" do
     options = {
-      api_token: 'good_token',
-      room_name: 'room_name',
-      from: 'TrollFace'
+      api_token: "good_token",
+      room_name: "room_name",
+      from: "TrollFace"
     }
 
-    HipChat::Room.any_instance.expects(:send).with('TrollFace', fake_body, color: 'red')
+    HipChat::Room.any_instance.expects(:send).with("TrollFace", fake_body, {color: "red"})
 
     hipchat = ExceptionNotifier::HipchatNotifier.new(options)
     hipchat.call(fake_exception)
   end
 
-  test 'should not send hipchat notification if badly configured' do
+  test "should not send hipchat notification if badly configured" do
     wrong_params = {
-      api_token: 'bad_token',
-      room_name: 'test_room'
+      api_token: "bad_token",
+      room_name: "test_room"
     }
 
-    HipChat::Client.stubs(:new).with('bad_token', api_version: 'v1').returns(nil)
+    HipChat::Client.stubs(:new).with("bad_token", {api_version: "v1"}).returns(nil)
 
     hipchat = ExceptionNotifier::HipchatNotifier.new(wrong_params)
     assert_nil hipchat.room
   end
 
-  test 'should not send hipchat notification if api_key is missing' do
-    wrong_params = { room_name: 'test_room' }
+  test "should not send hipchat notification if api_key is missing" do
+    wrong_params = {room_name: "test_room"}
 
-    HipChat::Client.stubs(:new).with(nil, api_version: 'v1').returns(nil)
+    HipChat::Client.stubs(:new).with(nil, {api_version: "v1"}).returns(nil)
 
     hipchat = ExceptionNotifier::HipchatNotifier.new(wrong_params)
     assert_nil hipchat.room
   end
 
-  test 'should not send hipchat notification if room_name is missing' do
-    wrong_params = { api_token: 'good_token' }
+  test "should not send hipchat notification if room_name is missing" do
+    wrong_params = {api_token: "good_token"}
 
-    HipChat::Client.stubs(:new).with('good_token', api_version: 'v1').returns({})
+    HipChat::Client.stubs(:new).with("good_token", {api_version: "v1"}).returns({})
 
     hipchat = ExceptionNotifier::HipchatNotifier.new(wrong_params)
     assert_nil hipchat.room
   end
 
-  test 'should send hipchat notification with message_template' do
+  test "should send hipchat notification with message_template" do
     options = {
-      api_token: 'good_token',
-      room_name: 'room_name',
-      color: 'yellow',
+      api_token: "good_token",
+      room_name: "room_name",
+      color: "yellow",
       message_template: ->(exception, _) { "This is custom message: '#{exception.message}'" }
     }
 
     HipChat::Room.any_instance
-                 .expects(:send)
-                 .with('Exception', "This is custom message: '#{fake_exception.message}'", color: 'yellow')
+      .expects(:send)
+      .with("Exception", "This is custom message: '#{fake_exception.message}'", {color: "yellow"})
 
     hipchat = ExceptionNotifier::HipchatNotifier.new(options)
     hipchat.call(fake_exception)
   end
 
-  test 'should send hipchat notification exclude accumulated errors count' do
+  test "should send hipchat notification exclude accumulated errors count" do
     options = {
-      api_token: 'good_token',
-      room_name: 'room_name',
-      color: 'yellow'
+      api_token: "good_token",
+      room_name: "room_name",
+      color: "yellow"
     }
 
-    HipChat::Room.any_instance.expects(:send).with { |_, msg, _| msg.start_with?('A new exception occurred:') }
+    HipChat::Room.any_instance.expects(:send).with { |_, msg, _| msg.start_with?("A new exception occurred:") }
     hipchat = ExceptionNotifier::HipchatNotifier.new(options)
     hipchat.call(fake_exception)
   end
 
-  test 'should send hipchat notification include accumulated errors count' do
+  test "should send hipchat notification include accumulated errors count" do
     options = {
-      api_token: 'good_token',
-      room_name: 'room_name',
-      color: 'yellow'
+      api_token: "good_token",
+      room_name: "room_name",
+      color: "yellow"
     }
 
-    HipChat::Room.any_instance.expects(:send).with { |_, msg, _| msg.start_with?('The exception occurred 3 times:') }
+    HipChat::Room.any_instance.expects(:send).with { |_, msg, _| msg.start_with?("The exception occurred 3 times:") }
     hipchat = ExceptionNotifier::HipchatNotifier.new(options)
     hipchat.call(fake_exception, accumulated_errors_count: 3)
   end
 
-  test 'should send hipchat notification with HTML-escaped meessage if using default message_template' do
+  test "should send hipchat notification with HTML-escaped meessage if using default message_template" do
     options = {
-      api_token: 'good_token',
-      room_name: 'room_name',
-      color: 'yellow'
+      api_token: "good_token",
+      room_name: "room_name",
+      color: "yellow"
     }
 
     exception = fake_exception_with_html_characters
     body = "A new exception occurred: '#{Rack::Utils.escape_html(exception.message)}' on '#{exception.backtrace.first}'"
 
-    HipChat::Room.any_instance.expects(:send).with('Exception', body, color: 'yellow')
+    HipChat::Room.any_instance.expects(:send).with("Exception", body, {color: "yellow"})
 
     hipchat = ExceptionNotifier::HipchatNotifier.new(options)
     hipchat.call(exception)
   end
 
-  test 'should use APIv1 if api_version is not specified' do
+  test "should use APIv1 if api_version is not specified" do
     options = {
-      api_token: 'good_token',
-      room_name: 'room_name'
+      api_token: "good_token",
+      room_name: "room_name"
     }
 
-    HipChat::Client.stubs(:new).with('good_token', api_version: 'v1').returns({})
+    HipChat::Client.expects(:new).with("good_token", {api_version: "v1"}).returns({})
 
     hipchat = ExceptionNotifier::HipchatNotifier.new(options)
     hipchat.call(fake_exception)
   end
 
-  test 'should use APIv2 when specified' do
+  test "should use APIv2 when specified" do
     options = {
-      api_token: 'good_token',
-      room_name: 'room_name',
-      api_version: 'v2'
+      api_token: "good_token",
+      room_name: "room_name",
+      api_version: "v2"
     }
 
-    HipChat::Client.stubs(:new).with('good_token', api_version: 'v2').returns({})
+    HipChat::Client.expects(:new).with("good_token", {api_version: "v2"}).returns({})
 
     hipchat = ExceptionNotifier::HipchatNotifier.new(options)
     hipchat.call(fake_exception)
   end
 
-  test 'should allow server_url value (for a self-hosted HipChat Server) if set' do
+  test "should allow server_url value (for a self-hosted HipChat Server) if set" do
     options = {
-      api_token: 'good_token',
-      room_name: 'room_name',
-      api_version: 'v2',
-      server_url: 'https://domain.com'
+      api_token: "good_token",
+      room_name: "room_name",
+      api_version: "v2",
+      server_url: "https://domain.com"
     }
 
-    HipChat::Client.stubs(:new).with('good_token', api_version: 'v2', server_url: 'https://domain.com').returns({})
+    HipChat::Client.expects(:new)
+      .with("good_token", {api_version: "v2", server_url: "https://domain.com"})
+      .returns({})
 
     hipchat = ExceptionNotifier::HipchatNotifier.new(options)
     hipchat.call(fake_exception)
@@ -198,13 +200,13 @@ class HipchatNotifierTest < ActiveSupport::TestCase
 
   def fake_exception
     5 / 0
-  rescue StandardError => e
+  rescue => e
     e
   end
 
   def fake_exception_with_html_characters
-    raise StandardError, 'an error with <html> characters'
-  rescue StandardError => e
+    raise StandardError, "an error with <html> characters"
+  rescue => e
     e
   end
 
@@ -213,6 +215,6 @@ class HipchatNotifierTest < ActiveSupport::TestCase
   end
 
   def fake_exception_without_backtrace
-    StandardError.new('my custom error')
+    StandardError.new("my custom error")
   end
 end

data/test/exception_notifier/irc_notifier_test.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require 'test_helper'
-require 'carrier-pigeon'
+require "test_helper"
+require "carrier-pigeon"
 
 class IrcNotifierTest < ActiveSupport::TestCase
-  test 'should send irc notification if properly configured' do
+  test "should send irc notification if properly configured" do
     options = {
-      domain: 'irc.example.com'
+      domain: "irc.example.com"
     }
 
     CarrierPigeon.expects(:send).with(has_key(:uri)) do |v|
@@ -17,15 +17,15 @@ class IrcNotifierTest < ActiveSupport::TestCase
     irc.call(fake_exception)
   end
 
-  test 'should exclude errors count in message if :accumulated_errors_count nil' do
+  test "should exclude errors count in message if :accumulated_errors_count nil" do
     irc = ExceptionNotifier::IrcNotifier.new({})
     irc.stubs(:active?).returns(true)
 
-    irc.expects(:send_message).with { |message| message.include?('divided by 0') }.once
+    irc.expects(:send_message).with { |message| message.include?("divided by 0") }.once
     irc.call(fake_exception)
   end
 
-  test 'should include errors count in message if :accumulated_errors_count is 3' do
+  test "should include errors count in message if :accumulated_errors_count is 3" do
     irc = ExceptionNotifier::IrcNotifier.new({})
     irc.stubs(:active?).returns(true)
 
@@ -33,12 +33,12 @@ class IrcNotifierTest < ActiveSupport::TestCase
     irc.call(fake_exception, accumulated_errors_count: 3)
   end
 
-  test 'should call pre/post_callback if specified' do
+  test "should call pre/post_callback if specified" do
     pre_callback_called = 0
     post_callback_called = 0
 
     options = {
-      domain: 'irc.example.com',
+      domain: "irc.example.com",
       pre_callback: proc { |*| pre_callback_called += 1 },
       post_callback: proc { |*| post_callback_called += 1 }
     }
@@ -53,9 +53,9 @@ class IrcNotifierTest < ActiveSupport::TestCase
     assert_equal(1, post_callback_called)
   end
 
-  test 'should send irc notification without backtrace info if properly configured' do
+  test "should send irc notification without backtrace info if properly configured" do
     options = {
-      domain: 'irc.example.com'
+      domain: "irc.example.com"
     }
 
     CarrierPigeon.expects(:send).with(has_key(:uri)) do |v|
@@ -66,24 +66,24 @@ class IrcNotifierTest < ActiveSupport::TestCase
     irc.call(fake_exception_without_backtrace)
   end
 
-  test 'should properly construct URI from constituent parts' do
+  test "should properly construct URI from constituent parts" do
     options = {
-      nick: 'BadNewsBot',
-      password: 'secret',
-      domain: 'irc.example.com',
+      nick: "BadNewsBot",
+      password: "secret",
+      domain: "irc.example.com",
       port: 9999,
-      channel: '#exceptions'
+      channel: "#exceptions"
     }
 
-    CarrierPigeon.expects(:send).with(has_entry(uri: 'irc://BadNewsBot:secret@irc.example.com:9999/#exceptions'))
+    CarrierPigeon.expects(:send).with(has_entry(uri: "irc://BadNewsBot:secret@irc.example.com:9999/#exceptions"))
 
     irc = ExceptionNotifier::IrcNotifier.new(options)
     irc.call(fake_exception)
   end
 
-  test 'should properly add recipients if specified' do
+  test "should properly add recipients if specified" do
     options = {
-      domain: 'irc.example.com',
+      domain: "irc.example.com",
       recipients: %w[peter michael samir]
     }
 
@@ -95,13 +95,13 @@ class IrcNotifierTest < ActiveSupport::TestCase
     irc.call(fake_exception)
   end
 
-  test 'should properly set miscellaneous options' do
+  test "should properly set miscellaneous options" do
     options = {
-      domain: 'irc.example.com',
+      domain: "irc.example.com",
       ssl: true,
       join: true,
       notice: true,
-      prefix: '[test notification]'
+      prefix: "[test notification]"
     }
 
     entries = {
@@ -118,8 +118,8 @@ class IrcNotifierTest < ActiveSupport::TestCase
     irc.call(fake_exception)
   end
 
-  test 'should not send irc notification if badly configured' do
-    wrong_params = { domain: '##scriptkiddie.com###' }
+  test "should not send irc notification if badly configured" do
+    wrong_params = {domain: "##scriptkiddie.com###"}
     irc = ExceptionNotifier::IrcNotifier.new(wrong_params)
 
     assert_nil irc.call(fake_exception)
@@ -129,11 +129,11 @@ class IrcNotifierTest < 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
 end