airbrakeV4rails5 4.3.8

data/test/notifier_test.rb

@@ -0,0 +1,288 @@
+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

@@ -0,0 +1,204 @@
+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