airbrake 3.1.6 → 11.0.0

data/test/notifier_test.rb

@@ -1,276 +0,0 @@
-require File.expand_path '../helper', __FILE__
-
-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(Airbrake.sender, :send_to_airbrake) {|expect| expect.with(notice) }
-  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 "not pass the hash as an exception when sending a notice for it" do
-    set_public_env
-    notice = stub_notice!
-    notice_args = { :error_message => 'uh oh' }
-    stub_sender!
-
-    Airbrake.notify(notice_args)
-
-    assert_received(Airbrake::Notice, :new) {|expect| expect.with(Not(has_key(:exception))) }
-  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 exception in async-mode" do
-    Airbrake.configure do |config|
-      config.environment_name = 'production'
-      config.async do |notice|
-        Airbrake.sender.send_to_airbrake(notice)
-      end
-    end
-    exception = build_exception
-    sender = stub_sender!
-    notice = stub_notice!
-
-    Airbrake.notify(exception)
-
-    assert_sent(notice, :exception => exception)
-  end
-
-  should "pass notice in async-mode" do
-    received_notice = nil
-    Airbrake.configure do |config|
-      config.environment_name = 'production'
-      config.async {|notice| received_notice = notice}
-    end
-    exception = build_exception
-    sender = stub_sender!
-    notice = stub_notice!
-
-    Airbrake.notify(exception)
-
-    assert_equal received_notice, notice
-  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,:async? => nil)
-
-    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

@@ -1,58 +0,0 @@
-require File.expand_path '../helper', __FILE__
-
-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

@@ -1,36 +0,0 @@
-require File.expand_path '../helper', __FILE__
-
-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

@@ -1,10 +0,0 @@
-require File.expand_path '../helper', __FILE__
-
-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

@@ -1,288 +0,0 @@
-require File.expand_path '../helper', __FILE__
-
-class SenderTest < Test::Unit::TestCase
-
-  def setup
-    reset_config
-  end
-
-  def build_sender(opts = {})
-    Airbrake.configure do |conf|
-      opts.each {|opt, value| conf.send(:"#{opt}=", value) }
-    end
-  end
-
-  def send_exception(args = {})
-    notice = args.delete(:notice) || build_notice_data
-    notice.stubs(:to_xml)
-    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 with XML passed" do
-    xml_notice = Airbrake::Notice.new(:error_class => "FooBar", :error_message => "Foo Bar").to_xml
-
-    http = stub_http
-
-    sender = build_sender
-    sender.send_to_airbrake(xml_notice)
-
-    assert_received(http, :post) do |expect|
-      expect.with(anything, xml_notice, Airbrake::HEADERS)
-    end
-  end
-
-  should "post to Airbrake with a Notice instance passed" do
-    notice = Airbrake::Notice.new(:error_class => "FooBar", :error_message => "Foo Bar")
-
-    http = stub_http
-
-    sender = build_sender
-    sender.send_to_airbrake(notice)
-
-    assert_received(http, :post) do |expect|
-      expect.with(anything, notice.to_xml, Airbrake::HEADERS)
-    end
-  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://api.airbrake.io: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 => '<id type="integer">3799307</id>')
-    assert_equal "3799307", send_exception(:secure => false)
-  end
-
-  context "when encountering exceptions: " do
-    context "HTTP connection setup problems" do
-      should "not be rescued" do
-        proxy = stub()
-        proxy.stubs(:new).raises(NoMemoryError)
-        Net::HTTP.stubs(:Proxy => proxy)
-
-        assert_raise NoMemoryError do
-          build_sender.send(:setup_http_connection)
-        end
-      end
-
-      should "be logged" do
-        proxy = stub()
-        proxy.stubs(:new).raises(RuntimeError)
-        Net::HTTP.stubs(:Proxy => proxy)
-
-        sender = build_sender
-        sender.expects(:log)
-
-        assert_raise RuntimeError do
-          sender.send(:setup_http_connection)
-        end
-
-      end
-    end
-
-    context "unexpected exception sending problems" do
-      should "be logged" do
-        sender  = build_sender
-        sender.stubs(:setup_http_connection).raises(RuntimeError.new)
-
-        sender.expects(:log)
-        send_exception(:sender => sender)
-      end
-
-      should "return nil no matter what" do
-        sender  = build_sender
-        sender.stubs(:setup_http_connection).raises(LocalJumpError)
-
-        assert_nothing_thrown do
-          assert_nil sender.send_to_airbrake(build_notice_data)
-        end
-      end
-    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
-  end
-
-  context "SSL" do
-    should "post to the right url for non-ssl" do
-      http = stub_http
-      url = "http://api.airbrake.io: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://api.airbrake.io#{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_equal(Airbrake.configuration.local_cert_path, real_http.ca_file)
-    end
-
-    should "use the default DEFAULT_CERT_FILE if asked to" do
-      config = Airbrake::Configuration.new
-      config.use_system_ssl_cert_chain = true
-      sender = Airbrake::Sender.new(config)
-
-      assert(sender.use_system_ssl_cert_chain?)
-
-      http    = sender.send(:setup_http_connection)
-      assert_not_equal http.ca_file, config.local_cert_path
-    end
-
-    should "verify the connection when the use_ssl option is set (VERIFY_PEER)" do
-      sender  = build_sender(:secure => true)
-      http    = sender.send(:setup_http_connection)
-      assert_equal(OpenSSL::SSL::VERIFY_PEER, http.verify_mode)
-    end
-
-    should "use the default cert (OpenSSL::X509::DEFAULT_CERT_FILE) only if explicitly told to" do
-      sender  = build_sender(:secure => true)
-      http    = sender.send(:setup_http_connection)
-
-      assert_equal(Airbrake.configuration.local_cert_path, http.ca_file)
-
-      File.stubs(:exist?).with(OpenSSL::X509::DEFAULT_CERT_FILE).returns(true)
-      sender  = build_sender(:secure => true, :use_system_ssl_cert_chain => true)
-      http    = sender.send(:setup_http_connection)
-
-      assert_not_equal(Airbrake.configuration.local_cert_path, http.ca_file)
-      assert_equal(OpenSSL::X509::DEFAULT_CERT_FILE, http.ca_file)
-    end
-
-    should "connect to the right port for ssl" do
-      stub_http
-      send_exception(:secure => true)
-      assert_received(Net::HTTP, :new) {|expect| expect.with("api.airbrake.io", 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("api.airbrake.io", 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
-
-  context "network timeouts" do
-    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
-  end
-
-end