exception_notification 5.0.0 → 5.0.1

data/test/exception_notifier/slack_notifier_test.rb

@@ -1,228 +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 => 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] # standard:disable Style/SlicingWithRange
-  end
-
-  def fake_notification(exception = @exception, notification_options = {},
-    data_string = nil, expected_backtrace_lines = 10, additional_fields = [])
-    exception_name = "*#{/^[aeiou]/i.match?(exception.class.to_s) ? "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,181 +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")
-
-    # standard:disable Lint/LiteralInInterpolation
-    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"
-    )
-    # standard:enable Lint/LiteralInInterpolation
-    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")
-
-    # standard:disable Lint/LiteralInInterpolation
-    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"
-    )
-    # standard:enable Lint/LiteralInInterpolation
-    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 => 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.expects(: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 => e
-      e
-    end
-  end
-end