exception_notification 4.2.1 → 4.4.3

data/test/exception_notifier/google_chat_notifier_test.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'rack'
+require 'httparty'
+require 'timecop'
+require 'json'
+
+class GoogleChatNotifierTest < ActiveSupport::TestCase
+  URL = 'http://localhost:8000'
+
+  def setup
+    Timecop.freeze('2018-12-09 12:07:16 UTC')
+  end
+
+  def teardown
+    Timecop.return
+  end
+
+  test 'should send notification if properly configured' do
+    HTTParty.expects(:post).with(URL, post_opts("#{header}\n#{body}"))
+    notifier.call ArgumentError.new('foo')
+  end
+
+  test 'shoud use errors count if accumulated_errors_count is provided' do
+    text = [
+      '',
+      "Application: *#{app_name}*",
+      '5 *ArgumentError* occurred.',
+      '',
+      body
+    ].join("\n")
+
+    HTTParty.expects(:post).with(URL, post_opts(text))
+
+    notifier.call(ArgumentError.new('foo'), accumulated_errors_count: 5)
+  end
+
+  test 'Message request should be formatted as hash' do
+    text = [
+      header,
+      body,
+      '',
+      '*Request:*',
+      '```',
+      '* 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")
+
+    HTTParty.expects(:post).with(URL, post_opts(text))
+
+    notifier.call(ArgumentError.new('foo'), env: test_env)
+  end
+
+  test 'backtrace with less than 3 lines should be displayed fully' do
+    text = [
+      header,
+      body,
+      '',
+      backtrace
+    ].join("\n")
+
+    HTTParty.expects(:post).with(URL, post_opts(text))
+
+    exception = ArgumentError.new('foo')
+    exception.set_backtrace([
+                              "app/controllers/my_controller.rb:53:in `my_controller_params'",
+                              "app/controllers/my_controller.rb:34:in `update'"
+                            ])
+
+    notifier.call(exception)
+  end
+
+  test 'backtrace with more than 3 lines should display only top 3 lines' do
+    text = [
+      header,
+      body,
+      '',
+      '*Backtrace:*',
+      '```',
+      "* app/controllers/my_controller.rb:99:in `specific_function'",
+      "* app/controllers/my_controller.rb:70:in `specific_param'",
+      "* app/controllers/my_controller.rb:53:in `my_controller_params'",
+      '```'
+    ].join("\n")
+
+    HTTParty.expects(:post).with(URL, post_opts(text))
+
+    exception = ArgumentError.new('foo')
+    exception.set_backtrace([
+                              "app/controllers/my_controller.rb:99:in `specific_function'",
+                              "app/controllers/my_controller.rb:70:in `specific_param'",
+                              "app/controllers/my_controller.rb:53:in `my_controller_params'",
+                              "app/controllers/my_controller.rb:34:in `update'"
+                            ])
+
+    notifier.call(exception)
+  end
+
+  test 'Get text with backtrace and request info' do
+    text = [
+      header,
+      body,
+      '',
+      '*Request:*',
+      '```',
+      '* 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',
+      '```',
+      '',
+      backtrace
+    ].join("\n")
+
+    HTTParty.expects(:post).with(URL, post_opts(text))
+
+    exception = ArgumentError.new('foo')
+    exception.set_backtrace([
+                              "app/controllers/my_controller.rb:53:in `my_controller_params'",
+                              "app/controllers/my_controller.rb:34:in `update'"
+                            ])
+
+    notifier.call(exception, env: test_env)
+  end
+
+  private
+
+  def notifier
+    ExceptionNotifier::GoogleChatNotifier.new(webhook_url: URL)
+  end
+
+  def post_opts(text)
+    {
+      body: { text: text }.to_json,
+      headers: { 'Content-Type' => 'application/json' }
+    }
+  end
+
+  def test_env
+    Rack::MockRequest.env_for(
+      '/',
+      'HTTP_HOST' => 'test.address',
+      'REMOTE_ADDR' => '127.0.0.1',
+      'HTTP_USER_AGENT' => 'Rails Testing',
+      params: { id: 'foo' }
+    )
+  end
+
+  def header
+    [
+      '',
+      "Application: *#{app_name}*",
+      'An *ArgumentError* occurred.',
+      ''
+    ].join("\n")
+  end
+
+  def body
+    if defined?(::Rails) && ::Rails.respond_to?(:env)
+      "⚠️ Error occurred in test ⚠️\n*foo*"
+    else
+      "⚠️ Error occurred ⚠️\n*foo*"
+    end
+  end
+
+  def app_name
+    'dummy' if defined?(::Rails) && ::Rails.respond_to?(:application)
+  end
+
+  def backtrace
+    [
+      '*Backtrace:*',
+      '```',
+      "* app/controllers/my_controller.rb:53:in `my_controller_params'",
+      "* app/controllers/my_controller.rb:34:in `update'",
+      '```'
+    ]
+  end
+end

data/test/exception_notifier/hipchat_notifier_test.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require 'test_helper'
+require 'rack'
 
 # silence_warnings trick around require can be removed once
 # https://github.com/hipchat/hipchat-rb/pull/174
@@ -8,31 +11,33 @@ silence_warnings do
 end
 
 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
-    pre_callback_called, post_callback_called = 0,0
+  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',
-      :pre_callback => proc { |*| pre_callback_called += 1},
-      :post_callback => proc { |*| post_callback_called += 1}
+      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)))
+    HipChat::Room.any_instance
+                 .expects(:send)
+                 .with('Exception', fake_body, { color: 'yellow' }.merge(options.except(:api_token, :room_name)))
 
     hipchat = ExceptionNotifier::HipchatNotifier.new(options)
     hipchat.call(fake_exception)
@@ -40,112 +45,152 @@ 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',
-      :message_template => ->(exception) { "This is custom message: '#{exception.message}'" }
+      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' })
+    HipChat::Room.any_instance
+                 .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
+    options = {
+      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 = ExceptionNotifier::HipchatNotifier.new(options)
     hipchat.call(fake_exception)
   end
 
-  test "should send hipchat notification with HTML-escaped meessage if using default message_template" 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 = 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
+    options = {
+      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'
+    }
+
+    HipChat::Client.stubs(: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
     options = {
-      :api_token => 'good_token',
-      :room_name => 'room_name',
+      api_token: 'good_token',
+      room_name: 'room_name',
+      api_version: 'v2'
     }
 
-    HipChat::Client.stubs(:new).with('good_token', {:api_version => 'v1'}).returns({})
+    HipChat::Client.stubs(:new).with('good_token', api_version: 'v2').returns({})
 
     hipchat = ExceptionNotifier::HipchatNotifier.new(options)
     hipchat.call(fake_exception)
   end
 
-  test "should use APIv2 when specified" 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',
+      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'}).returns({})
+    HipChat::Client.stubs(:new).with('good_token', api_version: 'v2', server_url: 'https://domain.com').returns({})
 
     hipchat = ExceptionNotifier::HipchatNotifier.new(options)
     hipchat.call(fake_exception)
@@ -158,19 +203,15 @@ class HipchatNotifierTest < ActiveSupport::TestCase
   end
 
   def fake_exception
-    begin
-      5/0
-    rescue Exception => e
-      e
-    end
+    5 / 0
+  rescue StandardError => e
+    e
   end
 
   def fake_exception_with_html_characters
-    begin
-      raise StandardError.new('an error with <html> characters')
-    rescue Exception => e
-      e
-    end
+    raise StandardError, 'an error with <html> characters'
+  rescue StandardError => e
+    e
   end
 
   def fake_body_without_backtrace