exception_notification 4.3.0 → 4.5.0

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,29 +17,30 @@ 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)
 
-    irc.expects(:send_message).with{ |message| message.include?("(3 times)'divided by 0'") }.once
+    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, post_callback_called = 0,0
+  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|
@@ -51,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|
@@ -64,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|
@@ -93,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,
@@ -102,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
 
@@ -114,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)
@@ -124,11 +128,9 @@ class IrcNotifierTest < ActiveSupport::TestCase
   private
 
   def fake_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,105 +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)
 
-    assert options.has_key? :basic_auth
-    assert 'clara', options[:basic_auth][:username]
-    assert 'password', options[:basic_auth][:password]
+    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
 
-  test "should use 'An' for exceptions count if :accumulated_errors_count option is nil" do
-    mattermost_notifier = ExceptionNotifier::MattermostNotifier.new
-    exception = ArgumentError.new("foo")
-    mattermost_notifier.instance_variable_set(:@exception, exception)
-    mattermost_notifier.instance_variable_set(:@options, {})
+  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
+    }
 
-    assert_includes mattermost_notifier.send(:message_header), "An *ArgumentError* occured."
+    env = test_env.merge(
+      'exception_notifier.exception_data' => { foo: 'bar', john: 'doe' }
+    )
+
+    HTTParty.expects(:post).with(URL, opts)
+    notifier.call(ArgumentError.new('foo'), env: env)
   end
 
-  test "shoud use direct errors count if :accumulated_errors_count option is 5" do
-    mattermost_notifier = ExceptionNotifier::MattermostNotifier.new
-    exception = ArgumentError.new("foo")
-    mattermost_notifier.instance_variable_set(:@exception, exception)
-    mattermost_notifier.instance_variable_set(:@options, { accumulated_errors_count: 5 })
+  private
 
-    assert_includes mattermost_notifier.send(:message_header), "5 *ArgumentError* occured."
+  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
-end
 
-class FakeHTTParty
+  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 post(url, options)
-    return options
+  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

data/test/exception_notifier/modules/error_grouping_test.rb

@@ -1,18 +1,19 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class ErrorGroupTest < ActiveSupport::TestCase
-
   setup do
     module TestModule
       include ExceptionNotifier::ErrorGrouping
-      @@error_grouping_cache = ActiveSupport::Cache::FileStore.new("test/dummy/tmp/non_default_location")
+      @@error_grouping_cache = ActiveSupport::Cache::FileStore.new('test/dummy/tmp/non_default_location')
     end
 
-    @exception = RuntimeError.new("ERROR")
-    @exception.stubs(:backtrace).returns(["/path/where/error/raised:1"])
+    @exception = RuntimeError.new('ERROR')
+    @exception.stubs(:backtrace).returns(['/path/where/error/raised:1'])
 
-    @exception2 = RuntimeError.new("ERROR2")
-    @exception2.stubs(:backtrace).returns(["/path/where/error/found:2"])
+    @exception2 = RuntimeError.new('ERROR2')
+    @exception2.stubs(:backtrace).returns(['/path/where/error/found:2'])
   end
 
   teardown do
@@ -20,88 +21,88 @@ class ErrorGroupTest < ActiveSupport::TestCase
     TestModule.fallback_cache_store.clear
   end
 
-  test "should add additional option: error_grouping" do
+  test 'should add additional option: error_grouping' do
     assert_respond_to TestModule, :error_grouping
     assert_respond_to TestModule, :error_grouping=
   end
 
-  test "should set error_grouping to false default" do
+  test 'should set error_grouping to false default' do
     assert_equal false, TestModule.error_grouping
   end
 
-  test "should add additional option: error_grouping_cache" do
+  test 'should add additional option: error_grouping_cache' do
     assert_respond_to TestModule, :error_grouping_cache
     assert_respond_to TestModule, :error_grouping_cache=
   end
 
-  test "should add additional option: error_grouping_period" do
+  test 'should add additional option: error_grouping_period' do
     assert_respond_to TestModule, :error_grouping_period
     assert_respond_to TestModule, :error_grouping_period=
   end
 
-  test "shoud set error_grouping_period to 5.minutes default" do
+  test 'shoud set error_grouping_period to 5.minutes default' do
     assert_equal 300, TestModule.error_grouping_period
   end
 
-  test "should add additional option: notification_trigger" do
+  test 'should add additional option: notification_trigger' do
     assert_respond_to TestModule, :notification_trigger
     assert_respond_to TestModule, :notification_trigger=
   end
 
-  test "should return errors count nil when not same error for .error_count" do
-    assert_nil TestModule.error_count("something")
+  test 'should return errors count nil when not same error for .error_count' do
+    assert_nil TestModule.error_count('something')
   end
 
-  test "should return errors count when same error for .error_count" do
-    TestModule.error_grouping_cache.write("error_key", 13)
-    assert_equal 13, TestModule.error_count("error_key")
+  test 'should return errors count when same error for .error_count' do
+    TestModule.error_grouping_cache.write('error_key', 13)
+    assert_equal 13, TestModule.error_count('error_key')
   end
 
-  test "should fallback to memory store cache if specified cache store failed to read" do
-    TestModule.error_grouping_cache.stubs(:read).raises(RuntimeError.new "Failed to read")
+  test 'should fallback to memory store cache if specified cache store failed to read' do
+    TestModule.error_grouping_cache.stubs(:read).raises(RuntimeError.new('Failed to read'))
     original_fallback = TestModule.fallback_cache_store
     TestModule.expects(:fallback_cache_store).returns(original_fallback).at_least_once
 
-    assert_nil TestModule.error_count("something_to_read")
+    assert_nil TestModule.error_count('something_to_read')
   end
 
-  test "should save error with count for .save_error_count" do
+  test 'should save error with count for .save_error_count' do
     count = rand(1..10)
 
-    TestModule.save_error_count("error_key", count)
-    assert_equal count, TestModule.error_grouping_cache.read("error_key")
+    TestModule.save_error_count('error_key', count)
+    assert_equal count, TestModule.error_grouping_cache.read('error_key')
   end
 
-  test "should fallback to memory store cache if specified cache store failed to write" do
-    TestModule.error_grouping_cache.stubs(:write).raises(RuntimeError.new "Failed to write")
+  test 'should fallback to memory store cache if specified cache store failed to write' do
+    TestModule.error_grouping_cache.stubs(:write).raises(RuntimeError.new('Failed to write'))
     original_fallback = TestModule.fallback_cache_store
     TestModule.expects(:fallback_cache_store).returns(original_fallback).at_least_once
 
-    assert TestModule.save_error_count("something_to_cache", rand(1..10))
+    assert TestModule.save_error_count('something_to_cache', rand(1..10))
   end
 
-  test "should save accumulated_errors_count into options" do
+  test 'should save accumulated_errors_count into options' do
     options = {}
     TestModule.group_error!(@exception, options)
 
     assert_equal 1, options[:accumulated_errors_count]
   end
 
-  test "should not group error if different exception in .group_error!" do
+  test 'should not group error if different exception in .group_error!' do
     options1 = {}
-    TestModule.expects(:save_error_count).with{|key, count| key.is_a?(String) && count == 1}.times(4).returns(true)
+    TestModule.expects(:save_error_count).with { |key, count| key.is_a?(String) && count == 1 }.times(4).returns(true)
     TestModule.group_error!(@exception, options1)
 
     options2 = {}
-    TestModule.group_error!(NoMethodError.new("method not found"), options2)
+    TestModule.group_error!(NoMethodError.new('method not found'), options2)
 
     assert_equal 1, options1[:accumulated_errors_count]
     assert_equal 1, options2[:accumulated_errors_count]
   end
 
-  test "should not group error is same exception but different message or backtrace" do
+  test 'should not group error is same exception but different message or backtrace' do
     options1 = {}
-    TestModule.expects(:save_error_count).with{|key, count| key.is_a?(String) && count == 1}.times(4).returns(true)
+    TestModule.expects(:save_error_count).with { |key, count| key.is_a?(String) && count == 1 }.times(4).returns(true)
     TestModule.group_error!(@exception, options1)
 
     options2 = {}
@@ -111,7 +112,7 @@ class ErrorGroupTest < ActiveSupport::TestCase
     assert_equal 1, options2[:accumulated_errors_count]
   end
 
-  test "should group error if same exception and message" do
+  test 'should group error if same exception and message' do
     options = {}
 
     10.times do |i|
@@ -122,7 +123,7 @@ class ErrorGroupTest < ActiveSupport::TestCase
     assert_equal 10, options[:accumulated_errors_count]
   end
 
-  test "should group error if same exception and backtrace" do
+  test 'should group error if same exception and backtrace' do
     options = {}
 
     10.times do |i|
@@ -133,9 +134,9 @@ class ErrorGroupTest < ActiveSupport::TestCase
     assert_equal 10, options[:accumulated_errors_count]
   end
 
-  test "should group error by that message have high priority" do
+  test 'should group error by that message have high priority' do
     message_based_key = "exception:#{Zlib.crc32("RuntimeError\nmessage:ERROR")}"
-    backtrace_based_key = "exception:#{Zlib.crc32("RuntimeError\n/path/where/error/raised:1")}"
+    backtrace_based_key = "exception:#{Zlib.crc32("RuntimeError\npath:/path/where/error/raised:1")}"
 
     TestModule.save_error_count(message_based_key, 1)
     TestModule.save_error_count(backtrace_based_key, 1)
@@ -146,7 +147,7 @@ class ErrorGroupTest < ActiveSupport::TestCase
     TestModule.group_error!(@exception, {})
   end
 
-  test "use default formula if not specify notification_trigger in .send_notification?" do
+  test 'use default formula if not specify notification_trigger in .send_notification?' do
     TestModule.stubs(:notification_trigger).returns(nil)
 
     count = 16
@@ -155,12 +156,12 @@ class ErrorGroupTest < ActiveSupport::TestCase
     assert TestModule.send_notification?(@exception, count)
   end
 
-  test "use specified trigger in .send_notification?" do
-    trigger = Proc.new { |exception, count| count % 4 == 0 }
+  test 'use specified trigger in .send_notification?' do
+    trigger = proc { |_exception, count| (count % 4).zero? }
     TestModule.stubs(:notification_trigger).returns(trigger)
 
     count = 16
     trigger.expects(:call).with(@exception, count).returns(true)
     assert TestModule.send_notification?(@exception, count)
   end
-end
+end