exception_notification 4.2.1 → 4.4.3

data/test/exception_notifier/sns_notifier_test.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+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,92 @@
+# frozen_string_literal: true
+
+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

@@ -1,43 +1,44 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 require 'httparty'
 
 class WebhookNotifierTest < ActiveSupport::TestCase
-
-  test "should send webhook notification if properly configured" do
+  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 = 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_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].has_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].has_key?(:env_item1)
-    assert_equal response[:body][:request][:controller], "#<ControllerName:0x007f9642a04d00>"
-    assert response[:body][:request][:session].has_key?(:session_item1)
-    assert response[:body][:request][:parameters].has_key?(:controller)
-    assert response[:body][:data][:extra_data].has_key?(:data_item1)
+    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
+  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})
+    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
+  test 'should call pre/post_callback if specified' do
     HTTParty.stubs(:send).returns(fake_response)
-    webhook = ExceptionNotifier::WebhookNotifier.new({:url => 'http://localhost:8000'})
+    webhook = ExceptionNotifier::WebhookNotifier.new(url: 'http://localhost:8000')
     webhook.call(fake_exception)
   end
 
@@ -45,50 +46,53 @@ class WebhookNotifierTest < ActiveSupport::TestCase
 
   def fake_response
     {
-      :status => 200,
-      :body => {
-        :exception => {
-          :error_class => 'ZeroDivisionError',
-          :message => 'divided by 0',
-          :backtrace => '/exception_notification/test/webhook_notifier_test.rb:48:in `/'
+      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"}
+        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"}
+        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
-    {
-      :body => {
-        :server => Socket.gethostname,
-        :process => $$,
-        :rails_root => Rails.root,
-        :exception => {
-          :error_class => 'ZeroDivisionError',
-          :message => 'divided by 0'.inspect,
-          :backtrace => 'the backtrace'
+    params = {
+      body: {
+        server: Socket.gethostname,
+        process: $PROCESS_ID,
+        exception: {
+          error_class: 'ZeroDivisionError',
+          message: 'divided by 0'.inspect,
+          backtrace: 'the backtrace'
         },
-        :data => {}
+        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 Exception => e
-      e
-    end
+                          5 / 0
+                        rescue StandardError => e
+                          e
+                        end
   end
 end

data/test/exception_notifier_test.rb

@@ -1,29 +1,48 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
+class ExceptionOne < StandardError; end
+class ExceptionTwo < StandardError; end
+
 class ExceptionNotifierTest < ActiveSupport::TestCase
-  test "should have default ignored exceptions" do
+  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.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']
+                 ['ActiveRecord::RecordNotFound', 'Mongoid::Errors::DocumentNotFound',
+                  'AbstractController::ActionNotFound', 'ActionController::RoutingError',
+                  'ActionController::UnknownFormat', 'ActionController::UrlGenerationError']
   end
 
-  test "should have email notifier registered" do
+  test 'should have email notifier registered' do
     assert_equal ExceptionNotifier.notifiers, [:email]
   end
 
-  test "should have a valid email notifier" do
+  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
+  test 'should allow register/unregister another notifier' do
     called = false
-    proc_notifier = lambda { |exception, options| called = true }
+    proc_notifier = ->(_exception, _options) { called = true }
     ExceptionNotifier.register_exception_notifier(:proc, proc_notifier)
 
-    assert_equal ExceptionNotifier.notifiers.sort, [:email, :proc]
+    assert_equal ExceptionNotifier.notifiers.sort, %i[email proc]
 
     exception = StandardError.new
 
@@ -34,27 +53,27 @@ class ExceptionNotifierTest < ActiveSupport::TestCase
     assert_equal ExceptionNotifier.notifiers, [:email]
   end
 
-  test "should allow select notifiers to send error to" do
+  test 'should allow select notifiers to send error to' do
     notifier1_calls = 0
-    notifier1 = lambda { |exception, options| notifier1_calls += 1 }
+    notifier1 = ->(_exception, _options) { notifier1_calls += 1 }
     ExceptionNotifier.register_exception_notifier(:notifier1, notifier1)
 
     notifier2_calls = 0
-    notifier2 = lambda { |exception, options| notifier2_calls += 1 }
+    notifier2 = ->(_exception, _options) { notifier2_calls += 1 }
     ExceptionNotifier.register_exception_notifier(:notifier2, notifier2)
 
-    assert_equal ExceptionNotifier.notifiers.sort, [:email, :notifier1, :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})
+    ExceptionNotifier.notify_exception(exception, notifiers: :notifier1)
     assert_equal notifier1_calls, 2
     assert_equal notifier2_calls, 1
 
-    ExceptionNotifier.notify_exception(exception, {:notifiers => :notifier2})
+    ExceptionNotifier.notify_exception(exception, notifiers: :notifier2)
     assert_equal notifier1_calls, 2
     assert_equal notifier2_calls, 2
 
@@ -63,43 +82,207 @@ class ExceptionNotifierTest < ActiveSupport::TestCase
     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"
+  test 'should ignore exception if satisfies conditional ignore' do
+    env = 'production'
+    ExceptionNotifier.ignore_if do |_exception, _options|
+      env != 'production'
     end
 
-    notifier_calls = 0
-    test_notifier = lambda { |exception, options| notifier_calls += 1 }
-    ExceptionNotifier.register_exception_notifier(:test, test_notifier)
+    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
+  end
+
+  test 'should ignore exception if satisfies by-notifier conditional ignore' 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)
+
+    env = 'production'
+    ExceptionNotifier.ignore_notifier_if(:notifier1) do |_exception, _options|
+      env == 'development'
+    end
+    ExceptionNotifier.ignore_notifier_if(:notifier2) do |_exception, _options|
+      env == 'production'
+    end
 
     exception = StandardError.new
 
-    ExceptionNotifier.notify_exception(exception, {:notifiers => :test})
-    assert_equal notifier_calls, 1
+    ExceptionNotifier.notify_exception(exception)
+    assert_equal notifier1_calls, 1
+    assert_equal notifier2_calls, 0
+
+    env = 'development'
+
+    ExceptionNotifier.notify_exception(exception)
+    assert_equal notifier1_calls, 1
+    assert_equal notifier2_calls, 1
+
+    env = 'test'
+
+    ExceptionNotifier.notify_exception(exception)
+    assert_equal notifier1_calls, 2
+    assert_equal notifier2_calls, 2
+  end
+
+  test 'should return false if all the registered notifiers are ignored' do
+    ExceptionNotifier.notifiers.each do |notifier|
+      # make sure to register no other notifiers but the tested ones
+      ExceptionNotifier.unregister_exception_notifier(notifier)
+    end
+
+    ExceptionNotifier.register_exception_notifier(:notifier1, ->(_, _) {})
+    ExceptionNotifier.register_exception_notifier(:notifier2, ->(_, _) {})
+
+    ExceptionNotifier.ignore_notifier_if(:notifier1) do |exception, _options|
+      exception.message =~ /non_critical_error/
+    end
+    ExceptionNotifier.ignore_notifier_if(:notifier2) do |exception, _options|
+      exception.message =~ /non_critical_error/
+    end
 
-    env = "development"
-    ExceptionNotifier.notify_exception(exception, {:notifiers => :test})
-    assert_equal notifier_calls, 1
+    exception = StandardError.new('a non_critical_error occured.')
 
-    ExceptionNotifier.clear_ignore_conditions!
-    ExceptionNotifier.unregister_exception_notifier(:test)
+    refute ExceptionNotifier.notify_exception(exception)
   end
 
-  test "should not send notification if one of ignored exceptions" do
-    notifier_calls = 0
-    test_notifier = lambda { |exception, options| notifier_calls += 1 }
-    ExceptionNotifier.register_exception_notifier(:test, test_notifier)
+  test 'should return true if one of the notifiers fires' do
+    ExceptionNotifier.notifiers.each do |notifier|
+      # make sure to register no other notifiers but the tested ones
+      ExceptionNotifier.unregister_exception_notifier(notifier)
+    end
+
+    ExceptionNotifier.register_exception_notifier(:notifier1, ->(_, _) {})
+    ExceptionNotifier.register_exception_notifier(:notifier2, ->(_, _) {})
+
+    ExceptionNotifier.ignore_notifier_if(:notifier1) do |exception, _options|
+      exception.message =~ /non-critical\serror/
+    end
+
+    exception = StandardError.new('a non-critical error occured')
+
+    assert ExceptionNotifier.notify_exception(exception)
+  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 not send notification if extended module one of ignored exceptions' do
+    ExceptionNotifier.register_exception_notifier(:test, @test_notifier)
+
+    module StandardErrorModule; end
 
     exception = StandardError.new
+    exception.extend StandardErrorModule
+
+    ExceptionNotifier.notify_exception(exception, notifiers: :test)
+    assert_equal @notifier_calls, 1
+
+    ignore_exceptions = 'ExceptionNotifierTest::StandardErrorModule'
+    ExceptionNotifier.notify_exception(exception, notifiers: :test, ignore_exceptions: ignore_exceptions)
+    assert_equal @notifier_calls, 1
+  end
 
-    ExceptionNotifier.notify_exception(exception, {:notifiers => :test})
-    assert_equal notifier_calls, 1
+  test 'should not send notification if prepended module at singleton class one of ignored exceptions' do
+    ExceptionNotifier.register_exception_notifier(:test, @test_notifier)
 
-    ExceptionNotifier.notify_exception(exception, {:notifiers => :test, :ignore_exceptions => 'StandardError' })
-    assert_equal notifier_calls, 1
+    module StandardErrorModule; end
 
-    ExceptionNotifier.unregister_exception_notifier(:test)
+    exception = StandardError.new
+    exception.singleton_class.prepend StandardErrorModule
+
+    ExceptionNotifier.notify_exception(exception, notifiers: :test)
+    assert_equal @notifier_calls, 1
+
+    ignore_exceptions = 'ExceptionNotifierTest::StandardErrorModule'
+    ExceptionNotifier.notify_exception(exception, notifiers: :test, ignore_exceptions: ignore_exceptions)
+    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