airbrake 3.1.6 → 11.0.0

data/test/capistrano_test.rb

@@ -1,34 +0,0 @@
-require File.expand_path '../helper', __FILE__
-
-require 'capistrano/configuration'
-require 'airbrake/capistrano'
-
-class CapistranoTest < Test::Unit::TestCase
-  def setup
-    super
-    reset_config
-
-    @configuration = Capistrano::Configuration.new
-    Airbrake::Capistrano.load_into(@configuration)
-    @configuration.dry_run = true
-  end
-
-  should "define airbrake:deploy task" do
-    assert_not_nil @configuration.find_task('airbrake:deploy')
-  end
-
-  should "log when calling airbrake:deploy task" do
-    @configuration.set(:current_revision, '084505b1c0e0bcf1526e673bb6ac99fbcb18aecc')
-    @configuration.set(:repository, 'repository')
-    @configuration.set(:current_release, '/home/deploy/rails_app/hoptoad')
-    io = StringIO.new
-    logger = Capistrano::Logger.new(:output => io)
-    logger.level = Capistrano::Logger::MAX_LEVEL
-
-    @configuration.logger = logger
-    @configuration.find_and_execute_task('airbrake:deploy')
-
-    assert io.string.include?('** Notifying Airbrake of Deploy')
-    assert io.string.include?('** Airbrake Notification Complete')
-  end
-end

data/test/catcher_test.rb

@@ -1,333 +0,0 @@
-require File.expand_path '../helper', __FILE__
-
-class ActionControllerCatcherTest < Test::Unit::TestCase
-
-  include DefinesConstants
-
-  def setup
-    super
-    reset_config
-    Airbrake.sender = CollectingSender.new
-    define_constant('RAILS_ROOT', '/path/to/rails/root')
-  end
-
-  def ignore(exception_class)
-    Airbrake.configuration.ignore << exception_class
-  end
-
-  def build_controller_class(&definition)
-     Class.new(ActionController::Base).tap do |klass|
-      klass.__send__(:include, Airbrake::Rails::ActionControllerCatcher)
-      klass.class_eval(&definition) if definition
-      define_constant('AirbrakeTestController', klass)
-    end
-  end
-
-  def assert_sent_hash(hash, xpath)
-    hash.each do |key, value|
-      next if key.match(/^airbrake\./) # We added this key.
-
-      element_xpath = "#{xpath}/var[@key = '#{key}']"
-      if value.respond_to?(:to_hash)
-        assert_sent_hash value.to_hash, element_xpath
-      else
-        assert_sent_element value, element_xpath
-      end
-    end
-  end
-
-  def assert_sent_element(value, xpath)
-    assert_valid_node last_sent_notice_document, xpath, stringify_array_elements(value).to_s
-  end
-
-  def stringify_array_elements(data)
-    if data.respond_to?(:to_ary)
-      data.collect do |value|
-        stringify_array_elements(value)
-      end
-    else
-      data.to_s
-    end
-  end
-
-  def assert_sent_request_info_for(request)
-    params = request.parameters.to_hash
-    assert_sent_hash params, '/notice/request/params'
-    assert_sent_element params['controller'], '/notice/request/component'
-    assert_sent_element params['action'], '/notice/request/action'
-    assert_sent_element url_from_request(request), '/notice/request/url'
-    assert_sent_hash request.env, '/notice/request/cgi-data'
-  end
-
-  def url_from_request(request)
-    url = "#{request.protocol}#{request.host}"
-
-    unless [80, 443].include?(request.port)
-      url << ":#{request.port}"
-    end
-
-    url << request.request_uri
-    url
-  end
-
-  def sender
-    Airbrake.sender
-  end
-
-  def last_sent_notice_xml
-    sender.collected.last.to_xml
-  end
-
-  def last_sent_notice_document
-    assert_not_nil xml = last_sent_notice_xml, "No xml was sent"
-    Nokogiri::XML.parse(xml)
-  end
-
-  def process_action(opts = {}, &action)
-    opts[:request]  ||= ActionController::TestRequest.new
-    opts[:response] ||= ActionController::TestResponse.new
-    klass = build_controller_class do
-      cattr_accessor :local
-      define_method(:index, &action)
-      def local_request?
-        local
-      end
-    end
-    if opts[:filters]
-      klass.filter_parameter_logging *opts[:filters]
-    end
-    if opts[:user_agent]
-      if opts[:request].respond_to?(:user_agent=)
-        opts[:request].user_agent = opts[:user_agent]
-      else
-        opts[:request].env["HTTP_USER_AGENT"] = opts[:user_agent]
-      end
-    end
-    if opts[:port]
-      opts[:request].port = opts[:port]
-    end
-    klass.consider_all_requests_local = opts[:all_local]
-    klass.local                       = opts[:local]
-    controller = klass.new
-    controller.stubs(:rescue_action_in_public_without_airbrake)
-    opts[:request].query_parameters = opts[:request].query_parameters.merge(opts[:params] || {})
-    opts[:request].session = ActionController::TestSession.new(opts[:session] || {})
-    # Prevents request.fullpath from crashing Rails in tests
-    opts[:request].env['REQUEST_URI'] = opts[:request].request_uri
-    controller.process(opts[:request], opts[:response])
-    controller
-  end
-
-  def process_action_with_manual_notification(args = {})
-    process_action(args) do
-      notify_airbrake(:error_message => 'fail')
-      # Rails will raise a template error if we don't render something
-      render :nothing => true
-    end
-  end
-
-  def process_action_with_automatic_notification(args = {})
-    process_action(args) { raise "Hello" }
-  end
-
-  should "deliver notices from exceptions raised in public requests" do
-    process_action_with_automatic_notification
-    assert_caught_and_sent
-  end
-
-  should "not deliver notices from exceptions in local requests" do
-    process_action_with_automatic_notification(:local => true)
-    assert_caught_and_not_sent
-  end
-
-  should "not deliver notices from exceptions when all requests are local" do
-    process_action_with_automatic_notification(:all_local => true)
-    assert_caught_and_not_sent
-  end
-
-  should "not deliver notices from actions that don't raise" do
-    controller = process_action { render :text => 'Hello' }
-    assert_caught_and_not_sent
-    assert_equal 'Hello', controller.response.body
-  end
-
-  should "not deliver ignored exceptions raised by actions" do
-    ignore(RuntimeError)
-    process_action_with_automatic_notification
-    assert_caught_and_not_sent
-  end
-
-  should "deliver ignored exception raised manually" do
-    ignore(RuntimeError)
-    process_action_with_manual_notification
-    assert_caught_and_sent
-  end
-
-  should "deliver manually sent notices in public requests" do
-    process_action_with_manual_notification
-    assert_caught_and_sent
-  end
-
-  should "not deliver manually sent notices in local requests" do
-    process_action_with_manual_notification(:local => true)
-    assert_caught_and_not_sent
-  end
-
-  should "not deliver manually sent notices when all requests are local" do
-    process_action_with_manual_notification(:all_local => true)
-    assert_caught_and_not_sent
-  end
-
-  should "continue with default behavior after delivering an exception" do
-    controller = process_action_with_automatic_notification(:public => true)
-    # TODO: can we test this without stubbing?
-    assert_received(controller, :rescue_action_in_public_without_airbrake)
-  end
-
-  should "not create actions from Airbrake methods" do
-    controller = build_controller_class.new
-    assert_equal [], Airbrake::Rails::ActionControllerCatcher.instance_methods
-  end
-
-  should "ignore exceptions when user agent is being ignored by regular expression" do
-    Airbrake.configuration.ignore_user_agent_only = [/Ignored/]
-    process_action_with_automatic_notification(:user_agent => 'ShouldBeIgnored')
-    assert_caught_and_not_sent
-  end
-
-  should "ignore exceptions when user agent is being ignored by string" do
-    Airbrake.configuration.ignore_user_agent_only = ['IgnoredUserAgent']
-    process_action_with_automatic_notification(:user_agent => 'IgnoredUserAgent')
-    assert_caught_and_not_sent
-  end
-
-  should "not ignore exceptions when user agent is not being ignored" do
-    Airbrake.configuration.ignore_user_agent_only = ['IgnoredUserAgent']
-    process_action_with_automatic_notification(:user_agent => 'NonIgnoredAgent')
-    assert_caught_and_sent
-  end
-
-  should "send session data for manual notifications" do
-    data = { 'one' => 'two' }
-    process_action_with_manual_notification(:session => data)
-    assert_sent_hash data, "/notice/request/session"
-  end
-
-  should "send session data for automatic notification" do
-    data = { 'one' => 'two' }
-    process_action_with_automatic_notification(:session => data)
-    assert_sent_hash data, "/notice/request/session"
-  end
-
-  should "send request data for manual notification" do
-    params = { 'controller' => "airbrake_test", 'action' => "index" }
-    controller = process_action_with_manual_notification(:params => params)
-    assert_sent_request_info_for controller.request
-  end
-
-  should "send request data for manual notification with non-standard port" do
-    params = { 'controller' => "airbrake_test", 'action' => "index" }
-    controller = process_action_with_manual_notification(:params => params, :port => 81)
-    assert_sent_request_info_for controller.request
-  end
-
-  should "send request data for automatic notification" do
-    params = { 'controller' => "airbrake_test", 'action' => "index" }
-    controller = process_action_with_automatic_notification(:params => params)
-    assert_sent_request_info_for controller.request
-  end
-
-  should "send request data for automatic notification with non-standard port" do
-    params = { 'controller' => "airbrake_test", 'action' => "index" }
-    controller = process_action_with_automatic_notification(:params => params, :port => 81)
-    assert_sent_request_info_for controller.request
-  end
-
-  should "use standard rails logging filters on params and session and env" do
-    filtered_params = { "abc" => "123",
-                        "def" => "456",
-                        "ghi" => "[FILTERED]" }
-    filtered_session = { "abc" => "123",
-                         "ghi" => "[FILTERED]" }
-    ENV['ghi'] = 'abc'
-    filtered_env = { 'ghi' => '[FILTERED]' }
-    filtered_cgi = { 'REQUEST_METHOD' => '[FILTERED]' }
-
-    process_action_with_automatic_notification(:filters => [:ghi, :request_method],
-                                               :params => { "abc" => "123",
-                                                            "def" => "456",
-                                                            "ghi" => "789" },
-                                               :session => { "abc" => "123",
-                                                             "ghi" => "789" })
-    assert_sent_hash filtered_params, '/notice/request/params'
-    assert_sent_hash filtered_cgi, '/notice/request/cgi-data'
-    assert_sent_hash filtered_session, '/notice/request/session'
-  end
-
-  context "for a local error with development lookup enabled" do
-    setup do
-      Airbrake.configuration.development_lookup = true
-      Airbrake.stubs(:build_lookup_hash_for).returns({ :awesome => 2 })
-
-      @controller = process_action_with_automatic_notification(:local => true)
-      @response   = @controller.response
-    end
-
-    should "append custom CSS and JS to response body for a local error" do
-      assert_match /text\/css/, @response.body
-      assert_match /text\/javascript/, @response.body
-    end
-
-    should "contain host, API key and notice JSON" do
-      assert_match Airbrake.configuration.host.to_json, @response.body
-      assert_match Airbrake.configuration.api_key.to_json, @response.body
-      assert_match ({ :awesome => 2 }).to_json, @response.body
-    end
-  end
-
-  context "for a local error with development lookup disabled" do
-    setup do
-      Airbrake.configuration.development_lookup = false
-
-      @controller = process_action_with_automatic_notification(:local => true)
-      @response   = @controller.response
-    end
-
-    should "not append custom CSS and JS to response for a local error" do
-      assert_no_match /text\/css/, @response.body
-      assert_no_match /text\/javascript/, @response.body
-    end
-  end
-
-  should "call session.to_hash if available" do
-    hash_data = {:key => :value}
-
-    session = ActionController::TestSession.new
-    ActionController::TestSession.stubs(:new).returns(session)
-    session.stubs(:to_hash).returns(hash_data)
-
-    process_action_with_automatic_notification
-    assert_received(session, :to_hash)
-    assert_received(session, :data) { |expect| expect.never }
-    assert_caught_and_sent
-  end
-
-  should "call session.data if session.to_hash is undefined" do
-    hash_data = {:key => :value}
-
-    session = ActionController::TestSession.new
-    ActionController::TestSession.stubs(:new).returns(session)
-    session.stubs(:data).returns(hash_data)
-    if session.respond_to?(:to_hash)
-      class << session
-        undef to_hash
-      end
-    end
-
-    process_action_with_automatic_notification
-    assert_received(session, :to_hash) { |expect| expect.never }
-    assert_received(session, :data) { |expect| expect.at_least_once }
-    assert_caught_and_sent
-  end
-
-end

data/test/configuration_test.rb

@@ -1,233 +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 :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
-  end
-
-  should "set GirlFriday-callable for async=true" do
-    config = Airbrake::Configuration.new
-    config.async = true
-    assert config.async.respond_to?(:call)
-  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
-  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 "warn when attempting to write js_notifier" do
-    config = Airbrake::Configuration.new
-    config.
-      expects(:warn).
-      with(regexp_matches(/deprecated/i))
-    config.js_notifier = true
-  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 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
-
-  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
-
-  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 |config|
-      new_value = 'hello'
-      config.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
-
-end