exception_notification 4.2.0 → 4.4.1

data/test/exception_notifier/irc_notifier_test.rb

@@ -1,11 +1,12 @@
+# frozen_string_literal: true
+
 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|
@@ -16,13 +17,30 @@ class IrcNotifierTest < ActiveSupport::TestCase
     irc.call(fake_exception)
   end
 
-  test "should call pre/post_callback if specified" do
-    pre_callback_called, post_callback_called = 0,0
+  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}
+      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|
@@ -35,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|
@@ -48,25 +66,25 @@ 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',
-      :port => 9999,
-      :channel => '#exceptions'
+      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"))
+    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',
-      recipients: ['peter', 'michael', 'samir']
+      recipients: %w[peter michael samir]
     }
 
     CarrierPigeon.expects(:send).with(has_key(:uri)) do |v|
@@ -77,7 +95,7 @@ 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',
       ssl: true,
@@ -86,11 +104,13 @@ class IrcNotifierTest < ActiveSupport::TestCase
       prefix: '[test notification]'
     }
 
-    CarrierPigeon.expects(:send).with(has_entries(
+    entries = {
       ssl: true,
       join: true,
-      notice: true,
-    )) do |v|
+      notice: true
+    }
+
+    CarrierPigeon.expects(:send).with(has_entries(entries)) do |v|
       /\[test notification\]/.match(v[:message])
     end
 
@@ -98,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)
@@ -108,11 +128,9 @@ class IrcNotifierTest < ActiveSupport::TestCase
   private
 
   def fake_exception
-    exception = begin
-      5/0
-    rescue Exception => e
-      e
-    end
+    5 / 0
+  rescue StandardError => e
+    e
   end
 
   def fake_exception_without_backtrace

data/test/exception_notifier/mattermost_notifier_test.rb

@@ -1,88 +1,251 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 require 'httparty'
+require 'timecop'
+require 'json'
 
 class MattermostNotifierTest < 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
-    options = {
-      :webhook_url => 'http://localhost:8000'
+  test 'should send notification if properly configured' do
+    opts = {
+      body: default_body.to_json,
+      headers: default_headers
     }
-    mattermost_notifier = ExceptionNotifier::MattermostNotifier.new
-    mattermost_notifier.httparty = FakeHTTParty.new
 
-    options = mattermost_notifier.call ArgumentError.new("foo"), options
+    HTTParty.expects(:post).with(URL, opts)
+    notifier.call ArgumentError.new('foo')
+  end
 
-    body = ActiveSupport::JSON.decode options[:body]
-    assert body.has_key? 'text'
-    assert body.has_key? 'username'
+  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
+    }
 
-    text = body['text'].split("\n")
-    assert_equal 4, text.size
-    assert_equal '@channel', text[0]
-    assert_equal 'An *ArgumentError* occured.', text[2]
-    assert_equal '*foo*', text[3]
+    HTTParty.expects(:post).with(URL, opts)
+    notifier.call ArgumentError.new('foo'), git_url: 'github.com/aschen'
   end
 
-  test "should send notification with create issue link if specified" do
-    options = {
-      :webhook_url => 'http://localhost:8000',
-      :git_url => 'github.com/aschen'
+  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
     }
-    mattermost_notifier = ExceptionNotifier::MattermostNotifier.new
-    mattermost_notifier.httparty = FakeHTTParty.new
 
-    options = mattermost_notifier.call ArgumentError.new("foo"), options
+    HTTParty.expects(:post).with(URL, opts)
+    notifier.call(
+      ArgumentError.new('foo'),
+      username: 'Test Bot',
+      avatar: 'http://site.com/icon.png'
+    )
+  end
 
-    body = ActiveSupport::JSON.decode options[:body]
+  test 'should add other HTTParty options to params' do
+    opts = {
+      basic_auth: {
+        username: 'clara',
+        password: 'password'
+      },
+      body: default_body.to_json,
+      headers: default_headers
+    }
 
-    text = body['text'].split("\n")
-    assert_equal 5, text.size
-    assert_equal '[Create an issue](github.com/aschen/dummy/issues/new/?issue%5Btitle%5D=%5BBUG%5D+Error+500+%3A++%28ArgumentError%29+foo)', text[4]
+    HTTParty.expects(:post).with(URL, opts)
+    notifier.call(
+      ArgumentError.new('foo'),
+      basic_auth: {
+        username: 'clara',
+        password: 'password'
+      }
+    )
   end
 
-  test 'should add username and icon_url params to the notification if specified' do
-    options = {
-      :webhook_url => 'http://localhost:8000',
-      :username => "Test Bot",
-      :avatar => 'http://site.com/icon.png'
+  test "should use 'An' for exceptions count if :accumulated_errors_count option is nil" do
+    opts = {
+      body: default_body.to_json,
+      headers: default_headers
     }
-    mattermost_notifier = ExceptionNotifier::MattermostNotifier.new
-    mattermost_notifier.httparty = FakeHTTParty.new
 
-    options = mattermost_notifier.call ArgumentError.new("foo"), options
+    HTTParty.expects(:post).with(URL, opts)
+    notifier.call(ArgumentError.new('foo'))
+  end
 
-    body = ActiveSupport::JSON.decode options[:body]
+  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
+    }
 
-    assert_equal 'Test Bot', body['username']
-    assert_equal 'http://site.com/icon.png', body['icon_url']
+    HTTParty.expects(:post).with(URL, opts)
+    notifier.call(ArgumentError.new('foo'), accumulated_errors_count: 5)
   end
 
-  test 'should add other HTTParty options to params' do
-    options = {
-      :webhook_url => 'http://localhost:8000',
-      :username => "Test Bot",
-      :avatar => 'http://site.com/icon.png',
-      :basic_auth => {
-        :username => 'clara',
-        :password => 'password'
-      }
+  test 'should include backtrace and request info' do
+    body = default_body.merge(text: [
+      '@channel',
+      error_occurred_in,
+      'An *ArgumentError* occurred.',
+      '*foo*',
+      request_info,
+      backtrace_info
+    ].join("\n"))
+
+    opts = {
+      body: body.to_json,
+      headers: default_headers
     }
-    mattermost_notifier = ExceptionNotifier::MattermostNotifier.new
-    mattermost_notifier.httparty = FakeHTTParty.new
 
-    options = mattermost_notifier.call ArgumentError.new("foo"), options
+    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'"
+                            ])
 
-    assert options.has_key? :basic_auth
-    assert 'clara', options[:basic_auth][:username]
-    assert 'password', options[:basic_auth][:password]
+    notifier.call(exception, env: test_env)
   end
 
-end
+  test 'should include exception_data_info' do
+    body = default_body.merge(
+      text: [
+        '@channel',
+        error_occurred_in,
+        'An *ArgumentError* occurred.',
+        '*foo*',
+        request_info,
+        exception_data_info
+      ].join("\n")
+    )
+
+    opts = {
+      body: body.to_json,
+      headers: default_headers
+    }
 
-class FakeHTTParty
+    env = test_env.merge(
+      'exception_notifier.exception_data' => { foo: 'bar', john: 'doe' }
+    )
 
-  def post(url, options)
-    return options
+    HTTParty.expects(:post).with(URL, opts)
+    notifier.call(ArgumentError.new('foo'), env: 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
+
+  def request_info
+    [
+      '### 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',
+      '```'
+    ]
+  end
+
+  def backtrace_info
+    [
+      '### Backtrace',
+      '```',
+      "* app/controllers/my_controller.rb:53:in `my_controller_params'",
+      "* app/controllers/my_controller.rb:34:in `update'",
+      '```'
+    ]
+  end
+
+  def exception_data_info
+    [
+      '### Data',
+      '```',
+      '* foo : bar',
+      '* john : doe',
+      '```'
+    ]
+  end
 end