airbrake 4.3.8 → 5.0.0.rc.1

data/test/helper.rb

@@ -1,233 +0,0 @@
-require "simplecov" 
-
-if ENV["INTEGRATION"] then SimpleCov.command_name "test:integration"
-else SimpleCov.command_name "test:units"
-end
-
-SimpleCov.merge_timeout 3600 
-SimpleCov.start
-
-if ENV["CI"]
-  require "coveralls"
-  Coveralls.wear_merged!
-end
-
-$VERBOSE = ENV["VERBOSE"]
-
-module Kernel
-  def silence_warnings
-    with_warnings(nil) { yield }
-  end
-
-  def with_warnings(flag)
-    old_verbose, $VERBOSE = $VERBOSE, flag
-    yield
-  ensure
-    $VERBOSE = old_verbose
-  end
-end
-
-silence_warnings do
-  require 'test/unit'
-  require 'rubygems'
-
-  require 'thread'
-
-  require 'mocha/setup'
-  require 'nokogiri'
-  require 'rack'
-  require 'bourne'
-  require 'sham_rack'
-  require 'json-schema'
-  require "shoulda-matchers"
-  require "shoulda-context"
-  require "fakeweb"
-  require "pry"
-
-  begin require 'redgreen'; rescue LoadError; end
-end
-
-$LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
-
-require "airbrake"
-
-XSD_SCHEMA_PATH    = "http://airbrake.io/airbrake_#{Airbrake::API_VERSION.tr(".","_")}.xsd"
-COVERALLS_API_URL  = "https://coveralls.io/api/v1"
-
-FakeWeb.allow_net_connect = %r{#{XSD_SCHEMA_PATH}|#{COVERALLS_API_URL}}
-
-module TestMethods
-  def rescue_action e
-    raise e
-  end
-
-  def do_raise
-    raise "Airbrake"
-  end
-
-  def do_not_raise
-    render :text => "Success"
-  end
-
-  def do_raise_ignored
-    raise ActiveRecord::RecordNotFound.new("404")
-  end
-
-  def do_raise_not_ignored
-    raise ActiveRecord::StatementInvalid.new("Statement invalid")
-  end
-
-  def manual_notify
-    notify_airbrake(Exception.new)
-    render :text => "Success"
-  end
-
-  def manual_notify_ignored
-    notify_airbrake(ActiveRecord::RecordNotFound.new("404"))
-    render :text => "Success"
-  end
-end
-
-module TestHelpers
-  def stub_sender
-    stub('sender', :send_to_airbrake => nil)
-  end
-
-  def stub_sender!
-    Airbrake.sender = stub_sender
-  end
-
-  def stub_notice
-    stub('notice', :to_xml => 'some yaml', :ignore? => false)
-  end
-
-  def stub_notice!
-     stub_notice.tap do |notice|
-      Airbrake::Notice.stubs(:new => notice)
-    end
-  end
-
-  def reset_config
-    Airbrake.configuration = nil
-    Airbrake.configure do |config|
-      config.api_key = 'abc123'
-    end
-  end
-
-  def clear_backtrace_filters
-    Airbrake.configuration.backtrace_filters.clear
-  end
-
-  def build_exception(opts = {})
-    backtrace = ["airbrake/test/helper.rb:132:in `build_exception'",
-                 "airbrake/test/backtrace.rb:4:in `build_notice_data'",
-                 "/var/lib/gems/1.8/gems/airbrake-2.4.5/rails/init.rb:2:in `send_exception'"]
-    opts = {:backtrace => backtrace}.merge(opts)
-    BacktracedException.new(opts)
-  end
-
-  def build_notice_data(exception = nil)
-    exception ||= build_exception
-    {
-      :api_key       => 'abc123',
-      :error_class   => exception.class.name,
-      :error_message => "#{exception.class.name}: #{exception.message}",
-      :backtrace     => exception.backtrace,
-      :environment   => { 'PATH' => '/bin', 'REQUEST_URI' => '/users/1' },
-      :request       => {
-        :params     => { 'controller' => 'users', 'action' => 'show', 'id' => '1' },
-        :rails_root => '/path/to/application',
-        :url        => "http://test.host/users/1"
-      },
-      :session       => {
-        :key  => '123abc',
-        :data => { 'user_id' => '5', 'flash' => { 'notice' => 'Logged in successfully' } }
-      }
-    }
-  end
-
-  def assert_caught_and_sent
-    assert !Airbrake.sender.collected.empty?
-  end
-
-  def assert_caught_and_not_sent
-    assert Airbrake.sender.collected.empty?
-  end
-
-  def assert_array_starts_with(expected, actual)
-    assert_respond_to actual, :to_ary
-    array = actual.to_ary.reverse
-    expected.reverse.each_with_index do |value, i|
-      assert_equal value, array[i]
-    end
-  end
-
-  def assert_valid_node(document, xpath, content)
-    nodes = document.xpath(xpath)
-    assert nodes.any?{|node| node.content == content },
-           "Expected xpath #{xpath} to have content #{content}, " +
-           "but found #{nodes.map { |n| n.content }} in #{nodes.size} matching nodes." +
-           "Document:\n#{document.to_s}"
-  end
-
-  def assert_logged(expected)
-    assert_received(Airbrake, :write_verbose_log) do |expect|
-      expect.with {|actual| actual =~ expected }
-    end
-  end
-
-  def assert_not_logged(expected)
-    assert_received(Airbrake, :write_verbose_log) do |expect|
-      expect.with {|actual| actual =~ expected }.never
-    end
-  end
-end
-
-class Test::Unit::TestCase
-  include ::TestHelpers
-end
-
-module DefinesConstants
-  def setup
-    @defined_constants = []
-  end
-
-  def teardown
-    @defined_constants.each do |constant|
-      Object.__send__(:remove_const, constant)
-    end
-  end
-
-  def define_constant(name, value)
-    Object.const_set(name, value)
-    @defined_constants << name
-  end
-end
-
-class CollectingSender
-  attr_reader :collected
-
-  def initialize
-    @collected = []
-  end
-
-  def send_to_airbrake(data)
-    @collected << data
-  end
-end
-
-class BacktracedException < Exception
-  attr_accessor :backtrace
-
-  def initialize(opts)
-    @backtrace = opts[:backtrace]
-  end
-
-  def set_backtrace(bt)
-    @backtrace = bt
-  end
-
-  def message
-    "Something went wrong. Did you press the red button?"
-  end
-end

data/test/integration.rb

@@ -1,13 +0,0 @@
-require File.expand_path '../helper', __FILE__
-
-silence_warnings do
-  require 'action_controller'
-  require 'action_dispatch'
-  require 'active_support/dependencies'
-  require 'active_support/core_ext/kernel/reporting'
-
-  require "erb"
-  require "action_view"
-end
-
-require File.expand_path "../integration/catcher_test", __FILE__

data/test/integration/catcher_test.rb

@@ -1,371 +0,0 @@
-require 'airbrake/rails/controller_methods'
-require 'airbrake/rails/middleware'
-
-unless defined?(ActionDispatch::IntegrationTest) # Rails 3.0
-  # what follows is a dirty hack which makes
-  # AD::IntegrationTest possible in Rails 3.0
-  ActiveSupport::Deprecation.debug = true
-
-  FIXTURE_LOAD_PATH = File.join(File.dirname(__FILE__), 'fixtures')
-  FIXTURES = Pathname.new(FIXTURE_LOAD_PATH)
-
-  SharedTestRoutes = ActionDispatch::Routing::RouteSet.new
-
-  class RoutedRackApp
-    attr_reader :routes
-
-    def initialize(routes, &blk)
-      @routes = routes
-      @stack = ActionDispatch::MiddlewareStack.new(&blk).build(@routes)
-    end
-
-    def call(env)
-      @stack.call(env)
-    end
-  end
-
-  class ActionController::IntegrationTest < ActiveSupport::TestCase
-    def self.build_app(routes = nil)
-      RoutedRackApp.new(routes || ActionDispatch::Routing::RouteSet.new) do |middleware|
-        yield(middleware) if block_given?
-      end
-    end
-
-    self.app = build_app
-
-    # Stub Rails dispatcher so it does not get controller references and
-    # simply return the controller#action as Rack::Body.
-    class StubDispatcher < ::ActionDispatch::Routing::RouteSet::Dispatcher
-      protected
-      def controller_reference(controller_param)
-        controller_param
-      end
-
-      def dispatch(controller, action, env)
-        [200, {'Content-Type' => 'text/html'}, ["#{controller}##{action}"]]
-      end
-    end
-
-    def self.stub_controllers
-      old_dispatcher = ActionDispatch::Routing::RouteSet::Dispatcher
-      ActionDispatch::Routing::RouteSet.module_eval { remove_const :Dispatcher }
-      ActionDispatch::Routing::RouteSet.module_eval { const_set :Dispatcher, StubDispatcher }
-      yield ActionDispatch::Routing::RouteSet.new
-    ensure
-      ActionDispatch::Routing::RouteSet.module_eval { remove_const :Dispatcher }
-      ActionDispatch::Routing::RouteSet.module_eval { const_set :Dispatcher, old_dispatcher }
-    end
-
-    def with_routing(&block)
-      temporary_routes = ActionDispatch::Routing::RouteSet.new
-      old_app, self.class.app = self.class.app, self.class.build_app(temporary_routes)
-      old_routes = SharedTestRoutes
-      silence_warnings { Object.const_set(:SharedTestRoutes, temporary_routes) }
-
-      yield temporary_routes
-    ensure
-      self.class.app = old_app
-      silence_warnings { Object.const_set(:SharedTestRoutes, old_routes) }
-    end
-
-    def with_autoload_path(path)
-      path = File.join(File.dirname(__FILE__), "fixtures", path)
-      if ActiveSupport::Dependencies.autoload_paths.include?(path)
-        yield
-      else
-        begin
-          ActiveSupport::Dependencies.autoload_paths << path
-          yield
-        ensure
-          ActiveSupport::Dependencies.autoload_paths.reject! {|p| p == path}
-          ActiveSupport::Dependencies.clear
-        end
-      end
-    end
-  end
-
-  class ActionDispatch::IntegrationTest < ActiveSupport::TestCase
-    setup do
-      @routes = SharedTestRoutes
-    end
-  end
-
-  module ActionController
-    class Base
-      include ActionController::Testing
-    end
-
-    Base.view_paths = FIXTURE_LOAD_PATH
-
-    class TestCase
-      include ActionDispatch::TestProcess
-
-      setup do
-        @routes = SharedTestRoutes
-      end
-    end
-  end
-
-  # This stub emulates the Railtie including the URL helpers from a Rails application
-  module ActionController
-    class Base
-      include SharedTestRoutes.url_helpers
-    end
-  end
-end # end Rails 3.0 hack
-
-module ActionDispatch
-  class ShowExceptions
-    private
-    def public_path
-      "/null"
-    end
-
-    # Silence logger
-    def logger
-      Logger.new("/dev/null")
-    end
-  end
-end
-
-class ActionControllerCatcherTest < ActionDispatch::IntegrationTest
-
-  include DefinesConstants
-  include TestHelpers
-
-  def setup
-    super
-    reset_config
-    Airbrake.sender = CollectingSender.new
-    Airbrake.configuration.development_environments = []
-    define_constant('RAILS_ROOT', '/path/to/rails/root')
-  end
-
-  def ignore(exception_class)
-    Airbrake.configuration.ignore << exception_class
-  end
-
-  def assert_sent_hash(hash, xpath)
-    hash.each do |key, value|
-      next if key.match(/^airbrake\./) || # We added this key.
-        hash[key] !~ /\S/
-
-        element_xpath = "#{xpath}/var[@key = '#{key}']"
-      if value.respond_to?(:to_hash)
-        assert_sent_hash value.to_hash, element_xpath
-      else
-        next if key == "action_dispatch.exception" # TODO: Rails 3.2 only - review
-        value.gsub!(/\d/,"") if key == "PATH_INFO" # TODO: Rails 3.2 only - review
-        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.fullpath.gsub(%r{\d},"") # TODO: Rails 3.2 only - review
-
-    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
-
-  class AirbrakeTestController < ActionController::Base
-    begin
-      use ActionDispatch::ShowExceptions, ActionDispatch::PublicExceptions.new("/null")
-    rescue NameError
-      use ActionDispatch::ShowExceptions
-    end
-
-    use Airbrake::Rails::Middleware
-
-    include Airbrake::Rails::ControllerMethods
-
-    cattr_accessor :local
-
-    before_filter :set_session
-
-    def set_session
-      unless params.empty?
-        request.session = ActionController::TestSession.new(params[:session] || {})
-      end
-    end
-
-    def boom
-      raise "boom"
-      render :nothing => true
-    end
-
-    def hello
-      render :text => "hello"
-    end
-
-    def manual_airbrake
-      notify_airbrake(:error_message => "fail")
-      render :nothing => true
-    end
-
-    protected
-
-    def airbrake_local_request?
-      @@local
-    end
-  end
-
-  setup do
-    Airbrake.configuration.development_environments = []
-  end
-
-
-  def test_deliver_notices_from_exceptions_raised_in_public_requests
-    @app = AirbrakeTestController.action(:boom)
-    get '/'
-    assert_caught_and_sent
-  end
-
-  def test_not_deliver_notices_from_exceptions_in_development_environments
-    Airbrake.configuration.development_environments = ["test"]
-    Airbrake.configuration.environment_name = "test"
-    @app = AirbrakeTestController.action(:boom)
-    get '/'
-    assert_caught_and_not_sent
-  end
-
-  def test_not_deliver_notices_from_exceptions_with_no_api_key
-    Airbrake.configuration.api_key = nil
-    @app = AirbrakeTestController.action(:boom)
-    get '/'
-    assert_caught_and_not_sent
-  end
-
-  def test_not_deliver_notices_from_actions_that_dont_raise
-    @app = AirbrakeTestController.action(:hello)
-    get '/'
-    assert_caught_and_not_sent
-    assert_equal 'hello', response.body
-  end
-
-  def test_not_deliver_ignored_exceptions_raised_by_actions
-    @app = AirbrakeTestController.action(:boom)
-    ignore(RuntimeError)
-    get '/'
-    assert_caught_and_not_sent
-  end
-
-  def test_deliver_ignored_exception_raised_manually
-    @app = AirbrakeTestController.action(:manual_airbrake)
-    ignore(RuntimeError)
-    get '/'
-    assert_caught_and_sent
-  end
-
-  def test_not_deliver_manually_sent_notices_in_local_requests
-    AirbrakeTestController.local = true
-    @app = AirbrakeTestController.action(:manual_airbrake)
-    get '/'
-    assert_caught_and_not_sent
-    AirbrakeTestController.local = false
-  end
-
-  def test_not_create_actions_from_airbrake_methods
-    Airbrake::Rails::ControllerMethods.instance_methods.each do |method|
-      assert !(AirbrakeTestController.new.action_methods.include?(method))
-    end
-  end
-
-  def test_ignore_exceptions_when_user_agent_is_being_ignored_by_regular_expression
-    Airbrake.configuration.ignore_user_agent_only = [/Ignored/]
-    @app = AirbrakeTestController.action(:boom)
-    get "/", {}, {"HTTP_USER_AGENT" => "ShouldBeIgnored"}
-    assert_caught_and_not_sent
-  end
-
-  def test_ignore_exceptions_when_user_agent_is_being_ignored_by_string
-    Airbrake.configuration.ignore_user_agent_only = ['IgnoredUserAgent']
-    @app = AirbrakeTestController.action(:boom)
-    get "/", {}, {"HTTP_USER_AGENT" => "IgnoredUserAgent"}
-    assert_caught_and_not_sent
-  end
-
-  def test_not_ignore_exceptions_when_user_agent_is_not_being_ignored
-    Airbrake.configuration.ignore_user_agent_only = ['IgnoredUserAgent']
-    @app = AirbrakeTestController.action(:boom)
-    get "/", {}, {"HTTP_USER_AGENT" => "NonIgnoredAgent"}
-    assert_caught_and_sent
-  end
-
-  def test_send_session_data_for_manual_notifications
-    @app = AirbrakeTestController.action(:manual_airbrake)
-    data = { 'one' => 'two' }
-    get "/", :session => data
-    assert_sent_hash data, "/notice/request/session"
-  end
-
-  def test_send_request_data_for_manual_notification
-    params = { 'controller' => "airbrake_test", 'action' => "index" }
-    @app = AirbrakeTestController.action(:manual_airbrake)
-    get "/", params
-    assert_sent_request_info_for @request
-  end
-
-  def test_send_request_data_for_manual_notification_with_non_standard_port
-    params = { 'controller' => "airbrake_test", 'action' => "index" }
-    @app = AirbrakeTestController.action(:manual_airbrake)
-    get "/", params, {"SERVER_PORT" => 81}
-    assert_sent_request_info_for @request
-  end
-
-  def test_send_request_data_for_automatic_notification
-    params = { 'controller' => "airbrake_test", 'action' => "index" }
-    @app = AirbrakeTestController.action(:boom)
-    get "/", params
-    assert_sent_request_info_for @request
-  end
-
-  def test_send_request_data_for_automatic_notification_with_non_standard_port
-    params = { 'controller' => "airbrake_test", 'action' => "index" }
-    @app = AirbrakeTestController.action(:boom)
-    get "/", params, {"SERVER_PORT" => 81}
-    assert_sent_request_info_for @request
-    assert_sent_element 81, "/notice/request/cgi-data/var[@key = 'SERVER_PORT']"
-  end
-end