airbrakeV4rails5 4.3.8

data/test/configuration_test.rb

@@ -0,0 +1,303 @@
+require File.expand_path '../helper', __FILE__
+
+class ConfigurationTest < Test::Unit::TestCase
+
+  include DefinesConstants
+
+  should "provide default values" do
+    assert_config_default :proxy_host,          nil
+    assert_config_default :proxy_port,          nil
+    assert_config_default :proxy_user,          nil
+    assert_config_default :proxy_pass,          nil
+    assert_config_default :project_root,        nil
+    assert_config_default :environment_name,    nil
+    assert_config_default :logger,              nil
+    assert_config_default :notifier_version,    Airbrake::VERSION
+    assert_config_default :notifier_name,       'Airbrake Notifier'
+    assert_config_default :notifier_url,        'https://github.com/airbrake/airbrake'
+    assert_config_default :secure,              false
+    assert_config_default :host,                'api.airbrake.io'
+    assert_config_default :http_open_timeout,   2
+    assert_config_default :http_read_timeout,   5
+    assert_config_default :ignore_by_filters,   []
+    assert_config_default :ignore_user_agent,   []
+    assert_config_default :params_filters,
+                          Airbrake::Configuration::DEFAULT_PARAMS_FILTERS
+    assert_config_default :params_whitelist_filters,
+                          Airbrake::Configuration::DEFAULT_PARAMS_WHITELIST_FILTERS
+    assert_config_default :backtrace_filters,
+                          Airbrake::Configuration::DEFAULT_BACKTRACE_FILTERS
+    assert_config_default :rake_environment_filters, []
+    assert_config_default :ignore,
+                          Airbrake::Configuration::IGNORE_DEFAULT
+    assert_config_default :development_lookup, true
+    assert_config_default :framework, 'Standalone'
+    assert_config_default :async, nil
+    assert_config_default :project_id, nil
+  end
+
+  should "set GirlFriday/SuckerPunch-callable for async=true" do
+    config = Airbrake::Configuration.new
+    config.async = true
+    assert config.async.respond_to?(:call)
+  end
+
+  should "raise error for rake integration if rake handler isn't loaded" do
+    config = Airbrake::Configuration.new
+    assert_raises(LoadError) { config.rescue_rake_exceptions = true }
+  end
+
+  should "set provided-callable for async {}" do
+    config = Airbrake::Configuration.new
+    config.async {|notice| :ok}
+    assert config.async.respond_to?(:call)
+    assert_equal :ok, config.async.call
+  end
+
+  should "provide default values for secure connections" do
+    config = Airbrake::Configuration.new
+    config.secure = true
+    assert_equal 443, config.port
+    assert_equal 'https', config.protocol
+  end
+
+  should "provide default values for insecure connections" do
+    config = Airbrake::Configuration.new
+    config.secure = false
+    assert_equal 80, config.port
+    assert_equal 'http', config.protocol
+  end
+
+  should "not cache inferred ports" do
+    config = Airbrake::Configuration.new
+    config.secure = false
+    config.port
+    config.secure = true
+    assert_equal 443, config.port
+  end
+
+  should "allow values to be overwritten" do
+    assert_config_overridable :proxy_host
+    assert_config_overridable :proxy_port
+    assert_config_overridable :proxy_user
+    assert_config_overridable :proxy_pass
+    assert_config_overridable :secure
+    assert_config_overridable :host
+    assert_config_overridable :port
+    assert_config_overridable :http_open_timeout
+    assert_config_overridable :http_read_timeout
+    assert_config_overridable :project_root
+    assert_config_overridable :notifier_version
+    assert_config_overridable :notifier_name
+    assert_config_overridable :notifier_url
+    assert_config_overridable :environment_name
+    assert_config_overridable :development_lookup
+    assert_config_overridable :logger
+    assert_config_overridable :async
+    assert_config_overridable :project_id
+    assert_config_overridable :params_filters
+  end
+
+  should "have an api key" do
+    assert_config_overridable :api_key
+  end
+
+  should "act like a hash" do
+    config = Airbrake::Configuration.new
+    hash = config.to_hash
+    [:api_key, :backtrace_filters, :development_environments,
+     :environment_name, :host, :http_open_timeout,
+     :http_read_timeout, :ignore, :ignore_by_filters, :ignore_user_agent,
+     :notifier_name, :notifier_url, :notifier_version, :params_filters,
+     :project_root, :port, :protocol, :proxy_host, :proxy_pass, :proxy_port,
+     :proxy_user, :secure, :development_lookup, :async].each do |option|
+      assert_equal config[option], hash[option], "Wrong value for #{option}"
+    end
+  end
+
+  should "be mergable" do
+    config = Airbrake::Configuration.new
+    hash = config.to_hash
+    assert_equal hash.merge(:key => 'value'), config.merge(:key => 'value')
+  end
+
+  should "allow param filters to be appended" do
+    assert_appends_value :params_filters
+  end
+
+  should "allow rake environment filters to be appended" do
+    assert_appends_value :rake_environment_filters
+  end
+
+  should "allow ignored user agents to be appended" do
+    assert_appends_value :ignore_user_agent
+  end
+
+  should "allow backtrace filters to be appended" do
+    assert_appends_value(:backtrace_filters) do |config|
+      new_filter = lambda {}
+      config.filter_backtrace(&new_filter)
+      new_filter
+    end
+  end
+
+  should "allow ignore by filters to be appended" do
+    assert_appends_value(:ignore_by_filters) do |config|
+      new_filter = lambda {}
+      config.ignore_by_filter(&new_filter)
+      new_filter
+    end
+  end
+
+  should "allow ignored exceptions to be appended" do
+    config = Airbrake::Configuration.new
+    original_filters = config.ignore.dup
+    new_filter = 'hello'
+    config.ignore << new_filter
+    assert_same_elements original_filters + [new_filter], config.ignore
+  end
+
+  should "allow ignored exceptions to be replaced" do
+    assert_replaces(:ignore, :ignore_only=)
+  end
+
+  should "allow ignored rake exceptions to be appended" do
+    config = Airbrake::Configuration.new
+    original_filters = config.ignore_rake.dup
+    new_filter = 'hello'
+    config.ignore_rake << new_filter
+    assert_same_elements original_filters + [new_filter], config.ignore_rake
+  end
+
+  should "allow ignored rake exceptions to be replaced" do
+    assert_replaces(:ignore_rake, :ignore_rake_only=)
+  end
+
+  should "allow ignored user agents to be replaced" do
+    assert_replaces(:ignore_user_agent, :ignore_user_agent_only=)
+  end
+
+  should "use development and test as development environments by default" do
+    config = Airbrake::Configuration.new
+    assert_same_elements %w(development test cucumber), config.development_environments
+  end
+
+  context "configured?" do
+    setup do
+      @config = Airbrake::Configuration.new
+    end
+
+    should "be true if given an api_key" do
+      @config.api_key = "1234"
+      assert @config.configured?
+    end
+
+    should "be false with a nil api_key" do
+      @config.api_key = nil
+      assert !@config.configured?
+    end
+
+    should "be false with a blank api_key" do
+      @config.api_key = ''
+      assert !@config.configured?
+    end
+  end
+
+  should "be public in a public environment" do
+    config = Airbrake::Configuration.new
+    config.development_environments = %w(development)
+    config.environment_name = 'production'
+    assert config.public?
+  end
+
+  should "not be public in a development environment" do
+    config = Airbrake::Configuration.new
+    config.development_environments = %w(staging)
+    config.environment_name = 'staging'
+    assert !config.public?
+  end
+
+  should "be public without an environment name" do
+    config = Airbrake::Configuration.new
+    assert config.public?
+  end
+
+  should "use the assigned logger if set" do
+    config = Airbrake::Configuration.new
+    config.logger = "CUSTOM LOGGER"
+    assert_equal "CUSTOM LOGGER", config.logger
+  end
+
+  should 'give a new instance if non defined' do
+    Airbrake.configuration = nil
+    assert_kind_of Airbrake::Configuration, Airbrake.configuration
+  end
+
+  should 'reject invalid user attributes' do
+    silence_warnings
+    config = Airbrake::Configuration.new
+    config.user_attributes = %w(id foo)
+    assert_equal %w(id), config.user_attributes
+  end
+
+  should "warn about invalid attributes" do
+    stub_warnings
+    config = Airbrake::Configuration.new
+    config.user_attributes = %w(id foo bar baz)
+    %w(foo bar baz).each do |attr|
+      assert_match(/Unsupported user attribute: '#{attr}'/, Kernel.warnings)
+    end
+  end
+
+  def assert_config_default(option, default_value, config = nil)
+    config ||= Airbrake::Configuration.new
+    assert_equal default_value, config.send(option)
+  end
+
+  def assert_config_overridable(option, value = 'a value')
+    config = Airbrake::Configuration.new
+    config.send(:"#{option}=", value)
+    assert_equal value, config.send(option)
+  end
+
+  def assert_appends_value(option, &block)
+    config = Airbrake::Configuration.new
+    original_values = config.send(option).dup
+    block ||= lambda do |conf|
+      new_value = 'hello'
+      conf.send(option) << new_value
+      new_value
+    end
+    new_value = block.call(config)
+    assert_same_elements original_values + [new_value], config.send(option)
+  end
+
+  def assert_replaces(option, setter)
+    config = Airbrake::Configuration.new
+    new_value = 'hello'
+    config.send(setter, [new_value])
+    assert_equal [new_value], config.send(option)
+    config.send(setter, new_value)
+    assert_equal [new_value], config.send(option)
+  end
+
+  # monkeypatches Kernel.warn so we can read warnings from
+  # Kernel.warnings
+  def stub_warnings
+    Kernel.class_eval do
+      @@warnings = []
+
+      def warn(*messages)
+        @@warnings += messages
+      end
+
+      def self.warnings
+        @@warnings.join("\n")
+      end
+    end
+  end
+
+  def silence_warnings
+    Kernel.class_eval { def warn(*args); end }
+  end
+end

data/test/controller_methods_test.rb

@@ -0,0 +1,230 @@
+require File.expand_path '../helper', __FILE__
+
+require 'airbrake/rails/controller_methods'
+class TestController
+  include Airbrake::Rails::ControllerMethods
+
+  def params; {}; end
+  def session; nil; end
+  def request
+    OpenStruct.new(:port=> 80, :protocol => 'http://', host: 'example.com', :fullpath => 'path', :env => [])
+  end
+end
+
+class NilUserTestController < TestController
+  def current_user
+    nil
+  end
+end
+
+class CurrentUserTestController < TestController
+  def current_user
+    OpenStruct.new(:id => 123, :name => 'tape')
+  end
+end
+
+class CurrentMemberTestController < TestController
+  def current_member
+    OpenStruct.new(:id => 321, :name => 'mamba')
+  end
+end
+
+class CurrentUserErrorTestController < TestController
+  def current_user
+    fail 'Testing broken implementation for #current_user'
+  end
+end
+
+class CurrentMemberErrorTestController < TestController
+  def current_member
+    fail 'Testing broken implementation for #current_member'
+  end
+end
+
+class CurrentUserAttributeErrorTestController < TestController
+  def current_user
+    user = OpenStruct.new(:id => 123)
+    def user.name
+      fail 'Testing attribute that raises error on #current_user'
+    end
+    user
+  end
+end
+
+class NoSessionTestController < TestController
+  def session
+    nil
+  end
+end
+
+class ParamTestController < TestController
+  QUERY_PARAMS = { name: "|" } # URI parameter with invalid character
+  def request
+    query = QUERY_PARAMS.map { |k, v| "#{k}=#{v}"}.join("&")
+    OpenStruct.new(:port=> 80, :protocol => 'http://', host: 'example.com', :fullpath => "path?#{query}", :env => [])
+  end
+end
+
+class ControllerMethodsTest < Test::Unit::TestCase
+  include DefinesConstants
+
+  context "#airbrake_request_data" do
+    context "without a logged in user" do
+      setup do
+
+        NilClass.class_eval do
+          @@called = false
+
+          def self.called
+            !! @@called
+          end
+
+          def id
+            @@called = true
+          end
+        end
+
+        @controller = NilUserTestController.new
+      end
+
+      should "not call #id on NilClass" do
+        @controller.airbrake_request_data
+        assert_equal false, NilClass.called
+      end
+    end
+
+    context "with a logged in User" do
+      teardown do
+        Object.__send__(:remove_const, :ActiveRecord) if defined?(ActiveRecord)
+        Object.__send__(:remove_const, :POOL) if defined?(POOL)
+      end
+      should 'include user info in the data sent to Ab' do
+        Airbrake.configuration.user_attributes = %w(id)
+        controller = CurrentUserTestController.new
+        ab_data = controller.airbrake_request_data
+
+        assert_equal( {:id => 123},  ab_data[:user])
+      end
+
+      should 'include more info if asked to, discarding unknown attributes' do
+        Airbrake.configuration.user_attributes = %w(id name collar-size)
+
+        controller = CurrentUserTestController.new
+        ab_data = controller.airbrake_request_data
+
+        assert_equal( {:id => 123, :name => 'tape'},  ab_data[:user])
+      end
+
+      should 'work with a "current_member" method too' do
+        Airbrake.configuration.user_attributes = %w(id)
+        controller = CurrentMemberTestController.new
+        ab_data = controller.airbrake_request_data
+
+        assert_equal( {:id => 321},  ab_data[:user])
+      end
+
+      should "release DB connections" do
+        module ::ActiveRecord; class Base; end; end
+        ::ActiveRecord::Base.expects(:clear_active_connections!)
+
+        CurrentUserTestController.new.airbrake_request_data
+      end
+    end
+
+    context 'when loading the user raises an error' do
+      should 'send empty user info to Ab when current_user fails' do
+        Airbrake.configuration.user_attributes = %w(id)
+        controller = CurrentUserErrorTestController.new
+        ab_data = controller.airbrake_request_data
+
+        assert_equal( { },  ab_data[:user] )
+      end
+
+      should 'send empty user info to Ab when current_member fails' do
+        Airbrake.configuration.user_attributes = %w(id)
+        controller = CurrentMemberErrorTestController.new
+        ab_data = controller.airbrake_request_data
+
+        assert_equal( { },  ab_data[:user] )
+      end
+
+      should 'exclude any user attributes that raise an error' do
+        Airbrake.configuration.user_attributes = %w(id name)
+        controller = CurrentUserAttributeErrorTestController.new
+        ab_data = controller.airbrake_request_data
+
+        assert_equal( {:id => 123},  ab_data[:user])
+      end
+    end
+  end
+
+  context '#airbrake_session_data' do
+    setup do
+      @controller = NoSessionTestController.new
+    end
+    should 'not call session if no session' do
+      no_session = @controller.send(:airbrake_session_data)
+      assert_equal no_session, {:session => 'no session found'}
+    end
+  end
+
+  context "#airbrake_request_url" do
+    setup do
+      @controller = NoSessionTestController.new
+    end
+    should "return correct request url" do
+      request_url = @controller.send(:airbrake_request_url)
+      assert_equal request_url, "http://example.com/path"
+    end
+
+    should "handle invalid character in param" do
+      request_url = ParamTestController.new.send(:airbrake_request_url)
+      assert_equal request_url, "http://example.com/path?name=|"
+    end
+  end
+
+  context "Rails 3" do
+    setup do
+      @controller = NilUserTestController.new
+      ::Rails = Object.new
+      ::Rails.stubs(:version).returns("3.2.17")
+    end
+
+    should "respond to rails_3_or_4? with true" do
+      assert @controller.send(:rails_3_or_4?)
+    end
+
+    should "call filter_rails3_parameters" do
+      hash = {:a => "b"}
+      filtered_hash = {:c => "d"}
+
+      @controller.expects(:filter_rails3_parameters).with(hash).
+        returns(filtered_hash)
+      assert_equal filtered_hash,
+        @controller.send(:airbrake_filter_if_filtering, hash)
+    end
+  end
+
+  context "Rails 4.x" do
+    setup do
+      @controller = TestController.new
+      ::Rails = Object.new
+      ::Rails.stubs(:version).returns("4.5.6.7")
+    end
+
+    should 'be true when running Rails 4.x' do
+      assert @controller.send(:rails_3_or_4?)
+    end
+
+    should "call filter_rails3_parameters" do
+      hash = {:a => "b"}
+      filtered_hash = {:c => "d"}
+
+      @controller.expects(:filter_rails3_parameters).with(hash).
+        returns(filtered_hash)
+      assert_equal filtered_hash,
+        @controller.send(:airbrake_filter_if_filtering, hash)
+    end
+  end
+
+end