exception_notification 3.0.1 → 4.4.0

data/test/exception_notifier/hipchat_notifier_test.rb

@@ -0,0 +1,218 @@
+require 'test_helper'
+require 'rack'
+
+# silence_warnings trick around require can be removed once
+# https://github.com/hipchat/hipchat-rb/pull/174
+# gets merged and released
+silence_warnings do
+  require 'hipchat'
+end
+
+class HipchatNotifierTest < ActiveSupport::TestCase
+  test 'should send hipchat notification if properly configured' do
+    options = {
+      api_token: 'good_token',
+      room_name: 'room_name',
+      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 = 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 }
+    }
+
+    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)
+    assert_equal(1, pre_callback_called)
+    assert_equal(1, post_callback_called)
+  end
+
+  test 'should send hipchat notification without backtrace info if properly configured' do
+    options = {
+      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 = ExceptionNotifier::HipchatNotifier.new(options)
+    hipchat.call(fake_exception_without_backtrace)
+  end
+
+  test 'should allow custom from value if set' do
+    options = {
+      api_token: 'good_token',
+      room_name: 'room_name',
+      from: 'TrollFace'
+    }
+
+    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
+    wrong_params = {
+      api_token: 'bad_token',
+      room_name: 'test_room'
+    }
+
+    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' }
+
+    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' }
+
+    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
+    options = {
+      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 = 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 include 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?('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 = ExceptionNotifier::HipchatNotifier.new(options)
+    hipchat.call(exception)
+  end
+
+  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_version: 'v2'
+    }
+
+    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
+    options = {
+      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 = ExceptionNotifier::HipchatNotifier.new(options)
+    hipchat.call(fake_exception)
+  end
+
+  private
+
+  def fake_body
+    "A new exception occurred: '#{fake_exception.message}' on '#{fake_exception.backtrace.first}'"
+  end
+
+  def fake_exception
+    5 / 0
+  rescue StandardError => e
+    e
+  end
+
+  def fake_exception_with_html_characters
+    raise StandardError, 'an error with <html> characters'
+  rescue StandardError => e
+    e
+  end
+
+  def fake_body_without_backtrace
+    "A new exception occurred: '#{fake_exception_without_backtrace.message}'"
+  end
+
+  def fake_exception_without_backtrace
+    StandardError.new('my custom error')
+  end
+end

data/test/exception_notifier/irc_notifier_test.rb

@@ -0,0 +1,137 @@
+require 'test_helper'
+require 'carrier-pigeon'
+
+class IrcNotifierTest < ActiveSupport::TestCase
+  test 'should send irc notification if properly configured' do
+    options = {
+      domain: 'irc.example.com'
+    }
+
+    CarrierPigeon.expects(:send).with(has_key(:uri)) do |v|
+      /divided by 0/.match(v[:message])
+    end
+
+    irc = ExceptionNotifier::IrcNotifier.new(options)
+    irc.call(fake_exception)
+  end
+
+  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.call(fake_exception)
+  end
+
+  test 'should include errors count in message if :accumulated_errors_count is 3' do
+    irc = ExceptionNotifier::IrcNotifier.new({})
+    irc.stubs(:active?).returns(true)
+
+    irc.expects(:send_message).with { |message| message.include?("(3 times)'divided by 0'") }.once
+    irc.call(fake_exception, accumulated_errors_count: 3)
+  end
+
+  test 'should call pre/post_callback if specified' do
+    pre_callback_called = 0
+    post_callback_called = 0
+
+    options = {
+      domain: 'irc.example.com',
+      pre_callback: proc { |*| pre_callback_called += 1 },
+      post_callback: proc { |*| post_callback_called += 1 }
+    }
+
+    CarrierPigeon.expects(:send).with(has_key(:uri)) do |v|
+      /divided by 0/.match(v[:message])
+    end
+
+    irc = ExceptionNotifier::IrcNotifier.new(options)
+    irc.call(fake_exception)
+    assert_equal(1, pre_callback_called)
+    assert_equal(1, post_callback_called)
+  end
+
+  test 'should send irc notification without backtrace info if properly configured' do
+    options = {
+      domain: 'irc.example.com'
+    }
+
+    CarrierPigeon.expects(:send).with(has_key(:uri)) do |v|
+      /my custom error/.match(v[:message])
+    end
+
+    irc = ExceptionNotifier::IrcNotifier.new(options)
+    irc.call(fake_exception_without_backtrace)
+  end
+
+  test 'should properly construct URI from constituent parts' do
+    options = {
+      nick: 'BadNewsBot',
+      password: 'secret',
+      domain: 'irc.example.com',
+      port: 9999,
+      channel: '#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
+    options = {
+      domain: 'irc.example.com',
+      recipients: %w[peter michael samir]
+    }
+
+    CarrierPigeon.expects(:send).with(has_key(:uri)) do |v|
+      /peter, michael, samir/.match(v[:message])
+    end
+
+    irc = ExceptionNotifier::IrcNotifier.new(options)
+    irc.call(fake_exception)
+  end
+
+  test 'should properly set miscellaneous options' do
+    options = {
+      domain: 'irc.example.com',
+      ssl: true,
+      join: true,
+      notice: true,
+      prefix: '[test notification]'
+    }
+
+    entries = {
+      ssl: true,
+      join: true,
+      notice: true
+    }
+
+    CarrierPigeon.expects(:send).with(has_entries(entries)) do |v|
+      /\[test notification\]/.match(v[:message])
+    end
+
+    irc = ExceptionNotifier::IrcNotifier.new(options)
+    irc.call(fake_exception)
+  end
+
+  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)
+  end
+
+  private
+
+  def fake_exception
+    5 / 0
+  rescue StandardError => e
+    e
+  end
+
+  def fake_exception_without_backtrace
+    StandardError.new('my custom error')
+  end
+end

data/test/exception_notifier/mattermost_notifier_test.rb

@@ -0,0 +1,202 @@
+require 'test_helper'
+require 'httparty'
+require 'timecop'
+require 'json'
+
+class MattermostNotifierTest < ActiveSupport::TestCase
+  URL = 'http://localhost:8000'.freeze
+
+  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
+    opts = {
+      body: default_body.to_json,
+      headers: default_headers
+    }
+
+    HTTParty.expects(:post).with(URL, opts)
+    notifier.call ArgumentError.new('foo')
+  end
+
+  test 'should send notification with create issue link if specified' do
+    body = default_body.merge(
+      text: [
+        '@channel',
+        error_occurred_in,
+        'An *ArgumentError* occurred.',
+        '*foo*',
+        github_link
+      ].join("\n")
+    )
+
+    opts = {
+      body: body.to_json,
+      headers: default_headers
+    }
+
+    HTTParty.expects(:post).with(URL, opts)
+    notifier.call ArgumentError.new('foo'), git_url: 'github.com/aschen'
+  end
+
+  test 'should add username and icon_url params to the notification if specified' do
+    body = default_body.merge(
+      username: 'Test Bot',
+      icon_url: 'http://site.com/icon.png'
+    )
+
+    opts = {
+      body: body.to_json,
+      headers: default_headers
+    }
+
+    HTTParty.expects(:post).with(URL, opts)
+    notifier.call(
+      ArgumentError.new('foo'),
+      username: 'Test Bot',
+      avatar: 'http://site.com/icon.png'
+    )
+  end
+
+  test 'should add other HTTParty options to params' do
+    opts = {
+      basic_auth: {
+        username: 'clara',
+        password: 'password'
+      },
+      body: default_body.to_json,
+      headers: default_headers
+    }
+
+    HTTParty.expects(:post).with(URL, opts)
+    notifier.call(
+      ArgumentError.new('foo'),
+      basic_auth: {
+        username: 'clara',
+        password: 'password'
+      }
+    )
+  end
+
+  test "should use 'An' for exceptions count if :accumulated_errors_count option is nil" do
+    opts = {
+      body: default_body.to_json,
+      headers: default_headers
+    }
+
+    HTTParty.expects(:post).with(URL, opts)
+    notifier.call(ArgumentError.new('foo'))
+  end
+
+  test 'shoud use direct errors count if :accumulated_errors_count option is 5' do
+    body = default_body.merge(
+      text: [
+        '@channel',
+        error_occurred_in,
+        '5 *ArgumentError* occurred.',
+        '*foo*'
+      ].join("\n")
+    )
+
+    opts = {
+      body: body.to_json,
+      headers: default_headers
+    }
+
+    HTTParty.expects(:post).with(URL, opts)
+    notifier.call(ArgumentError.new('foo'), accumulated_errors_count: 5)
+  end
+
+  test 'should include backtrace and request info' do
+    body = default_body.merge(
+      text: [
+        '@channel',
+        error_occurred_in,
+        'An *ArgumentError* occurred.',
+        '*foo*',
+        '### 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',
+        '```',
+        "* app/controllers/my_controller.rb:53:in `my_controller_params'",
+        "* app/controllers/my_controller.rb:34:in `update'",
+        '```'
+      ].join("\n")
+    )
+
+    opts = {
+      body: body.to_json,
+      headers: default_headers
+    }
+
+    HTTParty.expects(:post).with(URL, opts)
+
+    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::MattermostNotifier.new(webhook_url: URL)
+  end
+
+  def default_body
+    {
+      text: [
+        '@channel',
+        error_occurred_in,
+        'An *ArgumentError* occurred.',
+        '*foo*'
+      ].join("\n"),
+      username: 'Exception Notifier'
+    }
+  end
+
+  def default_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 error_occurred_in
+    if defined?(::Rails) && ::Rails.respond_to?(:env)
+      '### ⚠️ Error occurred in test ⚠️'
+    else
+      '### ⚠️ Error occurred ⚠️'
+    end
+  end
+
+  def github_link
+    if defined?(::Rails) && ::Rails.respond_to?(:application)
+      '[Create an issue](github.com/aschen/dummy/issues/new/?issue%5Btitle%5D=%5BBUG%5D+Error+500+%3A++%28ArgumentError%29+foo)'
+    else
+      # TODO: fix missing app name
+      '[Create an issue](github.com/aschen//issues/new/?issue%5Btitle%5D=%5BBUG%5D+Error+500+%3A++%28ArgumentError%29+foo)'
+    end
+  end
+end