exception_notification 5.0.0 → 5.0.1

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,154 +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"}.to_s
-  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,342 +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]
-
-    # standard:disable Lint/LiteralInInterpolation
-    body = <<~BODY
-      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
-    # standard:enable Lint/LiteralInInterpolation
-
-    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 => 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 => 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_fragments = []
-
-    # standard:disable Lint/LiteralInInterpolation
-    body_fragments << <<~BODY
-      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_fragments << "    * Rails root : #{Rails.root}\n" if defined?(Rails) && Rails.respond_to?(:root)
-
-    body_fragments << <<~BODY
-        * Process: #{Process.pid}
-
-      -------------------------------
-      Session:
-      -------------------------------
-
-        * session id: [FILTERED]
-        * data: {}
-
-      -------------------------------
-      Environment:
-      -------------------------------
-
-    BODY
-
-    body_fragments << "* action_controller.instance"
-    body_fragments << "* rack.errors"
-    body_fragments << "[FILTERED]"
-
-    body_fragments << <<~BODY
-      -------------------------------
-      Backtrace:
-      -------------------------------
-
-        test/exception_notifier/email_notifier_test.rb:20
-
-      -------------------------------
-      Data:
-      -------------------------------
-
-        * data: #{{message: "My Custom Message"}}
-
-
-    BODY
-    # standard:enable Lint/LiteralInInterpolation
-    body_fragments.each do |fragment|
-      assert_includes @mail.decode_body, fragment
-    end
-  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