exception_notification_more_info 1.0.0

data/test/dummy/test/test_helper.rb

@@ -0,0 +1,13 @@
+ENV["RAILS_ENV"] = "test"
+require File.expand_path('../../config/environment', __FILE__)
+require 'rails/test_help'
+
+class ActiveSupport::TestCase
+  # Setup all fixtures in test/fixtures/*.(yml|csv) for all tests in alphabetical order.
+  #
+  # Note: You'll currently still have to declare fixtures explicitly in integration tests
+  # -- they do not yet inherit this setting
+  fixtures :all
+
+  # Add more helper methods to be used by all tests here...
+end

data/test/exception_notification/rack_test.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+
+class RackTest < ActiveSupport::TestCase
+
+  setup do
+    @pass_app = Object.new
+    @pass_app.stubs(:call).returns([nil, { 'X-Cascade' => 'pass' }, nil])
+  end
+
+  test "should ignore \"X-Cascade\" header by default" do
+    ExceptionNotifier.expects(:notify_exception).never
+    ExceptionNotification::Rack.new(@pass_app).call({})
+  end
+
+  test "should notify on \"X-Cascade\" = \"pass\" if ignore_cascade_pass option is false" do
+    ExceptionNotifier.expects(:notify_exception).once
+    ExceptionNotification::Rack.new(@pass_app, :ignore_cascade_pass => false).call({})
+  end
+
+end

data/test/exception_notifier/campfire_notifier_test.rb

@@ -0,0 +1,100 @@
+require 'test_helper'
+require 'tinder'
+
+class CampfireNotifierTest < ActiveSupport::TestCase
+
+  test "should send campfire notification if properly configured" do
+    ExceptionNotifier::CampfireNotifier.stubs(:new).returns(Object.new)
+    campfire = ExceptionNotifier::CampfireNotifier.new({:subdomain => 'test', :token => 'test_token', :room_name => 'test_room'})
+    campfire.stubs(:call).returns(fake_notification)
+    notif = campfire.call(fake_exception)
+
+    assert !notif[:message].empty?
+    assert_equal notif[:message][:type], 'PasteMessage'
+    assert_includes notif[:message][:body], "A new exception occurred:"
+    assert_includes notif[:message][:body], "divided by 0"
+    assert_includes notif[:message][:body], "/exception_notification/test/campfire_test.rb:45"
+  end
+
+  test "should send campfire notification without backtrace info if properly configured" do
+    ExceptionNotifier::CampfireNotifier.stubs(:new).returns(Object.new)
+    campfire = ExceptionNotifier::CampfireNotifier.new({:subdomain => 'test', :token => 'test_token', :room_name => 'test_room'})
+    campfire.stubs(:call).returns(fake_notification_without_backtrace)
+    notif = campfire.call(fake_exception_without_backtrace)
+
+    assert !notif[:message].empty?
+    assert_equal notif[:message][:type], 'PasteMessage'
+    assert_includes notif[:message][:body], "A new exception occurred:"
+    assert_includes notif[:message][:body], "my custom error"
+  end
+
+  test "should not send campfire notification if badly configured" do
+    wrong_params = {:subdomain => 'test', :token => 'bad_token', :room_name => 'test_room'}
+    Tinder::Campfire.stubs(:new).with('test', {:token => 'bad_token'}).returns(nil)
+    campfire = ExceptionNotifier::CampfireNotifier.new(wrong_params)
+
+    assert_nil campfire.room
+    assert_nil campfire.call(fake_exception)
+  end
+
+  test "should not send campfire notification if config attr missing" do
+    wrong_params  = {:subdomain => 'test', :room_name => 'test_room'}
+    Tinder::Campfire.stubs(:new).with('test', {}).returns(nil)
+    campfire = ExceptionNotifier::CampfireNotifier.new(wrong_params)
+
+    assert_nil campfire.room
+    assert_nil campfire.call(fake_exception)
+  end
+
+  test "should call pre/post_callback if specified" do 
+    pre_callback_called, post_callback_called = 0,0
+    Tinder::Campfire.stubs(:new).returns(Object.new)
+
+    campfire = ExceptionNotifier::CampfireNotifier.new(
+      {
+        :subdomain => 'test',
+        :token => 'test_token',
+        :room_name => 'test_room',
+        :pre_callback => proc { |opts, notifier, backtrace, message, message_opts|
+          pre_callback_called += 1
+        },
+        :post_callback => proc { |opts, notifier, backtrace, message, message_opts|
+          post_callback_called += 1
+        }
+      }
+    )
+    campfire.room = Object.new
+    campfire.room.stubs(:paste).returns(fake_notification)
+    campfire.call(fake_exception)
+    assert_equal(1, pre_callback_called)
+    assert_equal(1, post_callback_called)
+  end
+
+  private
+
+  def fake_notification
+    {:message => {:type => 'PasteMessage',
+                  :body => "A new exception occurred: 'divided by 0' on '/Users/sebastian/exception_notification/test/campfire_test.rb:45:in `/'"
+                 }
+    }
+  end
+
+  def fake_exception
+    exception = begin
+      5/0
+    rescue Exception => e
+      e
+    end
+  end
+
+  def fake_notification_without_backtrace
+    {:message => {:type => 'PasteMessage',
+                  :body => "A new exception occurred: 'my custom error'"
+                 }
+    }
+  end
+
+  def fake_exception_without_backtrace
+    StandardError.new('my custom error')
+  end
+end

data/test/exception_notifier/email_notifier_test.rb

@@ -0,0 +1,185 @@
+require 'test_helper'
+require 'action_mailer'
+
+class EmailNotifierTest < ActiveSupport::TestCase
+  setup do
+    Time.stubs(:current).returns('Sat, 20 Apr 2013 20:58:55 UTC +00:00')
+    @email_notifier = ExceptionNotifier.registered_exception_notifier(:email)
+    begin
+      1/0
+    rescue => e
+      @exception = e
+      @mail = @email_notifier.create_email(@exception,
+        :data => {:job => 'DivideWorkerJob', :payload => '1/0', :message => 'My Custom Message'})
+    end
+  end
+
+  test "should call pre/post_callback if specified" do
+    assert_equal @email_notifier.options[:pre_callback_called], 1
+    assert_equal @email_notifier.options[:post_callback_called], 1
+  end
+
+  test "should have default sender address overridden" do
+    assert_equal @email_notifier.sender_address, %("Dummy Notifier" <dummynotifier@example.com>)
+  end
+
+  test "should have default exception recipients overridden" do
+    assert_equal @email_notifier.exception_recipients, %w(dummyexceptions@example.com)
+  end
+
+  test "should have default email prefix overridden" do
+    assert_equal @email_notifier.email_prefix, "[Dummy ERROR] "
+  end
+
+  test "should have default email headers overridden" do
+    assert_equal @email_notifier.email_headers, { "X-Custom-Header" => "foobar"}
+  end
+
+  test "should have default sections overridden" do
+    for section in %w(new_section request session environment backtrace)
+      assert_includes @email_notifier.sections, section
+    end
+  end
+
+  test "should have default background sections" do
+    for section in %w(new_bkg_section backtrace data)
+      assert_includes @email_notifier.background_sections, section
+    end
+  end
+
+  test "should have email format by default" do
+    assert_equal @email_notifier.email_format, :text
+  end
+
+  test "should have verbose subject by default" do
+    assert @email_notifier.verbose_subject
+  end
+
+  test "should have normalize_subject false by default" do
+    refute @email_notifier.normalize_subject
+  end
+
+  test "should have delivery_method nil by default" do
+    assert_nil @email_notifier.delivery_method
+  end
+
+  test "should have mailer_settings nil by default" do
+    assert_nil @email_notifier.mailer_settings
+  end
+
+  test "should have mailer_parent by default" do
+    assert_equal @email_notifier.mailer_parent, 'ActionMailer::Base'
+  end
+
+  test "should have template_path by default" do
+    assert_equal @email_notifier.template_path, 'exception_notifier'
+  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 be plain text and UTF-8 enconded by default" do
+    assert_equal @mail.content_type, "text/plain; charset=UTF-8"
+  end
+
+  test "should have raised an exception" do
+    refute_nil @exception
+  end
+
+  test "should have generated a notification email" do
+    refute_nil @mail
+  end
+
+  test "mail should have a from address set" do
+    assert_equal @mail.from, ["dummynotifier@example.com"]
+  end
+
+  test "mail should have a to address set" do
+    assert_equal @mail.to, ["dummyexceptions@example.com"]
+  end
+
+  test "mail should have a descriptive subject" do
+    assert_match /^\[Dummy ERROR\]\s+\(ZeroDivisionError\) "divided by 0"$/, @mail.subject
+  end
+
+  test "mail should say exception was raised in background at show timestamp" do
+    assert_includes @mail.encoded, "A ZeroDivisionError occurred in background at #{Time.current}"
+  end
+
+  test "mail should prefix exception class with 'an' instead of 'a' when it starts with a vowel" do
+    begin
+      raise ActiveRecord::RecordNotFound
+    rescue => e
+      @vowel_exception = e
+      @vowel_mail = @email_notifier.create_email(@vowel_exception)
+    end
+
+    assert_includes @vowel_mail.encoded, "An ActiveRecord::RecordNotFound occurred in background at #{Time.current}"
+  end
+
+  test "mail should contain backtrace in body" do
+    assert @mail.encoded.include?("test/exception_notifier/email_notifier_test.rb:9"), "\n#{@mail.inspect}"
+  end
+
+  test "mail should contain data in body" do
+    assert_includes @mail.encoded, '* data:'
+    assert_includes @mail.encoded, ':payload=>"1/0"'
+    assert_includes @mail.encoded, ':job=>"DivideWorkerJob"'
+    assert_includes @mail.encoded, "My Custom Message"
+  end
+
+  test "mail should not contain any attachments" do
+    assert_equal @mail.attachments, []
+  end
+
+  test "should not send notification if one of ignored exceptions" do
+    begin
+      raise ActiveRecord::RecordNotFound
+    rescue => e
+      @ignored_exception = e
+      unless ExceptionNotifier.ignored_exceptions.include?(@ignored_exception.class.name)
+        @ignored_mail = @email_notifier.create_email(@ignored_exception)
+      end
+    end
+
+    assert_equal @ignored_exception.class.inspect, "ActiveRecord::RecordNotFound"
+    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},
+      :deliver_with => :deliver_now
+    )
+
+    mail = email_notifier.create_email(
+      @exception,
+      :env => {
+        "REQUEST_METHOD" => "GET",
+        "rack.input" => "",
+        "invalid_encoding" => "R\xC3\xA9sum\xC3\xA9".force_encoding(Encoding::ASCII),
+      },
+      :email_format => :text
+    )
+
+    assert_match /invalid_encoding\s+: R__sum__/, mail.encoded
+  end
+
+  test "should send email using ActionMailer" do
+    ActionMailer::Base.deliveries.clear
+
+    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
+    )
+
+    email_notifier.call(@exception)
+
+    assert_equal 1, ActionMailer::Base.deliveries.count
+  end
+end

data/test/exception_notifier/hipchat_notifier_test.rb

@@ -0,0 +1,177 @@
+require 'test_helper'
+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, post_callback_called = 0,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 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.stubs(: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.stubs(:new).with('good_token', {:api_version => 'v2'}).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
+    exception = begin
+      5/0
+    rescue Exception => e
+      e
+    end
+  end
+
+  def fake_exception_with_html_characters
+    exception = begin
+      raise StandardError.new('an error with <html> characters')
+    rescue Exception => e
+      e
+    end
+  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