exception_notification 4.6.0 → 5.0.1

data/test/exception_notifier/slack_notifier_test.rb

@@ -1,229 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-require 'slack-notifier'
-
-class SlackNotifierTest < ActiveSupport::TestCase
-  def setup
-    @exception = fake_exception
-    @exception.stubs(:backtrace).returns(fake_backtrace)
-    @exception.stubs(:message).returns('exception message')
-    ExceptionNotifier::SlackNotifier.any_instance.stubs(:clean_backtrace).returns(fake_cleaned_backtrace)
-    Socket.stubs(:gethostname).returns('example.com')
-  end
-
-  test 'should send a slack notification if properly configured' do
-    options = {
-      webhook_url: 'http://slack.webhook.url'
-    }
-
-    Slack::Notifier.any_instance.expects(:ping).with('', fake_notification)
-
-    slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
-    slack_notifier.call(@exception)
-  end
-
-  test 'should send a slack notification without backtrace info if properly configured' do
-    options = {
-      webhook_url: 'http://slack.webhook.url'
-    }
-
-    Slack::Notifier.any_instance.expects(:ping).with('', fake_notification(fake_exception_without_backtrace))
-
-    slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
-    slack_notifier.call(fake_exception_without_backtrace)
-  end
-
-  test 'should send the notification to the specified channel' do
-    options = {
-      webhook_url: 'http://slack.webhook.url',
-      channel: 'channel'
-    }
-
-    Slack::Notifier.any_instance.expects(:ping).with('', fake_notification)
-
-    slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
-    slack_notifier.call(@exception)
-
-    channel = slack_notifier.notifier.config.defaults[:channel]
-    assert_equal channel, options[:channel]
-  end
-
-  test 'should send the notification to the specified username' do
-    options = {
-      webhook_url: 'http://slack.webhook.url',
-      username: 'username'
-    }
-
-    Slack::Notifier.any_instance.expects(:ping).with('', fake_notification)
-
-    slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
-    slack_notifier.call(@exception)
-
-    username = slack_notifier.notifier.config.defaults[:username]
-    assert_equal username, options[:username]
-  end
-
-  test 'should send the notification with specific backtrace lines' do
-    options = {
-      webhook_url: 'http://slack.webhook.url',
-      backtrace_lines: 1
-    }
-
-    Slack::Notifier.any_instance.expects(:ping).with('', fake_notification(@exception, {}, nil, 1))
-
-    slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
-    slack_notifier.call(@exception)
-  end
-
-  test 'should send the notification with additional fields' do
-    field = { title: 'Branch', value: 'master', short: true }
-    options = {
-      webhook_url: 'http://slack.webhook.url',
-      additional_fields: [field]
-    }
-
-    Slack::Notifier.any_instance.expects(:ping).with('', fake_notification(@exception, {}, nil, 10, [field]))
-
-    slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
-    slack_notifier.call(@exception)
-
-    additional_fields = slack_notifier.notifier.config.defaults[:additional_fields]
-    assert_equal additional_fields, options[:additional_fields]
-  end
-
-  test 'should pass the additional parameters to Slack::Notifier.ping' do
-    options = {
-      webhook_url: 'http://slack.webhook.url',
-      username: 'test',
-      custom_hook: 'hook',
-      additional_parameters: {
-        icon_url: 'icon'
-      }
-    }
-
-    Slack::Notifier.any_instance.expects(:ping).with('', options[:additional_parameters].merge(fake_notification))
-
-    slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
-    slack_notifier.call(@exception)
-  end
-
-  test "shouldn't send a slack notification if webhook url is missing" do
-    options = {}
-
-    slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
-
-    assert_nil slack_notifier.notifier
-    assert_nil slack_notifier.call(@exception)
-  end
-
-  test 'should pass along environment data' do
-    options = {
-      webhook_url: 'http://slack.webhook.url',
-      ignore_data_if: lambda { |k, v|
-        k.to_s == 'key_to_be_ignored' || v.is_a?(Hash)
-      }
-    }
-
-    notification_options = {
-      env: {
-        'exception_notifier.exception_data' => { foo: 'bar', john: 'doe' }
-      },
-      data: {
-        'user_id' => 5,
-        'key_to_be_ignored' => 'whatever',
-        'ignore_as_well' => { what: 'ever' }
-      }
-    }
-
-    expected_data_string = "foo: bar\njohn: doe\nuser_id: 5"
-
-    Slack::Notifier.any_instance
-                   .expects(:ping)
-                   .with('', fake_notification(@exception, notification_options, expected_data_string))
-    slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
-    slack_notifier.call(@exception, notification_options)
-  end
-
-  test 'should call pre/post_callback proc if specified' do
-    post_callback_called = 0
-    options = {
-      webhook_url: 'http://slack.webhook.url',
-      username: 'test',
-      custom_hook: 'hook',
-      pre_callback: proc { |_opts, _notifier, backtrace, _message, message_opts|
-        (message_opts[:attachments] = []) << { text: backtrace.join("\n").to_s, color: 'danger' }
-      },
-      post_callback: proc { |_opts, _notifier, _backtrace, _message, _message_opts|
-        post_callback_called = 1
-      },
-      additional_parameters: {
-        icon_url: 'icon'
-      }
-    }
-
-    Slack::Notifier.any_instance.expects(:ping).with('',
-                                                     icon_url: 'icon',
-                                                     attachments: [{
-                                                       text: fake_backtrace.join("\n"),
-                                                       color: 'danger'
-                                                     }])
-
-    slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
-    slack_notifier.call(@exception)
-    assert_equal(post_callback_called, 1)
-  end
-
-  private
-
-  def fake_exception
-    5 / 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
-
-  def fake_cleaned_backtrace
-    fake_backtrace[2..-1]
-  end
-
-  def fake_notification(exception = @exception, notification_options = {},
-                        data_string = nil, expected_backtrace_lines = 10, additional_fields = [])
-
-    exception_name = "*#{exception.class.to_s =~ /^[aeiou]/i ? 'An' : 'A'}* `#{exception.class}`"
-    if notification_options[:env].nil?
-      text = "#{exception_name} *occured in background*"
-    else
-      env = notification_options[:env]
-
-      kontroller = env['action_controller.instance']
-      request = "#{env['REQUEST_METHOD']} <#{env['REQUEST_URI']}>"
-
-      text = "#{exception_name} *occurred while* `#{request}`"
-      text += " *was processed by* `#{kontroller.controller_name}##{kontroller.action_name}`" if kontroller
-    end
-
-    text += "\n"
-
-    fields = [{ title: 'Exception', value: exception.message }]
-    fields.push(title: 'Hostname', value: 'example.com')
-    if exception.backtrace
-      formatted_backtrace = "```#{fake_cleaned_backtrace.first(expected_backtrace_lines).join("\n")}```"
-      fields.push(title: 'Backtrace', value: formatted_backtrace)
-    end
-    fields.push(title: 'Data', value: "```#{data_string}```") if data_string
-    additional_fields.each { |f| fields.push(f) }
-
-    { attachments: [color: 'danger', text: text, fields: fields, mrkdwn_in: %w[text fields]] }
-  end
-end

data/test/exception_notifier/sns_notifier_test.rb

@@ -1,178 +0,0 @@
-# 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" \
-             "Data: {}\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" \
-             "Data: {}\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
-
-  test 'should put data from env["exception_notifier.exception_data"] into text' 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" \
-             "Data: {:current_user=>12}\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,
-                        'exception_notifier.exception_data' => { current_user: 12 }
-                      })
-  end
-  test 'should put optional data into text' 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" \
-             "Data: {:current_user=>12}\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
-                      },
-                      data: {
-                        current_user: 12
-                      })
-  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

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