exception_notification 4.6.0 → 5.0.1

data/test/exception_notification/rack_test.rb

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class RackTest < ActiveSupport::TestCase
-  setup do
-    @pass_app = Object.new
-    @pass_app.stubs(:call).returns([nil, { 'X-Cascade' => 'pass' }, nil])
-
-    @normal_app = Object.new
-    @normal_app.stubs(:call).returns([nil, {}, nil])
-  end
-
-  teardown do
-    ExceptionNotifier.reset_notifiers!
-  end
-
-  test 'should ignore "X-Cascade" header by default' do
-    ExceptionNotifier.expects(:notify_exception).never
-    ExceptionNotification::Rack.new(@pass_app).call({})
-  end
-
-  test 'should notify on "X-Cascade" = "pass" if ignore_cascade_pass option is false' do
-    ExceptionNotifier.expects(:notify_exception).once
-    ExceptionNotification::Rack.new(@pass_app, ignore_cascade_pass: false).call({})
-  end
-
-  test 'should assign error_grouping if error_grouping is specified' do
-    refute ExceptionNotifier.error_grouping
-    ExceptionNotification::Rack.new(@normal_app, error_grouping: true).call({})
-    assert ExceptionNotifier.error_grouping
-  end
-
-  test 'should assign notification_trigger if notification_trigger is specified' do
-    assert_nil ExceptionNotifier.notification_trigger
-    ExceptionNotification::Rack.new(@normal_app, notification_trigger: ->(_i) { true }).call({})
-    assert_respond_to ExceptionNotifier.notification_trigger, :call
-  end
-
-  if defined?(Rails) && Rails.respond_to?(:cache)
-    test 'should set default cache to Rails cache' do
-      ExceptionNotification::Rack.new(@normal_app, error_grouping: true).call({})
-      assert_equal Rails.cache, ExceptionNotifier.error_grouping_cache
-    end
-  end
-
-  test 'should ignore exceptions with Usar Agent in ignore_crawlers' do
-    exception_app = Object.new
-    exception_app.stubs(:call).raises(RuntimeError)
-
-    env = { 'HTTP_USER_AGENT' => 'Mozilla/5.0 (compatible; Crawlerbot/2.1;)' }
-
-    begin
-      ExceptionNotification::Rack.new(exception_app, ignore_crawlers: %w[Crawlerbot]).call(env)
-
-      flunk
-    rescue StandardError
-      refute env['exception_notifier.delivered']
-    end
-  end
-
-  test 'should ignore exceptions if ignore_if condition is met' do
-    exception_app = Object.new
-    exception_app.stubs(:call).raises(RuntimeError)
-
-    env = {}
-
-    begin
-      ExceptionNotification::Rack.new(
-        exception_app,
-        ignore_if: ->(_env, exception) { exception.is_a? RuntimeError }
-      ).call(env)
-
-      flunk
-    rescue StandardError
-      refute env['exception_notifier.delivered']
-    end
-  end
-
-  test 'should ignore exceptions with notifiers that satisfies ignore_notifier_if condition' do
-    exception_app = Object.new
-    exception_app.stubs(:call).raises(RuntimeError)
-
-    notifier1_called = notifier2_called = false
-    notifier1 = ->(_exception, _options) { notifier1_called = true }
-    notifier2 = ->(_exception, _options) { notifier2_called = true }
-
-    env = {}
-
-    begin
-      ExceptionNotification::Rack.new(
-        exception_app,
-        ignore_notifier_if: {
-          notifier1: ->(_env, exception) { exception.is_a? RuntimeError }
-        },
-        notifier1: notifier1,
-        notifier2: notifier2
-      ).call(env)
-
-      flunk
-    rescue StandardError
-      refute notifier1_called
-      assert notifier2_called
-    end
-  end
-end

data/test/exception_notification/rake_test.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-require 'rake'
-require 'exception_notification/rake'
-
-class RakeTest < ActiveSupport::TestCase
-  setup do
-    Rake::Task.define_task :dependency_1 do
-      puts :dependency_1
-    end
-    Rake::Task.define_task raise_exception: :dependency_1 do
-      raise 'test exception'
-    end
-    @task = Rake::Task[:raise_exception]
-  end
-
-  test 'notifies of exception' do
-    ExceptionNotifier.expects(:notify_exception).with do |ex, opts|
-      data = opts[:data]
-      ex.is_a?(RuntimeError) &&
-        ex.message == 'test exception' &&
-        data[:error_class] == 'RuntimeError' &&
-        data[:error_message] == 'test exception' &&
-        data[:rake][:rake_command_line] == 'rake ' &&
-        data[:rake][:name] == 'raise_exception' &&
-        data[:rake][:timestamp] &&
-        data[:rake][:sources] == ['dependency_1'] &&
-        data[:rake][:prerequisite_tasks][0][:name] == 'dependency_1'
-    end
-
-    # The original error is re-raised
-    assert_raises(RuntimeError) do
-      @task.invoke
-    end
-  end
-end

data/test/exception_notification/resque_test.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-require 'exception_notification/resque'
-require 'resque'
-require 'mock_redis'
-require 'resque/failure/multiple'
-require 'resque/failure/redis'
-
-class ResqueTest < ActiveSupport::TestCase
-  setup do
-    # Resque.redis=() only supports a String or Redis instance in Resque 1.8
-    Resque.instance_variable_set(:@redis, MockRedis.new)
-
-    Resque::Failure::Multiple.classes = [Resque::Failure::Redis, ExceptionNotification::Resque]
-    Resque::Failure.backend = Resque::Failure::Multiple
-
-    @worker = Resque::Worker.new(:jobs)
-    # Forking causes issues with Mocha's `.expects`
-    @worker.cant_fork = true
-  end
-
-  test 'count returns the number of failures' do
-    Resque::Job.create(:jobs, BadJob)
-    @worker.work(0)
-    assert_equal 1, ExceptionNotification::Resque.count
-  end
-
-  test 'notifies exception when job fails' do
-    ExceptionNotifier.expects(:notify_exception).with do |ex, opts|
-      ex.is_a?(RuntimeError) &&
-        ex.message == 'Bad job!' &&
-        opts[:data][:resque][:error_class] == 'RuntimeError' &&
-        opts[:data][:resque][:error_message] == 'Bad job!' &&
-        opts[:data][:resque][:failed_at].present? &&
-        opts[:data][:resque][:payload] == {
-          'class' => 'ResqueTest::BadJob',
-          'args' => []
-        } &&
-        opts[:data][:resque][:queue] == :jobs &&
-        opts[:data][:resque][:worker].present?
-    end
-
-    Resque::Job.create(:jobs, BadJob)
-    @worker.work(0)
-  end
-
-  class BadJob
-    def self.perform
-      raise 'Bad job!'
-    end
-  end
-end

data/test/exception_notifier/datadog_notifier_test.rb

@@ -1,153 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-require 'dogapi/common'
-require 'dogapi/event'
-
-class DatadogNotifierTest < ActiveSupport::TestCase
-  def setup
-    @client = FakeDatadogClient.new
-    @options = {
-      client: @client
-    }
-    @notifier = ExceptionNotifier::DatadogNotifier.new(@options)
-    @exception = FakeException.new
-    @controller = FakeController.new
-    @request = FakeRequest.new
-  end
-
-  test 'should send an event to datadog' do
-    fake_event = Dogapi::Event.any_instance
-    @client.expects(:emit_event).with(fake_event)
-
-    @notifier.stubs(:datadog_event).returns(fake_event)
-    @notifier.call(@exception)
-  end
-
-  test 'should include exception class in event title' do
-    event = @notifier.datadog_event(@exception)
-    assert_includes event.msg_title, 'FakeException'
-  end
-
-  test 'should include prefix in event title and not append previous events' do
-    options = {
-      client: @client,
-      title_prefix: 'prefix'
-    }
-
-    notifier = ExceptionNotifier::DatadogNotifier.new(options)
-    event = notifier.datadog_event(@exception)
-    assert_equal event.msg_title, 'prefix (DatadogNotifierTest::FakeException) "Fake exception message"'
-
-    event2 = notifier.datadog_event(@exception)
-    assert_equal event2.msg_title, 'prefix (DatadogNotifierTest::FakeException) "Fake exception message"'
-  end
-
-  test 'should include exception message in event title' do
-    event = @notifier.datadog_event(@exception)
-    assert_includes event.msg_title, 'Fake exception message'
-  end
-
-  test 'should include controller info in event title if controller information is available' do
-    event = @notifier.datadog_event(@exception,
-                                    env: {
-                                      'action_controller.instance' => @controller,
-                                      'REQUEST_METHOD' => 'GET',
-                                      'rack.input' => ''
-                                    })
-    assert_includes event.msg_title, 'Fake controller'
-    assert_includes event.msg_title, 'Fake action'
-  end
-
-  test 'should include backtrace info in event body' do
-    event = @notifier.datadog_event(@exception)
-    assert_includes event.msg_text, "backtrace line 1\nbacktrace line 2\nbacktrace line 3"
-  end
-
-  test 'should include request info in event body' do
-    ActionDispatch::Request.stubs(:new).returns(@request)
-
-    event = @notifier.datadog_event(@exception,
-                                    env: {
-                                      'action_controller.instance' => @controller,
-                                      'REQUEST_METHOD' => 'GET',
-                                      'rack.input' => ''
-                                    })
-    assert_includes event.msg_text, 'http://localhost:8080'
-    assert_includes event.msg_text, 'GET'
-    assert_includes event.msg_text, '127.0.0.1'
-    assert_includes event.msg_text, '{"param 1"=>"value 1", "param 2"=>"value 2"}'
-  end
-
-  test 'should include tags in event' do
-    options = {
-      client: @client,
-      tags: %w[error production]
-    }
-    notifier = ExceptionNotifier::DatadogNotifier.new(options)
-    event = notifier.datadog_event(@exception)
-    assert_equal event.tags, %w[error production]
-  end
-
-  test 'should include event title in event aggregation key' do
-    event = @notifier.datadog_event(@exception)
-    assert_equal event.aggregation_key, [event.msg_title]
-  end
-
-  class FakeDatadogClient
-    def emit_event(event); end
-  end
-
-  class FakeController
-    def controller_name
-      'Fake controller'
-    end
-
-    def action_name
-      'Fake action'
-    end
-  end
-
-  class FakeException
-    def backtrace
-      [
-        'backtrace line 1',
-        'backtrace line 2',
-        'backtrace line 3',
-        'backtrace line 4',
-        'backtrace line 5'
-      ]
-    end
-
-    def message
-      'Fake exception message'
-    end
-  end
-
-  class FakeRequest
-    def url
-      'http://localhost:8080'
-    end
-
-    def request_method
-      'GET'
-    end
-
-    def remote_ip
-      '127.0.0.1'
-    end
-
-    def filtered_parameters
-      {
-        'param 1' => 'value 1',
-        'param 2' => 'value 2'
-      }
-    end
-
-    def session
-      {
-        'session_id' => '1234'
-      }
-    end
-  end
-end

data/test/exception_notifier/email_notifier_test.rb

@@ -1,351 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-require 'action_mailer'
-require 'action_controller'
-
-class EmailNotifierTest < ActiveSupport::TestCase
-  setup do
-    Time.stubs(:current).returns('Sat, 20 Apr 2013 20:58:55 UTC +00:00')
-
-    @exception = ZeroDivisionError.new('divided by 0')
-    @exception.set_backtrace(['test/exception_notifier/email_notifier_test.rb:20'])
-
-    @email_notifier = ExceptionNotifier::EmailNotifier.new(
-      email_prefix: '[Dummy ERROR] ',
-      sender_address: %("Dummy Notifier" <dummynotifier@example.com>),
-      exception_recipients: %w[dummyexceptions@example.com],
-      email_headers: { 'X-Custom-Header' => 'foobar' },
-      sections: %w[new_section request session environment backtrace],
-      background_sections: %w[new_bkg_section backtrace data],
-      pre_callback: proc { |_opts, _notifier, _backtrace, _message, _message_opts| @pre_callback_called = true },
-      post_callback: proc { |_opts, _notifier, _backtrace, _message, _message_opts| @post_callback_called = true },
-      smtp_settings: {
-        user_name: 'Dummy user_name',
-        password: 'Dummy password'
-      }
-    )
-
-    @mail = @email_notifier.call(
-      @exception,
-      data: { job: 'DivideWorkerJob', payload: '1/0', message: 'My Custom Message' }
-    )
-  end
-
-  test 'should call pre/post_callback if specified' do
-    assert @pre_callback_called
-    assert @post_callback_called
-  end
-
-  test 'sends mail with correct content' do
-    assert_equal %("Dummy Notifier" <dummynotifier@example.com>), @mail[:from].value
-    assert_equal %w[dummyexceptions@example.com], @mail.to
-    assert_equal '[Dummy ERROR]  (ZeroDivisionError) "divided by 0"', @mail.subject
-    assert_equal 'foobar', @mail['X-Custom-Header'].value
-    assert_equal 'text/plain; charset=UTF-8', @mail.content_type
-    assert_equal [], @mail.attachments
-    assert_equal 'Dummy user_name', @mail.delivery_method.settings[:user_name]
-    assert_equal 'Dummy password', @mail.delivery_method.settings[:password]
-
-    body = <<-BODY.gsub(/^      /, '')
-      A ZeroDivisionError occurred in background at Sat, 20 Apr 2013 20:58:55 UTC +00:00 :
-
-        divided by 0
-        test/exception_notifier/email_notifier_test.rb:20
-
-      -------------------------------
-      New bkg section:
-      -------------------------------
-
-        * New background section for testing
-
-      -------------------------------
-      Backtrace:
-      -------------------------------
-
-        test/exception_notifier/email_notifier_test.rb:20
-
-      -------------------------------
-      Data:
-      -------------------------------
-
-        * data: {:job=>"DivideWorkerJob", :payload=>"1/0", :message=>"My Custom Message"}
-
-
-    BODY
-
-    assert_equal body, @mail.decode_body
-  end
-
-  test 'should normalize multiple digits into one N' do
-    assert_equal 'N foo N bar N baz N',
-                 ExceptionNotifier::EmailNotifier.normalize_digits('1 foo 12 bar 123 baz 1234')
-  end
-
-  test "mail should prefix exception class with 'an' instead of 'a' when it starts with a vowel" do
-    begin
-      raise ArgumentError
-    rescue StandardError => e
-      @vowel_exception = e
-      @vowel_mail = @email_notifier.call(@vowel_exception)
-    end
-
-    assert_includes @vowel_mail.encoded, "An ArgumentError occurred in background at #{Time.current}"
-  end
-
-  test 'should not send notification if one of ignored exceptions' do
-    begin
-      raise AbstractController::ActionNotFound
-    rescue StandardError => e
-      @ignored_exception = e
-      unless ExceptionNotifier.ignored_exceptions.include?(@ignored_exception.class.name)
-        ignored_mail = @email_notifier.call(@ignored_exception)
-      end
-    end
-
-    assert_equal @ignored_exception.class.inspect, 'AbstractController::ActionNotFound'
-    assert_nil ignored_mail
-  end
-
-  test 'should encode environment strings' do
-    email_notifier = ExceptionNotifier::EmailNotifier.new(
-      sender_address: '<dummynotifier@example.com>',
-      exception_recipients: %w[dummyexceptions@example.com]
-    )
-
-    mail = email_notifier.call(
-      @exception,
-      env: {
-        'REQUEST_METHOD' => 'GET',
-        'rack.input' => '',
-        'invalid_encoding' => "R\xC3\xA9sum\xC3\xA9".dup.force_encoding(Encoding::ASCII)
-      }
-    )
-
-    assert_match(/invalid_encoding\s+: R__sum__/, mail.encoded)
-  end
-
-  test 'should send email using ActionMailer' do
-    ActionMailer::Base.deliveries.clear
-    @email_notifier.call(@exception)
-    assert_equal 1, ActionMailer::Base.deliveries.count
-  end
-
-  test 'should be able to specify ActionMailer::MessageDelivery method' do
-    ActionMailer::Base.deliveries.clear
-
-    deliver_with = if ActionMailer.version < Gem::Version.new('4.2')
-                     :deliver
-                   else
-                     :deliver_now
-                   end
-
-    email_notifier = ExceptionNotifier::EmailNotifier.new(
-      email_prefix: '[Dummy ERROR] ',
-      sender_address: %("Dummy Notifier" <dummynotifier@example.com>),
-      exception_recipients: %w[dummyexceptions@example.com],
-      deliver_with: deliver_with
-    )
-
-    email_notifier.call(@exception)
-
-    assert_equal 1, ActionMailer::Base.deliveries.count
-  end
-
-  test 'should lazily evaluate exception_recipients' do
-    exception_recipients = %w[first@example.com second@example.com]
-    email_notifier = ExceptionNotifier::EmailNotifier.new(
-      email_prefix: '[Dummy ERROR] ',
-      sender_address: %("Dummy Notifier" <dummynotifier@example.com>),
-      exception_recipients: -> { [exception_recipients.shift] },
-      delivery_method: :test
-    )
-
-    mail = email_notifier.call(@exception)
-    assert_equal %w[first@example.com], mail.to
-    mail = email_notifier.call(@exception)
-    assert_equal %w[second@example.com], mail.to
-  end
-
-  test 'should prepend accumulated_errors_count in email subject if accumulated_errors_count larger than 1' do
-    email_notifier = ExceptionNotifier::EmailNotifier.new(
-      email_prefix: '[Dummy ERROR] ',
-      sender_address: %("Dummy Notifier" <dummynotifier@example.com>),
-      exception_recipients: %w[dummyexceptions@example.com],
-      delivery_method: :test
-    )
-
-    mail = email_notifier.call(@exception, accumulated_errors_count: 3)
-    assert mail.subject.start_with?('[Dummy ERROR] (3 times) (ZeroDivisionError)')
-  end
-
-  test 'should not include exception message in subject when verbose_subject: false' do
-    email_notifier = ExceptionNotifier::EmailNotifier.new(
-      sender_address: %("Dummy Notifier" <dummynotifier@example.com>),
-      exception_recipients: %w[dummyexceptions@example.com],
-      verbose_subject: false
-    )
-
-    mail = email_notifier.call(@exception)
-
-    assert_equal '[ERROR]  (ZeroDivisionError)', mail.subject
-  end
-
-  test 'should send html email when selected html format' do
-    email_notifier = ExceptionNotifier::EmailNotifier.new(
-      sender_address: %("Dummy Notifier" <dummynotifier@example.com>),
-      exception_recipients: %w[dummyexceptions@example.com],
-      email_format: :html
-    )
-
-    mail = email_notifier.call(@exception)
-
-    assert mail.multipart?
-  end
-end
-
-class EmailNotifierWithEnvTest < ActiveSupport::TestCase
-  class HomeController < ActionController::Metal
-    def index; end
-  end
-
-  setup do
-    Time.stubs(:current).returns('Sat, 20 Apr 2013 20:58:55 UTC +00:00')
-
-    @exception = ZeroDivisionError.new('divided by 0')
-    @exception.set_backtrace(['test/exception_notifier/email_notifier_test.rb:20'])
-
-    @email_notifier = ExceptionNotifier::EmailNotifier.new(
-      email_prefix: '[Dummy ERROR] ',
-      sender_address: %("Dummy Notifier" <dummynotifier@example.com>),
-      exception_recipients: %w[dummyexceptions@example.com],
-      email_headers: { 'X-Custom-Header' => 'foobar' },
-      sections: %w[new_section request session environment backtrace],
-      background_sections: %w[new_bkg_section backtrace data],
-      pre_callback:
-        proc { |_opts, _notifier, _backtrace, _message, message_opts| message_opts[:pre_callback_called] = 1 },
-      post_callback:
-        proc { |_opts, _notifier, _backtrace, _message, message_opts| message_opts[:post_callback_called] = 1 }
-    )
-
-    @controller = HomeController.new
-    @controller.process(:index)
-
-    @test_env = Rack::MockRequest.env_for(
-      '/',
-      'HTTP_HOST' => 'test.address',
-      'REMOTE_ADDR' => '127.0.0.1',
-      'HTTP_USER_AGENT' => 'Rails Testing',
-      'action_dispatch.parameter_filter' => ['secret'],
-      'HTTPS' => 'on',
-      'action_controller.instance' => @controller,
-      'rack.session.options' => {},
-      params: { id: 'foo', secret: 'secret' }
-    )
-
-    @mail = @email_notifier.call(@exception, env: @test_env, data: { message: 'My Custom Message' })
-  end
-
-  test 'sends mail with correct content' do
-    assert_equal %("Dummy Notifier" <dummynotifier@example.com>), @mail[:from].value
-    assert_equal %w[dummyexceptions@example.com], @mail.to
-    assert_equal '[Dummy ERROR] home#index (ZeroDivisionError) "divided by 0"', @mail.subject
-    assert_equal 'foobar', @mail['X-Custom-Header'].value
-    assert_equal 'text/plain; charset=UTF-8', @mail.content_type
-    assert_equal [], @mail.attachments
-
-    body = <<-BODY.gsub(/^      /, '')
-      A ZeroDivisionError occurred in home#index:
-
-        divided by 0
-        test/exception_notifier/email_notifier_test.rb:20
-
-
-      -------------------------------
-      New section:
-      -------------------------------
-
-        * New text section for testing
-
-      -------------------------------
-      Request:
-      -------------------------------
-
-        * URL        : https://test.address/?id=foo&secret=secret
-        * HTTP Method: GET
-        * IP address : 127.0.0.1
-        * Parameters : {\"id\"=>\"foo\", \"secret\"=>\"[FILTERED]\"}
-        * Timestamp  : Sat, 20 Apr 2013 20:58:55 UTC +00:00
-        * Server : #{Socket.gethostname}
-    BODY
-
-    body << "    * Rails root : #{Rails.root}\n" if defined?(Rails) && Rails.respond_to?(:root)
-
-    body << <<-BODY.gsub(/^      /, '')
-        * Process: #{Process.pid}
-
-      -------------------------------
-      Session:
-      -------------------------------
-
-        * session id: [FILTERED]
-        * data: {}
-
-      -------------------------------
-      Environment:
-      -------------------------------
-
-        * HTTPS                                     : on
-          * HTTP_HOST                                 : test.address
-          * HTTP_USER_AGENT                           : Rails Testing
-          * PATH_INFO                                 : /
-          * QUERY_STRING                              : id=foo&secret=secret
-          * REMOTE_ADDR                               : 127.0.0.1
-          * REQUEST_METHOD                            : GET
-          * SCRIPT_NAME                               :
-          * SERVER_NAME                               : example.org
-          * SERVER_PORT                               : 80
-          * SERVER_PROTOCOL                           : HTTP/1.1
-          * action_controller.instance                : #{@controller}
-          * action_dispatch.parameter_filter          : [\"secret\"]
-          * action_dispatch.request.parameters        : {"id"=>"foo", "secret"=>"[FILTERED]"}
-          * action_dispatch.request.path_parameters   : {}
-          * action_dispatch.request.query_parameters  : {"id"=>"foo", "secret"=>"[FILTERED]"}
-          * action_dispatch.request.request_parameters: {}
-          * rack.errors                               : #{@test_env['rack.errors']}
-          * rack.request.form_hash                    : {}
-          * rack.request.form_input                   :
-          * rack.session                              : #{@test_env['rack.session']}
-          * rack.session.options                      : #{@test_env['rack.session.options']}
-          * rack.url_scheme                           : http
-
-      -------------------------------
-      Backtrace:
-      -------------------------------
-
-        test/exception_notifier/email_notifier_test.rb:20
-
-      -------------------------------
-      Data:
-      -------------------------------
-
-        * data: {:message=>\"My Custom Message\"}
-
-
-    BODY
-
-    assert_equal body, @mail.decode_body
-  end
-
-  test 'should not include controller and action names in subject' do
-    email_notifier = ExceptionNotifier::EmailNotifier.new(
-      sender_address: %("Dummy Notifier" <dummynotifier@example.com>),
-      exception_recipients: %w[dummyexceptions@example.com],
-      include_controller_and_action_names_in_subject: false
-    )
-
-    mail = email_notifier.call(@exception, env: @test_env)
-
-    assert_equal '[ERROR]  (ZeroDivisionError) "divided by 0"', mail.subject
-  end
-end