airbrake 4.3.8 → 5.0.0

data/test/notifier_test.rb

@@ -1,288 +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
-    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
-    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
-    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
-    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' }
-    stub_notice!
-    stub_sender!
-    Airbrake.configuration = stub('config', :merge => config_opts, :configured? => true, :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
-
-      should "keep exception if #original_exception is nil" do
-        @exception.stubs(:original_exception).returns(nil)
-        @hash = Airbrake.build_lookup_hash_for(@exception)
-        assert_equal "BacktracedException", @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
-
-      should "keep exception if #continued_exception is nil" do
-        @exception.stubs(:continued_exception).returns(nil)
-        @hash = Airbrake.build_lookup_hash_for(@exception)
-        assert_equal "BacktracedException", @hash[:error_class]
-      end
-    end
-  end
-end

data/test/params_cleaner_test.rb

@@ -1,204 +0,0 @@
-require File.expand_path '../helper', __FILE__
-
-class ParamsCleanerTest < Test::Unit::TestCase
-
-  def clean(opts = {})
-    cleaner = Airbrake::Utils::ParamsCleaner.new(:blacklist_filters  => opts.delete(:params_filters) || [],
-                                                 :whitelist_filters  => opts.delete(:whitelist_params_filters) || [],
-                                                 :to_clean => opts)
-    cleaner.clean
-  end
-
-  def assert_serializes_hash(attribute)
-    [File.open(__FILE__), Proc.new { puts "boo!" }, Module.new, nil].each do |object|
-      hash = {
-        :strange_object => object,
-        :sub_hash => {
-          :sub_object => object
-        },
-        :array => [object]
-      }
-      clean_params = clean(attribute => hash)
-      hash = clean_params.send(attribute)
-      object_serialized = object.nil? ? nil : object.to_s
-      assert_equal object_serialized, hash[:strange_object], "objects should be serialized"
-      assert_kind_of Hash, hash[:sub_hash], "subhashes should be kept"
-      assert_equal object_serialized, hash[:sub_hash][:sub_object], "subhash members should be serialized"
-      assert_kind_of Array, hash[:array], "arrays should be kept"
-      assert_equal object_serialized, hash[:array].first, "array members should be serialized"
-    end
-  end
-
-  def assert_filters_hash(attribute)
-    filters  = ['abc', :def]
-    original = {
-      'abc' => '123',
-      'def' => '456',
-      'ghi' => '789',
-      'something_with_abc' => 'match the entire string',
-      'nested_hash' => { 'abc' => '100', 'ghi' => '789' },
-      'nested_array' => [{ 'abc' => '100' }, { 'ghi' => '789' }, 'xyz', [['asd', []]]]
-    }
-    filtered = {
-      'abc' => '[FILTERED]',
-      'def' => '[FILTERED]',
-      'ghi' => '789',
-      'something_with_abc' => 'match the entire string',
-      'nested_hash' => { 'abc' => '[FILTERED]', 'ghi' => '789' },
-      'nested_array' => [{ 'abc' => '[FILTERED]' }, { 'ghi' => '789' }, 'xyz', [['asd', []]]]
-    }
-
-    clean_params = clean(:params_filters => filters, attribute => original)
-
-    assert_equal(filtered, clean_params.send(attribute))
-  end
-
-  should "should always remove a Rails application's secret token" do
-    original = {
-      "action_dispatch.secret_token" => "abc123xyz456",
-      "abc" => "123"
-    }
-    clean_params = clean(:cgi_data => original)
-    assert_equal({"abc" => "123"}, clean_params.cgi_data)
-  end
-
-  should "remove sensitive rack vars" do
-    original = {
-      "HTTP_X_CSRF_TOKEN" => "remove_me",
-      "HTTP_COOKIE" => "remove_me",
-      "HTTP_AUTHORIZATION" => "remove_me",
-      "action_dispatch.request.unsigned_session_cookie" => "remove_me",
-      "action_dispatch.cookies" => "remove_me",
-      "action_dispatch.unsigned_session_cookie" => "remove_me",
-      "action_dispatch.secret_key_base" => "remove_me",
-      "action_dispatch.signed_cookie_salt" => "remove_me",
-      "action_dispatch.encrypted_cookie_salt" => "remove_me",
-      "action_dispatch.encrypted_signed_cookie_salt" => "remove_me",
-      "action_dispatch.http_auth_salt" => "remove_me",
-      "action_dispatch.secret_token" => "remove_me",
-      "rack.request.cookie_hash" => "remove_me",
-      "rack.request.cookie_string" => "remove_me",
-      "rack.request.form_vars" => "remove_me",
-      "rack.session" => "remove_me",
-      "rack.session.options" => "remove_me",
-      "rack.request.form_vars" => "story%5Btitle%5D=The+TODO+label",
-      "abc" => "123"
-    }
-
-    clean_params = clean(:cgi_data => original)
-    assert_equal({"abc" => "123"}, clean_params.cgi_data)
-  end
-
-  should "remove secrets from cgi_data" do
-    original = {
-      "aws_secret_key"   => "secret",
-      "service_password" => "password",
-      "abc" => "123"
-    }
-
-    clean_params = clean(:cgi_data => original)
-    assert_equal({"abc" => "123"}, clean_params.cgi_data)
-  end
-
-  should "handle frozen objects" do
-    params = {
-      'filter_me' => ['a', 'b', 'c', 'd'].freeze
-    }
-
-    clean_params = clean({:params_filters => ['filter_me'], :parameters => params})
-    assert_equal({'filter_me' => '[FILTERED]'}, clean_params.parameters)
-  end
-
-  should "filter parameters" do
-    assert_filters_hash(:parameters)
-  end
-
-  should "whitelist filter parameters" do
-    whitelist_filters  = ["abc", :def]
-    original = { 'abc' => "123", 'def' => "456", 'ghi' => "789", 'nested' => { 'abc' => '100' },
-      'something_with_abc' => 'match the entire string'}
-    filtered = { 'abc'    => "123",
-      'def'    => "456",
-      'something_with_abc' => "[FILTERED]",
-      'ghi'    => "[FILTERED]",
-      'nested' => "[FILTERED]" }
-
-    clean_params = clean(:whitelist_params_filters => whitelist_filters,
-                         :parameters => original)
-
-    assert_equal(filtered,
-                 clean_params.send(:parameters))
-  end
-
-  should "not filter everything if whitelist filters are empty" do
-    whitelist_filters  = []
-    original = { 'abc' => '123' }
-    clean_params = clean(:whitelist_params_filters => whitelist_filters,
-                         :parameters => original)
-    assert_equal(original, clean_params.send(:parameters))
-  end
-
-  should "not care if filters are defined in nested array" do
-    filters  = [[/crazy/, :foo, ["bar", ["too"]]]]
-    original = {
-      'this_is_crazy' => 'yes_it_is',
-      'I_am_good' => 'yes_you_are',
-      'foo' => '1212',
-      'too' => '2121',
-      'bar' => 'secret'
-    }
-    filtered = {
-      'this_is_crazy' => '[FILTERED]',
-      'I_am_good' => 'yes_you_are',
-      'foo' => '[FILTERED]',
-      'too' => '[FILTERED]',
-      'bar' => '[FILTERED]'
-    }
-    clean_params = clean(:params_filters => filters,
-                         :parameters => original)
-    assert_equal(filtered, clean_params.send(:parameters))
-  end
-
-  should "filter key if it is defined as blacklist and whitelist" do
-    original = { 'filter_me' => 'secret' }
-    filtered = { 'filter_me' => '[FILTERED]' }
-    clean_params = clean(:params_filters => [:filter_me],
-                         :params_whitelist_filters => [:filter_me],
-                         :parameters => original)
-    assert_equal(filtered, clean_params.send(:parameters))
-  end
-
-  should "filter cgi data" do
-    assert_filters_hash(:cgi_data)
-  end
-
-  should "filter session" do
-    assert_filters_hash(:session_data)
-  end
-
-  should "convert unserializable objects to strings" do
-    assert_serializes_hash(:parameters)
-    assert_serializes_hash(:cgi_data)
-    assert_serializes_hash(:session_data)
-  end
-
-  should "handle closed IO objects by converting them to strings" do
-    params = {
-      :files => [Tempfile.new('a').tap(&:close), IO.new(0).tap(&:close)]
-    }
-    clean_params = clean(:params_filters => ['files'], :parameters => params)
-    assert_match(/\A#<(Temp)?[Ff]ile:0x.+>\z/, clean_params.parameters[:files][0])
-    assert_match(/\A#<IO:0x.+>\z/, clean_params.parameters[:files][1])
-  end
-
-  should "not break on filtering multi-dimensional array as possible in action_dispatch.cookies" do
-    original = { 'cgi_cookies_to_filter' => [['any_cookie_key', 'some_cookie_value'], ['secret', 'some_secret_value']] }
-    clean_params = clean(:params_filters => [:secret],
-                         :params_whitelist_filters => [:secret],
-                         :parameters => original)
-    assert_nothing_raised do
-      clean_params.send(:parameters)
-    end
-  end
-
-end

data/test/rack_test.rb

@@ -1,62 +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
-
-  %w(rack.exception sinatra.error).each do |ex|
-
-    should "deliver an exception in #{ex}" do
-      Airbrake.stubs(:notify_or_ignore)
-      exception = build_exception
-      environment = { 'key' => 'value' }
-
-      response = [200, {}, ['okay']]
-      app = lambda do |env|
-        env[ex] = 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
-
-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/response_test.rb

@@ -1,18 +0,0 @@
-require File.expand_path '../helper', __FILE__
-
-class ResponseTest < Test::Unit::TestCase
-  include DefinesConstants
-
-  def response_body
-    File.read File.expand_path('../support/response_shim.xml', __FILE__)
-  end
-
-  should "output a nicely formatted notice details" do
-    output = Airbrake::Response.pretty_format(response_body)
-
-    assert %r{ID: b6817316-9c45-ed26-45eb-780dbb86aadb}, "#{output}"
-    assert %r{URL: http://airbrake.io/locate/b6817316-9c45-ed26-45eb-780dbb86aadb},
-      "#{output}"
-
-  end
-end