airbrake 3.1.6 → 3.1.7

data/lib/airbrake/shared_tasks.rb

@@ -14,11 +14,11 @@ namespace :airbrake do
     end
 
     AirbrakeTasks.deploy(:rails_env      => ENV['TO'],
-                        :scm_revision   => ENV['REVISION'],
-                        :scm_repository => ENV['REPO'],
-                        :local_username => ENV['USER'],
-                        :api_key        => ENV['API_KEY'],
-                        :dry_run        => ENV['DRY_RUN'])
+                         :scm_revision   => ENV['REVISION'],
+                         :scm_repository => ENV['REPO'],
+                         :local_username => ENV['USER'],
+                         :api_key        => ENV['API_KEY'],
+                         :dry_run        => ENV['DRY_RUN'])
   end
 
   task :log_stdout do
@@ -30,15 +30,28 @@ namespace :airbrake do
     desc "Install Heroku deploy notifications addon"
     task :add_deploy_notification => [:environment] do
 
-      def heroku_var(var)
-        `heroku config | grep -E "#{var.upcase}" | awk '{ print $3; }'`.strip
+      def get_heroku_vars
+        config = `heroku config --shell`
+        array_of_vars = config.split.map do |var|
+          var.partition("=").tap {|part| part.delete_at(1)}
+        end.flatten
+        @heroku_vars = Hash[*array_of_vars]
       end
 
-      heroku_rails_env = heroku_var("rails_env")
-      heroku_api_key = heroku_var("(hoptoad|airbrake)_api_key").split.find {|x| x unless x.blank?} ||
-        Airbrake.configuration.api_key
+      get_heroku_vars
 
-      command = %Q(heroku addons:add deployhooks:http --url="http://airbrake.io/deploys.txt?deploy[rails_env]=#{heroku_rails_env}&api_key=#{heroku_api_key}")
+      heroku_rails_env = @heroku_vars["RAILS_ENV"]        || ENV["RAILS_ENV"] || "production"
+      heroku_api_key   = @heroku_vars["AIRBRAKE_API_KEY"] || Airbrake.configuration.api_key || ENV["AIRBRAKE_API_KEY"]
+      heroku_app       = ENV["HEROKU_APP"]
+      repo             = `git config --get remote.origin.url` || ENV["REPO"]
+
+      command = %Q(heroku addons:add deployhooks:http --url="http://airbrake.io/deploys.txt?api_key=#{heroku_api_key})
+      command << "&deploy[local_username]={{user}}"    
+      command << "&deploy[scm_revision]={{head_long}}" 
+      command << "&deploy[rails_env]=#{heroku_rails_env}"  if heroku_rails_env
+      command << "&deploy[scm_repository]=#{repo}"         if repo
+      command << '"'
+      command << " --app=#{heroku_app}"                    if heroku_app
 
       puts "\nRunning:\n#{command}\n"
       puts `#{command}`

data/lib/airbrake/sinatra.rb

@@ -0,0 +1,34 @@
+module Airbrake
+  # Middleware for Sinatra applications. Any errors raised by the upstream
+  # application will be delivered to Airbrake and re-raised.
+
+  # Synopsis:
+
+  #   require 'sinatra'
+  #   require 'airbrake'
+
+  #   Airbrake.configure do |config|
+  #     config.api_key = 'my api key'
+  #   end
+
+  #   use Airbrake::Sinatra
+
+  #   get '/' do
+  #     raise "Sinatra has left the building"
+  #   end
+  #
+  # Use a standard Airbrake.configure call to configure your api key.
+  class Sinatra < Rack
+
+    def initialize(app)
+      super
+      Airbrake.configuration.environment_name = "#{app.settings.environment}"
+      Airbrake.configuration.framework = "Sinatra: #{::Sinatra::VERSION}"
+    end 
+
+    def framework_exception
+      @env['sinatra.error']
+    end
+
+  end
+end

data/lib/airbrake/user_informer.rb

@@ -9,7 +9,12 @@ module Airbrake
     end
 
     def call(env)
+      dup._call(env)
+    end
+
+    def _call(env)
       status, headers, body = @app.call(env)
+
       if env['airbrake.error_id'] && Airbrake.configuration.user_information
         new_body = []
         replace  = replacement(env['airbrake.error_id'])
@@ -20,7 +25,11 @@ module Airbrake
         headers['Content-Length'] = new_body.sum(&:bytesize).to_s
         body = new_body
       end
+
       [status, headers, body]
+
+    ensure
+      body.close if body && body.respond_to?(:close) && $!
     end
   end
 end

data/lib/airbrake/version.rb

@@ -1,3 +1,3 @@
 module Airbrake
-  VERSION = "3.1.6".freeze
+  VERSION = "3.1.7"
 end

data/lib/rails/generators/airbrake/airbrake_generator.rb

@@ -49,7 +49,7 @@ class AirbrakeGenerator < Rails::Generators::Base
     s = if options[:api_key]
       "'#{options[:api_key]}'"
     elsif options[:heroku]
-      "ENV['HOPTOAD_API_KEY']"
+      "ENV['AIRBRAKE_API_KEY']"
     end
   end
 
@@ -59,31 +59,31 @@ class AirbrakeGenerator < Rails::Generators::Base
 
   def determine_api_key
     puts "Attempting to determine your API Key from Heroku..."
-    ENV['HOPTOAD_API_KEY'] = heroku_api_key
-    if ENV['HOPTOAD_API_KEY'].blank?
+    ENV['AIRBRAKE_API_KEY'] = heroku_api_key
+    if ENV['AIRBRAKE_API_KEY'].blank?
       puts "... Failed."
       puts "WARNING: We were unable to detect the Airbrake API Key from your Heroku environment."
       puts "Your Heroku application environment may not be configured correctly."
       exit 1
     else
       puts "... Done."
-      puts "Heroku's Airbrake API Key is '#{ENV['HOPTOAD_API_KEY']}'"
+      puts "Heroku's Airbrake API Key is '#{ENV['AIRBRAKE_API_KEY']}'"
     end
   end
 
   def heroku_var(var,app_name = nil)
-    app = app_name ? "--app #{app_name}" : ''
-    `heroku config #{app} | grep -E "#{var.upcase}" | awk '{ print $3; }'`.strip
+    app = app_name ? "-a #{app_name}" : ''
+    `heroku config:get #{var} #{app}`
   end
 
   def heroku_api_key
-    heroku_var("(hoptoad|airbrake)_api_key",options[:app]).split.find {|x| x unless x.blank?}
+    heroku_var("AIRBRAKE_API_KEY",options[:app]).split.find {|x| x unless x.blank?}
   end
 
   def heroku?
     options[:heroku] ||
-      system("grep HOPTOAD_API_KEY config/initializers/airbrake.rb") ||
-      system("grep HOPTOAD_API_KEY config/environment.rb")
+      system("grep AIRBRAKE_API_KEY config/initializers/airbrake.rb") ||
+      system("grep AIRBRAKE_API_KEY config/environment.rb")
   end
 
   def api_key_configured?
@@ -91,7 +91,7 @@ class AirbrakeGenerator < Rails::Generators::Base
   end
 
   def test_airbrake
-    puts run("rake airbrake:test --trace")
+    puts run("rake airbrake:test")
   end
 
   def plugin_is_present?

data/{test/airbrake_2_3.xsd → resources/airbrake_2_4.xsd}

@@ -10,6 +10,7 @@
         <xs:element name="request" type="request" minOccurs="0"/>
         <xs:element name="server-environment" type="serverEnvironment"/>
         <xs:element name="current-user" type="current-user" minOccurs="0"/>
+        <xs:element name="framework" type="xs:string" minOccurs="0"/>
       </xs:all>
       <xs:attribute name="version" type="xs:string" use="required"/>
     </xs:complexType>

data/resources/airbrake_3_0.json

@@ -0,0 +1,52 @@
+{
+  "type"                 : "object",
+  "additionalProperties" : false,
+  "properties"           : {
+     "notifier" : {
+        "type"                 : "hash",
+        "required"             : true,
+        "additionalProperties" : false,
+        "properties"           : {
+             "name"    : {"type" : "string", "required" : true},
+             "version" : {"type" : "string", "required" : true},
+             "url"     : {"type" : "string", "required" : true}
+        }
+     },
+     "errors" : {
+       "type"     : "array",
+       "required" : true,
+       "items"    : {
+         "type"   : [{
+            "type" : "hash",
+            "additionalProperties" : false,
+            "properties" : {
+               "backtrace" : {"type" : "array",  "required" : true},
+               "type"      : {"type" : "string", "required" : true},
+               "message"   : {"type" : "string", "required" : true}
+            } 
+         }]
+       }
+     },
+    "context" : {
+       "type"                 : "hash",
+       "additionalProperties" : false,
+       "properties" : {
+         "os"             : {"type" : "string"},
+         "language"       : {"type" : "string"},
+         "environment"    : {"type" : "string"},
+         "version"        : {"type" : "string"},
+         "url"            : {"type" : "string"},
+         "rootDirectory"  : {"type" : "string"},
+         "userId"         : {"type" : "string"},
+         "userName"       : {"type" : "string"},
+         "userEmail"      : {"type" : "string"},
+         "component"      : {"type" : "string"},
+         "action"         : {"type" : "string"}
+       }
+     },
+   "environment" : {"type" : "hash"},
+   "session"     : {"type" : "hash"},
+   "params"      : {"type" : "hash"}
+  }
+}
+

data/test/catcher_test.rb

@@ -1,6 +1,23 @@
 require File.expand_path '../helper', __FILE__
 
-class ActionControllerCatcherTest < Test::Unit::TestCase
+require 'airbrake/rails/controller_methods'
+require 'airbrake/rails/middleware'
+
+module ActionDispatch
+  class ShowExceptions
+    private
+    def public_path
+      "/null"
+    end
+
+    # Silence logger
+    def logger
+      nil
+    end
+  end
+end
+
+class ActionControllerCatcherTest < ActionDispatch::IntegrationTest
 
   include DefinesConstants
 
@@ -8,6 +25,7 @@ class ActionControllerCatcherTest < Test::Unit::TestCase
     super
     reset_config
     Airbrake.sender = CollectingSender.new
+    Airbrake.configuration.development_environments = []
     define_constant('RAILS_ROOT', '/path/to/rails/root')
   end
 
@@ -15,22 +33,17 @@ class ActionControllerCatcherTest < Test::Unit::TestCase
     Airbrake.configuration.ignore << exception_class
   end
 
-  def build_controller_class(&definition)
-     Class.new(ActionController::Base).tap do |klass|
-      klass.__send__(:include, Airbrake::Rails::ActionControllerCatcher)
-      klass.class_eval(&definition) if definition
-      define_constant('AirbrakeTestController', klass)
-    end
-  end
-
   def assert_sent_hash(hash, xpath)
     hash.each do |key, value|
-      next if key.match(/^airbrake\./) # We added this key.
+      next if key.match(/^airbrake\./) || # We added this key.
+        hash[key].blank?
 
       element_xpath = "#{xpath}/var[@key = '#{key}']"
       if value.respond_to?(:to_hash)
         assert_sent_hash value.to_hash, element_xpath
       else
+        next if key == "action_dispatch.exception" # TODO: Rails 3.2 only - review
+        value.gsub!(/\d/,"") if key == "PATH_INFO" # TODO: Rails 3.2 only - review
         assert_sent_element value, element_xpath
       end
     end
@@ -66,7 +79,8 @@ class ActionControllerCatcherTest < Test::Unit::TestCase
       url << ":#{request.port}"
     end
 
-    url << request.request_uri
+    url << request.fullpath.gsub(%r{\d},"") # TODO: Rails 3.2 only - review
+
     url
   end
 
@@ -83,251 +97,195 @@ class ActionControllerCatcherTest < Test::Unit::TestCase
     Nokogiri::XML.parse(xml)
   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
-    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_airbrake)
-    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_airbrake(:error_message => 'fail')
-      # Rails will raise a template error if we don't render something
-      render :nothing => true
+  class AirbrakeTestController < ActionController::Base
+    begin
+      use ActionDispatch::ShowExceptions, ActionDispatch::PublicExceptions.new("/null")
+    rescue NameError
+      use ActionDispatch::ShowExceptions
     end
-  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 "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 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 "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 "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 "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_airbrake)
-  end
-
-  should "not create actions from Airbrake methods" do
-    controller = build_controller_class.new
-    assert_equal [], Airbrake::Rails::ActionControllerCatcher.instance_methods
-  end
-
-  should "ignore exceptions when user agent is being ignored by regular expression" do
-    Airbrake.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
-    Airbrake.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
-    Airbrake.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, "/notice/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, "/notice/request/session"
-  end
-
-  should "send request data for manual notification" do
-    params = { 'controller' => "airbrake_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' => "airbrake_test", 'action' => "index" }
-    controller = process_action_with_manual_notification(:params => params, :port => 81)
-    assert_sent_request_info_for controller.request
-  end
+    use Airbrake::Rails::Middleware
 
-  should "send request data for automatic notification" do
-    params = { 'controller' => "airbrake_test", 'action' => "index" }
-    controller = process_action_with_automatic_notification(:params => params)
-    assert_sent_request_info_for controller.request
-  end
+    include Airbrake::Rails::ControllerMethods
 
-  should "send request data for automatic notification with non-standard port" do
-    params = { 'controller' => "airbrake_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, '/notice/request/params'
-    assert_sent_hash filtered_cgi, '/notice/request/cgi-data'
-    assert_sent_hash filtered_session, '/notice/request/session'
-  end
+    cattr_accessor :local
 
-  context "for a local error with development lookup enabled" do
-    setup do
-      Airbrake.configuration.development_lookup = true
-      Airbrake.stubs(:build_lookup_hash_for).returns({ :awesome => 2 })
+    before_filter :set_session
 
-      @controller = process_action_with_automatic_notification(:local => true)
-      @response   = @controller.response
+    def set_session
+      unless params.empty?
+        request.session = ActionController::TestSession.new(params[:session] || {})
+      end
     end
 
-    should "append custom CSS and JS to response body for a local error" do
-      assert_match /text\/css/, @response.body
-      assert_match /text\/javascript/, @response.body
+    def boom
+      raise "boom"
+      render :nothing => true
     end
 
-    should "contain host, API key and notice JSON" do
-      assert_match Airbrake.configuration.host.to_json, @response.body
-      assert_match Airbrake.configuration.api_key.to_json, @response.body
-      assert_match ({ :awesome => 2 }).to_json, @response.body
+    def hello
+      render :text => "hello"
     end
-  end
 
-  context "for a local error with development lookup disabled" do
-    setup do
-      Airbrake.configuration.development_lookup = false
-
-      @controller = process_action_with_automatic_notification(:local => true)
-      @response   = @controller.response
-    end
-
-    should "not append custom CSS and JS to response for a local error" do
-      assert_no_match /text\/css/, @response.body
-      assert_no_match /text\/javascript/, @response.body
+    def manual_airbrake
+      notify_airbrake(:error_message => "fail")
+      render :nothing => true
     end
-  end
 
-  should "call session.to_hash if available" do
-    hash_data = {:key => :value}
+    protected
 
-    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
-
-  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
-      end
+    def airbrake_local_request?
+      @@local
     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
   end
 
+  setup do
+    Airbrake.configuration.development_environments = []
+  end
+
+
+   should "deliver notices from exceptions raised in public requests" do
+     @app = AirbrakeTestController.action(:boom)
+     get '/'
+     assert_caught_and_sent
+   end
+
+  should "not deliver notices from exceptions in development environments" do
+     Airbrake.configuration.development_environments = ["test"]
+     Airbrake.configuration.environment_name = "test"
+     @app = AirbrakeTestController.action(:boom)
+     get '/'
+     assert_caught_and_not_sent
+  end
+
+   should "not deliver notices from actions that don't raise" do
+     @app = AirbrakeTestController.action(:hello)
+     get '/'
+     assert_caught_and_not_sent
+     assert_equal 'hello', response.body
+   end
+
+   should "not deliver ignored exceptions raised by actions" do
+     @app = AirbrakeTestController.action(:boom)
+     ignore(RuntimeError)
+     get '/'
+     assert_caught_and_not_sent
+   end
+
+   should "deliver ignored exception raised manually" do
+     @app = AirbrakeTestController.action(:manual_airbrake)
+     ignore(RuntimeError)
+     get '/'
+     assert_caught_and_sent
+   end
+
+   should "not deliver manually sent notices in local requests" do
+     AirbrakeTestController.local = true
+     @app = AirbrakeTestController.action(:manual_airbrake)
+     get '/'
+     assert_caught_and_not_sent
+     AirbrakeTestController.local = false
+   end
+
+   should "not create actions from Airbrake methods" do
+     Airbrake::Rails::ControllerMethods.instance_methods.each do |method|
+       assert !(AirbrakeTestController.new.action_methods.include?(method))
+     end
+   end
+
+   should "ignore exceptions when user agent is being ignored by regular expression" do
+     Airbrake.configuration.ignore_user_agent_only = [/Ignored/]
+     @app = AirbrakeTestController.action(:boom)
+     get "/", {}, {"HTTP_USER_AGENT" => "ShouldBeIgnored"}
+     assert_caught_and_not_sent
+   end
+
+   should "ignore exceptions when user agent is being ignored by string" do
+     Airbrake.configuration.ignore_user_agent_only = ['IgnoredUserAgent']
+     @app = AirbrakeTestController.action(:boom)
+     get "/", {}, {"HTTP_USER_AGENT" => "IgnoredUserAgent"}
+     assert_caught_and_not_sent
+   end
+
+   should "not ignore exceptions when user agent is not being ignored" do
+     Airbrake.configuration.ignore_user_agent_only = ['IgnoredUserAgent']
+     @app = AirbrakeTestController.action(:boom)
+     get "/", {}, {"HTTP_USER_AGENT" => "NonIgnoredAgent"}
+     assert_caught_and_sent
+   end
+
+   should "send session data for manual notifications" do
+     @app = AirbrakeTestController.action(:manual_airbrake)
+     data = { 'one' => 'two' }
+     get "/", :session => data
+     assert_sent_hash data, "/notice/request/session"
+   end
+
+   should "send request data for manual notification" do
+     params = { 'controller' => "airbrake_test", 'action' => "index" }
+     @app = AirbrakeTestController.action(:manual_airbrake)
+     get "/", params
+     assert_sent_request_info_for @request
+   end
+
+   should "send request data for manual notification with non-standard port" do
+     params = { 'controller' => "airbrake_test", 'action' => "index" }
+     @app = AirbrakeTestController.action(:manual_airbrake)
+     get "/", params, {"SERVER_PORT" => 81}
+     assert_sent_request_info_for @request
+  end
+
+   should "send request data for automatic notification" do
+     params = { 'controller' => "airbrake_test", 'action' => "index" }
+     @app = AirbrakeTestController.action(:boom)
+     get "/", params
+     assert_sent_request_info_for @request
+   end
+
+   should "send request data for automatic notification with non-standard port" do
+     params = { 'controller' => "airbrake_test", 'action' => "index" }
+     @app = AirbrakeTestController.action(:boom)
+     get "/", params, {"SERVER_PORT" => 81}
+     assert_sent_request_info_for @request
+     assert_sent_element 81, "/notice/request/cgi-data/var[@key = 'SERVER_PORT']"
+   end
+
+  # 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)
+
+  #   Airbrake.configuration.environment_name = "production"
+
+  #   @app = AirbrakeTestController.action(:boom)
+  #   get '/'
+
+  #   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}
+
+  #   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
+
+  #   Airbrake.configuration.environment_name = "production"
+
+  #   @app = AirbrakeTestController.action(:boom)
+  #   get '/'
+
+  #   assert_received(session, :to_hash) { |expect| expect.never }
+  #   assert_received(session, :data) { |expect| expect.at_least_once }
+  #   assert_caught_and_sent
+  # end
 end