airbrake 4.3.8 → 5.0.0.rc.1

data/test/configuration_test.rb

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

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