airbrakeV4rails5 4.3.8

data/test/helper.rb

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

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

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