airbrake 3.0.rc1

data/test/notifier_test.rb

@@ -0,0 +1,235 @@
+require File.dirname(__FILE__) + '/helper'
+
+class NotifierTest < Test::Unit::TestCase
+
+  class OriginalException < Exception
+  end
+
+  class ContinuedException < Exception
+  end
+
+  include DefinesConstants
+
+  def setup
+    super
+    reset_config
+  end
+
+  def assert_sent(notice, notice_args)
+    assert_received(Airbrake::Notice, :new) {|expect| expect.with(has_entries(notice_args)) }
+    assert_received(notice, :to_xml)
+    assert_received(Airbrake.sender, :send_to_airbrake) {|expect| expect.with(notice.to_xml) }
+  end
+
+  def set_public_env
+    Airbrake.configure { |config| config.environment_name = 'production' }
+  end
+
+  def set_development_env
+    Airbrake.configure { |config| config.environment_name = 'development' }
+  end
+
+  should "yield and save a configuration when configuring" do
+    yielded_configuration = nil
+    Airbrake.configure do |config|
+      yielded_configuration = config
+    end
+
+    assert_kind_of Airbrake::Configuration, yielded_configuration
+    assert_equal yielded_configuration, Airbrake.configuration
+  end
+
+  should "not remove existing config options when configuring twice" do
+    first_config = nil
+    Airbrake.configure do |config|
+      first_config = config
+    end
+    Airbrake.configure do |config|
+      assert_equal first_config, config
+    end
+  end
+
+  should "configure the sender" do
+    sender = stub_sender
+    Airbrake::Sender.stubs(:new => sender)
+    configuration = nil
+
+    Airbrake.configure { |yielded_config| configuration = yielded_config }
+
+    assert_received(Airbrake::Sender, :new) { |expect| expect.with(configuration) }
+    assert_equal sender, Airbrake.sender
+  end
+
+  should "create and send a notice for an exception" do
+    set_public_env
+    exception = build_exception
+    stub_sender!
+    notice = stub_notice!
+
+    Airbrake.notify(exception)
+
+    assert_sent notice, :exception => exception
+  end
+
+  should "create and send a notice for a hash" do
+    set_public_env
+    notice = stub_notice!
+    notice_args = { :error_message => 'uh oh' }
+    stub_sender!
+
+    Airbrake.notify(notice_args)
+
+    assert_sent(notice, notice_args)
+  end
+
+  should "create and send a notice for an exception that responds to to_hash" do
+    set_public_env
+    exception = build_exception
+    notice = stub_notice!
+    notice_args = { :error_message => 'uh oh' }
+    exception.stubs(:to_hash).returns(notice_args)
+    stub_sender!
+
+    Airbrake.notify(exception)
+
+    assert_sent(notice, notice_args.merge(:exception => exception))
+  end
+
+  should "create and sent a notice for an exception and hash" do
+    set_public_env
+    exception = build_exception
+    notice = stub_notice!
+    notice_args = { :error_message => 'uh oh' }
+    stub_sender!
+
+    Airbrake.notify(exception, notice_args)
+
+    assert_sent(notice, notice_args.merge(:exception => exception))
+  end
+
+  should "not create a notice in a development environment" do
+    set_development_env
+    sender = stub_sender!
+
+    Airbrake.notify(build_exception)
+    Airbrake.notify_or_ignore(build_exception)
+
+    assert_received(sender, :send_to_airbrake) {|expect| expect.never }
+  end
+
+  should "not deliver an ignored exception when notifying implicitly" do
+    set_public_env
+    exception = build_exception
+    sender = stub_sender!
+    notice = stub_notice!
+    notice.stubs(:ignore? => true)
+
+    Airbrake.notify_or_ignore(exception)
+
+    assert_received(sender, :send_to_airbrake) {|expect| expect.never }
+  end
+
+  should "deliver an ignored exception when notifying manually" do
+    set_public_env
+    exception = build_exception
+    sender = stub_sender!
+    notice = stub_notice!
+    notice.stubs(:ignore? => true)
+
+    Airbrake.notify(exception)
+
+    assert_sent(notice, :exception => exception)
+  end
+
+  should "pass config to created notices" do
+    exception = build_exception
+    config_opts = { 'one' => 'two', 'three' => 'four' }
+    notice = stub_notice!
+    stub_sender!
+    Airbrake.configuration = stub('config', :merge => config_opts, :public? => true)
+
+    Airbrake.notify(exception)
+
+    assert_received(Airbrake::Notice, :new) do |expect|
+      expect.with(has_entries(config_opts))
+    end
+  end
+
+  context "building notice JSON for an exception" do
+    setup do
+      @params    = { :controller => "users", :action => "create" }
+      @exception = build_exception
+      @hash      = Airbrake.build_lookup_hash_for(@exception, @params)
+    end
+
+    should "set action" do
+      assert_equal @params[:action], @hash[:action]
+    end
+
+    should "set controller" do
+      assert_equal @params[:controller], @hash[:component]
+    end
+
+    should "set line number" do
+      assert @hash[:line_number] =~ /\d+/
+    end
+
+    should "set file" do
+      assert_match /test\/helper\.rb$/, @hash[:file]
+    end
+
+    should "set rails_env to production" do
+      assert_equal 'production', @hash[:environment_name]
+    end
+
+    should "set error class" do
+      assert_equal @exception.class.to_s, @hash[:error_class]
+    end
+
+    should "not set file or line number with no backtrace" do
+      @exception.stubs(:backtrace).returns([])
+
+      @hash = Airbrake.build_lookup_hash_for(@exception)
+
+      assert_nil @hash[:line_number]
+      assert_nil @hash[:file]
+    end
+
+    should "not set action or controller when not provided" do
+      @hash = Airbrake.build_lookup_hash_for(@exception)
+
+      assert_nil @hash[:action]
+      assert_nil @hash[:controller]
+    end
+
+    context "when an exception that provides #original_exception is raised" do
+      setup do
+        @exception.stubs(:original_exception).returns(begin
+          raise NotifierTest::OriginalException.new
+        rescue Exception => e
+          e
+        end)
+      end
+
+      should "unwrap exceptions that provide #original_exception" do
+        @hash = Airbrake.build_lookup_hash_for(@exception)
+        assert_equal "NotifierTest::OriginalException", @hash[:error_class]
+      end
+    end
+
+    context "when an exception that provides #continued_exception is raised" do
+      setup do
+        @exception.stubs(:continued_exception).returns(begin
+          raise NotifierTest::ContinuedException.new
+        rescue Exception => e
+          e
+        end)
+      end
+
+      should "unwrap exceptions that provide #continued_exception" do
+        @hash = Airbrake.build_lookup_hash_for(@exception)
+        assert_equal "NotifierTest::ContinuedException", @hash[:error_class]
+      end
+    end
+  end
+end

data/test/rack_test.rb

@@ -0,0 +1,58 @@
+require File.dirname(__FILE__) + '/helper'
+
+class RackTest < Test::Unit::TestCase
+
+  should "call the upstream app with the environment" do
+    environment = { 'key' => 'value' }
+    app = lambda { |env| ['response', {}, env] }
+    stack = Airbrake::Rack.new(app)
+
+    response = stack.call(environment)
+
+    assert_equal ['response', {}, environment], response
+  end
+
+  should "deliver an exception raised while calling an upstream app" do
+    Airbrake.stubs(:notify_or_ignore)
+
+    exception = build_exception
+    environment = { 'key' => 'value' }
+    app = lambda do |env|
+      raise exception
+    end
+
+    begin
+      stack = Airbrake::Rack.new(app)
+      stack.call(environment)
+    rescue Exception => raised
+      assert_equal exception, raised
+    else
+      flunk "Didn't raise an exception"
+    end
+
+    assert_received(Airbrake, :notify_or_ignore) do |expect|
+      expect.with(exception, :rack_env => environment)
+    end
+  end
+
+  should "deliver an exception in rack.exception" do
+    Airbrake.stubs(:notify_or_ignore)
+    exception = build_exception
+    environment = { 'key' => 'value' }
+
+    response = [200, {}, ['okay']]
+    app = lambda do |env|
+      env['rack.exception'] = exception
+      response
+    end
+    stack = Airbrake::Rack.new(app)
+
+    actual_response = stack.call(environment)
+
+    assert_equal response, actual_response
+    assert_received(Airbrake, :notify_or_ignore) do |expect|
+      expect.with(exception, :rack_env => environment)
+    end
+  end
+
+end

data/test/rails_initializer_test.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + '/helper'
+
+require 'airbrake/rails'
+
+class RailsInitializerTest < Test::Unit::TestCase
+  include DefinesConstants
+
+  should "trigger use of Rails' logger if logger isn't set and Rails' logger exists" do
+    rails = Module.new do
+      def self.logger
+        "RAILS LOGGER"
+      end
+    end
+    define_constant("Rails", rails)
+    Airbrake::Rails.initialize
+    assert_equal "RAILS LOGGER", Airbrake.logger
+  end
+
+  should "trigger use of Rails' default logger if logger isn't set and Rails.logger doesn't exist" do
+    define_constant("RAILS_DEFAULT_LOGGER", "RAILS DEFAULT LOGGER")
+
+    Airbrake::Rails.initialize
+    assert_equal "RAILS DEFAULT LOGGER", Airbrake.logger
+  end
+
+  should "allow overriding of the logger if already assigned" do
+    define_constant("RAILS_DEFAULT_LOGGER", "RAILS DEFAULT LOGGER")
+    Airbrake::Rails.initialize
+
+    Airbrake.configure(true) do |config|
+      config.logger = "OVERRIDDEN LOGGER"
+    end
+
+    assert_equal "OVERRIDDEN LOGGER", Airbrake.logger
+  end
+end

data/test/recursion_test.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + '/helper'
+
+class RecursionTest < Test::Unit::TestCase
+  should "not allow infinite recursion" do
+    hash = {:a => :a}
+    hash[:hash] = hash
+    notice = Airbrake::Notice.new(:parameters => hash)
+    assert_equal "[possible infinite recursion halted]", notice.parameters[:hash]
+  end
+end

data/test/sender_test.rb

@@ -0,0 +1,193 @@
+require File.dirname(__FILE__) + '/helper'
+
+class SenderTest < Test::Unit::TestCase
+
+  def setup
+    reset_config
+  end
+
+  def build_sender(opts = {})
+    config = Airbrake::Configuration.new
+    opts.each {|opt, value| config.send(:"#{opt}=", value) }
+    Airbrake::Sender.new(config)
+  end
+
+  def send_exception(args = {})
+    notice = args.delete(:notice) || build_notice_data
+    sender = args.delete(:sender) || build_sender(args)
+    sender.send_to_airbrake(notice)
+  end
+
+  def stub_http(options = {})
+    response = stub(:body => options[:body] || 'body')
+    http = stub(:post          => response,
+                :read_timeout= => nil,
+                :open_timeout= => nil,
+                :ca_file=      => nil,
+                :verify_mode=  => nil,
+                :use_ssl=      => nil)
+    Net::HTTP.stubs(:new => http)
+    http
+  end
+
+  should "post to Airbrake when using an HTTP proxy" do
+    response = stub(:body => 'body')
+    http     = stub(:post          => response,
+                    :read_timeout= => nil,
+                    :open_timeout= => nil,
+                    :use_ssl=      => nil)
+    proxy    = stub(:new => http)
+    Net::HTTP.stubs(:Proxy => proxy)
+
+    url = "http://airbrakeapp.com:80#{Airbrake::Sender::NOTICES_URI}"
+    uri = URI.parse(url)
+
+    proxy_host = 'some.host'
+    proxy_port = 88
+    proxy_user = 'login'
+    proxy_pass = 'passwd'
+
+    send_exception(:proxy_host => proxy_host,
+                   :proxy_port => proxy_port,
+                   :proxy_user => proxy_user,
+                   :proxy_pass => proxy_pass)
+    assert_received(http, :post) do |expect| 
+      expect.with(uri.path, anything, Airbrake::HEADERS)
+    end
+    assert_received(Net::HTTP, :Proxy) do |expect|
+      expect.with(proxy_host, proxy_port, proxy_user, proxy_pass)
+    end
+  end
+
+  should "return the created group's id on successful posting" do
+    http = stub_http(:body => '<error-id type="integer">3799307</error-id>')
+    assert_equal "3799307", send_exception(:secure => false)
+  end
+
+  should "return nil on failed posting" do
+    http = stub_http
+    http.stubs(:post).raises(Errno::ECONNREFUSED)
+    assert_equal nil, send_exception(:secure => false)
+  end
+
+  should "not fail when posting and a timeout exception occurs" do
+    http = stub_http
+    http.stubs(:post).raises(TimeoutError)
+    assert_nothing_thrown do
+      send_exception(:secure => false)
+    end
+  end
+
+  should "not fail when posting and a connection refused exception occurs" do
+    http = stub_http
+    http.stubs(:post).raises(Errno::ECONNREFUSED)
+    assert_nothing_thrown do
+      send_exception(:secure => false)
+    end
+  end
+
+  should "not fail when posting any http exception occurs" do
+    http = stub_http
+    Airbrake::Sender::HTTP_ERRORS.each do |error|
+      http.stubs(:post).raises(error)
+      assert_nothing_thrown do
+        send_exception(:secure => false)
+      end
+    end
+  end
+
+  should "post to the right url for non-ssl" do
+    http = stub_http
+    url = "http://airbrakeapp.com:80#{Airbrake::Sender::NOTICES_URI}"
+    uri = URI.parse(url)
+    send_exception(:secure => false)
+    assert_received(http, :post) {|expect| expect.with(uri.path, anything, Airbrake::HEADERS) }
+  end
+
+  should "post to the right path for ssl" do
+    http = stub_http
+    send_exception(:secure => true)
+    assert_received(http, :post) {|expect| expect.with(Airbrake::Sender::NOTICES_URI, anything, Airbrake::HEADERS) }
+  end
+
+  should "verify the SSL peer when the use_ssl option is set to true" do
+    url = "https://airbrakeapp.com#{Airbrake::Sender::NOTICES_URI}"
+    uri = URI.parse(url)
+
+    real_http = Net::HTTP.new(uri.host, uri.port)
+    real_http.stubs(:post => nil)
+    proxy = stub(:new => real_http)
+    Net::HTTP.stubs(:Proxy => proxy)
+    File.stubs(:exist?).with(OpenSSL::X509::DEFAULT_CERT_FILE).returns(false)
+
+    send_exception(:secure => true)
+    assert(real_http.use_ssl)
+    assert_equal(OpenSSL::SSL::VERIFY_PEER,        real_http.verify_mode)
+    assert_nil real_http.ca_file
+  end
+
+  should "verify the SSL peer when the use_ssl option is set to true and the default cert exists" do
+    url = "https://airbrakeapp.com#{Airbrake::Sender::NOTICES_URI}"
+    uri = URI.parse(url)
+
+    real_http = Net::HTTP.new(uri.host, uri.port)
+    real_http.stubs(:post => nil)
+    proxy = stub(:new => real_http)
+    Net::HTTP.stubs(:Proxy => proxy)
+    File.stubs(:exist?).with(OpenSSL::X509::DEFAULT_CERT_FILE).returns(true)
+
+    send_exception(:secure => true)
+    assert(real_http.use_ssl)
+    assert_equal(OpenSSL::SSL::VERIFY_PEER,        real_http.verify_mode)
+    assert_equal(OpenSSL::X509::DEFAULT_CERT_FILE, real_http.ca_file)
+  end
+
+  should "default the open timeout to 2 seconds" do
+    http = stub_http
+    send_exception
+    assert_received(http, :open_timeout=) {|expect| expect.with(2) }
+  end
+
+  should "default the read timeout to 5 seconds" do
+    http = stub_http
+    send_exception
+    assert_received(http, :read_timeout=) {|expect| expect.with(5) }
+  end
+
+  should "allow override of the open timeout" do
+    http = stub_http
+    send_exception(:http_open_timeout => 4)
+    assert_received(http, :open_timeout=) {|expect| expect.with(4) }
+  end
+
+  should "allow override of the read timeout" do
+    http = stub_http
+    send_exception(:http_read_timeout => 10)
+    assert_received(http, :read_timeout=) {|expect| expect.with(10) }
+  end
+
+  should "connect to the right port for ssl" do
+    stub_http
+    send_exception(:secure => true)
+    assert_received(Net::HTTP, :new) {|expect| expect.with("airbrakeapp.com", 443) }
+  end
+
+  should "connect to the right port for non-ssl" do
+    stub_http
+    send_exception(:secure => false)
+    assert_received(Net::HTTP, :new) {|expect| expect.with("airbrakeapp.com", 80) }
+  end
+
+  should "use ssl if secure" do
+    stub_http
+    send_exception(:secure => true, :host => 'example.org')
+    assert_received(Net::HTTP, :new) {|expect| expect.with('example.org', 443) }
+  end
+
+  should "not use ssl if not secure" do
+    stub_http
+    send_exception(:secure => false, :host => 'example.org')
+    assert_received(Net::HTTP, :new) {|expect| expect.with('example.org', 80) }
+  end
+
+end