airbrake 9.2.1 → 9.2.2

data/spec/unit/rails/action_controller_performance_breakdown_subscriber_spec.rb

@@ -1,63 +0,0 @@
-require 'airbrake/rails/action_controller_performance_breakdown_subscriber'
-
-RSpec.describe Airbrake::Rails::ActionControllerPerformanceBreakdownSubscriber do
-  let(:app) { double(Airbrake::Rails::App) }
-  let(:event) { double(Airbrake::Rails::Event) }
-
-  before do
-    allow(Airbrake::Rails::Event).to receive(:new).and_return(event)
-  end
-
-  after { Airbrake::Rack::RequestStore.clear }
-
-  context "when routes are not set in the request store" do
-    before { Airbrake::Rack::RequestStore[:routes] = nil }
-
-    it "doesn't send performance breakdown info" do
-      expect(Airbrake).not_to receive(:notify_performance_breakdown)
-      subject.call([])
-    end
-  end
-
-  context "when there are no routes in the request store" do
-    before { Airbrake::Rack::RequestStore[:routes] = {} }
-
-    it "doesn't send performance breakdown info" do
-      expect(Airbrake).not_to receive(:notify_performance_breakdown)
-      subject.call([])
-    end
-  end
-
-  context "when there's a route in the request store" do
-    before do
-      expect(event).to receive(:groups).and_return(db: 0.5, view: 0.5)
-      expect(event).to receive(:method).and_return('GET')
-      expect(event).to receive(:response_type).and_return(:html)
-      expect(event).to receive(:time).and_return(Time.new)
-    end
-
-    context "when request store routes have extra groups" do
-      before do
-        Airbrake::Rack::RequestStore[:routes] = {
-          '/test-route' => {
-            method: 'GET',
-            response_type: :html,
-            groups: { http: 0.5 }
-          }
-        }
-      end
-
-      it "sends performance info to Airbrake with extra groups" do
-        expect(Airbrake).to receive(:notify_performance_breakdown).with(
-          hash_including(
-            route: '/test-route',
-            method: 'GET',
-            response_type: :html,
-            groups: { db: 0.5, view: 0.5, http: 0.5 }
-          )
-        )
-        subject.call([])
-      end
-    end
-  end
-end

data/spec/unit/rails/action_controller_route_subscriber_spec.rb

@@ -1,84 +0,0 @@
-require 'ostruct'
-require 'airbrake/rails/action_controller_route_subscriber'
-
-RSpec.describe Airbrake::Rails::ActionControllerRouteSubscriber do
-  describe "#call" do
-    let(:app) { double(Airbrake::Rails::App) }
-    let(:event) { double(Airbrake::Rails::Event) }
-
-    let(:event_params) do
-      [
-        'start_processing.action_controller',
-        Time.new,
-        Time.new,
-        '123',
-        { method: 'HEAD', path: '/crash' }
-      ]
-    end
-
-    before do
-      allow(Airbrake::Rails::App).to receive(:new).and_return(app)
-      allow(Airbrake::Rails::Event).to receive(:new).and_return(event)
-    end
-
-    context "when request store has the :routes key" do
-      let(:routes) do
-        [Airbrake::Rails::App::Route.new('/crash', 'DummyController', 'crash')]
-      end
-
-      before do
-        allow(app).to receive(:routes).and_return(routes)
-        allow(event).to receive(:params).and_return(params)
-        allow(event).to receive(:method).and_return('HEAD')
-        allow(event).to receive(:response_type).and_return(:html)
-
-        Airbrake::Rack::RequestStore[:routes] = {}
-      end
-
-      after { Airbrake::Rack::RequestStore.clear }
-
-      context "and when the route can be found" do
-        let(:params) do
-          OpenStruct.new(controller: 'DummyController', action: 'crash')
-        end
-
-        it "stores a route in the request store under :routes" do
-          subject.call(event_params)
-          expect(Airbrake::Rack::RequestStore[:routes])
-            .to eq('/crash' => { method: 'HEAD', response_type: :html, groups: {} })
-        end
-      end
-
-      context "and when the event controller can't be found" do
-        let(:params) do
-          OpenStruct.new(controller: 'BananaController', action: 'crash')
-        end
-
-        it "doesn't store any routes in the request store under :routes" do
-          subject.call(event_params)
-          expect(Airbrake::Rack::RequestStore[:routes]).to be_empty
-        end
-      end
-
-      context "and when the event action can't be found" do
-        let(:params) do
-          OpenStruct.new(controller: 'DummyController', action: 'banana')
-        end
-
-        it "doesn't store any routes in the request store under :routes" do
-          subject.call(event_params)
-          expect(Airbrake::Rack::RequestStore[:routes]).to be_empty
-        end
-      end
-    end
-
-    context "when request store doesn't have the :routes key" do
-      before { Airbrake::Rack::RequestStore.clear }
-
-      it "doesn't store any routes in the request store" do
-        subject.call(event_params)
-        expect(Airbrake::Rack::RequestStore[:routes]).to be_nil
-      end
-    end
-  end
-end

data/spec/unit/rails/active_record_subscriber_spec.rb

@@ -1,70 +0,0 @@
-require 'airbrake/rails/active_record_subscriber'
-
-RSpec.describe Airbrake::Rails::ActiveRecordSubscriber do
-  after { Airbrake::Rack::RequestStore.clear }
-
-  describe "#call" do
-    let(:event) { double(Airbrake::Rails::Event) }
-
-    before do
-      allow(Airbrake::Rails::Event).to receive(:new).and_return(event)
-    end
-
-    context "when there are no routes in the request store" do
-      it "doesn't notify requests" do
-        expect(Airbrake).not_to receive(:notify_query)
-        subject.call([])
-      end
-    end
-
-    context "when there's a route in the request store" do
-      before do
-        Airbrake::Rack::RequestStore[:routes] = {
-          '/test-route' => { method: 'GET', response_type: :html }
-        }
-
-        allow(event).to receive(:sql).and_return('SELECT * FROM bananas')
-        allow(event).to receive(:time).and_return(Time.now)
-        allow(event).to receive(:end).and_return(Time.now)
-        allow(Airbrake::Rails::BacktraceCleaner).to receive(:clean).and_return(
-          "/lib/pry/cli.rb:117:in `start'"
-        )
-      end
-
-      it "sends query info to Airbrake" do
-        expect(Airbrake).to receive(:notify_query).with(
-          hash_including(
-            method: 'GET',
-            route: '/test-route',
-            query: 'SELECT * FROM bananas',
-            func: 'start',
-            line: 117,
-            file: '/lib/pry/cli.rb'
-          )
-        )
-        subject.call([])
-      end
-
-      context "and when backtrace couldn't be parsed" do
-        before do
-          allow(Airbrake::Rails::BacktraceCleaner)
-            .to receive(:clean).and_return([])
-        end
-
-        it "sends empty func/file/line to Airbrake" do
-          expect(Airbrake).to receive(:notify_query).with(
-            hash_including(
-              method: 'GET',
-              route: '/test-route',
-              query: 'SELECT * FROM bananas',
-              func: nil,
-              line: nil,
-              file: nil
-            )
-          )
-          subject.call([])
-        end
-      end
-    end
-  end
-end

data/spec/unit/rails/excon_spec.rb

@@ -1,46 +0,0 @@
-require 'airbrake/rails/excon_subscriber'
-
-RSpec.describe Airbrake::Rails::Excon do
-  after { Airbrake::Rack::RequestStore.clear }
-
-  let(:event) { double(Airbrake::Rails::Event) }
-
-  before do
-    allow(Airbrake::Rails::Event).to receive(:new).and_return(event)
-  end
-
-  context "when there are no routes in the request store" do
-    it "doesn't notify requests" do
-      expect(Airbrake).not_to receive(:notify_performance_breakdown)
-      subject.call([])
-    end
-  end
-
-  context "when there's a route in the request store" do
-    let(:route) { Airbrake::Rack::RequestStore[:routes]['/test-route'] }
-
-    before do
-      Airbrake::Rack::RequestStore[:routes] = {
-        '/test-route' => { groups: {} }
-      }
-
-      expect(event).to receive(:duration).and_return(0.1)
-    end
-
-    it "sets http group value of that route" do
-      subject.call([])
-      expect(route[:groups][:http]).to eq(0.1)
-    end
-
-    context "and when the subscriber is called multiple times" do
-      before { expect(event).to receive(:duration).and_return(0.1) }
-
-      it "increments http group value of that route" do
-        subject.call([])
-        subject.call([])
-
-        expect(route[:groups][:http]).to eq(0.2)
-      end
-    end
-  end
-end

data/spec/unit/rake/tasks_spec.rb

@@ -1,70 +0,0 @@
-RSpec.describe "airbrake/rake/tasks" do
-  let(:endpoint) do
-    'https://api.airbrake.io/api/v4/projects/113743/deploys'
-  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: '{}')
-    allow(STDOUT).to receive(:puts).and_return(nil)
-  end
-
-  describe "airbrake:deploy" do
-    let(:task) { Rake::Task['airbrake:deploy'] }
-
-    after { task.reenable }
-
-    shared_examples 'deploy payload' do |key, val|
-      it "sends #{key}" do
-        ENV[key.upcase] = val
-        task.invoke
-
-        wait_for_a_request_with_body(/{.*"#{key}":"#{val}".*}/)
-        ENV[key.upcase] = nil
-      end
-    end
-
-    [%w[environment production],
-     %w[username john],
-     %w[revision 123abcdef],
-     %w[repository https://github.com/airbrake/airbrake'],
-     %w[version v2.0]].each do |(key, val)|
-      include_examples 'deploy payload', key, val
-    end
-
-    context "when Airbrake is not configured" do
-      let(:deploy_endpoint) { 'https://api.airbrake.io/api/v3/projects/113743/notices' }
-
-      before do
-        stub_request(:post, deploy_endpoint)
-        expect(Airbrake).to receive(:configured?).and_return(false)
-      end
-
-      it "raises error" do
-        expect { task.invoke }
-          .to raise_error(Airbrake::Error, 'airbrake-ruby is not configured')
-      end
-    end
-  end
-
-  describe "airbrake:install_heroku_deploy_hook" do
-    let(:task) { Rake::Task['airbrake:install_heroku_deploy_hook'] }
-
-    after { task.reenable }
-
-    let(:airbrake_vars) { "AIRBRAKE_PROJECT_ID=1\nAIRBRAKE_API_KEY=2\nRAILS_ENV=3\n" }
-    let(:silenced_stdout) { File.new(File::NULL, 'w') }
-
-    describe "parsing environment variables" do
-      it "does not raise when an env variable value contains '='" do
-        heroku_config = airbrake_vars + "URL=https://airbrake.io/docs?key=11\n"
-        expect(Bundler).to receive(:with_clean_env).twice.and_return(heroku_config)
-
-        task.invoke
-      end
-    end
-  end
-end

data/spec/unit/shoryuken_spec.rb

@@ -1,55 +0,0 @@
-require 'airbrake/shoryuken'
-
-RSpec.describe Airbrake::Shoryuken::ErrorHandler do
-  let(:error) { AirbrakeTestError.new('shoryuken error') }
-  let(:body) { { message: 'message' } }
-  let(:queue) { 'foo_queue' }
-
-  let(:worker) do
-    Class.new do
-      def self.to_s
-        'FooWorker'
-      end
-    end.new
-  end
-
-  let(:endpoint) { 'https://api.airbrake.io/api/v3/projects/113743/notices' }
-
-  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
-
-  context "when there's an error" do
-    it 'notifies' do
-      expect do
-        subject.call(worker, queue, nil, body) { raise error }
-      end.to raise_error(error)
-
-      wait_for_a_request_with_body(/"message":"shoryuken\serror"/)
-      wait_for_a_request_with_body(/"params":{.*"queue":"#{queue}"/)
-      wait_for_a_request_with_body(/"params":{.*"body":\{"message":"message"\}/)
-      wait_for_a_request_with_body(/"component":"shoryuken","action":"FooWorker"/)
-    end
-
-    context "and it's a batch" do
-      let(:body) { [{ message1: 'message1' }, { message2: 'message2' }] }
-
-      it 'notifies' do
-        expect do
-          subject.call(worker, queue, nil, body) { raise error }
-        end.to raise_error(error)
-
-        wait_for_a_request_with_body(/"message":"shoryuken\serror"/)
-        wait_for_a_request_with_body(/"params":{.*"queue":"#{queue}"/)
-        wait_for_a_request_with_body(
-          /"params":{.*"batch":\[\{"message1":"message1"\},\{"message2":"message2"\}\]/
-        )
-        wait_for_a_request_with_body(/"component":"shoryuken","action":"FooWorker"/)
-      end
-    end
-  end
-end

data/spec/unit/sidekiq/retryable_jobs_filter_spec.rb

@@ -1,36 +0,0 @@
-if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.2.2')
-  require 'sidekiq'
-  require 'sidekiq/cli'
-  require 'airbrake/sidekiq'
-
-  RSpec.describe "airbrake/sidekiq/retryable_jobs_filter" do
-    subject(:filter) { Airbrake::Sidekiq::RetryableJobsFilter.new }
-    def build_notice(job = nil)
-      Airbrake::Notice.new(StandardError.new, job: job)
-    end
-
-    it "does not ignore notices that are not from jobs" do
-      notice = build_notice
-      filter.call(notice)
-      expect(build_notice).to_not be_ignored
-    end
-
-    it "does not ignore notices from jobs that have retries disabled" do
-      notice = build_notice('retry' => false)
-      filter.call(notice)
-      expect(build_notice).to_not be_ignored
-    end
-
-    it "ignore notices from jobs that will be retried" do
-      notice = build_notice('retry' => true, 'retry_count' => 0)
-      filter.call(notice)
-      expect(notice).to be_ignored
-    end
-
-    it "does not ignore notices from jobs that will not be retried" do
-      notice = build_notice('retry' => 5, 'retry_count' => 5)
-      filter.call(notice)
-      expect(build_notice).to_not be_ignored
-    end
-  end
-end

data/spec/unit/sidekiq_spec.rb

@@ -1,33 +0,0 @@
-if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.2.2')
-  require 'sidekiq'
-  require 'sidekiq/cli'
-  require 'airbrake/sidekiq'
-
-  RSpec.describe "airbrake/sidekiq/error_handler" do
-    let(:endpoint) { 'https://api.airbrake.io/api/v3/projects/113743/notices' }
-
-    def wait_for_a_request_with_body(body)
-      wait_for(a_request(:post, endpoint).with(body: body)).to have_been_made.once
-    end
-
-    def call_handler
-      handler = Sidekiq.error_handlers.last
-      handler.call(
-        AirbrakeTestError.new('sidekiq error'),
-        'class' => 'HardSidekiqWorker', 'args' => %w[bango bongo]
-      )
-    end
-
-    before do
-      stub_request(:post, endpoint).to_return(status: 201, body: '{}')
-    end
-
-    it "sends a notice to Airbrake" do
-      expect(call_handler).to be_a(Airbrake::Promise)
-
-      wait_for_a_request_with_body(/"message":"sidekiq\serror"/)
-      wait_for_a_request_with_body(/"params":{.*"args":\["bango","bongo"\]/)
-      wait_for_a_request_with_body(/"component":"sidekiq","action":"HardSidekiqWorker"/)
-    end
-  end
-end