exception_notification 4.6.0 → 5.0.1

data/test/exception_notifier/mattermost_notifier_test.rb

@@ -1,251 +0,0 @@
-# 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
-    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_info,
-      backtrace_info
-    ].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
-
-  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
-    }
-
-    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
-
-  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

data/test/exception_notifier/modules/error_grouping_test.rb

@@ -1,167 +0,0 @@
-# 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')
-    end
-
-    @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'])
-  end
-
-  teardown do
-    TestModule.error_grouping_cache.clear
-    TestModule.fallback_cache_store.clear
-  end
-
-  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
-    assert_equal false, TestModule.error_grouping
-  end
-
-  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
-    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
-    assert_equal 300, TestModule.error_grouping_period
-  end
-
-  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')
-  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')
-  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'))
-    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')
-  end
-
-  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')
-  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'))
-    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))
-  end
-
-  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
-    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)
-
-    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
-    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!(@exception2, options2)
-
-    assert_equal 1, options1[:accumulated_errors_count]
-    assert_equal 1, options2[:accumulated_errors_count]
-  end
-
-  test 'should group error if same exception and message' do
-    options = {}
-
-    10.times do |i|
-      @exception2.stubs(:backtrace).returns(["/path:#{i}"])
-      TestModule.group_error!(@exception2, options)
-    end
-
-    assert_equal 10, options[:accumulated_errors_count]
-  end
-
-  test 'should group error if same exception and backtrace' do
-    options = {}
-
-    10.times do |i|
-      @exception2.stubs(:message).returns("ERRORS#{i}")
-      TestModule.group_error!(@exception2, options)
-    end
-
-    assert_equal 10, options[:accumulated_errors_count]
-  end
-
-  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")}"
-
-    TestModule.save_error_count(message_based_key, 1)
-    TestModule.save_error_count(backtrace_based_key, 1)
-
-    TestModule.expects(:save_error_count).with(message_based_key, 2).once
-    TestModule.expects(:save_error_count).with(backtrace_based_key, 2).never
-
-    TestModule.group_error!(@exception, {})
-  end
-
-  test 'use default formula if not specify notification_trigger in .send_notification?' do
-    TestModule.stubs(:notification_trigger).returns(nil)
-
-    count = 16
-    Math.expects(:log2).with(count).returns(4)
-
-    assert TestModule.send_notification?(@exception, count)
-  end
-
-  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

data/test/exception_notifier/modules/formatter_test.rb

@@ -1,152 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-require 'timecop'
-
-class FormatterTest < ActiveSupport::TestCase
-  setup do
-    @exception = RuntimeError.new('test')
-    Timecop.freeze('2018-12-09 12:07:16 UTC')
-  end
-
-  teardown do
-    Timecop.return
-  end
-
-  #
-  # #title
-  #
-  test 'title returns correct content' do
-    formatter = ExceptionNotifier::Formatter.new(@exception)
-
-    title = if defined?(::Rails) && ::Rails.respond_to?(:env)
-              '⚠️ Error occurred in test ⚠️'
-            else
-              '⚠️ Error occurred ⚠️'
-            end
-
-    assert_equal title, formatter.title
-  end
-
-  #
-  # #subtitle
-  #
-  test 'subtitle without accumulated error' do
-    formatter = ExceptionNotifier::Formatter.new(@exception)
-    assert_equal 'A *RuntimeError* occurred.', formatter.subtitle
-  end
-
-  test 'subtitle with accumulated error' do
-    formatter = ExceptionNotifier::Formatter.new(@exception, accumulated_errors_count: 3)
-    assert_equal '3 *RuntimeError* occurred.', formatter.subtitle
-  end
-
-  test 'subtitle with controller' do
-    env = Rack::MockRequest.env_for(
-      '/', 'action_controller.instance' => test_controller
-    )
-
-    formatter = ExceptionNotifier::Formatter.new(@exception, env: env)
-    assert_equal 'A *RuntimeError* occurred in *home#index*.', formatter.subtitle
-  end
-
-  #
-  # #app_name
-  #
-  test 'app_name defaults to Rails app name' do
-    formatter = ExceptionNotifier::Formatter.new(@exception)
-
-    if defined?(::Rails) && ::Rails.respond_to?(:application)
-      assert_equal 'dummy', formatter.app_name
-    else
-      assert_nil formatter.app_name
-    end
-  end
-
-  test 'app_name can be overwritten using options' do
-    formatter = ExceptionNotifier::Formatter.new(@exception, app_name: 'test')
-    assert_equal 'test', formatter.app_name
-  end
-
-  #
-  # #request_message
-  #
-  test 'request_message when env set' do
-    text = [
-      '```',
-      '* 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")
-
-    env = Rack::MockRequest.env_for(
-      '/',
-      'HTTP_HOST' => 'test.address',
-      'REMOTE_ADDR' => '127.0.0.1',
-      params: { id: 'foo' }
-    )
-
-    formatter = ExceptionNotifier::Formatter.new(@exception, env: env)
-    assert_equal text, formatter.request_message
-  end
-
-  test 'request_message when env not set' do
-    formatter = ExceptionNotifier::Formatter.new(@exception)
-    assert_nil formatter.request_message
-  end
-
-  #
-  # #backtrace_message
-  #
-  test 'backtrace_message when backtrace set' do
-    text = [
-      '```',
-      "* app/controllers/my_controller.rb:53:in `my_controller_params'",
-      "* app/controllers/my_controller.rb:34:in `update'",
-      '```'
-    ].join("\n")
-
-    @exception.set_backtrace([
-                               "app/controllers/my_controller.rb:53:in `my_controller_params'",
-                               "app/controllers/my_controller.rb:34:in `update'"
-                             ])
-
-    formatter = ExceptionNotifier::Formatter.new(@exception)
-    assert_equal text, formatter.backtrace_message
-  end
-
-  test 'backtrace_message when no backtrace' do
-    formatter = ExceptionNotifier::Formatter.new(@exception)
-    assert_nil formatter.backtrace_message
-  end
-
-  #
-  # #controller_and_action
-  #
-  test 'correct controller_and_action if controller is present' do
-    env = Rack::MockRequest.env_for(
-      '/', 'action_controller.instance' => test_controller
-    )
-
-    formatter = ExceptionNotifier::Formatter.new(@exception, env: env)
-    assert_equal 'home#index', formatter.controller_and_action
-  end
-
-  test 'controller_and_action is nil if no controller' do
-    env = Rack::MockRequest.env_for('/')
-
-    formatter = ExceptionNotifier::Formatter.new(@exception, env: env)
-    assert_nil formatter.controller_and_action
-  end
-
-  def test_controller
-    controller = mock('controller')
-    controller.stubs(:action_name).returns('index')
-    controller.stubs(:controller_name).returns('home')
-
-    controller
-  end
-end

data/test/exception_notifier/sidekiq_test.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-# To allow sidekiq error handlers to be registered, sidekiq must be in
-# "server mode". This mode is triggered by loading sidekiq/cli. Note this
-# has to be loaded before exception_notification/sidekiq.
-require 'sidekiq/cli'
-require 'sidekiq/testing'
-
-require 'exception_notification/sidekiq'
-
-class MockSidekiqServer
-  include ::Sidekiq::Component
-
-  def config
-    Sidekiq.default_configuration
-  end
-end
-
-class SidekiqTest < ActiveSupport::TestCase
-  test 'should call notify_exception when sidekiq raises an error' do
-    server = MockSidekiqServer.new
-    message = {}
-    exception = RuntimeError.new
-
-    ExceptionNotifier.expects(:notify_exception).with(
-      exception,
-      data: { sidekiq: message }
-    )
-
-    server.handle_exception(exception, message)
-  end
-end