exception_notification 3.0.1 → 4.4.0

data/test/exception_notifier/sns_notifier_test.rb

@@ -0,0 +1,121 @@
+require 'test_helper'
+require 'aws-sdk-sns'
+
+class SnsNotifierTest < ActiveSupport::TestCase
+  def setup
+    @exception = fake_exception
+    @exception.stubs(:class).returns('MyException')
+    @exception.stubs(:backtrace).returns(fake_backtrace)
+    @exception.stubs(:message).returns("undefined method 'method=' for Empty")
+    @options = {
+      access_key_id: 'my-access_key_id',
+      secret_access_key: 'my-secret_access_key',
+      region: 'us-east',
+      topic_arn: 'topicARN',
+      sns_prefix: '[App Exception]'
+    }
+    Socket.stubs(:gethostname).returns('example.com')
+  end
+
+  # initialize
+
+  test 'should initialize aws notifier with received params' do
+    Aws::SNS::Client.expects(:new).with(
+      region: 'us-east',
+      access_key_id: 'my-access_key_id',
+      secret_access_key: 'my-secret_access_key'
+    )
+
+    ExceptionNotifier::SnsNotifier.new(@options)
+  end
+
+  test 'should raise an exception if region is not received' do
+    @options[:region] = nil
+
+    error = assert_raises ArgumentError do
+      ExceptionNotifier::SnsNotifier.new(@options)
+    end
+    assert_equal "You must provide 'region' option", error.message
+  end
+
+  test 'should raise an exception on publish if access_key_id is not received' do
+    @options[:access_key_id] = nil
+    error = assert_raises ArgumentError do
+      ExceptionNotifier::SnsNotifier.new(@options)
+    end
+
+    assert_equal "You must provide 'access_key_id' option", error.message
+  end
+
+  test 'should raise an exception on publish if secret_access_key is not received' do
+    @options[:secret_access_key] = nil
+    error = assert_raises ArgumentError do
+      ExceptionNotifier::SnsNotifier.new(@options)
+    end
+
+    assert_equal "You must provide 'secret_access_key' option", error.message
+  end
+
+  # call
+
+  test 'should send a sns notification in background' do
+    Aws::SNS::Client.any_instance.expects(:publish).with(
+      topic_arn: 'topicARN',
+      message: "3 MyException occured in background\n"\
+             "Exception: undefined method 'method=' for Empty\n"\
+             "Hostname: example.com\n"\
+             "Backtrace:\n#{fake_backtrace.join("\n")}\n",
+      subject: '[App Exception] - 3 MyException occurred'
+    )
+
+    sns_notifier = ExceptionNotifier::SnsNotifier.new(@options)
+    sns_notifier.call(@exception, accumulated_errors_count: 3)
+  end
+
+  test 'should send a sns notification with controller#action information' do
+    controller = mock('controller')
+    controller.stubs(:action_name).returns('index')
+    controller.stubs(:controller_name).returns('examples')
+
+    Aws::SNS::Client.any_instance.expects(:publish).with(
+      topic_arn: 'topicARN',
+      message: 'A MyException occurred while GET </examples> '\
+             "was processed by examples#index\n"\
+             "Exception: undefined method 'method=' for Empty\n"\
+             "Hostname: example.com\n"\
+             "Backtrace:\n#{fake_backtrace.join("\n")}\n",
+      subject: '[App Exception] - A MyException occurred'
+    )
+
+    sns_notifier = ExceptionNotifier::SnsNotifier.new(@options)
+    sns_notifier.call(@exception,
+                      env: {
+                        'REQUEST_METHOD' => 'GET',
+                        'REQUEST_URI' => '/examples',
+                        'action_controller.instance' => controller
+                      })
+  end
+
+  private
+
+  def fake_exception
+    1 / 0
+  rescue StandardError => e
+    e
+  end
+
+  def fake_exception_without_backtrace
+    StandardError.new('my custom error')
+  end
+
+  def fake_backtrace
+    [
+      'backtrace line 1',
+      'backtrace line 2',
+      'backtrace line 3',
+      'backtrace line 4',
+      'backtrace line 5',
+      'backtrace line 6'
+    ]
+  end
+end

data/test/exception_notifier/teams_notifier_test.rb

@@ -0,0 +1,90 @@
+require 'test_helper'
+require 'httparty'
+
+class TeamsNotifierTest < ActiveSupport::TestCase
+  test 'should send notification if properly configured' do
+    options = {
+      webhook_url: 'http://localhost:8000'
+    }
+    teams_notifier = ExceptionNotifier::TeamsNotifier.new
+    teams_notifier.httparty = FakeHTTParty.new
+
+    options = teams_notifier.call ArgumentError.new('foo'), options
+
+    body = ActiveSupport::JSON.decode options[:body]
+    assert body.key? 'title'
+    assert body.key? 'sections'
+
+    sections = body['sections']
+    header = sections[0]
+
+    assert_equal 2, sections.size
+    assert_equal 'A *ArgumentError* occurred.', header['activityTitle']
+    assert_equal 'foo', header['activitySubtitle']
+  end
+
+  test 'should send notification with create gitlab issue link if specified' do
+    options = {
+      webhook_url: 'http://localhost:8000',
+      git_url: 'github.com/aschen'
+    }
+    teams_notifier = ExceptionNotifier::TeamsNotifier.new
+    teams_notifier.httparty = FakeHTTParty.new
+
+    options = teams_notifier.call ArgumentError.new('foo'), options
+
+    body = ActiveSupport::JSON.decode options[:body]
+
+    potential_action = body['potentialAction']
+    assert_equal 2, potential_action.size
+    assert_equal '🦊 View in GitLab', potential_action[0]['name']
+    assert_equal '🦊 Create Issue in GitLab', potential_action[1]['name']
+  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'
+      }
+    }
+    teams_notifier = ExceptionNotifier::TeamsNotifier.new
+    teams_notifier.httparty = FakeHTTParty.new
+
+    options = teams_notifier.call ArgumentError.new('foo'), options
+
+    assert options.key? :basic_auth
+    assert 'clara', options[:basic_auth][:username]
+    assert 'password', options[:basic_auth][:password]
+  end
+
+  test "should use 'A' for exceptions count if :accumulated_errors_count option is nil" do
+    teams_notifier = ExceptionNotifier::TeamsNotifier.new
+    exception = ArgumentError.new('foo')
+    teams_notifier.instance_variable_set(:@exception, exception)
+    teams_notifier.instance_variable_set(:@options, {})
+
+    message_text = teams_notifier.send(:message_text)
+    header = message_text['sections'][0]
+    assert_equal 'A *ArgumentError* occurred.', header['activityTitle']
+  end
+
+  test 'should use direct errors count if :accumulated_errors_count option is 5' do
+    teams_notifier = ExceptionNotifier::TeamsNotifier.new
+    exception = ArgumentError.new('foo')
+    teams_notifier.instance_variable_set(:@exception, exception)
+    teams_notifier.instance_variable_set(:@options, accumulated_errors_count: 5)
+    message_text = teams_notifier.send(:message_text)
+    header = message_text['sections'][0]
+    assert_equal '5 *ArgumentError* occurred.', header['activityTitle']
+  end
+end
+
+class FakeHTTParty
+  def post(_url, options)
+    options
+  end
+end

data/test/exception_notifier/webhook_notifier_test.rb

@@ -0,0 +1,96 @@
+require 'test_helper'
+require 'httparty'
+
+class WebhookNotifierTest < ActiveSupport::TestCase
+  test 'should send webhook notification if properly configured' do
+    ExceptionNotifier::WebhookNotifier.stubs(:new).returns(Object.new)
+    webhook = ExceptionNotifier::WebhookNotifier.new(url: 'http://localhost:8000')
+    webhook.stubs(:call).returns(fake_response)
+    response = webhook.call(fake_exception)
+
+    refute_nil response
+    assert_equal response[:status], 200
+    assert_equal response[:body][:exception][:error_class], 'ZeroDivisionError'
+    assert_includes response[:body][:exception][:message], 'divided by 0'
+    assert_includes response[:body][:exception][:backtrace], '/exception_notification/test/webhook_notifier_test.rb:48'
+
+    assert response[:body][:request][:cookies].key?(:cookie_item1)
+    assert_equal response[:body][:request][:url], 'http://example.com/example'
+    assert_equal response[:body][:request][:ip_address], '192.168.1.1'
+    assert response[:body][:request][:environment].key?(:env_item1)
+    assert_equal response[:body][:request][:controller], '#<ControllerName:0x007f9642a04d00>'
+    assert response[:body][:request][:session].key?(:session_item1)
+    assert response[:body][:request][:parameters].key?(:controller)
+    assert response[:body][:data][:extra_data].key?(:data_item1)
+  end
+
+  test 'should send webhook notification with correct params data' do
+    url = 'http://localhost:8000'
+    fake_exception.stubs(:backtrace).returns('the backtrace')
+    webhook = ExceptionNotifier::WebhookNotifier.new(url: url)
+
+    HTTParty.expects(:send).with(:post, url, fake_params)
+
+    webhook.call(fake_exception)
+  end
+
+  test 'should call pre/post_callback if specified' do
+    HTTParty.stubs(:send).returns(fake_response)
+    webhook = ExceptionNotifier::WebhookNotifier.new(url: 'http://localhost:8000')
+    webhook.call(fake_exception)
+  end
+
+  private
+
+  def fake_response
+    {
+      status: 200,
+      body: {
+        exception: {
+          error_class: 'ZeroDivisionError',
+          message: 'divided by 0',
+          backtrace: '/exception_notification/test/webhook_notifier_test.rb:48:in `/'
+        },
+        data: {
+          extra_data: { data_item1: 'datavalue1', data_item2: 'datavalue2' }
+        },
+        request: {
+          cookies: { cookie_item1: 'cookieitemvalue1', cookie_item2: 'cookieitemvalue2' },
+          url: 'http://example.com/example',
+          ip_address: '192.168.1.1',
+          environment: { env_item1: 'envitem1', env_item2: 'envitem2' },
+          controller: '#<ControllerName:0x007f9642a04d00>',
+          session: { session_item1: 'sessionitem1', session_item2: 'sessionitem2' },
+          parameters: { action: 'index', controller: 'projects' }
+        }
+      }
+    }
+  end
+
+  def fake_params
+    params = {
+      body: {
+        server: Socket.gethostname,
+        process: $PROCESS_ID,
+        exception: {
+          error_class: 'ZeroDivisionError',
+          message: 'divided by 0'.inspect,
+          backtrace: 'the backtrace'
+        },
+        data: {}
+      }
+    }
+
+    params[:body][:rails_root] = Rails.root if defined?(::Rails) && Rails.respond_to?(:root)
+
+    params
+  end
+
+  def fake_exception
+    @fake_exception ||= begin
+      5 / 0
+    rescue StandardError => e
+      e
+    end
+  end
+end

data/test/exception_notifier_test.rb

@@ -0,0 +1,182 @@
+require 'test_helper'
+
+class ExceptionOne < StandardError; end
+class ExceptionTwo < StandardError; end
+
+class ExceptionNotifierTest < ActiveSupport::TestCase
+  setup do
+    ExceptionNotifier.register_exception_notifier(:email, exception_recipients: %w[dummyexceptions@example.com])
+
+    @notifier_calls = 0
+    @test_notifier = ->(_exception, _options) { @notifier_calls += 1 }
+  end
+
+  teardown do
+    ExceptionNotifier.error_grouping = false
+    ExceptionNotifier.notification_trigger = nil
+    ExceptionNotifier.class_eval('@@notifiers.delete_if { |k, _| k.to_s != "email"}') # reset notifiers
+
+    Rails.cache.clear if defined?(Rails) && Rails.respond_to?(:cache)
+  end
+
+  test 'should have default ignored exceptions' do
+    assert_equal ExceptionNotifier.ignored_exceptions,
+                 ['ActiveRecord::RecordNotFound', 'Mongoid::Errors::DocumentNotFound', 'AbstractController::ActionNotFound',
+                  'ActionController::RoutingError', 'ActionController::UnknownFormat', 'ActionController::UrlGenerationError']
+  end
+
+  test 'should have email notifier registered' do
+    assert_equal ExceptionNotifier.notifiers, [:email]
+  end
+
+  test 'should have a valid email notifier' do
+    @email_notifier = ExceptionNotifier.registered_exception_notifier(:email)
+    refute_nil @email_notifier
+    assert_equal @email_notifier.class, ExceptionNotifier::EmailNotifier
+    assert_respond_to @email_notifier, :call
+  end
+
+  test 'should allow register/unregister another notifier' do
+    called = false
+    proc_notifier = ->(_exception, _options) { called = true }
+    ExceptionNotifier.register_exception_notifier(:proc, proc_notifier)
+
+    assert_equal ExceptionNotifier.notifiers.sort, %i[email proc]
+
+    exception = StandardError.new
+
+    ExceptionNotifier.notify_exception(exception)
+    assert called
+
+    ExceptionNotifier.unregister_exception_notifier(:proc)
+    assert_equal ExceptionNotifier.notifiers, [:email]
+  end
+
+  test 'should allow select notifiers to send error to' do
+    notifier1_calls = 0
+    notifier1 = ->(_exception, _options) { notifier1_calls += 1 }
+    ExceptionNotifier.register_exception_notifier(:notifier1, notifier1)
+
+    notifier2_calls = 0
+    notifier2 = ->(_exception, _options) { notifier2_calls += 1 }
+    ExceptionNotifier.register_exception_notifier(:notifier2, notifier2)
+
+    assert_equal ExceptionNotifier.notifiers.sort, %i[email notifier1 notifier2]
+
+    exception = StandardError.new
+    ExceptionNotifier.notify_exception(exception)
+    assert_equal notifier1_calls, 1
+    assert_equal notifier2_calls, 1
+
+    ExceptionNotifier.notify_exception(exception, notifiers: :notifier1)
+    assert_equal notifier1_calls, 2
+    assert_equal notifier2_calls, 1
+
+    ExceptionNotifier.notify_exception(exception, notifiers: :notifier2)
+    assert_equal notifier1_calls, 2
+    assert_equal notifier2_calls, 2
+
+    ExceptionNotifier.unregister_exception_notifier(:notifier1)
+    ExceptionNotifier.unregister_exception_notifier(:notifier2)
+    assert_equal ExceptionNotifier.notifiers, [:email]
+  end
+
+  test 'should ignore exception if satisfies conditional ignore' do
+    env = 'production'
+    ExceptionNotifier.ignore_if do |_exception, _options|
+      env != 'production'
+    end
+
+    ExceptionNotifier.register_exception_notifier(:test, @test_notifier)
+
+    exception = StandardError.new
+
+    ExceptionNotifier.notify_exception(exception, notifiers: :test)
+    assert_equal @notifier_calls, 1
+
+    env = 'development'
+    ExceptionNotifier.notify_exception(exception, notifiers: :test)
+    assert_equal @notifier_calls, 1
+
+    ExceptionNotifier.clear_ignore_conditions!
+  end
+
+  test 'should not send notification if one of ignored exceptions' do
+    ExceptionNotifier.register_exception_notifier(:test, @test_notifier)
+
+    exception = StandardError.new
+
+    ExceptionNotifier.notify_exception(exception, notifiers: :test)
+    assert_equal @notifier_calls, 1
+
+    ExceptionNotifier.notify_exception(exception, notifiers: :test, ignore_exceptions: 'StandardError')
+    assert_equal @notifier_calls, 1
+  end
+
+  test 'should not send notification if subclass of one of ignored exceptions' do
+    ExceptionNotifier.register_exception_notifier(:test, @test_notifier)
+
+    class StandardErrorSubclass < StandardError
+    end
+
+    exception = StandardErrorSubclass.new
+
+    ExceptionNotifier.notify_exception(exception, notifiers: :test)
+    assert_equal @notifier_calls, 1
+
+    ExceptionNotifier.notify_exception(exception, notifiers: :test, ignore_exceptions: 'StandardError')
+    assert_equal @notifier_calls, 1
+  end
+
+  test 'should call received block' do
+    @block_called = false
+    notifier = ->(_exception, _options, &block) { block.call }
+    ExceptionNotifier.register_exception_notifier(:test, notifier)
+
+    exception = ExceptionOne.new
+
+    ExceptionNotifier.notify_exception(exception) do
+      @block_called = true
+    end
+
+    assert @block_called
+  end
+
+  test 'should not call group_error! or send_notification? if error_grouping false' do
+    exception = StandardError.new
+    ExceptionNotifier.expects(:group_error!).never
+    ExceptionNotifier.expects(:send_notification?).never
+
+    ExceptionNotifier.notify_exception(exception)
+  end
+
+  test 'should call group_error! and send_notification? if error_grouping true' do
+    ExceptionNotifier.error_grouping = true
+
+    exception = StandardError.new
+    ExceptionNotifier.expects(:group_error!).once
+    ExceptionNotifier.expects(:send_notification?).once
+
+    ExceptionNotifier.notify_exception(exception)
+  end
+
+  test 'should skip notification if send_notification? is false' do
+    ExceptionNotifier.error_grouping = true
+
+    exception = StandardError.new
+    ExceptionNotifier.expects(:group_error!).once.returns(1)
+    ExceptionNotifier.expects(:send_notification?).with(exception, 1).once.returns(false)
+
+    refute ExceptionNotifier.notify_exception(exception)
+  end
+
+  test 'should send notification if send_notification? is true' do
+    ExceptionNotifier.error_grouping = true
+
+    exception = StandardError.new
+    ExceptionNotifier.expects(:group_error!).once.returns(1)
+    ExceptionNotifier.expects(:send_notification?).with(exception, 1).once.returns(true)
+
+    assert ExceptionNotifier.notify_exception(exception)
+  end
+end