airbrake 9.2.1 → 9.2.2

data/spec/integration/rails/rake_spec.rb

@@ -1,97 +0,0 @@
-RSpec.describe "Rake integration" do
-  let(:task) { Rake::Task['bingo:bango'] }
-
-  before { Rails.application.load_tasks }
-
-  after do
-    expect { task.invoke }.to raise_error(AirbrakeTestError)
-
-    # Rake ensures that each task is executed only once per session. For testing
-    # purposes, we run the task multiple times.
-    task.reenable
-  end
-
-  it "sends the exception to Airbrake" do
-    expect(Airbrake).to receive(:notify_sync)
-      .with(an_instance_of(Airbrake::Notice))
-  end
-
-  describe "contains the context payload, which" do
-    it "includes correct component" do
-      expect(Airbrake).to receive(:notify_sync)
-        .with(a_notice_with(%i[context component], 'rake'))
-    end
-
-    it "includes correct action" do
-      expect(Airbrake).to receive(:notify_sync)
-        .with(a_notice_with(%i[context action], 'bingo:bango'))
-    end
-  end
-
-  describe "contains the params payload, which" do
-    it "includes a task name" do
-      expect(Airbrake).to receive(:notify_sync)
-        .with(a_notice_with(%i[params rake_task name], 'bingo:bango'))
-    end
-
-    it "includes a timestamp" do
-      expected_notice = a_notice_with(
-        %i[params rake_task timestamp], /20\d\d\-\d\d-\d\d.+/
-      )
-      expect(Airbrake).to receive(:notify_sync).with(expected_notice)
-    end
-
-    it "includes investigation" do
-      expected_notice = a_notice_with(
-        %i[params rake_task investigation], /Investigating bingo:bango/
-      )
-      expect(Airbrake).to receive(:notify_sync).with(expected_notice)
-    end
-
-    it "includes full comment" do
-      expect(Airbrake).to receive(:notify_sync)
-        .with(a_notice_with(%i[params rake_task full_comment], 'Dummy description'))
-    end
-
-    it "includes arg names" do
-      expect(Airbrake).to receive(:notify_sync)
-        .with(a_notice_with(%i[params rake_task arg_names], [:dummy_arg]))
-    end
-
-    it "includes arg description" do
-      expect(Airbrake).to receive(:notify_sync)
-        .with(a_notice_with(%i[params rake_task arg_description], '[dummy_arg]'))
-    end
-
-    it "includes locations" do
-      expect(Airbrake).to receive(:notify_sync) do |notice|
-        expect(notice[:params][:rake_task][:locations])
-          .to match(array_including(%r{spec/apps/rails/dummy_task.rake:\d+:in}))
-      end
-    end
-
-    it "includes sources" do
-      expect(Airbrake).to receive(:notify_sync)
-        .with(a_notice_with(%i[params rake_task sources], ['environment']))
-    end
-
-    it "includes prerequisite tasks" do
-      expect(Airbrake).to receive(:notify_sync) do |notice|
-        expect(notice[:params][:rake_task][:prerequisite_tasks])
-          .to match(array_including(hash_including(name: 'bingo:environment')))
-      end
-    end
-
-    it "includes argv info" do
-      expect(Airbrake).to receive(:notify_sync)
-        .with(a_notice_with(%i[params argv], %r{spec/integration/rails/.+_spec.rb}))
-    end
-
-    it "includes execute args" do
-      expect(Airbrake).to receive(:notify_sync) do |notice|
-        expect(notice[:params][:execute_args])
-          .to be_an_instance_of(Rake::TaskArguments)
-      end
-    end
-  end
-end

data/spec/integration/shared_examples/rack_examples.rb

@@ -1,110 +0,0 @@
-RSpec.shared_examples 'rack examples' do
-  include Warden::Test::Helpers
-
-  let(:endpoint) { 'https://api.airbrake.io/api/v3/projects/113743/notices' }
-
-  before do
-    stub_request(:post, endpoint).to_return(status: 200, body: '')
-    Airbrake::Config.instance.merge(performance_stats: false)
-  end
-
-  after { Warden.test_reset! }
-
-  describe "application routes" do
-    describe "/index" do
-      it "successfully returns 200 and body" do
-        expect(Airbrake).not_to receive(:notify)
-
-        get '/'
-
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('Hello from index')
-      end
-    end
-
-    describe "/crash" do
-      it "returns 500 and sends a notice to Airbrake" do
-        expect(Airbrake).to receive(:notify).with(
-          an_instance_of(Airbrake::Notice)
-        ) do |notice|
-          expect(notice[:errors].first[:type]).to eq('AirbrakeTestError')
-        end
-
-        get '/crash'
-      end
-    end
-  end
-
-  describe "user payload" do
-    let(:user) do
-      OpenStruct.new(
-        id: 1,
-        email: 'qa@example.com',
-        username: 'qa-dept',
-        first_name: 'John',
-        last_name: 'Doe'
-      )
-    end
-
-    before { login_as(user) }
-
-    it "reports user info" do
-      get '/crash'
-      sleep 2
-
-      body = /
-        "context":{.*
-          "user":{
-            "id":"1",
-            "name":"John\sDoe",
-            "username":"qa-dept",
-            "email":"qa@example.com"}
-      /x
-      expect(a_request(:post, endpoint).with(body: body))
-        .to have_been_made.at_least_once
-    end
-  end
-
-  context "when additional parameters are present" do
-    before do
-      get '/crash', nil, 'HTTP_USER_AGENT' => 'Bot', 'HTTP_REFERER' => 'bingo.com'
-      sleep 2
-    end
-
-    it "contains url" do
-      body = %r("context":{.*"url":"http://example\.org/crash".*})
-      expect(a_request(:post, endpoint).with(body: body))
-        .to have_been_made.at_least_once
-    end
-
-    it "contains hostname" do
-      body = /"context":{.*"hostname":".+".*}/
-      expect(a_request(:post, endpoint).with(body: body))
-        .to have_been_made.at_least_once
-    end
-
-    it "contains userAgent" do
-      body = /"context":{.*"userAgent":"Bot".*}/
-      expect(a_request(:post, endpoint).with(body: body))
-        .to have_been_made.at_least_once
-    end
-
-    it "contains referer" do
-      body = /"context":{.*"referer":"bingo.com".*}/
-      expect(a_request(:post, endpoint).with(body: body))
-        .to have_been_made.at_least_once
-    end
-
-    it "contains HTTP headers" do
-      body = /"context":{.*"headers":{.*"CONTENT_LENGTH":"0".*}/
-      expect(a_request(:post, endpoint).with(body: body))
-        .to have_been_made.at_least_once
-    end
-
-    it "contains HTTP method" do
-      body = /"context":{.*"httpMethod":"GET".*}/
-      expect(a_request(:post, endpoint).with(body: body))
-        .to have_been_made.at_least_once
-    end
-  end
-end

data/spec/integration/sinatra/sinatra_spec.rb

@@ -1,30 +0,0 @@
-require 'sinatra'
-
-require 'apps/sinatra/sinatra_test_app'
-require 'integration/shared_examples/rack_examples'
-
-RSpec.describe "Sinatra integration specs" do
-  let(:app) { SinatraTestApp }
-
-  include_examples 'rack examples'
-
-  describe "context payload" do
-    before { stub_request(:post, endpoint).to_return(status: 200, body: '') }
-
-    it "includes version" do
-      get '/crash'
-      sleep 2
-
-      body = /"context":{.*"versions":{"sinatra":"\d\./
-      expect(a_request(:post, endpoint).with(body: body)).to have_been_made
-    end
-
-    it "includes route" do
-      get '/crash'
-      sleep 2
-
-      body = %r("context":{.*"route":"\/crash".*})
-      expect(a_request(:post, endpoint).with(body: body)).to have_been_made
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,105 +0,0 @@
-# Gems from the gemspec.
-require 'webmock'
-require 'webmock/rspec'
-require 'rspec/wait'
-require 'rack'
-require 'rack/test'
-require 'rake'
-require 'pry'
-
-require 'airbrake'
-require 'airbrake/rake/tasks'
-
-Dir[
-  File.expand_path(File.join(File.dirname(__FILE__), 'support', '**', '*.rb'))
-].each do |file|
-  require file
-end
-
-Airbrake.configure do |c|
-  c.project_id = 113743
-  c.project_key = 'fd04e13d806a90f96614ad8e529b2822'
-  c.app_version = '1.2.3'
-  c.workers = 5
-  c.performance_stats = true
-  c.performance_stats_flush_period = 1
-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
-
-# 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)
-
-    ENV['DATABASE_URL'] = if rails_vsn <= Gem::Version.new('4.2')
-                            'sqlite3:///:memory:'
-                          else
-                            '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'
-    Resque::Failure.backend = Resque::Failure::Airbrake
-
-    require 'delayed_job'
-    require 'delayed_job_active_record'
-    require 'airbrake/delayed_job'
-    Delayed::Worker.delay_jobs = false
-
-    require 'airbrake/rails'
-
-    load 'apps/rails/dummy_task.rake'
-    require 'apps/rails/dummy_app'
-  rescue LoadError
-    puts '** Skipped Rails specs'
-  end
-
-  # Load a Rack app or skip.
-  begin
-    # Don't load the Rack app since we want to test Sinatra if it's loaded.
-    raise LoadError if defined?(Sinatra)
-
-    require 'apps/rack/dummy_app'
-  rescue LoadError
-    puts '** Skipped Rack specs'
-  end
-end
-
-# Make sure tests that use async requests fail.
-Thread.abort_on_exception = true
-
-AirbrakeTestError = Class.new(StandardError)

data/spec/support/matchers/a_notice_with.rb

@@ -1,29 +0,0 @@
-RSpec::Matchers.define :a_notice_with do |access_keys, expected_val|
-  match do |notice|
-    payload = notice[access_keys.shift]
-    break(false) unless payload
-
-    actual_val =
-      if payload.respond_to?(:dig)
-        payload.dig(*access_keys)
-      else
-        dig_pre_23(payload, *access_keys)
-      end
-
-    if expected_val.is_a?(Regexp)
-      actual_val =~ expected_val
-    else
-      actual_val == expected_val
-    end
-  end
-
-  # TODO: Use the normal "dig" version once we support Ruby 2.3 and above.
-  def dig_pre_23(hash, *keys)
-    v = hash[keys.shift]
-    while keys.any?
-      return unless v.is_a?(Hash)
-      v = v[keys.shift]
-    end
-    v
-  end
-end

data/spec/unit/logger_spec.rb

@@ -1,125 +0,0 @@
-RSpec.describe Airbrake::AirbrakeLogger do
-  let(:project_id) { 113743 }
-  let(:project_key) { 'fd04e13d806a90f96614ad8e529b2822' }
-  let(:endpoint) { "https://api.airbrake.io/api/v3/projects/#{project_id}/notices" }
-  let(:airbrake) { Airbrake::NoticeNotifier.new }
-  let(:logger) { Logger.new('/dev/null') }
-
-  subject { described_class.new(logger) }
-
-  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 "#airbrake_notifier" do
-    it "installs Airbrake notifier" do
-      notifier_id = airbrake.object_id
-      expect(subject.airbrake_notifier.object_id).not_to eq(notifier_id)
-
-      subject.airbrake_notifier = airbrake
-      expect(subject.airbrake_notifier.object_id).to eq(notifier_id)
-    end
-
-    context "when Airbrake is installed explicitly" do
-      let(:out) { StringIO.new }
-      let(:logger) { Logger.new(out) }
-
-      before do
-        subject.airbrake_notifier = airbrake
-      end
-
-      it "both logs and notifies" do
-        msg = 'bingo'
-        subject.fatal(msg)
-
-        wait_for_a_request_with_body(/"message":"#{msg}"/)
-        expect(out.string).to match(/FATAL -- : #{msg}/)
-      end
-
-      it "sets the correct severity" do
-        subject.fatal('bango')
-        wait_for_a_request_with_body(/"context":{.*"severity":"critical".*}/)
-      end
-
-      it "sets the correct component" do
-        subject.fatal('bingo')
-        wait_for_a_request_with_body(/"component":"log"/)
-      end
-
-      it "strips out internal logger frames" do
-        subject.fatal('bongo')
-
-        wait_for(
-          a_request(:post, endpoint)
-            .with(body: %r{"file":".+/logger.rb"})
-        ).not_to have_been_made
-        wait_for(a_request(:post, endpoint)).to have_been_made.once
-      end
-    end
-
-    context "when Airbrake is not installed" do
-      it "only logs, never notifies" do
-        out = StringIO.new
-        l = described_class.new(Logger.new(out))
-        l.airbrake_notifier = nil
-        msg = 'bango'
-
-        l.fatal(msg)
-
-        wait_for(a_request(:post, endpoint)).not_to have_been_made
-        expect(out.string).to match('FATAL -- : bango')
-      end
-    end
-  end
-
-  describe "#airbrake_level" do
-    context "when not set" do
-      it "defaults to Logger::WARN" do
-        expect(subject.airbrake_level).to eq(Logger::WARN)
-      end
-    end
-
-    context "when set" do
-      before do
-        subject.airbrake_level = Logger::FATAL
-      end
-
-      it "does not notify below the specified level" do
-        subject.error('bingo')
-        wait_for(a_request(:post, endpoint)).not_to have_been_made
-      end
-
-      it "notifies in the current or above level" do
-        subject.fatal('bingo')
-        wait_for(a_request(:post, endpoint)).to have_been_made
-      end
-
-      it "raises error when below the allowed level" do
-        expect do
-          subject.airbrake_level = Logger::DEBUG
-        end.to raise_error(/severity level \d is not allowed/)
-      end
-    end
-  end
-
-  describe "#level=" do
-    it "sets logger level" do
-      subject.level = Logger::FATAL
-      expect(subject.level).to eq(Logger::FATAL)
-    end
-
-    it "sets airbrake level" do
-      subject.level = Logger::FATAL
-      expect(subject.airbrake_level).to eq(Logger::FATAL)
-    end
-
-    it "normalizes airbrake logger level when provided level is below WARN" do
-      subject.level = Logger::DEBUG
-      expect(subject.airbrake_level).to eq(Logger::WARN)
-    end
-  end
-end