exception_notification 4.3.0 → 4.5.0

data/test/exception_notifier/google_chat_notifier_test.rb

@@ -1,128 +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'
 
-  test "should send notification if properly configured" do
-    options = {
-      :webhook_url => 'http://localhost:8000'
-    }
-    google_chat_notifier = ExceptionNotifier::GoogleChatNotifier.new
-    google_chat_notifier.httparty = FakeHTTParty.new
-
-    options = google_chat_notifier.call ArgumentError.new("foo"), options
+  def setup
+    Timecop.freeze('2018-12-09 12:07:16 UTC')
+  end
 
-    body = ActiveSupport::JSON.decode options[:body]
-    assert body.has_key? 'text'
+  def teardown
+    Timecop.return
+  end
 
-    text = body['text'].split("\n")
-    assert_equal 6, text.size
-    assert_equal 'Application: *dummy*', text[1]
-    assert_equal 'An *ArgumentError* occured.', text[2]
-    assert_equal '*foo*', text[5]
+  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 "should use 'An' for exceptions count if :accumulated_errors_count option is nil" do
-    google_chat_notifier = ExceptionNotifier::GoogleChatNotifier.new
-    exception = ArgumentError.new("foo")
-    google_chat_notifier.instance_variable_set(:@exception, exception)
-    google_chat_notifier.instance_variable_set(:@options, {})
+  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))
 
-    assert_includes google_chat_notifier.send(:header), "An *ArgumentError* occured."
+    notifier.call(ArgumentError.new('foo'), accumulated_errors_count: 5)
   end
 
-  test "shoud use direct errors count if :accumulated_errors_count option is 5" do
-    google_chat_notifier = ExceptionNotifier::GoogleChatNotifier.new
-    exception = ArgumentError.new("foo")
-    google_chat_notifier.instance_variable_set(:@exception, exception)
-    google_chat_notifier.instance_variable_set(:@options, { accumulated_errors_count: 5 })
+  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
 
-    assert_includes google_chat_notifier.send(:header), "5 *ArgumentError* occured."
+  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 "Message request should be formatted as hash" do
-    google_chat_notifier = ExceptionNotifier::GoogleChatNotifier.new
-    request_items = { url: 'http://test.address',
-                      http_method: :get,
-                      ip_address: '127.0.0.1',
-                      parameters: '{"id"=>"foo"}',
-                      timestamp: Time.parse('2018-08-13 12:13:24 UTC') }
-    google_chat_notifier.instance_variable_set(:@request_items, request_items)
-
-    message_request =  google_chat_notifier.send(:message_request).join("\n")
-    assert_includes message_request, '* url : http://test.address'
-    assert_includes message_request, '* http_method : get'
-    assert_includes message_request, '* ip_address : 127.0.0.1'
-    assert_includes message_request, '* parameters : {"id"=>"foo"}'
-    assert_includes message_request, '* timestamp : 2018-08-13 12:13:24 UTC'
+  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 'backtrace with less than 3 lines should be displayed fully' do
-    google_chat_notifier = ExceptionNotifier::GoogleChatNotifier.new
+  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
 
-    backtrace = ["app/controllers/my_controller.rb:53:in `my_controller_params'", "app/controllers/my_controller.rb:34:in `update'"]
-    google_chat_notifier.instance_variable_set(:@backtrace, backtrace)
+  private
 
-    message_backtrace =  google_chat_notifier.send(:message_backtrace).join("\n")
-    assert_includes message_backtrace, "* app/controllers/my_controller.rb:53:in `my_controller_params'"
-    assert_includes message_backtrace, "* app/controllers/my_controller.rb:34:in `update'"
+  def notifier
+    ExceptionNotifier::GoogleChatNotifier.new(webhook_url: URL)
   end
 
-  test 'backtrace with more than 3 lines should display only top 3 lines' do
-    google_chat_notifier = ExceptionNotifier::GoogleChatNotifier.new
+  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
 
-    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'"]
-    google_chat_notifier.instance_variable_set(:@backtrace, backtrace)
+  def header
+    [
+      '',
+      "Application: *#{app_name}*",
+      'An *ArgumentError* occurred.',
+      ''
+    ].join("\n")
+  end
 
-    message_backtrace =  google_chat_notifier.send(:message_backtrace).join("\n")
-    assert_includes message_backtrace, "* app/controllers/my_controller.rb:99:in `specific_function'"
-    assert_includes message_backtrace, "* app/controllers/my_controller.rb:70:in `specific_param'"
-    assert_includes message_backtrace, "* app/controllers/my_controller.rb:53:in `my_controller_params'"
-    assert_not_includes message_backtrace, "* app/controllers/my_controller.rb:34:in `update'"
+  def body
+    if defined?(::Rails) && ::Rails.respond_to?(:env)
+      "⚠️ Error occurred in test ⚠️\n*foo*"
+    else
+      "⚠️ Error occurred ⚠️\n*foo*"
+    end
   end
 
-  test 'Get text with backtrace and request info' do
-    google_chat_notifier = ExceptionNotifier::GoogleChatNotifier.new
-
-    backtrace = ["app/controllers/my_controller.rb:53:in `my_controller_params'", "app/controllers/my_controller.rb:34:in `update'"]
-    google_chat_notifier.instance_variable_set(:@backtrace, backtrace)
-
-    request_items = { url: 'http://test.address',
-                      http_method: :get,
-                      ip_address: '127.0.0.1',
-                      parameters: '{"id"=>"foo"}',
-                      timestamp: Time.parse('2018-08-13 12:13:24 UTC') }
-    google_chat_notifier.instance_variable_set(:@request_items, request_items)
-
-    google_chat_notifier.instance_variable_set(:@options, {accumulated_errors_count: 0})
-
-    google_chat_notifier.instance_variable_set(:@application_name, 'dummy')
-
-    exception = ArgumentError.new("foo")
-    google_chat_notifier.instance_variable_set(:@exception, exception)
-
-    text = google_chat_notifier.send(:exception_text)
-    expected_text = %q(
-Application: *dummy*
-An *ArgumentError* occured.
-
-⚠️ Error 500 in test ⚠️
-*foo*
-
-*Request:*
-```
-* url : http://test.address
-* http_method : get
-* ip_address : 127.0.0.1
-* parameters : {"id"=>"foo"}
-* timestamp : 2018-08-13 12:13:24 UTC
-```
-
-*Backtrace:*
-```
-* app/controllers/my_controller.rb:53:in `my_controller_params'
-* app/controllers/my_controller.rb:34:in `update'
-```)
-    assert_equal text, expected_text
+  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,150 +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
+  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 })
+    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.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
+  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.stubs(: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.stubs(:new).with('good_token', api_version: 'v2', server_url: 'https://domain.com').returns({})
 
     hipchat = ExceptionNotifier::HipchatNotifier.new(options)
     hipchat.call(fake_exception)
@@ -196,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