exception_notification 5.0.0 → 5.0.1

data/test/exception_notifier/mattermost_notifier_test.rb

@@ -1,251 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-require "httparty"
-require "timecop"
-require "json"
-
-class MattermostNotifierTest < ActiveSupport::TestCase
-  URL = "http://localhost:8000"
-
-  def setup
-    Timecop.freeze("2018-12-09 12:07:16 UTC")
-  end
-
-  def teardown
-    Timecop.return
-  end
-
-  test "should send notification if properly configured" do
-    opts = {
-      body: default_body.to_json,
-      headers: default_headers
-    }
-
-    HTTParty.expects(:post).with(URL, opts)
-    notifier.call ArgumentError.new("foo")
-  end
-
-  test "should send notification with create issue link if specified" do
-    body = default_body.merge(
-      text: [
-        "@channel",
-        error_occurred_in,
-        "An *ArgumentError* occurred.",
-        "*foo*",
-        github_link
-      ].join("\n")
-    )
-
-    opts = {
-      body: body.to_json,
-      headers: default_headers
-    }
-
-    HTTParty.expects(:post).with(URL, opts)
-    notifier.call ArgumentError.new("foo"), git_url: "github.com/aschen"
-  end
-
-  test "should add username and icon_url params to the notification if specified" do
-    body = default_body.merge(
-      username: "Test Bot",
-      icon_url: "http://site.com/icon.png"
-    )
-
-    opts = {
-      body: body.to_json,
-      headers: default_headers
-    }
-
-    HTTParty.expects(:post).with(URL, opts)
-    notifier.call(
-      ArgumentError.new("foo"),
-      username: "Test Bot",
-      avatar: "http://site.com/icon.png"
-    )
-  end
-
-  test "should add other HTTParty options to params" do
-    opts = {
-      basic_auth: {
-        username: "clara",
-        password: "password"
-      },
-      body: default_body.to_json,
-      headers: default_headers
-    }
-
-    HTTParty.expects(:post).with(URL, opts)
-    notifier.call(
-      ArgumentError.new("foo"),
-      basic_auth: {
-        username: "clara",
-        password: "password"
-      }
-    )
-  end
-
-  test "should use 'An' for exceptions count if :accumulated_errors_count option is nil" do
-    opts = {
-      body: default_body.to_json,
-      headers: default_headers
-    }
-
-    HTTParty.expects(:post).with(URL, opts)
-    notifier.call(ArgumentError.new("foo"))
-  end
-
-  test "shoud use direct errors count if :accumulated_errors_count option is 5" do
-    body = default_body.merge(
-      text: [
-        "@channel",
-        error_occurred_in,
-        "5 *ArgumentError* occurred.",
-        "*foo*"
-      ].join("\n")
-    )
-
-    opts = {
-      body: body.to_json,
-      headers: default_headers
-    }
-
-    HTTParty.expects(:post).with(URL, opts)
-    notifier.call(ArgumentError.new("foo"), accumulated_errors_count: 5)
-  end
-
-  test "should include backtrace and request info" do
-    body = default_body.merge(text: [
-      "@channel",
-      error_occurred_in,
-      "An *ArgumentError* occurred.",
-      "*foo*",
-      request_info,
-      backtrace_info
-    ].join("\n"))
-
-    opts = {
-      body: body.to_json,
-      headers: default_headers
-    }
-
-    HTTParty.expects(:post).with(URL, opts)
-
-    exception = ArgumentError.new("foo")
-    exception.set_backtrace([
-      "app/controllers/my_controller.rb:53:in `my_controller_params'",
-      "app/controllers/my_controller.rb:34:in `update'"
-    ])
-
-    notifier.call(exception, env: test_env)
-  end
-
-  test "should include exception_data_info" do
-    body = default_body.merge(
-      text: [
-        "@channel",
-        error_occurred_in,
-        "An *ArgumentError* occurred.",
-        "*foo*",
-        request_info,
-        exception_data_info
-      ].join("\n")
-    )
-
-    opts = {
-      body: body.to_json,
-      headers: default_headers
-    }
-
-    env = test_env.merge(
-      "exception_notifier.exception_data" => {foo: "bar", john: "doe"}
-    )
-
-    HTTParty.expects(:post).with(URL, opts)
-    notifier.call(ArgumentError.new("foo"), env: env)
-  end
-
-  private
-
-  def notifier
-    ExceptionNotifier::MattermostNotifier.new(webhook_url: URL)
-  end
-
-  def default_body
-    {
-      text: [
-        "@channel",
-        error_occurred_in,
-        "An *ArgumentError* occurred.",
-        "*foo*"
-      ].join("\n"),
-      username: "Exception Notifier"
-    }
-  end
-
-  def default_headers
-    {"Content-Type" => "application/json"}
-  end
-
-  def test_env
-    Rack::MockRequest.env_for(
-      "/",
-      "HTTP_HOST" => "test.address",
-      "REMOTE_ADDR" => "127.0.0.1",
-      "HTTP_USER_AGENT" => "Rails Testing",
-      :params => {id: "foo"}
-    )
-  end
-
-  def error_occurred_in
-    if defined?(::Rails) && ::Rails.respond_to?(:env)
-      "### ⚠️ Error occurred in test ⚠️"
-    else
-      "### ⚠️ Error occurred ⚠️"
-    end
-  end
-
-  def github_link
-    if defined?(::Rails) && ::Rails.respond_to?(:application)
-      "[Create an issue]" \
-      "(github.com/aschen/dummy/issues/new/?issue%5Btitle%5D=%5BBUG%5D+Error+500+%3A++%28ArgumentError%29+foo)"
-    else
-      # TODO: fix missing app name
-      "[Create an issue]" \
-      "(github.com/aschen//issues/new/?issue%5Btitle%5D=%5BBUG%5D+Error+500+%3A++%28ArgumentError%29+foo)"
-    end
-  end
-
-  def request_info
-    [
-      "### Request",
-      "```",
-      "* url : http://test.address/?id=foo",
-      "* http_method : GET",
-      "* ip_address : 127.0.0.1",
-      "* parameters : #{{"id" => "foo"}}", # standard:disable Lint/LiteralInInterpolation
-      "* timestamp : 2018-12-09 12:07:16 UTC",
-      "```"
-    ]
-  end
-
-  def backtrace_info
-    [
-      "### Backtrace",
-      "```",
-      "* app/controllers/my_controller.rb:53:in `my_controller_params'",
-      "* app/controllers/my_controller.rb:34:in `update'",
-      "```"
-    ]
-  end
-
-  def exception_data_info
-    [
-      "### Data",
-      "```",
-      "* foo : bar",
-      "* john : doe",
-      "```"
-    ]
-  end
-end

data/test/exception_notifier/modules/error_grouping_test.rb

@@ -1,167 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-class ErrorGroupTest < ActiveSupport::TestCase
-  module TestModule
-    include ExceptionNotifier::ErrorGrouping
-    @@error_grouping_cache = ActiveSupport::Cache::FileStore.new("test/dummy/tmp/non_default_location")
-  end
-
-  setup do
-    @exception = RuntimeError.new("ERROR")
-    @exception.stubs(:backtrace).returns(["/path/where/error/raised:1"])
-
-    @exception2 = RuntimeError.new("ERROR2")
-    @exception2.stubs(:backtrace).returns(["/path/where/error/found:2"])
-  end
-
-  teardown do
-    TestModule.error_grouping_cache.clear
-    TestModule.fallback_cache_store.clear
-  end
-
-  test "should add additional option: error_grouping" do
-    assert_respond_to TestModule, :error_grouping
-    assert_respond_to TestModule, :error_grouping=
-  end
-
-  test "should set error_grouping to false default" do
-    assert_equal false, TestModule.error_grouping
-  end
-
-  test "should add additional option: error_grouping_cache" do
-    assert_respond_to TestModule, :error_grouping_cache
-    assert_respond_to TestModule, :error_grouping_cache=
-  end
-
-  test "should add additional option: error_grouping_period" do
-    assert_respond_to TestModule, :error_grouping_period
-    assert_respond_to TestModule, :error_grouping_period=
-  end
-
-  test "shoud set error_grouping_period to 5.minutes default" do
-    assert_equal 300, TestModule.error_grouping_period
-  end
-
-  test "should add additional option: notification_trigger" do
-    assert_respond_to TestModule, :notification_trigger
-    assert_respond_to TestModule, :notification_trigger=
-  end
-
-  test "should return errors count nil when not same error for .error_count" do
-    assert_nil TestModule.error_count("something")
-  end
-
-  test "should return errors count when same error for .error_count" do
-    TestModule.error_grouping_cache.write("error_key", 13)
-    assert_equal 13, TestModule.error_count("error_key")
-  end
-
-  test "should fallback to memory store cache if specified cache store failed to read" do
-    TestModule.error_grouping_cache.stubs(:read).raises(RuntimeError.new("Failed to read"))
-    original_fallback = TestModule.fallback_cache_store
-    TestModule.expects(:fallback_cache_store).returns(original_fallback).at_least_once
-
-    assert_nil TestModule.error_count("something_to_read")
-  end
-
-  test "should save error with count for .save_error_count" do
-    count = rand(1..10)
-
-    TestModule.save_error_count("error_key", count)
-    assert_equal count, TestModule.error_grouping_cache.read("error_key")
-  end
-
-  test "should fallback to memory store cache if specified cache store failed to write" do
-    TestModule.error_grouping_cache.stubs(:write).raises(RuntimeError.new("Failed to write"))
-    original_fallback = TestModule.fallback_cache_store
-    TestModule.expects(:fallback_cache_store).returns(original_fallback).at_least_once
-
-    assert TestModule.save_error_count("something_to_cache", rand(1..10))
-  end
-
-  test "should save accumulated_errors_count into options" do
-    options = {}
-    TestModule.group_error!(@exception, options)
-
-    assert_equal 1, options[:accumulated_errors_count]
-  end
-
-  test "should not group error if different exception in .group_error!" do
-    options1 = {}
-    TestModule.expects(:save_error_count).with { |key, count| key.is_a?(String) && count == 1 }.times(4).returns(true)
-    TestModule.group_error!(@exception, options1)
-
-    options2 = {}
-    TestModule.group_error!(NoMethodError.new("method not found"), options2)
-
-    assert_equal 1, options1[:accumulated_errors_count]
-    assert_equal 1, options2[:accumulated_errors_count]
-  end
-
-  test "should not group error is same exception but different message or backtrace" do
-    options1 = {}
-    TestModule.expects(:save_error_count).with { |key, count| key.is_a?(String) && count == 1 }.times(4).returns(true)
-    TestModule.group_error!(@exception, options1)
-
-    options2 = {}
-    TestModule.group_error!(@exception2, options2)
-
-    assert_equal 1, options1[:accumulated_errors_count]
-    assert_equal 1, options2[:accumulated_errors_count]
-  end
-
-  test "should group error if same exception and message" do
-    options = {}
-
-    10.times do |i|
-      @exception2.stubs(:backtrace).returns(["/path:#{i}"])
-      TestModule.group_error!(@exception2, options)
-    end
-
-    assert_equal 10, options[:accumulated_errors_count]
-  end
-
-  test "should group error if same exception and backtrace" do
-    options = {}
-
-    10.times do |i|
-      @exception2.stubs(:message).returns("ERRORS#{i}")
-      TestModule.group_error!(@exception2, options)
-    end
-
-    assert_equal 10, options[:accumulated_errors_count]
-  end
-
-  test "should group error by that message have high priority" do
-    message_based_key = "exception:#{Zlib.crc32("RuntimeError\nmessage:ERROR")}"
-    backtrace_based_key = "exception:#{Zlib.crc32("RuntimeError\npath:/path/where/error/raised:1")}"
-
-    TestModule.save_error_count(message_based_key, 1)
-    TestModule.save_error_count(backtrace_based_key, 1)
-
-    TestModule.expects(:save_error_count).with(message_based_key, 2).once
-    TestModule.expects(:save_error_count).with(backtrace_based_key, 2).never
-
-    TestModule.group_error!(@exception, {})
-  end
-
-  test "use default formula if not specify notification_trigger in .send_notification?" do
-    TestModule.stubs(:notification_trigger).returns(nil)
-
-    count = 16
-    Math.expects(:log2).with(count).returns(4)
-
-    assert TestModule.send_notification?(@exception, count)
-  end
-
-  test "use specified trigger in .send_notification?" do
-    trigger = proc { |_exception, count| (count % 4).zero? }
-    TestModule.stubs(:notification_trigger).returns(trigger)
-
-    count = 16
-    trigger.expects(:call).with(@exception, count).returns(true)
-    assert TestModule.send_notification?(@exception, count)
-  end
-end

data/test/exception_notifier/modules/formatter_test.rb

@@ -1,154 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-require "timecop"
-
-class FormatterTest < ActiveSupport::TestCase
-  setup do
-    @exception = RuntimeError.new("test")
-    Timecop.freeze("2018-12-09 12:07:16 UTC")
-  end
-
-  teardown do
-    Timecop.return
-  end
-
-  #
-  # #title
-  #
-  test "title returns correct content" do
-    formatter = ExceptionNotifier::Formatter.new(@exception)
-
-    title = if defined?(::Rails) && ::Rails.respond_to?(:env)
-      "⚠️ Error occurred in test ⚠️"
-    else
-      "⚠️ Error occurred ⚠️"
-    end
-
-    assert_equal title, formatter.title
-  end
-
-  #
-  # #subtitle
-  #
-  test "subtitle without accumulated error" do
-    formatter = ExceptionNotifier::Formatter.new(@exception)
-    assert_equal "A *RuntimeError* occurred.", formatter.subtitle
-  end
-
-  test "subtitle with accumulated error" do
-    formatter = ExceptionNotifier::Formatter.new(@exception, accumulated_errors_count: 3)
-    assert_equal "3 *RuntimeError* occurred.", formatter.subtitle
-  end
-
-  test "subtitle with controller" do
-    env = Rack::MockRequest.env_for(
-      "/", "action_controller.instance" => test_controller
-    )
-
-    formatter = ExceptionNotifier::Formatter.new(@exception, env: env)
-    assert_equal "A *RuntimeError* occurred in *home#index*.", formatter.subtitle
-  end
-
-  #
-  # #app_name
-  #
-  test "app_name defaults to Rails app name" do
-    formatter = ExceptionNotifier::Formatter.new(@exception)
-
-    if defined?(::Rails) && ::Rails.respond_to?(:application)
-      assert_equal "dummy", formatter.app_name
-    else
-      assert_nil formatter.app_name
-    end
-  end
-
-  test "app_name can be overwritten using options" do
-    formatter = ExceptionNotifier::Formatter.new(@exception, app_name: "test")
-    assert_equal "test", formatter.app_name
-  end
-
-  #
-  # #request_message
-  #
-  test "request_message when env set" do
-    text = [
-      "```",
-      "* url : http://test.address/?id=foo",
-      "* http_method : GET",
-      "* ip_address : 127.0.0.1",
-      "* parameters : #{{"id" => "foo"}}", # standard:disable Lint/LiteralInInterpolation:
-      "* timestamp : 2018-12-09 12:07:16 UTC",
-      "```"
-    ].join("\n")
-
-    env = Rack::MockRequest.env_for(
-      "/",
-      "HTTP_HOST" => "test.address",
-      "REMOTE_ADDR" => "127.0.0.1",
-      :params => {id: "foo"}
-    )
-
-    formatter = ExceptionNotifier::Formatter.new(@exception, env: env)
-    assert_equal text, formatter.request_message
-  end
-
-  test "request_message when env not set" do
-    formatter = ExceptionNotifier::Formatter.new(@exception)
-    assert_nil formatter.request_message
-  end
-
-  #
-  # #backtrace_message
-  #
-  test "backtrace_message when backtrace set" do
-    text = [
-      "```",
-      "* app/controllers/my_controller.rb:53:in `my_controller_params'",
-      "* app/controllers/my_controller.rb:34:in `update'",
-      "```"
-    ].join("\n")
-
-    @exception.set_backtrace([
-      "app/controllers/my_controller.rb:53:in `my_controller_params'",
-      "app/controllers/my_controller.rb:34:in `update'"
-    ])
-
-    formatter = ExceptionNotifier::Formatter.new(@exception)
-    assert_equal text, formatter.backtrace_message
-  end
-
-  test "backtrace_message when no backtrace" do
-    formatter = ExceptionNotifier::Formatter.new(@exception)
-    assert_nil formatter.backtrace_message
-  end
-
-  #
-  # #controller_and_action
-  #
-  test "correct controller_and_action if controller is present" do
-    env = Rack::MockRequest.env_for(
-      "/", "action_controller.instance" => test_controller
-    )
-
-    formatter = ExceptionNotifier::Formatter.new(@exception, env: env)
-    assert_equal "home#index", formatter.controller_and_action
-  end
-
-  test "controller_and_action is nil if no controller" do
-    env = Rack::MockRequest.env_for("/")
-
-    formatter = ExceptionNotifier::Formatter.new(@exception, env: env)
-    assert_nil formatter.controller_and_action
-  end
-
-  private
-
-  def test_controller
-    controller = mock("controller")
-    controller.stubs(:action_name).returns("index")
-    controller.stubs(:controller_name).returns("home")
-
-    controller
-  end
-end

data/test/exception_notifier/sidekiq_test.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-# To allow sidekiq error handlers to be registered, sidekiq must be in
-# "server mode". This mode is triggered by loading sidekiq/cli. Note this
-# has to be loaded before exception_notification/sidekiq.
-require "sidekiq/cli"
-require "sidekiq/testing"
-
-require "exception_notification/sidekiq"
-
-class MockSidekiqServer
-  include ::Sidekiq::Component
-
-  def config
-    @config ||= (Sidekiq.default_configuration.tap { |config| config.logger = Logger.new(nil) })
-  end
-end
-
-class SidekiqTest < ActiveSupport::TestCase
-  test "should call notify_exception when sidekiq raises an error" do
-    server = MockSidekiqServer.new
-    message = {}
-    exception = RuntimeError.new
-
-    if ::Sidekiq::VERSION < "7.1.5"
-      ExceptionNotifier.expects(:notify_exception).with(
-        exception,
-        data: {sidekiq: message}
-      )
-    else
-      ExceptionNotifier.expects(:notify_exception).with(
-        exception,
-        data: {sidekiq: {context: message, config: server.config}}
-      )
-    end
-
-    server.handle_exception(exception, message)
-  end
-end