airbrake 4.3.8 → 5.0.0

data/spec/apps/sinatra/dummy_app.rb

@@ -0,0 +1,12 @@
+class DummyApp < Sinatra::Base
+  use Airbrake::Rack::Middleware
+  use Warden::Manager
+
+  get '/' do
+    'Hello from index'
+  end
+
+  get '/crash' do
+    raise AirbrakeTestError
+  end
+end

data/spec/integration/rack/rack_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+require 'integration/shared_examples/rack_examples'
+
+RSpec.describe "Rack integration specs" do
+  let(:app) { DummyApp }
+
+  include_examples 'rack examples'
+
+  describe "context payload" do
+    it "includes version" do
+      get '/crash'
+      wait_for_a_request_with_body(
+        /"context":{.*"version":"1.2.3 Rack\.version.+Rack\.release/
+      )
+    end
+  end
+end

data/spec/integration/rails/rails_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+require 'integration/shared_examples/rack_examples'
+
+RSpec.describe "Rails integration specs" do
+  include Warden::Test::Helpers
+
+  let(:app) { Rails.application }
+
+  include_examples 'rack examples'
+
+  it "inserts the Airbrake Rack middleware after DebugExceptions" do
+    middlewares = Rails.configuration.middleware.middlewares.map(&:inspect)
+    own_idx = middlewares.index('Airbrake::Rack::Middleware')
+
+    expect(middlewares[own_idx - 1]).to eq('ActionDispatch::DebugExceptions')
+  end
+
+  shared_examples 'context payload content' do |route|
+    before do
+      login_as(OpenStruct.new(id: 1, email: 'qa@example.com', username: 'qa-dept'))
+      get(route, foo: :bar)
+    end
+
+    it "includes component information" do
+      wait_for_a_request_with_body(/"context":{.*"component":"dummy".*}/)
+    end
+
+    it "includes action information" do
+      case route
+      when '/crash'
+        wait_for_a_request_with_body(/"context":{.*"action":"crash".*}/)
+      when '/notify_airbrake_helper'
+        wait_for_a_request_with_body(
+          /"context":{.*"action":"notify_airbrake_helper".*}/
+        )
+      when '/notify_airbrake_sync_helper'
+        wait_for_a_request_with_body(
+          /"context":{.*"action":"notify_airbrake_sync_helper".*}/
+        )
+      else
+        raise 'Unknown route'
+      end
+    end
+
+    it "includes version" do
+      wait_for_a_request_with_body(/"context":{.*"version":"1.2.3 Rails/)
+    end
+
+    it "includes session" do
+      wait_for_a_request_with_body(
+        /"context":{.*"session":{.*"session_id":"\w+".*}/
+      )
+    end
+
+    it "includes params" do
+      action = route[1..-1]
+      wait_for_a_request_with_body(
+        /"context":{.*"params":{.*"controller":"dummy","action":"#{action}".*}/
+      )
+    end
+  end
+
+  describe "context payload" do
+    context "when exception reported through middleware" do
+      include_examples('context payload content', '/crash')
+    end
+
+    context "when exception reported through the notify_airbrake helper" do
+      include_examples('context payload content', '/notify_airbrake_helper')
+    end
+
+    context "when exception reported through the notify_airbrake_sync helper" do
+      include_examples('context payload content', '/notify_airbrake_sync_helper')
+    end
+  end
+
+  describe "Active Record callbacks" do
+    it "reports exceptions in after_commit callbacks" do
+      get '/active_record_after_commit'
+      wait_for_a_request_with_body(
+        /"type":"AirbrakeTestError","message":"after_commit"/
+      )
+    end
+
+    it "reports exceptions in after_rollback callbacks" do
+      get '/active_record_after_rollback'
+      wait_for_a_request_with_body(
+        /"type":"AirbrakeTestError","message":"after_rollback"/
+      )
+    end
+  end
+
+  if Gem::Version.new(Rails.version) >= Gem::Version.new('4.2')
+    describe "ActiveJob jobs" do
+      it "reports exceptions occurring in ActiveJob workers" do
+        get '/active_job'
+        sleep 2
+
+        wait_for(
+          a_request(:post, endpoint).
+          with(body: /"message":"active_job error"/)
+        ).to have_been_made.twice
+      end
+    end
+  end
+
+  describe "Resque workers" do
+    it "reports exceptions occurring in Resque workers" do
+      with_resque { get '/resque' }
+
+      wait_for_a_request_with_body(
+        /"message":"resque\serror".*"params":{.*
+         "class":"BingoWorker","args":\["bango","bongo"\].*}/x
+      )
+    end
+  end
+
+  describe "DelayedJob jobs" do
+    it "reports exceptions occurring in DelayedJob jobs" do
+      get '/delayed_job'
+      sleep 2
+
+      wait_for_a_request_with_body(
+        %r("message":"delayed_job\serror".*"params":{.*
+           "handler":"---\s!ruby/struct:BangoJob\\nbingo:\s
+                     bingo\\nbongo:\sbongo\\n".*})x
+      )
+
+      # Two requests are performed during this example. We care only about one.
+      # Sleep guarantees that we let the unimportant request occur here and not
+      # elsewhere.
+      sleep 2
+    end
+  end
+end

data/spec/integration/rails/rake_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper'
+
+RSpec.describe "Rake integration" do
+  let(:endpoint) do
+    'https://airbrake.io/api/v3/projects/113743/notices?key=fd04e13d806a90f96614ad8e529b2822'
+  end
+
+  def wait_for_a_request_with_body(body)
+    wait_for(a_request(:post, endpoint).with(body: body)).to have_been_made.once
+  end
+
+  def expect_no_requests_with_body(body)
+    sleep 1
+    expect(a_request(:post, endpoint).with(body: body)).not_to have_been_made
+  end
+
+  before do
+    Rails.application.load_tasks
+    stub_request(:post, endpoint).to_return(status: 201, body: '{}')
+    expect { faulty_task.invoke }.to raise_error(AirbrakeTestError)
+  end
+
+  after do
+    # Rake ensures that each task is executed only once per session. For testing
+    # purposes, we run the task multiple times.
+    faulty_task.reenable
+  end
+
+  describe "a task with maximum information, which raises an exception" do
+    let(:faulty_task) { Rake::Task['bingo:bango'] }
+
+    it "sends the exception to Airbrake" do
+      wait_for_a_request_with_body(/"errors":\[{"type":"AirbrakeTestError"/)
+    end
+
+    describe "contains the context payload, which" do
+      it "includes correct component" do
+        wait_for_a_request_with_body(/"context":{.*"component":"rake".*}/)
+      end
+
+      it "includes correct action" do
+        wait_for_a_request_with_body(
+          /"context":{.*"action":"bingo:bango".*/
+        )
+      end
+    end
+
+    describe "contains the params payload, which" do
+      it "includes a task name" do
+        wait_for_a_request_with_body(
+          /"params":{.*"rake_task":{.*"name":"bingo:bango".*}.*}/
+        )
+      end
+
+      it "includes a timestamp" do
+        wait_for_a_request_with_body(
+          /"params":{.*"rake_task":{.*"timestamp":"201\d\-\d\d-\d\d.+".*}.*}/
+        )
+      end
+
+      it "includes investigation" do
+        # rubocop:disable Metrics/LineLength
+        wait_for_a_request_with_body(
+          /"params":{.*"rake_task":{.*"investigation":".+Investigating bingo:bango.+".*}.*}/
+        )
+        # rubocop:enable Metrics/LineLength
+      end
+
+      it "includes full comment" do
+        wait_for_a_request_with_body(
+          /"params":{.*"rake_task":{.*"full_comment":"Dummy description".*}.*}/
+        )
+      end
+
+      it "includes arg names" do
+        wait_for_a_request_with_body(
+          /"params":{.*"rake_task":{.*"arg_names":\["dummy_arg"\].*}.*}/
+        )
+      end
+
+      it "includes arg description" do
+        wait_for_a_request_with_body(
+          /"params":{.*"rake_task":{.*"arg_description":"\[dummy_arg\]".*}.*}/
+        )
+      end
+
+      it "includes locations" do
+        # rubocop:disable Metrics/LineLength
+        wait_for_a_request_with_body(
+          %r("params":{.*"rake_task":{.*"locations":\[".+spec/apps/rails/dummy_task.rake:\d+:in.+"\].*}.*})
+        )
+        # rubocop:enable Metrics/LineLength
+      end
+
+      it "includes sources" do
+        wait_for_a_request_with_body(
+          /"params":{.*"rake_task":{.*"sources":\["environment"\].*}.*}/
+        )
+      end
+
+      it "includes prerequisite tasks" do
+        # rubocop:disable Metrics/LineLength
+        wait_for_a_request_with_body(
+          /"params":{.*"rake_task":{.*"prerequisite_tasks":\[{"name":"bingo:environment".+\].*}.*}/
+        )
+        # rubocop:enable Metrics/LineLength
+      end
+
+      it "includes argv info" do
+        wait_for_a_request_with_body(
+          %r("params":{.*"argv":"--pattern spec/integration/rails/\*_spec.rb".*})
+        )
+      end
+
+      it "includes #execute args" do
+        wait_for_a_request_with_body(
+          /"params":{.*"execute_args":\[\].*}/
+        )
+      end
+    end
+  end
+
+  describe "a task with minimum information, which raises an exception" do
+    let(:faulty_task) { Rake::Task['bingo:bongo'] }
+
+    describe "doesn't contain in the params payload" do
+      it "full comment" do
+        expect_no_requests_with_body(
+          /"params":{.*"rake_task":{.*"full_comment":"Dummy description".*}.*}/
+        )
+      end
+
+      it "arg names" do
+        expect_no_requests_with_body(
+          /"params":{.*"rake_task":{.*"arg_names":\["dummy_arg"\].*}.*}/
+        )
+      end
+
+      it "arg description" do
+        expect_no_requests_with_body(
+          /"params":{.*"rake_task":{.*"arg_description":"\[dummy_arg\]".*}.*}/
+        )
+      end
+
+      it "sources" do
+        expect_no_requests_with_body(
+          /"params":{.*"rake_task":{.*"sources":\["environment"\].*}.*}/
+        )
+      end
+
+      it "prerequisite tasks" do
+        # rubocop:disable Metrics/LineLength
+        expect_no_requests_with_body(
+          /"params":{.*"rake_task":{.*"prerequisite_tasks":\[{"name":"bingo:environment".+\].*}.*}/
+        )
+        # rubocop:enable Metrics/LineLength
+      end
+    end
+  end
+end

data/spec/integration/shared_examples/rack_examples.rb

@@ -0,0 +1,106 @@
+RSpec.shared_examples 'rack examples' do
+  include Warden::Test::Helpers
+
+  after { Warden.test_reset! }
+
+  let(:endpoint) do
+    'https://airbrake.io/api/v3/projects/113743/notices?key=fd04e13d806a90f96614ad8e529b2822'
+  end
+
+  def wait_for_a_request_with_body(body)
+    wait_for(a_request(:post, endpoint).with(body: body)).to have_been_made.once
+  end
+
+  before do
+    stub_request(:post, endpoint).to_return(status: 201, body: '{}')
+  end
+
+  describe "application routes" do
+    describe "/index" do
+      it "successfully returns 200 and body" do
+        get '/'
+
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('Hello from index')
+
+        wait_for(a_request(:post, endpoint)).not_to have_been_made
+      end
+    end
+
+    describe "/crash" do
+      it "returns 500 and sends a notice to Airbrake" do
+        get '/crash'
+
+        expect(last_response.status).to eq(500)
+        wait_for_a_request_with_body(/"errors":\[{"type":"AirbrakeTestError"/)
+      end
+    end
+  end
+
+  describe "context payload" do
+    context "when the user is present" do
+      let(:common_user_params) do
+        { id: 1, email: 'qa@example.com', username: 'qa-dept' }
+      end
+
+      before do
+        login_as(OpenStruct.new(user_params))
+        get '/crash'
+      end
+
+      context "when the user has first and last names" do
+        let(:user_params) do
+          common_user_params.merge(first_name: 'Bingo', last_name: 'Bongo')
+        end
+
+        it "reports the user's first and last names" do
+          wait_for_a_request_with_body(/
+            "context":{.*
+              "user":{
+                "id":"1",
+                "name":"Bingo\sBongo",
+                "username":"qa-dept",
+                "email":"qa@example.com"}
+          /x)
+        end
+      end
+
+      context "when the user has only name" do
+        let(:user_params) do
+          common_user_params.merge(name: 'Bingo')
+        end
+
+        it "reports the user's name" do
+          wait_for_a_request_with_body(/
+            "context":{.*
+              "user":{
+                "id":"1",
+                "name":"Bingo",
+                "username":"qa-dept",
+                "email":"qa@example.com"}
+          /x)
+        end
+      end
+    end
+
+    context "when additional parameters present" do
+      before do
+        get '/crash', nil, 'HTTP_USER_AGENT' => 'Bot'
+      end
+
+      it "features url" do
+        wait_for_a_request_with_body(
+          %r("context":{.*"url":"http://example\.org/crash".*})
+        )
+      end
+
+      it "features hostname" do
+        wait_for_a_request_with_body(/"context":{.*"hostname":".+".*}/)
+      end
+
+      it "features userAgent" do
+        wait_for_a_request_with_body(/"context":{.*"userAgent":"Bot".*}/)
+      end
+    end
+  end
+end

data/spec/integration/sinatra/sinatra_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+require 'integration/shared_examples/rack_examples'
+
+RSpec.describe "Sinatra integration specs" do
+  let(:app) { DummyApp }
+
+  include_examples 'rack examples'
+
+  describe "context payload" do
+    it "includes version" do
+      get '/crash'
+      wait_for_a_request_with_body(/"context":{.*"version":"1.2.3 Sinatra/)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,127 @@
+# Gems from the gemspec.
+require 'webmock'
+require 'webmock/rspec'
+require 'rspec/wait'
+require 'pry'
+require 'rack'
+require 'rack/test'
+require 'rake'
+
+if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.0')
+  require 'sidekiq'
+  require 'sidekiq/cli'
+end
+
+require 'airbrake'
+require 'airbrake/rake/tasks'
+
+# Load integration tests only when they're run through appraisals.
+if ENV['APPRAISAL_INITIALIZED']
+  # Gems from appraisals that every application uses.
+  require 'warden'
+
+  # Load a Rails app or skip.
+  begin
+    ENV['RAILS_ENV'] = 'test'
+
+    if RUBY_ENGINE == 'jruby'
+      require 'activerecord-jdbcsqlite3-adapter'
+    else
+      require 'sqlite3'
+    end
+
+    require 'rails'
+
+    rails_vsn = Gem::Version.new(Rails.version)
+
+    if rails_vsn <= Gem::Version.new('4.2')
+      ENV['DATABASE_URL'] = 'sqlite3:///:memory:'
+    else
+      ENV['DATABASE_URL'] = 'sqlite3::memory:'
+    end
+
+    require 'action_controller'
+    require 'action_view'
+    require 'action_view/testing/resolvers'
+    require 'active_record/railtie'
+    if rails_vsn >= Gem::Version.new('4.2')
+      require 'active_job'
+
+      # Silence logger.
+      ActiveJob::Base.logger.level = 99
+    end
+
+    require 'resque'
+    require 'resque_spec'
+    require 'airbrake/resque/failure'
+    Resque::Failure.backend = Resque::Failure::Airbrake
+
+    require 'delayed_job'
+    require 'delayed_job_active_record'
+    require 'airbrake/delayed_job/plugin'
+    Delayed::Worker.delay_jobs = false
+
+    require 'airbrake/rails/railtie'
+
+    load 'apps/rails/dummy_task.rake'
+    require 'apps/rails/dummy_app'
+  rescue LoadError
+    puts '** Skipped Rails specs'
+  end
+
+  # Load a Sinatra app or skip.
+  begin
+    # Resque depends on Sinatra, so when we launch Rails specs, we also
+    # accidentally load Sinatra.
+    raise LoadError if defined?(Resque)
+
+    require 'sinatra'
+    require 'apps/sinatra/dummy_app'
+  rescue LoadError
+    puts '** Skipped Sinatra specs'
+  end
+
+  # Load a Rack app or skip.
+  begin
+    require 'apps/rack/dummy_app'
+  rescue LoadError
+    puts '** Skipped Rack specs'
+  end
+end
+
+RSpec.configure do |c|
+  c.order = 'random'
+  c.color = true
+  c.disable_monkey_patching!
+  c.wait_timeout = 3
+
+  c.include Rack::Test::Methods
+end
+
+Airbrake.configure do |c|
+  c.project_id = 113743
+  c.project_key = 'fd04e13d806a90f96614ad8e529b2822'
+  c.logger = Logger.new('/dev/null')
+  c.app_version = '1.2.3'
+  c.workers = 5
+end
+
+# Make sure tests that use async requests fail.
+Thread.abort_on_exception = true
+
+AirbrakeTestError = Class.new(StandardError)
+
+# Print header with versions information. This simplifies debugging of build
+# failures on CircleCI.
+versions = <<EOS
+#{'#' * 80}
+# RUBY_VERSION: #{RUBY_VERSION}
+# RUBY_ENGINE: #{RUBY_ENGINE}
+EOS
+versions << "# JRUBY_VERSION #{JRUBY_VERSION}\n" if defined?(JRUBY_VERSION)
+versions << "# Rails version: #{Rails.version}\n" if defined?(Rails)
+versions << "# Sinatra version: #{Sinatra::VERSION}\n" if defined?(Sinatra)
+versions << "# Rack release: #{Rack.release}\n"
+versions << '#' * 80
+
+puts versions

data/spec/unit/rack/middleware_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+RSpec.describe Airbrake::Rack::Middleware do
+  let(:app) do
+    proc { |env| [200, env, 'Bingo bango content'] }
+  end
+
+  let(:faulty_app) do
+    proc { raise AirbrakeTestError }
+  end
+
+  let(:endpoint) do
+    'https://airbrake.io/api/v3/projects/113743/notices?key=fd04e13d806a90f96614ad8e529b2822'
+  end
+
+  let(:middleware) { described_class.new(app) }
+
+  def env_for(url, opts = {})
+    Rack::MockRequest.env_for(url, opts)
+  end
+
+  def wait_for_a_request_with_body(body)
+    wait_for(a_request(:post, endpoint).with(body: body)).to have_been_made.once
+  end
+
+  before do
+    stub_request(:post, endpoint).to_return(status: 201, body: '{}')
+  end
+
+  describe "#call" do
+    context "when app raises an exception" do
+      it "rescues the exception, notifies Airbrake & re-raises it" do
+        expect { described_class.new(faulty_app).call(env_for('/')) }.
+          to raise_error(AirbrakeTestError)
+
+        wait_for_a_request_with_body(/"errors":\[{"type":"AirbrakeTestError"/)
+      end
+
+      it "sends framework version and name" do
+        expect { described_class.new(faulty_app).call(env_for('/bingo/bango')) }.
+          to raise_error(AirbrakeTestError)
+
+        wait_for_a_request_with_body(
+          %r("context":{.*"version":"1.2.3 (Rails|Sinatra|Rack\.version)/.+".+})
+        )
+      end
+    end
+
+    context "when app doesn't raise" do
+      context "and previous middleware stored an exception in env" do
+        shared_examples 'stored exception' do |type|
+          it "notifies on #{type}, but doesn't raise" do
+            env = env_for('/').merge(type => AirbrakeTestError.new)
+            described_class.new(app).call(env)
+
+            wait_for_a_request_with_body(/"errors":\[{"type":"AirbrakeTestError"/)
+          end
+        end
+
+        ['action_dispatch.exception', 'sinatra.error'].each do |type|
+          include_examples 'stored exception', type
+        end
+      end
+
+      it "doesn't notify Airbrake" do
+        described_class.new(app).call(env_for('/'))
+        sleep 1
+        expect(a_request(:post, endpoint)).not_to have_been_made
+      end
+    end
+
+    it "returns a response" do
+      response =  described_class.new(app).call(env_for('/'))
+
+      expect(response[0]).to eq(200)
+      expect(response[1]).to be_a(Hash)
+      expect(response[2]).to eq('Bingo bango content')
+    end
+  end
+end

data/spec/unit/rack/notice_builder_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+RSpec.describe Airbrake::Rack::NoticeBuilder do
+  describe "#build_notice" do
+    it "doesn't overwrite session with nil" do
+      notice_builder = described_class.new('rack.session' => nil)
+      notice = notice_builder.build_notice(AirbrakeTestError.new)
+
+      expect(notice[:session]).to eq({})
+    end
+
+    it "sets session if it is present" do
+      session = { a: 1, b: 2 }
+      notice_builder = described_class.new('rack.session' => session)
+      notice = notice_builder.build_notice(AirbrakeTestError.new)
+
+      expect(notice[:session]).to eq(session)
+    end
+
+    it "doesn't overwrite params with nil" do
+      notice_builder = described_class.new('action_dispatch.request.parameters' => nil)
+      notice = notice_builder.build_notice(AirbrakeTestError.new)
+
+      expect(notice[:session]).to eq({})
+    end
+
+    it "sets params if they're present" do
+      params = { a: 1, b: 2 }
+      notice_builder = described_class.new('action_dispatch.request.parameters' => params)
+      notice = notice_builder.build_notice(AirbrakeTestError.new)
+
+      expect(notice[:params]).to eq(params)
+    end
+  end
+end