honeybadger 1.5.0 → 1.6.0

data/lib/honeybadger/rack.rb

@@ -22,7 +22,6 @@ module Honeybadger
   class Rack
     def initialize(app)
       @app = app
-      Honeybadger.configuration.logger ||= Logger.new STDOUT
     end
 
     def ignored_user_agent?(env)

data/lib/honeybadger/rails/controller_methods.rb

@@ -37,13 +37,14 @@ module Honeybadger
       def honeybadger_filter_if_filtering(hash)
         return hash if ! hash.is_a?(Hash)
 
-        if respond_to?(:filter_parameters) # Rails 2
+        # Rails 2 filters parameters in the controller
+        # In Rails 3+ we use request.env['action_dispatch.parameter_filter']
+        # to filter parameters in Honeybadger::Notice (avoids filtering twice)
+        if respond_to?(:filter_parameters)
           filter_parameters(hash)
-        elsif defined?(ActionDispatch::Http::ParameterFilter) # Rails 3
-          ActionDispatch::Http::ParameterFilter.new(::Rails.application.config.filter_parameters).filter(hash)
         else
           hash
-        end rescue hash
+        end
       end
 
       def honeybadger_session_data

data/lib/honeybadger/rails3_tasks.rb

@@ -13,6 +13,8 @@ namespace :honeybadger do
 
     Honeybadger.configure(true) do |config|
       config.logger = Rails.logger
+      config.debug = true
+      config.development_environments = []
     end
 
     # Suppress error logging in Rails' exception handling middleware. Rails 3.0
@@ -23,7 +25,17 @@ namespace :honeybadger do
     class ActionDispatch::DebugExceptions ; def logger(*args) ; @logger ||= Logger.new('/dev/null') ; end ; end
     class ActionDispatch::ShowExceptions ; def logger(*args) ; @logger ||= Logger.new('/dev/null') ; end ; end
 
-    require './app/controllers/application_controller'
+    # Detect and disable the better_errors gem
+    if defined? BetterErrors::Middleware
+      puts 'Better Errors detected: temporarily disabling middleware.'
+      class BetterErrors::Middleware ; def call(env) ; end ; end
+    end
+
+    begin
+      require './app/controllers/application_controller'
+    rescue LoadError
+      nil
+    end
 
     class HoneybadgerTestingException < RuntimeError; end
 
@@ -37,8 +49,6 @@ namespace :honeybadger do
       Honeybadger.configuration.async = nil
     end
 
-    Honeybadger.configuration.development_environments = []
-
     puts "Configuration:"
     Honeybadger.configuration.to_hash.each do |key, value|
       puts sprintf("%25s: %s", key.to_s, value.inspect.slice(0, 55))
@@ -74,7 +84,9 @@ namespace :honeybadger do
     end
 
     puts 'Processing request.'
-    env = Rack::MockRequest.env_for("/verify")
+
+    ssl = defined?(Rails.configuration.force_ssl) && Rails.configuration.force_ssl
+    env = Rack::MockRequest.env_for("http#{ ssl ? 's' : nil }://www.example.com/verify")
 
     Rails.application.call(env)
   end

data/lib/honeybadger/sender.rb

@@ -32,14 +32,14 @@ module Honeybadger
     #
     # notice - The notice data to be sent (Hash or JSON string)
     #
-    # Returns nothing
+    # Returns error id from successful response
     def send_to_honeybadger(notice)
       data = notice.is_a?(String) ? notice : notice.to_json
 
       http     = setup_http_connection
       headers  = HEADERS
 
-      headers.merge!({ 'X-API-Key' => api_key}) if api_key.present?
+      headers.merge!({ 'X-API-Key' => api_key}) unless api_key.nil?
 
       response = begin
                    http.post(url.path, data, headers)
@@ -50,17 +50,14 @@ module Honeybadger
 
       case response
       when Net::HTTPSuccess then
-        log(:info, "Success: #{response.class}", response, data)
+        log(Honeybadger.configuration.debug ? :info : :debug, "Success: #{response.class}", response, data)
+        JSON.parse(response.body)['id']
       else
         log(:error, "Failure: #{response.class}", response, data)
-      end
-
-      if response && response.respond_to?(:body)
-        notice = JSON.parse(response.body)
-        error_id = notice['id']
+        nil
       end
     rescue => e
-      log(:error, "[Honeybadger::Sender#send_to_honeybadger] Cannot send notification. Error: #{e.class} - #{e.message}\nBacktrace:\n#{e.backtrace.join("\n\t")}")
+      log(:error, "[Honeybadger::Sender#send_to_honeybadger] Error: #{e.class} - #{e.message}\nBacktrace:\n#{e.backtrace.join("\n\t")}")
       nil
     end
 
@@ -87,19 +84,13 @@ module Honeybadger
     end
 
     def log(level, message, response = nil, data = nil)
-      if logger
-        logger.send(level, LOG_PREFIX + message)
-
-        # Log the notice payload for debugging
-        logger.debug(LOG_PREFIX + "Notice: #{data}") if data
-      end
+      # Log result:
+      Honeybadger.write_verbose_log(message, level)
 
+      # Log debug information:
       Honeybadger.report_environment_info
       Honeybadger.report_response_body(response.body) if response && response.respond_to?(:body)
-    end
-
-    def logger
-      Honeybadger.logger
+      Honeybadger.write_verbose_log("Notice: #{data}", :debug) if data && Honeybadger.configuration.debug
     end
 
     def setup_http_connection

data/lib/honeybadger/shared_tasks.rb

@@ -35,10 +35,9 @@ namespace :honeybadger do
       end
 
       heroku_rails_env = heroku_var('RAILS_ENV', ENV['APP'])
-      heroku_api_key = heroku_var('HONEYBADGER_API_KEY', ENV['APP']).split.find {|x| x unless x.blank?} ||
-        Honeybadger.configuration.api_key
+      heroku_api_key = heroku_var('HONEYBADGER_API_KEY', ENV['APP']).split.find(Honeybadger.configuration.api_key) {|x| x =~ /\S/ }
 
-      if heroku_api_key.blank? || heroku_rails_env.blank?
+      unless heroku_api_key =~ /\S/ && heroku_rails_env =~ /\S/
         puts "WARNING: We were unable to detect the configuration from your Heroku environment."
         puts "Your Heroku application environment may not be configured correctly."
         puts "Have you configured multiple Heroku apps? Try using APP=[app name]'" unless ENV['APP']

data/lib/honeybadger/tasks.rb

@@ -8,7 +8,11 @@ namespace :honeybadger do
 
     require 'action_controller/test_process'
 
-    Dir["app/controllers/application*.rb"].each { |file| require(File.expand_path(file)) } 
+    begin
+      Dir["app/controllers/application*.rb"].each { |file| require(File.expand_path(file)) }
+    rescue LoadError
+      nil
+    end
 
     class HoneybadgerTestingException < RuntimeError; end
 
@@ -22,14 +26,9 @@ namespace :honeybadger do
       Honeybadger.configuration.async = nil
     end
 
-    Honeybadger.configuration.development_environments = []
-
-    catcher = Honeybadger::Rails::ActionControllerCatcher
-    in_controller = ApplicationController.included_modules.include?(catcher)
-    in_base = ActionController::Base.included_modules.include?(catcher)
-    if !in_controller || !in_base
-      puts "Rails initialization did not occur"
-      exit
+    Honeybadger.configure(true) do |config|
+      config.debug = true
+      config.development_environments = []
     end
 
     puts "Configuration:"
@@ -42,6 +41,14 @@ namespace :honeybadger do
       exit
     end
 
+    catcher = Honeybadger::Rails::ActionControllerCatcher
+    in_controller = ApplicationController.included_modules.include?(catcher)
+    in_base = ActionController::Base.included_modules.include?(catcher)
+    if !in_controller || !in_base
+      puts "Rails initialization did not occur"
+      exit
+    end
+
     puts 'Setting up the Controller.'
     class ApplicationController
       # This is to bypass any filters that may prevent access to the action.

data/lib/honeybadger_tasks.rb

@@ -1,6 +1,5 @@
 require 'net/http'
 require 'uri'
-require 'active_support'
 
 # Capistrano tasks for notifying Honeybadger of deploys
 module HoneybadgerTasks
@@ -17,12 +16,12 @@ module HoneybadgerTasks
   # Returns true or false
   def self.deploy(opts = {})
     api_key = opts.delete(:api_key) || Honeybadger.configuration.api_key
-    if api_key.blank?
+    unless api_key =~ /\S/
       puts "I don't seem to be configured with an API key.  Please check your configuration."
       return false
     end
 
-    if opts[:environment].blank?
+    unless opts[:environment] =~ /\S/
       puts "I don't know to which environment you are deploying (use the TO=production option)."
       return false
     end

data/lib/rails/generators/honeybadger/honeybadger_generator.rb

@@ -59,15 +59,15 @@ class HoneybadgerGenerator < Rails::Generators::Base
   def determine_api_key
     puts "Attempting to determine your API Key from Heroku..."
     ENV['HONEYBADGER_API_KEY'] = heroku_api_key
-    if ENV['HONEYBADGER_API_KEY'].blank?
+    if ENV['HONEYBADGER_API_KEY'] =~ /\S/
+      puts "... Done."
+      puts "Heroku's Honeybadger API Key is '#{ENV['HONEYBADGER_API_KEY']}'"
+    else
       puts "... Failed."
       puts "WARNING: We were unable to detect the Honeybadger API Key from your Heroku environment."
       puts "Your Heroku application environment may not be configured correctly."
       puts "Have you configured multiple Heroku apps? Try using the '--app [app name]' flag." unless options[:app]
       exit 1
-    else
-      puts "... Done."
-      puts "Heroku's Honeybadger API Key is '#{ENV['HONEYBADGER_API_KEY']}'"
     end
   end
 
@@ -77,7 +77,7 @@ class HoneybadgerGenerator < Rails::Generators::Base
   end
 
   def heroku_api_key
-    heroku_var("HONEYBADGER_API_KEY", options[:app]).split.find {|x| x unless x.blank?}
+    heroku_var("HONEYBADGER_API_KEY", options[:app]).split.find {|x| x =~ /\S/ }
   end
 
   def heroku?

data/test/test_helper.rb

@@ -5,11 +5,6 @@ require 'shoulda'
 require 'bourne'
 require 'rack'
 
-require 'action_controller'
-require 'action_controller/test_process'
-require 'active_record'
-require 'active_support'
-
 require 'honeybadger'
 
 class BacktracedException < Exception
@@ -126,13 +121,13 @@ class Test::Unit::TestCase
 
   def assert_logged(expected)
     assert_received(Honeybadger, :write_verbose_log) do |expect|
-      expect.with {|actual| actual =~ expected }
+      expect.with {|actual, level| actual =~ expected }
     end
   end
 
   def assert_not_logged(expected)
     assert_received(Honeybadger, :write_verbose_log) do |expect|
-      expect.with {|actual| actual =~ expected }.never
+      expect.with {|actual, level| actual =~ expected }.never
     end
   end
 

data/test/unit/backtrace_test.rb

@@ -84,23 +84,23 @@ class BacktraceTest < Test::Unit::TestCase
     end
 
     should "include a snippet from the source file for each line of the backtrace" do
-      assert_equal 4, @backtrace.lines.first.source.keys.size
-      assert_match /\$:<</, @backtrace.lines.first.source[1]
-      assert_match /require/, @backtrace.lines.first.source[2]
-      assert_match /\n/, @backtrace.lines.first.source[3]
-      assert_match /begin/, @backtrace.lines.first.source[4]
-
-      assert_equal 5, @backtrace.lines.second.source.keys.size
-      assert_match /require/, @backtrace.lines.second.source[2]
-      assert_match /\n/, @backtrace.lines.second.source[3]
-      assert_match /begin/, @backtrace.lines.second.source[4]
-      assert_match /StandardError/, @backtrace.lines.second.source[5]
-      assert_match /rescue/, @backtrace.lines.second.source[6]
-
-      assert_equal 3, @backtrace.lines.third.source.keys.size
-      assert_match /rescue/, @backtrace.lines.third.source[6]
-      assert_match /Honeybadger/, @backtrace.lines.third.source[7]
-      assert_match /end/, @backtrace.lines.third.source[8]
+      assert_equal 4, @backtrace.lines[0].source.keys.size
+      assert_match /\$:<</, @backtrace.lines[0].source[1]
+      assert_match /require/, @backtrace.lines[0].source[2]
+      assert_match /\n/, @backtrace.lines[0].source[3]
+      assert_match /begin/, @backtrace.lines[0].source[4]
+
+      assert_equal 5, @backtrace.lines[1].source.keys.size
+      assert_match /require/, @backtrace.lines[1].source[2]
+      assert_match /\n/, @backtrace.lines[1].source[3]
+      assert_match /begin/, @backtrace.lines[1].source[4]
+      assert_match /StandardError/, @backtrace.lines[1].source[5]
+      assert_match /rescue/, @backtrace.lines[1].source[6]
+
+      assert_equal 3, @backtrace.lines[2].source.keys.size
+      assert_match /rescue/, @backtrace.lines[2].source[6]
+      assert_match /Honeybadger/, @backtrace.lines[2].source[7]
+      assert_match /end/, @backtrace.lines[2].source[8]
     end
   end
 
@@ -112,8 +112,8 @@ class BacktraceTest < Test::Unit::TestCase
 
     backtrace = Honeybadger::Backtrace.parse(array)
 
-    assert_equal backtrace.lines.first.source, {}
-    assert_equal backtrace.lines.second.source, {}
+    assert_equal backtrace.lines[0].source, {}
+    assert_equal backtrace.lines[1].source, {}
   end
 
   should "have an empty application trace by default" do

data/test/unit/configuration_test.rb

@@ -27,6 +27,8 @@ class ConfigurationTest < Test::Unit::TestCase
     assert_config_default :framework, 'Standalone'
     assert_config_default :source_extract_radius, 2
     assert_config_default :async, nil
+    assert_config_default :send_request_session, true
+    assert_config_default :debug, false
   end
 
   should "configure async as Proc" do
@@ -89,6 +91,10 @@ class ConfigurationTest < Test::Unit::TestCase
     assert_config_overridable :notifier_url
     assert_config_overridable :environment_name
     assert_config_overridable :logger
+    assert_config_overridable :source_extract_radius
+    assert_config_overridable :async
+    assert_config_overridable :send_request_session
+    assert_config_overridable :debug
   end
 
   should "have an api key" do
@@ -99,11 +105,11 @@ class ConfigurationTest < Test::Unit::TestCase
     config = Honeybadger::Configuration.new
     hash = config.to_hash
     [:api_key, :backtrace_filters, :development_environments,
-     :environment_name, :host, :http_open_timeout,
-     :http_read_timeout, :ignore, :ignore_by_filters, :ignore_user_agent,
-     :notifier_name, :notifier_url, :notifier_version, :params_filters,
-     :project_root, :port, :protocol, :proxy_host, :proxy_pass, :proxy_port,
-     :proxy_user, :secure].each do |option|
+     :environment_name, :host, :http_open_timeout, :http_read_timeout, :ignore,
+     :ignore_by_filters, :ignore_user_agent, :notifier_name, :notifier_url,
+     :notifier_version, :params_filters, :project_root, :port, :protocol,
+     :proxy_host, :proxy_pass, :proxy_port, :proxy_user, :secure,
+     :source_extract_radius, :async, :send_request_session, :debug].each do |option|
       assert_equal config[option], hash[option], "Wrong value for #{option}"
     end
   end

data/test/unit/notice_test.rb

@@ -163,7 +163,7 @@ class NoticeTest < Test::Unit::TestCase
         @string_io.rewind
 
         assert_not_equal notice_from_exception.source_extract, {}, 'Expected backtrace source extract to be found'
-        assert_equal backtrace.lines.second.source, notice_from_exception.source_extract
+        assert_equal backtrace.lines[1].source, notice_from_exception.source_extract
       end
     end
   end
@@ -325,10 +325,23 @@ class NoticeTest < Test::Unit::TestCase
     assert notice.ignore?
   end
 
-  should "ignore an exception with a matching error class name" do
+  should "ignore an exception with an equal error class name" do
     notice = build_notice(:error_class => 'ArgumentError',
                           :ignore      => ['ArgumentError'])
-    assert notice.ignore?
+    assert notice.ignore?, "Expected ArgumentError to ignore ArgumentError"
+  end
+
+  should "ignore an exception matching error class name" do
+    notice = build_notice(:error_class => 'ArgumentError',
+                          :ignore      => [/Error$/])
+    assert notice.ignore?, "Expected /Error$/ to ignore ArgumentError"
+  end
+
+  should "ignore an exception that inherits from ignored error class" do
+    class ::FooError < ArgumentError ; end
+    notice = build_notice(:exception => FooError.new('Oh noes!'),
+                          :ignore      => [ArgumentError])
+    assert notice.ignore?, "Expected ArgumentError to ignore FooError"
   end
 
   should "ignore an exception with a matching filter" do
@@ -442,6 +455,11 @@ class NoticeTest < Test::Unit::TestCase
     assert_equal session_data, notice.session_data
   end
 
+  should "not send session data when send_request_session is false" do
+    notice = build_notice(:send_request_session => false, :session_data => { :foo => :bar })
+    assert_equal nil, notice.session_data
+  end
+
   should "not allow infinite recursion" do
     hash = {:a => :a}
     hash[:hash] = hash

data/test/unit/rails/action_controller_catcher_test.rb

@@ -1,300 +1,309 @@
 require 'test_helper'
-require 'honeybadger/rails'
 
-class ActionControllerCatcherTest < Test::Unit::TestCase
-  include DefinesConstants
+begin
+  require 'active_support'
+  require 'action_controller'
+  require 'action_controller/test_process'
+  require 'honeybadger/rails'
 
-  def setup
-    super
-    reset_config
-    Honeybadger.sender = CollectingSender.new
-    define_constant('RAILS_ROOT', '/path/to/rails/root')
-  end
-
-  def ignore(exception_class)
-    Honeybadger.configuration.ignore << exception_class
-  end
+  class ActionControllerCatcherTest < Test::Unit::TestCase
+    include DefinesConstants
 
-  def build_controller_class(&definition)
-    Class.new(ActionController::Base).tap do |klass|
-      klass.__send__(:include, Honeybadger::Rails::ActionControllerCatcher)
-      klass.class_eval(&definition) if definition
-      define_constant('HoneybadgerTestController', klass)
+    def setup
+      super
+      reset_config
+      Honeybadger.sender = CollectingSender.new
+      define_constant('RAILS_ROOT', '/path/to/rails/root')
     end
-  end
-
-  def assert_sent_hash(hash, &block)
-    hash.each do |key, value|
-      next if key.match(/^honeybadger\./) # We added this key.
 
-      new_block = Proc.new {
-        block.call(last_sent_notice_payload)[key]
-      }
+    def ignore(exception_class)
+      Honeybadger.configuration.ignore << exception_class
+    end
 
-      if value.respond_to?(:to_hash)
-        assert_sent_hash(value.to_hash, &new_block)
-      else
-        assert_sent_element(value, &new_block)
+    def build_controller_class(&definition)
+      Class.new(ActionController::Base).tap do |klass|
+        klass.__send__(:include, Honeybadger::Rails::ActionControllerCatcher)
+        klass.class_eval(&definition) if definition
+        define_constant('HoneybadgerTestController', klass)
       end
     end
-  end
 
-  def assert_sent_element(value, &block)
-    assert_equal yield(last_sent_notice_payload), stringify_array_elements(value)
-  end
+    def assert_sent_hash(hash, &block)
+      hash.each do |key, value|
+        next if key.match(/^honeybadger\./) # We added this key.
 
-  def stringify_array_elements(data)
-    if data.is_a?(Array)
-      data.collect do |value|
-        stringify_array_elements(value)
+        new_block = Proc.new {
+          block.call(last_sent_notice_payload)[key]
+        }
+
+        if value.respond_to?(:to_hash)
+          assert_sent_hash(value.to_hash, &new_block)
+        else
+          assert_sent_element(value, &new_block)
+        end
       end
-    else
-      data.to_s
     end
-  end
 
-  def assert_sent_request_info_for(request)
-    params = request.parameters.to_hash
-    assert_sent_hash(params) { |h| h['request']['params'] }
-    assert_sent_element(params['controller']) { |h| h['request']['component'] }
-    assert_sent_element(params['action']) { |h| h['request']['action'] }
-    assert_sent_element(url_from_request(request)) { |h| h['request']['url'] }
-    assert_sent_hash(request.env) { |h| h['request']['cgi_data'] }
-  end
+    def assert_sent_element(value, &block)
+      assert_equal yield(last_sent_notice_payload), stringify_array_elements(value)
+    end
 
-  def url_from_request(request)
-    url = "#{request.protocol}#{request.host}"
+    def stringify_array_elements(data)
+      if data.is_a?(Array)
+        data.collect do |value|
+          stringify_array_elements(value)
+        end
+      else
+        data.to_s
+      end
+    end
 
-    unless [80, 443].include?(request.port)
-      url << ":#{request.port}"
+    def assert_sent_request_info_for(request)
+      params = request.parameters.to_hash
+      assert_sent_hash(params) { |h| h['request']['params'] }
+      assert_sent_element(params['controller']) { |h| h['request']['component'] }
+      assert_sent_element(params['action']) { |h| h['request']['action'] }
+      assert_sent_element(url_from_request(request)) { |h| h['request']['url'] }
+      assert_sent_hash(request.env) { |h| h['request']['cgi_data'] }
     end
 
-    url << request.request_uri
-    url
-  end
+    def url_from_request(request)
+      url = "#{request.protocol}#{request.host}"
 
-  def sender
-    Honeybadger.sender
-  end
+      unless [80, 443].include?(request.port)
+        url << ":#{request.port}"
+      end
 
-  def last_sent_notice_json
-    sender.collected.last
-  end
+      url << request.request_uri
+      url
+    end
 
-  def last_sent_notice_payload
-    assert_not_nil last_sent_notice_json, "No json was sent"
-    JSON.parse(last_sent_notice_json)
-  end
+    def sender
+      Honeybadger.sender
+    end
 
-  def process_action(opts = {}, &action)
-    opts[:request]  ||= ActionController::TestRequest.new
-    opts[:response] ||= ActionController::TestResponse.new
-    klass = build_controller_class do
-      cattr_accessor :local
-      define_method(:index, &action)
-      def local_request?
-        local
-      end
+    def last_sent_notice_json
+      sender.collected.last
     end
-    if opts[:filters]
-      klass.filter_parameter_logging *opts[:filters]
+
+    def last_sent_notice_payload
+      assert_not_nil last_sent_notice_json, "No json was sent"
+      JSON.parse(last_sent_notice_json)
     end
-    if opts[:user_agent]
-      if opts[:request].respond_to?(:user_agent=)
-        opts[:request].user_agent = opts[:user_agent]
-      else
-        opts[:request].env["HTTP_USER_AGENT"] = opts[:user_agent]
+
+    def process_action(opts = {}, &action)
+      opts[:request]  ||= ActionController::TestRequest.new
+      opts[:response] ||= ActionController::TestResponse.new
+      klass = build_controller_class do
+        cattr_accessor :local
+        define_method(:index, &action)
+        def local_request?
+          local
+        end
+      end
+      if opts[:filters]
+        klass.filter_parameter_logging *opts[:filters]
+      end
+      if opts[:user_agent]
+        if opts[:request].respond_to?(:user_agent=)
+          opts[:request].user_agent = opts[:user_agent]
+        else
+          opts[:request].env["HTTP_USER_AGENT"] = opts[:user_agent]
+        end
       end
+      if opts[:port]
+        opts[:request].port = opts[:port]
+      end
+      klass.consider_all_requests_local = opts[:all_local]
+      klass.local                       = opts[:local]
+      controller = klass.new
+      controller.stubs(:rescue_action_in_public_without_honeybadger)
+      opts[:request].query_parameters = opts[:request].query_parameters.merge(opts[:params] || {})
+      opts[:request].session = ActionController::TestSession.new(opts[:session] || {})
+      # Prevents request.fullpath from crashing Rails in tests
+      opts[:request].env['REQUEST_URI'] = opts[:request].request_uri
+      controller.process(opts[:request], opts[:response])
+      controller
     end
-    if opts[:port]
-      opts[:request].port = opts[:port]
-    end
-    klass.consider_all_requests_local = opts[:all_local]
-    klass.local                       = opts[:local]
-    controller = klass.new
-    controller.stubs(:rescue_action_in_public_without_honeybadger)
-    opts[:request].query_parameters = opts[:request].query_parameters.merge(opts[:params] || {})
-    opts[:request].session = ActionController::TestSession.new(opts[:session] || {})
-    # Prevents request.fullpath from crashing Rails in tests
-    opts[:request].env['REQUEST_URI'] = opts[:request].request_uri
-    controller.process(opts[:request], opts[:response])
-    controller
-  end
 
-  def process_action_with_manual_notification(args = {})
-    process_action(args) do
-      notify_honeybadger(:error_message => 'fail')
-      # Rails will raise a template error if we don't render something
-      render :nothing => true
+    def process_action_with_manual_notification(args = {})
+      process_action(args) do
+        notify_honeybadger(:error_message => 'fail')
+        # Rails will raise a template error if we don't render something
+        render :nothing => true
+      end
     end
-  end
 
-  def process_action_with_automatic_notification(args = {})
-    process_action(args) { raise "Hello" }
-  end
+    def process_action_with_automatic_notification(args = {})
+      process_action(args) { raise "Hello" }
+    end
 
-  should "deliver notices from exceptions raised in public requests" do
-    process_action_with_automatic_notification
-    assert_caught_and_sent
-  end
+    should "deliver notices from exceptions raised in public requests" do
+      process_action_with_automatic_notification
+      assert_caught_and_sent
+    end
 
-  should "not deliver notices from exceptions in local requests" do
-    process_action_with_automatic_notification(:local => true)
-    assert_caught_and_not_sent
-  end
+    should "not deliver notices from exceptions in local requests" do
+      process_action_with_automatic_notification(:local => true)
+      assert_caught_and_not_sent
+    end
 
-  should "not deliver notices from exceptions when all requests are local" do
-    process_action_with_automatic_notification(:all_local => true)
-    assert_caught_and_not_sent
-  end
+    should "not deliver notices from exceptions when all requests are local" do
+      process_action_with_automatic_notification(:all_local => true)
+      assert_caught_and_not_sent
+    end
 
-  should "not deliver notices from actions that don't raise" do
-    controller = process_action { render :text => 'Hello' }
-    assert_caught_and_not_sent
-    assert_equal 'Hello', controller.response.body
-  end
+    should "not deliver notices from actions that don't raise" do
+      controller = process_action { render :text => 'Hello' }
+      assert_caught_and_not_sent
+      assert_equal 'Hello', controller.response.body
+    end
 
-  should "not deliver ignored exceptions raised by actions" do
-    ignore(RuntimeError)
-    process_action_with_automatic_notification
-    assert_caught_and_not_sent
-  end
+    should "not deliver ignored exceptions raised by actions" do
+      ignore(RuntimeError)
+      process_action_with_automatic_notification
+      assert_caught_and_not_sent
+    end
 
-  should "deliver ignored exception raised manually" do
-    ignore(RuntimeError)
-    process_action_with_manual_notification
-    assert_caught_and_sent
-  end
+    should "deliver ignored exception raised manually" do
+      ignore(RuntimeError)
+      process_action_with_manual_notification
+      assert_caught_and_sent
+    end
 
-  should "deliver manually sent notices in public requests" do
-    process_action_with_manual_notification
-    assert_caught_and_sent
-  end
+    should "deliver manually sent notices in public requests" do
+      process_action_with_manual_notification
+      assert_caught_and_sent
+    end
 
-  should "not deliver manually sent notices in local requests" do
-    process_action_with_manual_notification(:local => true)
-    assert_caught_and_not_sent
-  end
+    should "not deliver manually sent notices in local requests" do
+      process_action_with_manual_notification(:local => true)
+      assert_caught_and_not_sent
+    end
 
-  should "not deliver manually sent notices when all requests are local" do
-    process_action_with_manual_notification(:all_local => true)
-    assert_caught_and_not_sent
-  end
+    should "not deliver manually sent notices when all requests are local" do
+      process_action_with_manual_notification(:all_local => true)
+      assert_caught_and_not_sent
+    end
 
-  should "continue with default behavior after delivering an exception" do
-    controller = process_action_with_automatic_notification(:public => true)
-    # TODO: can we test this without stubbing?
-    assert_received(controller, :rescue_action_in_public_without_honeybadger)
-  end
+    should "continue with default behavior after delivering an exception" do
+      controller = process_action_with_automatic_notification(:public => true)
+      # TODO: can we test this without stubbing?
+      assert_received(controller, :rescue_action_in_public_without_honeybadger)
+    end
 
-  should "not create actions from Honeybadger methods" do
-    controller = build_controller_class.new
-    assert_equal [], Honeybadger::Rails::ActionControllerCatcher.instance_methods
-  end
+    should "not create actions from Honeybadger methods" do
+      controller = build_controller_class.new
+      assert_equal [], Honeybadger::Rails::ActionControllerCatcher.instance_methods
+    end
 
-  should "ignore exceptions when user agent is being ignored by regular expression" do
-    Honeybadger.configuration.ignore_user_agent_only = [/Ignored/]
-    process_action_with_automatic_notification(:user_agent => 'ShouldBeIgnored')
-    assert_caught_and_not_sent
-  end
+    should "ignore exceptions when user agent is being ignored by regular expression" do
+      Honeybadger.configuration.ignore_user_agent_only = [/Ignored/]
+      process_action_with_automatic_notification(:user_agent => 'ShouldBeIgnored')
+      assert_caught_and_not_sent
+    end
 
-  should "ignore exceptions when user agent is being ignored by string" do
-    Honeybadger.configuration.ignore_user_agent_only = ['IgnoredUserAgent']
-    process_action_with_automatic_notification(:user_agent => 'IgnoredUserAgent')
-    assert_caught_and_not_sent
-  end
+    should "ignore exceptions when user agent is being ignored by string" do
+      Honeybadger.configuration.ignore_user_agent_only = ['IgnoredUserAgent']
+      process_action_with_automatic_notification(:user_agent => 'IgnoredUserAgent')
+      assert_caught_and_not_sent
+    end
 
-  should "not ignore exceptions when user agent is not being ignored" do
-    Honeybadger.configuration.ignore_user_agent_only = ['IgnoredUserAgent']
-    process_action_with_automatic_notification(:user_agent => 'NonIgnoredAgent')
-    assert_caught_and_sent
-  end
+    should "not ignore exceptions when user agent is not being ignored" do
+      Honeybadger.configuration.ignore_user_agent_only = ['IgnoredUserAgent']
+      process_action_with_automatic_notification(:user_agent => 'NonIgnoredAgent')
+      assert_caught_and_sent
+    end
 
-  should "send session data for manual notifications" do
-    data = { 'one' => 'two' }
-    process_action_with_manual_notification(:session => data)
-    assert_sent_hash(data) { |h| h['request']['session'] }
-  end
+    should "send session data for manual notifications" do
+      data = { 'one' => 'two' }
+      process_action_with_manual_notification(:session => data)
+      assert_sent_hash(data) { |h| h['request']['session'] }
+    end
 
-  should "send session data for automatic notification" do
-    data = { 'one' => 'two' }
-    process_action_with_automatic_notification(:session => data)
-    assert_sent_hash(data) { |h| h['request']['session'] }
-  end
+    should "send session data for automatic notification" do
+      data = { 'one' => 'two' }
+      process_action_with_automatic_notification(:session => data)
+      assert_sent_hash(data) { |h| h['request']['session'] }
+    end
 
-  should "send request data for manual notification" do
-    params = { 'controller' => "honeybadger_test", 'action' => "index" }
-    controller = process_action_with_manual_notification(:params => params)
-    assert_sent_request_info_for controller.request
-  end
+    should "send request data for manual notification" do
+      params = { 'controller' => "honeybadger_test", 'action' => "index" }
+      controller = process_action_with_manual_notification(:params => params)
+      assert_sent_request_info_for controller.request
+    end
 
-  should "send request data for manual notification with non-standard port" do
-    params = { 'controller' => "honeybadger_test", 'action' => "index" }
-    controller = process_action_with_manual_notification(:params => params, :port => 81)
-    assert_sent_request_info_for controller.request
-  end
+    should "send request data for manual notification with non-standard port" do
+      params = { 'controller' => "honeybadger_test", 'action' => "index" }
+      controller = process_action_with_manual_notification(:params => params, :port => 81)
+      assert_sent_request_info_for controller.request
+    end
 
-  should "send request data for automatic notification" do
-    params = { 'controller' => "honeybadger_test", 'action' => "index" }
-    controller = process_action_with_automatic_notification(:params => params)
-    assert_sent_request_info_for controller.request
-  end
+    should "send request data for automatic notification" do
+      params = { 'controller' => "honeybadger_test", 'action' => "index" }
+      controller = process_action_with_automatic_notification(:params => params)
+      assert_sent_request_info_for controller.request
+    end
 
-  should "send request data for automatic notification with non-standard port" do
-    params = { 'controller' => "honeybadger_test", 'action' => "index" }
-    controller = process_action_with_automatic_notification(:params => params, :port => 81)
-    assert_sent_request_info_for controller.request
-  end
+    should "send request data for automatic notification with non-standard port" do
+      params = { 'controller' => "honeybadger_test", 'action' => "index" }
+      controller = process_action_with_automatic_notification(:params => params, :port => 81)
+      assert_sent_request_info_for controller.request
+    end
 
-  should "use standard rails logging filters on params and session and env" do
-    filtered_params = { "abc" => "123",
-                        "def" => "456",
-                        "ghi" => "[FILTERED]" }
-    filtered_session = { "abc" => "123",
-                         "ghi" => "[FILTERED]" }
-    ENV['ghi'] = 'abc'
-    filtered_env = { 'ghi' => '[FILTERED]' }
-    filtered_cgi = { 'REQUEST_METHOD' => '[FILTERED]' }
-
-    process_action_with_automatic_notification(:filters => [:ghi, :request_method],
-                                               :params => { "abc" => "123",
-                                                            "def" => "456",
-                                                            "ghi" => "789" },
-                                                            :session => { "abc" => "123",
-                                                                          "ghi" => "789" })
-    assert_sent_hash(filtered_params) { |h| h['request']['params'] }
-    assert_sent_hash(filtered_cgi) { |h| h['request']['cgi_data'] }
-    assert_sent_hash(filtered_session) { |h| h['request']['session'] }
-  end
+    should "use standard rails logging filters on params and session and env" do
+      filtered_params = { "abc" => "123",
+                          "def" => "456",
+                          "ghi" => "[FILTERED]" }
+      filtered_session = { "abc" => "123",
+                           "ghi" => "[FILTERED]" }
+      ENV['ghi'] = 'abc'
+      filtered_env = { 'ghi' => '[FILTERED]' }
+      filtered_cgi = { 'REQUEST_METHOD' => '[FILTERED]' }
+
+      process_action_with_automatic_notification(:filters => [:ghi, :request_method],
+                                                 :params => { "abc" => "123",
+                                                              "def" => "456",
+                                                              "ghi" => "789" },
+                                                              :session => { "abc" => "123",
+                                                                            "ghi" => "789" })
+      assert_sent_hash(filtered_params) { |h| h['request']['params'] }
+      assert_sent_hash(filtered_cgi) { |h| h['request']['cgi_data'] }
+      assert_sent_hash(filtered_session) { |h| h['request']['session'] }
+    end
 
-  should "call session.to_hash if available" do
-    hash_data = {:key => :value}
+    should "call session.to_hash if available" do
+      hash_data = {:key => :value}
 
-    session = ActionController::TestSession.new
-    ActionController::TestSession.stubs(:new).returns(session)
-    session.stubs(:to_hash).returns(hash_data)
+      session = ActionController::TestSession.new
+      ActionController::TestSession.stubs(:new).returns(session)
+      session.stubs(:to_hash).returns(hash_data)
 
-    process_action_with_automatic_notification
-    assert_received(session, :to_hash)
-    assert_received(session, :data) { |expect| expect.never }
-    assert_caught_and_sent
-  end
+      process_action_with_automatic_notification
+      assert_received(session, :to_hash)
+      assert_received(session, :data) { |expect| expect.never }
+      assert_caught_and_sent
+    end
 
-  should "call session.data if session.to_hash is undefined" do
-    hash_data = {:key => :value}
+    should "call session.data if session.to_hash is undefined" do
+      hash_data = {:key => :value}
 
-    session = ActionController::TestSession.new
-    ActionController::TestSession.stubs(:new).returns(session)
-    session.stubs(:data).returns(hash_data)
-    if session.respond_to?(:to_hash)
-      class << session
-        undef to_hash
+      session = ActionController::TestSession.new
+      ActionController::TestSession.stubs(:new).returns(session)
+      session.stubs(:data).returns(hash_data)
+      if session.respond_to?(:to_hash)
+        class << session
+          undef to_hash
+        end
       end
-    end
 
-    process_action_with_automatic_notification
-    assert_received(session, :to_hash) { |expect| expect.never }
-    assert_received(session, :data) { |expect| expect.at_least_once }
-    assert_caught_and_sent
+      process_action_with_automatic_notification
+      assert_received(session, :to_hash) { |expect| expect.never }
+      assert_received(session, :data) { |expect| expect.at_least_once }
+      assert_caught_and_sent
+    end
   end
+
+rescue LoadError
+  nil
 end