exception_notification 5.0.0 → 5.0.1

data/test/exception_notifier/google_chat_notifier_test.rb

@@ -1,185 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-require "rack"
-require "httparty"
-require "timecop"
-require "json"
-
-class GoogleChatNotifierTest < 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
-    HTTParty.expects(:post).with(URL, **post_opts("#{header}\n#{body}"))
-    notifier.call ArgumentError.new("foo")
-  end
-
-  test "shoud use errors count if accumulated_errors_count is provided" do
-    text = [
-      "",
-      "Application: *#{app_name}*",
-      "5 *ArgumentError* occurred.",
-      "",
-      body
-    ].join("\n")
-
-    HTTParty.expects(:post).with(URL, **post_opts(text))
-
-    notifier.call(ArgumentError.new("foo"), accumulated_errors_count: 5)
-  end
-
-  test "Message request should be formatted as hash" do
-    text = [
-      header,
-      body,
-      "",
-      "*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",
-      "```"
-    ].join("\n")
-
-    HTTParty.expects(:post).with(URL, **post_opts(text))
-
-    notifier.call(ArgumentError.new("foo"), env: test_env)
-  end
-
-  test "backtrace with less than 3 lines should be displayed fully" do
-    text = [
-      header,
-      body,
-      "",
-      backtrace
-    ].join("\n")
-
-    HTTParty.expects(:post).with(URL, **post_opts(text))
-
-    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)
-  end
-
-  test "backtrace with more than 3 lines should display only top 3 lines" do
-    text = [
-      header,
-      body,
-      "",
-      "*Backtrace:*",
-      "```",
-      "* app/controllers/my_controller.rb:99:in `specific_function'",
-      "* app/controllers/my_controller.rb:70:in `specific_param'",
-      "* app/controllers/my_controller.rb:53:in `my_controller_params'",
-      "```"
-    ].join("\n")
-
-    HTTParty.expects(:post).with(URL, **post_opts(text))
-
-    exception = ArgumentError.new("foo")
-    exception.set_backtrace([
-      "app/controllers/my_controller.rb:99:in `specific_function'",
-      "app/controllers/my_controller.rb:70:in `specific_param'",
-      "app/controllers/my_controller.rb:53:in `my_controller_params'",
-      "app/controllers/my_controller.rb:34:in `update'"
-    ])
-
-    notifier.call(exception)
-  end
-
-  test "Get text with backtrace and request info" do
-    text = [
-      header,
-      body,
-      "",
-      "*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",
-      "```",
-      "",
-      backtrace
-    ].join("\n")
-
-    HTTParty.expects(:post).with(URL, **post_opts(text))
-
-    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
-
-  private
-
-  def notifier
-    ExceptionNotifier::GoogleChatNotifier.new(webhook_url: URL)
-  end
-
-  def post_opts(text)
-    {
-      body: {text: text}.to_json,
-      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 header
-    [
-      "",
-      "Application: *#{app_name}*",
-      "An *ArgumentError* occurred.",
-      ""
-    ].join("\n")
-  end
-
-  def body
-    if defined?(::Rails) && ::Rails.respond_to?(:env)
-      "⚠️ Error occurred in test ⚠️\n*foo*"
-    else
-      "⚠️ Error occurred ⚠️\n*foo*"
-    end
-  end
-
-  def app_name
-    "dummy" if defined?(::Rails) && ::Rails.respond_to?(:application)
-  end
-
-  def backtrace
-    [
-      "*Backtrace:*",
-      "```",
-      "* app/controllers/my_controller.rb:53:in `my_controller_params'",
-      "* app/controllers/my_controller.rb:34:in `update'",
-      "```"
-    ]
-  end
-end

data/test/exception_notifier/hipchat_notifier_test.rb

@@ -1,220 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-require "rack"
-require "hipchat"
-
-class HipchatNotifierTest < ActiveSupport::TestCase
-  test "should send hipchat notification if properly configured" do
-    options = {
-      api_token: "good_token",
-      room_name: "room_name",
-      color: "yellow"
-    }
-
-    HipChat::Room.any_instance.expects(:send).with("Exception", fake_body, {color: "yellow"})
-
-    hipchat = ExceptionNotifier::HipchatNotifier.new(options)
-    hipchat.call(fake_exception)
-  end
-
-  test "should call pre/post_callback if specified" do
-    pre_callback_called = 0
-    post_callback_called = 0
-    options = {
-      api_token: "good_token",
-      room_name: "room_name",
-      color: "yellow",
-      pre_callback: proc { |*| pre_callback_called += 1 },
-      post_callback: proc { |*| post_callback_called += 1 }
-    }
-
-    HipChat::Room.any_instance
-      .expects(:send)
-      .with("Exception", fake_body, {color: "yellow"}.merge(options.except(:api_token, :room_name)))
-
-    hipchat = ExceptionNotifier::HipchatNotifier.new(options)
-    hipchat.call(fake_exception)
-    assert_equal(1, pre_callback_called)
-    assert_equal(1, post_callback_called)
-  end
-
-  test "should send hipchat notification without backtrace info if properly configured" do
-    options = {
-      api_token: "good_token",
-      room_name: "room_name",
-      color: "yellow"
-    }
-
-    HipChat::Room.any_instance.expects(:send).with("Exception", fake_body_without_backtrace, {color: "yellow"})
-
-    hipchat = ExceptionNotifier::HipchatNotifier.new(options)
-    hipchat.call(fake_exception_without_backtrace)
-  end
-
-  test "should allow custom from value if set" do
-    options = {
-      api_token: "good_token",
-      room_name: "room_name",
-      from: "TrollFace"
-    }
-
-    HipChat::Room.any_instance.expects(:send).with("TrollFace", fake_body, {color: "red"})
-
-    hipchat = ExceptionNotifier::HipchatNotifier.new(options)
-    hipchat.call(fake_exception)
-  end
-
-  test "should not send hipchat notification if badly configured" do
-    wrong_params = {
-      api_token: "bad_token",
-      room_name: "test_room"
-    }
-
-    HipChat::Client.stubs(:new).with("bad_token", {api_version: "v1"}).returns(nil)
-
-    hipchat = ExceptionNotifier::HipchatNotifier.new(wrong_params)
-    assert_nil hipchat.room
-  end
-
-  test "should not send hipchat notification if api_key is missing" do
-    wrong_params = {room_name: "test_room"}
-
-    HipChat::Client.stubs(:new).with(nil, {api_version: "v1"}).returns(nil)
-
-    hipchat = ExceptionNotifier::HipchatNotifier.new(wrong_params)
-    assert_nil hipchat.room
-  end
-
-  test "should not send hipchat notification if room_name is missing" do
-    wrong_params = {api_token: "good_token"}
-
-    HipChat::Client.stubs(:new).with("good_token", {api_version: "v1"}).returns({})
-
-    hipchat = ExceptionNotifier::HipchatNotifier.new(wrong_params)
-    assert_nil hipchat.room
-  end
-
-  test "should send hipchat notification with message_template" do
-    options = {
-      api_token: "good_token",
-      room_name: "room_name",
-      color: "yellow",
-      message_template: ->(exception, _) { "This is custom message: '#{exception.message}'" }
-    }
-
-    HipChat::Room.any_instance
-      .expects(:send)
-      .with("Exception", "This is custom message: '#{fake_exception.message}'", {color: "yellow"})
-
-    hipchat = ExceptionNotifier::HipchatNotifier.new(options)
-    hipchat.call(fake_exception)
-  end
-
-  test "should send hipchat notification exclude accumulated errors count" do
-    options = {
-      api_token: "good_token",
-      room_name: "room_name",
-      color: "yellow"
-    }
-
-    HipChat::Room.any_instance.expects(:send).with { |_, msg, _| msg.start_with?("A new exception occurred:") }
-    hipchat = ExceptionNotifier::HipchatNotifier.new(options)
-    hipchat.call(fake_exception)
-  end
-
-  test "should send hipchat notification include accumulated errors count" do
-    options = {
-      api_token: "good_token",
-      room_name: "room_name",
-      color: "yellow"
-    }
-
-    HipChat::Room.any_instance.expects(:send).with { |_, msg, _| msg.start_with?("The exception occurred 3 times:") }
-    hipchat = ExceptionNotifier::HipchatNotifier.new(options)
-    hipchat.call(fake_exception, accumulated_errors_count: 3)
-  end
-
-  test "should send hipchat notification with HTML-escaped meessage if using default message_template" do
-    options = {
-      api_token: "good_token",
-      room_name: "room_name",
-      color: "yellow"
-    }
-
-    exception = fake_exception_with_html_characters
-    body = "A new exception occurred: '#{Rack::Utils.escape_html(exception.message)}' on '#{exception.backtrace.first}'"
-
-    HipChat::Room.any_instance.expects(:send).with("Exception", body, {color: "yellow"})
-
-    hipchat = ExceptionNotifier::HipchatNotifier.new(options)
-    hipchat.call(exception)
-  end
-
-  test "should use APIv1 if api_version is not specified" do
-    options = {
-      api_token: "good_token",
-      room_name: "room_name"
-    }
-
-    HipChat::Client.expects(:new).with("good_token", {api_version: "v1"}).returns({})
-
-    hipchat = ExceptionNotifier::HipchatNotifier.new(options)
-    hipchat.call(fake_exception)
-  end
-
-  test "should use APIv2 when specified" do
-    options = {
-      api_token: "good_token",
-      room_name: "room_name",
-      api_version: "v2"
-    }
-
-    HipChat::Client.expects(:new).with("good_token", {api_version: "v2"}).returns({})
-
-    hipchat = ExceptionNotifier::HipchatNotifier.new(options)
-    hipchat.call(fake_exception)
-  end
-
-  test "should allow server_url value (for a self-hosted HipChat Server) if set" do
-    options = {
-      api_token: "good_token",
-      room_name: "room_name",
-      api_version: "v2",
-      server_url: "https://domain.com"
-    }
-
-    HipChat::Client.expects(:new)
-      .with("good_token", {api_version: "v2", server_url: "https://domain.com"})
-      .returns({})
-
-    hipchat = ExceptionNotifier::HipchatNotifier.new(options)
-    hipchat.call(fake_exception)
-  end
-
-  private
-
-  def fake_body
-    "A new exception occurred: '#{fake_exception.message}' on '#{fake_exception.backtrace.first}'"
-  end
-
-  def fake_exception
-    5 / 0
-  rescue => e
-    e
-  end
-
-  def fake_exception_with_html_characters
-    raise StandardError, "an error with <html> characters"
-  rescue => e
-    e
-  end
-
-  def fake_body_without_backtrace
-    "A new exception occurred: '#{fake_exception_without_backtrace.message}'"
-  end
-
-  def fake_exception_without_backtrace
-    StandardError.new("my custom error")
-  end
-end

data/test/exception_notifier/irc_notifier_test.rb

@@ -1,139 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-require "carrier-pigeon"
-
-class IrcNotifierTest < ActiveSupport::TestCase
-  test "should send irc notification if properly configured" do
-    options = {
-      domain: "irc.example.com"
-    }
-
-    CarrierPigeon.expects(:send).with(has_key(:uri)) do |v|
-      /divided by 0/.match(v[:message])
-    end
-
-    irc = ExceptionNotifier::IrcNotifier.new(options)
-    irc.call(fake_exception)
-  end
-
-  test "should exclude errors count in message if :accumulated_errors_count nil" do
-    irc = ExceptionNotifier::IrcNotifier.new({})
-    irc.stubs(:active?).returns(true)
-
-    irc.expects(:send_message).with { |message| message.include?("divided by 0") }.once
-    irc.call(fake_exception)
-  end
-
-  test "should include errors count in message if :accumulated_errors_count is 3" do
-    irc = ExceptionNotifier::IrcNotifier.new({})
-    irc.stubs(:active?).returns(true)
-
-    irc.expects(:send_message).with { |message| message.include?("(3 times)'divided by 0'") }.once
-    irc.call(fake_exception, accumulated_errors_count: 3)
-  end
-
-  test "should call pre/post_callback if specified" do
-    pre_callback_called = 0
-    post_callback_called = 0
-
-    options = {
-      domain: "irc.example.com",
-      pre_callback: proc { |*| pre_callback_called += 1 },
-      post_callback: proc { |*| post_callback_called += 1 }
-    }
-
-    CarrierPigeon.expects(:send).with(has_key(:uri)) do |v|
-      /divided by 0/.match(v[:message])
-    end
-
-    irc = ExceptionNotifier::IrcNotifier.new(options)
-    irc.call(fake_exception)
-    assert_equal(1, pre_callback_called)
-    assert_equal(1, post_callback_called)
-  end
-
-  test "should send irc notification without backtrace info if properly configured" do
-    options = {
-      domain: "irc.example.com"
-    }
-
-    CarrierPigeon.expects(:send).with(has_key(:uri)) do |v|
-      /my custom error/.match(v[:message])
-    end
-
-    irc = ExceptionNotifier::IrcNotifier.new(options)
-    irc.call(fake_exception_without_backtrace)
-  end
-
-  test "should properly construct URI from constituent parts" do
-    options = {
-      nick: "BadNewsBot",
-      password: "secret",
-      domain: "irc.example.com",
-      port: 9999,
-      channel: "#exceptions"
-    }
-
-    CarrierPigeon.expects(:send).with(has_entry(uri: "irc://BadNewsBot:secret@irc.example.com:9999/#exceptions"))
-
-    irc = ExceptionNotifier::IrcNotifier.new(options)
-    irc.call(fake_exception)
-  end
-
-  test "should properly add recipients if specified" do
-    options = {
-      domain: "irc.example.com",
-      recipients: %w[peter michael samir]
-    }
-
-    CarrierPigeon.expects(:send).with(has_key(:uri)) do |v|
-      /peter, michael, samir/.match(v[:message])
-    end
-
-    irc = ExceptionNotifier::IrcNotifier.new(options)
-    irc.call(fake_exception)
-  end
-
-  test "should properly set miscellaneous options" do
-    options = {
-      domain: "irc.example.com",
-      ssl: true,
-      join: true,
-      notice: true,
-      prefix: "[test notification]"
-    }
-
-    entries = {
-      ssl: true,
-      join: true,
-      notice: true
-    }
-
-    CarrierPigeon.expects(:send).with(has_entries(entries)) do |v|
-      /\[test notification\]/.match(v[:message])
-    end
-
-    irc = ExceptionNotifier::IrcNotifier.new(options)
-    irc.call(fake_exception)
-  end
-
-  test "should not send irc notification if badly configured" do
-    wrong_params = {domain: "##scriptkiddie.com###"}
-    irc = ExceptionNotifier::IrcNotifier.new(wrong_params)
-
-    assert_nil irc.call(fake_exception)
-  end
-
-  private
-
-  def fake_exception
-    5 / 0
-  rescue => e
-    e
-  end
-
-  def fake_exception_without_backtrace
-    StandardError.new("my custom error")
-  end
-end