exception_notification 4.6.0 → 5.0.0

data/test/exception_notifier/mattermost_notifier_test.rb

@@ -1,38 +1,38 @@
 # frozen_string_literal: true
 
-require 'test_helper'
-require 'httparty'
-require 'timecop'
-require 'json'
+require "test_helper"
+require "httparty"
+require "timecop"
+require "json"
 
 class MattermostNotifierTest < ActiveSupport::TestCase
-  URL = 'http://localhost:8000'
+  URL = "http://localhost:8000"
 
   def setup
-    Timecop.freeze('2018-12-09 12:07:16 UTC')
+    Timecop.freeze("2018-12-09 12:07:16 UTC")
   end
 
   def teardown
     Timecop.return
   end
 
-  test 'should send notification if properly configured' do
+  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')
+    notifier.call ArgumentError.new("foo")
   end
 
-  test 'should send notification with create issue link if specified' do
+  test "should send notification with create issue link if specified" do
     body = default_body.merge(
       text: [
-        '@channel',
+        "@channel",
         error_occurred_in,
-        'An *ArgumentError* occurred.',
-        '*foo*',
+        "An *ArgumentError* occurred.",
+        "*foo*",
         github_link
       ].join("\n")
     )
@@ -43,13 +43,13 @@ class MattermostNotifierTest < ActiveSupport::TestCase
     }
 
     HTTParty.expects(:post).with(URL, opts)
-    notifier.call ArgumentError.new('foo'), git_url: 'github.com/aschen'
+    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
+  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'
+      username: "Test Bot",
+      icon_url: "http://site.com/icon.png"
     )
 
     opts = {
@@ -59,17 +59,17 @@ class MattermostNotifierTest < ActiveSupport::TestCase
 
     HTTParty.expects(:post).with(URL, opts)
     notifier.call(
-      ArgumentError.new('foo'),
-      username: 'Test Bot',
-      avatar: 'http://site.com/icon.png'
+      ArgumentError.new("foo"),
+      username: "Test Bot",
+      avatar: "http://site.com/icon.png"
     )
   end
 
-  test 'should add other HTTParty options to params' do
+  test "should add other HTTParty options to params" do
     opts = {
       basic_auth: {
-        username: 'clara',
-        password: 'password'
+        username: "clara",
+        password: "password"
       },
       body: default_body.to_json,
       headers: default_headers
@@ -77,10 +77,10 @@ class MattermostNotifierTest < ActiveSupport::TestCase
 
     HTTParty.expects(:post).with(URL, opts)
     notifier.call(
-      ArgumentError.new('foo'),
+      ArgumentError.new("foo"),
       basic_auth: {
-        username: 'clara',
-        password: 'password'
+        username: "clara",
+        password: "password"
       }
     )
   end
@@ -92,16 +92,16 @@ class MattermostNotifierTest < ActiveSupport::TestCase
     }
 
     HTTParty.expects(:post).with(URL, opts)
-    notifier.call(ArgumentError.new('foo'))
+    notifier.call(ArgumentError.new("foo"))
   end
 
-  test 'shoud use direct errors count if :accumulated_errors_count option is 5' do
+  test "shoud use direct errors count if :accumulated_errors_count option is 5" do
     body = default_body.merge(
       text: [
-        '@channel',
+        "@channel",
         error_occurred_in,
-        '5 *ArgumentError* occurred.',
-        '*foo*'
+        "5 *ArgumentError* occurred.",
+        "*foo*"
       ].join("\n")
     )
 
@@ -111,15 +111,15 @@ class MattermostNotifierTest < ActiveSupport::TestCase
     }
 
     HTTParty.expects(:post).with(URL, opts)
-    notifier.call(ArgumentError.new('foo'), accumulated_errors_count: 5)
+    notifier.call(ArgumentError.new("foo"), accumulated_errors_count: 5)
   end
 
-  test 'should include backtrace and request info' do
+  test "should include backtrace and request info" do
     body = default_body.merge(text: [
-      '@channel',
+      "@channel",
       error_occurred_in,
-      'An *ArgumentError* occurred.',
-      '*foo*',
+      "An *ArgumentError* occurred.",
+      "*foo*",
       request_info,
       backtrace_info
     ].join("\n"))
@@ -131,22 +131,22 @@ class MattermostNotifierTest < ActiveSupport::TestCase
 
     HTTParty.expects(:post).with(URL, opts)
 
-    exception = ArgumentError.new('foo')
+    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'"
-                            ])
+      "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 include exception_data_info' do
+  test "should include exception_data_info" do
     body = default_body.merge(
       text: [
-        '@channel',
+        "@channel",
         error_occurred_in,
-        'An *ArgumentError* occurred.',
-        '*foo*',
+        "An *ArgumentError* occurred.",
+        "*foo*",
         request_info,
         exception_data_info
       ].join("\n")
@@ -158,11 +158,11 @@ class MattermostNotifierTest < ActiveSupport::TestCase
     }
 
     env = test_env.merge(
-      'exception_notifier.exception_data' => { foo: 'bar', john: 'doe' }
+      "exception_notifier.exception_data" => {foo: "bar", john: "doe"}
     )
 
     HTTParty.expects(:post).with(URL, opts)
-    notifier.call(ArgumentError.new('foo'), env: env)
+    notifier.call(ArgumentError.new("foo"), env: env)
   end
 
   private
@@ -174,78 +174,78 @@ class MattermostNotifierTest < ActiveSupport::TestCase
   def default_body
     {
       text: [
-        '@channel',
+        "@channel",
         error_occurred_in,
-        'An *ArgumentError* occurred.',
-        '*foo*'
+        "An *ArgumentError* occurred.",
+        "*foo*"
       ].join("\n"),
-      username: 'Exception Notifier'
+      username: "Exception Notifier"
     }
   end
 
   def default_headers
-    { 'Content-Type' => 'application/json' }
+    {"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' }
+      "/",
+      "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 ⚠️'
+      "### ⚠️ Error occurred in test ⚠️"
     else
-      '### ⚠️ Error occurred ⚠️'
+      "### ⚠️ 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)'
+      "[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)'
+      "[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',
-      '```'
+      "### Request",
+      "```",
+      "* url : http://test.address/?id=foo",
+      "* http_method : GET",
+      "* ip_address : 127.0.0.1",
+      "* parameters : #{{"id" => "foo"}}", # standard:disable Lint/LiteralInInterpolation
+      "* timestamp : 2018-12-09 12:07:16 UTC",
+      "```"
     ]
   end
 
   def backtrace_info
     [
-      '### Backtrace',
-      '```',
+      "### 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',
-      '```'
+      "### Data",
+      "```",
+      "* foo : bar",
+      "* john : doe",
+      "```"
     ]
   end
 end

data/test/exception_notifier/modules/error_grouping_test.rb

@@ -1,19 +1,19 @@
 # frozen_string_literal: true
 
-require 'test_helper'
+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')
-    end
+  module TestModule
+    include ExceptionNotifier::ErrorGrouping
+    @@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'])
+  setup do
+    @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
@@ -21,86 +21,86 @@ 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.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.group_error!(@exception, options1)
@@ -112,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|
@@ -123,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|
@@ -134,7 +134,7 @@ 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\npath:/path/where/error/raised:1")}"
 
@@ -147,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
@@ -156,7 +156,7 @@ class ErrorGroupTest < ActiveSupport::TestCase
     assert TestModule.send_notification?(@exception, count)
   end
 
-  test 'use specified trigger in .send_notification?' do
+  test "use specified trigger in .send_notification?" do
     trigger = proc { |_exception, count| (count % 4).zero? }
     TestModule.stubs(:notification_trigger).returns(trigger)