airbrake-ruby 5.1.1-java → 6.0.1-java

data/spec/remote_settings/callback_spec.rb

@@ -22,10 +22,13 @@ RSpec.describe Airbrake::RemoteSettings::Callback do
     end
 
     it "logs given data" do
-      expect(logger).to receive(:debug) do |&block|
+      allow(logger).to receive(:debug)
+
+      described_class.new(config).call(data)
+
+      expect(logger).to have_received(:debug) do |&block|
         expect(block.call).to match(/applying remote settings/)
       end
-      described_class.new(config).call(data)
     end
 
     context "when the config disables error notifications" do
@@ -34,6 +37,7 @@ RSpec.describe Airbrake::RemoteSettings::Callback do
         allow(data).to receive(:error_notifications?).and_return(true)
       end
 
+      # rubocop:disable RSpec/MultipleExpectations
       it "keeps the option disabled forever" do
         callback = described_class.new(config)
 
@@ -46,22 +50,29 @@ RSpec.describe Airbrake::RemoteSettings::Callback do
         callback.call(data)
         expect(config.error_notifications).to eq(false)
       end
+      # rubocop:enable RSpec/MultipleExpectations
     end
 
     context "when the config enables error notifications" do
       before { config.error_notifications = true }
 
+      # rubocop:disable RSpec/MultipleExpectations
       it "can disable and enable error notifications" do
-        expect(data).to receive(:error_notifications?).and_return(false)
-
         callback = described_class.new(config)
+
+        allow(data).to receive(:error_notifications?).and_return(false)
+
         callback.call(data)
         expect(config.error_notifications).to eq(false)
 
-        expect(data).to receive(:error_notifications?).and_return(true)
+        allow(data).to receive(:error_notifications?).and_return(true)
+
         callback.call(data)
         expect(config.error_notifications).to eq(true)
+
+        expect(data).to have_received(:error_notifications?).twice
       end
+      # rubocop:enable RSpec/MultipleExpectations
     end
 
     context "when the config disables performance_stats" do
@@ -70,6 +81,7 @@ RSpec.describe Airbrake::RemoteSettings::Callback do
         allow(data).to receive(:performance_stats?).and_return(true)
       end
 
+      # rubocop:disable RSpec/MultipleExpectations
       it "keeps the option disabled forever" do
         callback = described_class.new(config)
 
@@ -82,22 +94,29 @@ RSpec.describe Airbrake::RemoteSettings::Callback do
         callback.call(data)
         expect(config.performance_stats).to eq(false)
       end
+      # rubocop:enable RSpec/MultipleExpectations
     end
 
     context "when the config enables performance stats" do
       before { config.performance_stats = true }
 
+      # rubocop:disable RSpec/MultipleExpectations
       it "can disable and enable performance_stats" do
-        expect(data).to receive(:performance_stats?).and_return(false)
-
         callback = described_class.new(config)
+
+        allow(data).to receive(:performance_stats?).and_return(false)
+
         callback.call(data)
         expect(config.performance_stats).to eq(false)
 
-        expect(data).to receive(:performance_stats?).and_return(true)
+        allow(data).to receive(:performance_stats?).and_return(true)
+
         callback.call(data)
         expect(config.performance_stats).to eq(true)
+
+        expect(data).to have_received(:performance_stats?).twice
       end
+      # rubocop:enable RSpec/MultipleExpectations
     end
 
     context "when error_host returns a value" do

data/spec/remote_settings/settings_data_spec.rb

@@ -312,6 +312,8 @@ RSpec.describe Airbrake::RemoteSettings::SettingsData do
   end
 
   describe "#to_h" do
+    subject(:settings_data) { described_class.new(project_id, data) }
+
     let(:data) do
       {
         'poll_sec' => 123,
@@ -324,17 +326,15 @@ RSpec.describe Airbrake::RemoteSettings::SettingsData do
       }
     end
 
-    subject { described_class.new(project_id, data) }
-
     it "returns a hash representation of settings" do
       expect(described_class.new(project_id, data).to_h).to eq(data)
     end
 
     it "doesn't allow mutation of the original data object" do
-      hash = subject.to_h
+      hash = settings_data.to_h
       hash['poll_sec'] = 0
 
-      expect(subject.to_h).to eq(
+      expect(settings_data.to_h).to eq(
         'poll_sec' => 123,
         'settings' => [
           {

data/spec/remote_settings_spec.rb

@@ -37,19 +37,20 @@ RSpec.describe Airbrake::RemoteSettings do
 
       it "yields the config to the block twice" do
         block = proc {}
-        expect(block).to receive(:call).twice
+        allow(block).to receive(:call)
 
         remote_settings = described_class.poll(project_id, host, &block)
         sleep(0.2)
         remote_settings.stop_polling
 
         expect(stub).to have_been_requested.once
+        expect(block).to have_received(:call).twice
       end
     end
 
     context "when no errors are raised" do
       it "makes a request to AWS S3" do
-        remote_settings = described_class.poll(project_id, host) {}
+        remote_settings = described_class.poll(project_id, host) { anything }
         sleep(0.1)
         remote_settings.stop_polling
 
@@ -57,7 +58,7 @@ RSpec.describe Airbrake::RemoteSettings do
       end
 
       it "sends params about the environment with the request" do
-        remote_settings = described_class.poll(project_id, host) {}
+        remote_settings = described_class.poll(project_id, host) { anything }
         sleep(0.1)
         remote_settings.stop_polling
 
@@ -67,6 +68,7 @@ RSpec.describe Airbrake::RemoteSettings do
         expect(stub_with_query_params).to have_been_requested.at_least_once
       end
 
+      # rubocop:disable RSpec/MultipleExpectations
       it "fetches remote settings" do
         settings = nil
         remote_settings = described_class.poll(project_id, host) do |data|
@@ -79,11 +81,16 @@ RSpec.describe Airbrake::RemoteSettings do
         expect(settings.performance_stats?).to eq(false)
         expect(settings.interval).to eq(1)
       end
+      # rubocop:enable RSpec/MultipleExpectations
     end
 
     context "when an error is raised while making a HTTP request" do
+      let(:https) { instance_double(Net::HTTP) }
+
       before do
-        allow(Net::HTTP).to receive(:get_response).and_raise(StandardError)
+        allow(Net::HTTP).to receive(:new).and_return(https)
+        allow(https).to receive(:use_ssl=).with(true)
+        allow(https).to receive(:request).and_raise(StandardError)
       end
 
       it "doesn't fetch remote settings" do
@@ -136,11 +143,13 @@ RSpec.describe Airbrake::RemoteSettings do
       end
 
       it "logs error" do
-        expect(Airbrake::Loggable.instance).to receive(:error).with(body.to_json)
+        allow(Airbrake::Loggable.instance).to receive(:error)
 
-        remote_settings = described_class.poll(project_id, host) {}
+        remote_settings = described_class.poll(project_id, host) { anything }
         sleep(0.1)
         remote_settings.stop_polling
+
+        expect(Airbrake::Loggable.instance).to have_received(:error).with(body.to_json)
       end
     end
 
@@ -151,14 +160,18 @@ RSpec.describe Airbrake::RemoteSettings do
       end
 
       it "doesn't log errors" do
-        expect(Airbrake::Loggable.instance).not_to receive(:error)
+        allow(Airbrake::Loggable.instance).to receive(:error)
 
-        remote_settings = described_class.poll(project_id, host) {}
+        remote_settings = described_class.poll(project_id, host) { anything }
         sleep(0.1)
         remote_settings.stop_polling
+
+        expect(Airbrake::Loggable.instance).not_to have_received(:error)
+        expect(stub).to have_been_requested.once
       end
     end
 
+    # rubocop:disable RSpec/MultipleMemoizedHelpers
     context "when a config route is specified in the returned data" do
       let(:new_config_route) do
         '213/config/111/config.json'
@@ -174,7 +187,7 @@ RSpec.describe Airbrake::RemoteSettings do
       end
 
       it "makes the next request to the specified config route" do
-        remote_settings = described_class.poll(project_id, host) {}
+        remote_settings = described_class.poll(project_id, host) { anything }
         sleep(0.2)
 
         remote_settings.stop_polling
@@ -183,5 +196,6 @@ RSpec.describe Airbrake::RemoteSettings do
         expect(new_stub).to have_been_requested.once
       end
     end
+    # rubocop:enable RSpec/MultipleMemoizedHelpers
   end
 end

data/spec/response_spec.rb

@@ -2,24 +2,34 @@ RSpec.describe Airbrake::Response do
   describe ".parse" do
     [200, 201, 204].each do |code|
       context "when response code is #{code}" do
+        before do
+          allow(Airbrake::Loggable.instance).to receive(:debug)
+        end
+
         it "logs response body" do
-          expect(Airbrake::Loggable.instance).to receive(:debug).with(
+          described_class.parse(OpenStruct.new(code: code, body: '{}'))
+
+          expect(Airbrake::Loggable.instance).to have_received(:debug).with(
             /Airbrake::Response \(#{code}\): {}/,
           )
-          described_class.parse(OpenStruct.new(code: code, body: '{}'))
         end
       end
     end
 
     [400, 401, 403, 420].each do |code|
       context "when response code is #{code}" do
+        before do
+          allow(Airbrake::Loggable.instance).to receive(:error)
+        end
+
         it "logs response message" do
-          expect(Airbrake::Loggable.instance).to receive(:error).with(
-            /Airbrake: foo/,
-          )
           described_class.parse(
             OpenStruct.new(code: code, body: '{"message":"foo"}'),
           )
+
+          expect(Airbrake::Loggable.instance).to have_received(:error).with(
+            /Airbrake: foo/,
+          )
         end
       end
     end
@@ -27,11 +37,15 @@ RSpec.describe Airbrake::Response do
     context "when response code is 429" do
       let(:response) { OpenStruct.new(code: 429, body: '{"message":"rate limited"}') }
 
+      before do
+        allow(Airbrake::Loggable.instance).to receive(:error)
+      end
+
       it "logs response message" do
-        expect(Airbrake::Loggable.instance).to receive(:error).with(
+        described_class.parse(response)
+        expect(Airbrake::Loggable.instance).to have_received(:error).with(
           /Airbrake: rate limited/,
         )
-        described_class.parse(response)
       end
 
       it "returns an error response" do
@@ -49,11 +63,15 @@ RSpec.describe Airbrake::Response do
     context "when response code is unhandled" do
       let(:response) { OpenStruct.new(code: 500, body: 'foo') }
 
+      before do
+        allow(Airbrake::Loggable.instance).to receive(:error)
+      end
+
       it "logs response body" do
-        expect(Airbrake::Loggable.instance).to receive(:error).with(
+        described_class.parse(response)
+        expect(Airbrake::Loggable.instance).to have_received(:error).with(
           /Airbrake: unexpected code \(500\)\. Body: foo/,
         )
-        described_class.parse(response)
       end
 
       it "returns an error response" do
@@ -64,18 +82,22 @@ RSpec.describe Airbrake::Response do
       it "truncates body" do
         response.body *= 1000
         resp = described_class.parse(response)
-        expect(resp).to eq('error' => ('foo' * 33) + 'fo...')
+        expect(resp).to eq('error' => "#{'foo' * 33}fo...")
       end
     end
 
     context "when response body can't be parsed as JSON" do
       let(:response) { OpenStruct.new(code: 201, body: 'foo') }
 
+      before do
+        allow(Airbrake::Loggable.instance).to receive(:error)
+      end
+
       it "logs response body" do
-        expect(Airbrake::Loggable.instance).to receive(:error).with(
+        described_class.parse(response)
+        expect(Airbrake::Loggable.instance).to have_received(:error).with(
           /Airbrake: error while parsing body \(.*unexpected token.*\)\. Body: foo/,
         )
-        described_class.parse(response)
       end
 
       it "returns an error message" do

data/spec/stashable_spec.rb

@@ -5,19 +5,19 @@ RSpec.describe Airbrake::Stashable do
   end
 
   describe "#stash" do
-    subject { klass.new }
+    subject(:instance) { klass.new }
 
     it "returns a hash" do
-      expect(subject.stash).to be_a(Hash)
+      expect(instance.stash).to be_a(Hash)
     end
 
     it "returns an empty hash" do
-      expect(subject.stash).to be_empty
+      expect(instance.stash).to be_empty
     end
 
     it "remembers what was put in the stash" do
-      subject.stash[:foo] = 1
-      expect(subject.stash[:foo]).to eq(1)
+      instance.stash[:foo] = 1
+      expect(instance.stash[:foo]).to eq(1)
     end
   end
 end

data/spec/stat_spec.rb

@@ -1,7 +1,9 @@
 RSpec.describe Airbrake::Stat do
+  subject(:stat) { described_class.new }
+
   describe "#to_h" do
     it "converts to a hash" do
-      expect(subject.to_h).to eq(
+      expect(stat.to_h).to eq(
         'count' => 0,
         'sum' => 0.0,
         'sumsq' => 0.0,
@@ -11,19 +13,19 @@ RSpec.describe Airbrake::Stat do
   end
 
   describe "#increment_ms" do
-    before { subject.increment_ms(1000) }
+    before { stat.increment_ms(1000) }
 
     its(:sum) { is_expected.to eq(1000) }
     its(:sumsq) { is_expected.to eq(1000000) }
 
     it "updates tdigest" do
-      expect(subject.tdigest.size).to eq(1)
+      expect(stat.tdigest.size).to eq(1)
     end
   end
 
   describe "#inspect" do
     it "provides custom inspect output" do
-      expect(subject.inspect).to eq(
+      expect(stat.inspect).to eq(
         '#<struct Airbrake::Stat count=0, sum=0.0, sumsq=0.0>',
       )
     end
@@ -31,7 +33,7 @@ RSpec.describe Airbrake::Stat do
 
   describe "#pretty_print" do
     it "is an alias of #inspect" do
-      expect(subject.method(:pretty_print)).to eql(subject.method(:inspect))
+      expect(stat.method(:pretty_print)).to eql(stat.method(:inspect))
     end
   end
 end

data/spec/sync_sender_spec.rb

@@ -1,4 +1,6 @@
 RSpec.describe Airbrake::SyncSender do
+  subject(:sync_sender) { described_class.new }
+
   before do
     Airbrake::Config.instance = Airbrake::Config.new(
       project_id: 1, project_key: 'banana',
@@ -14,7 +16,7 @@ RSpec.describe Airbrake::SyncSender do
     before { stub_request(:post, endpoint).to_return(body: '{}') }
 
     it "sets the Content-Type header to JSON" do
-      subject.send({}, promise)
+      sync_sender.send({}, promise)
       expect(
         a_request(:post, endpoint).with(
           headers: { 'Content-Type' => 'application/json' },
@@ -23,7 +25,7 @@ RSpec.describe Airbrake::SyncSender do
     end
 
     it "sets the User-Agent header to the notifier slug" do
-      subject.send({}, promise)
+      sync_sender.send({}, promise)
       expect(
         a_request(:post, endpoint).with(
           headers: {
@@ -36,7 +38,7 @@ RSpec.describe Airbrake::SyncSender do
     end
 
     it "sets the Authorization header to the project key" do
-      subject.send({}, promise)
+      sync_sender.send({}, promise)
       expect(
         a_request(:post, endpoint).with(
           headers: { 'Authorization' => 'Bearer banana' },
@@ -45,19 +47,46 @@ RSpec.describe Airbrake::SyncSender do
     end
 
     it "catches exceptions raised while sending" do
+      # rubocop:disable RSpec/VerifiedDoubles
       https = double("foo")
-      allow(subject).to receive(:build_https).and_return(https)
+      # rubocop:enable RSpec/VerifiedDoubles
+
+      # rubocop:disable RSpec/SubjectStub
+      allow(sync_sender).to receive(:build_https).and_return(https)
+      # rubocop:enable RSpec/SubjectStub
+
       allow(https).to receive(:request).and_raise(StandardError.new('foo'))
-      expect(Airbrake::Loggable.instance).to receive(:error).with(
+
+      expect(sync_sender.send({}, promise)).to be_an(Airbrake::Promise)
+      expect(promise.value).to eq('error' => '**Airbrake: HTTP error: foo')
+    end
+
+    it "logs exceptions raised while sending" do
+      allow(Airbrake::Loggable.instance).to receive(:error)
+
+      # rubocop:disable RSpec/VerifiedDoubles
+      https = double("foo")
+      # rubocop:enable RSpec/VerifiedDoubles
+
+      # rubocop:disable RSpec/SubjectStub
+      allow(sync_sender).to receive(:build_https).and_return(https)
+      # rubocop:enable RSpec/SubjectStub
+
+      allow(https).to receive(:request).and_raise(StandardError.new('foo'))
+
+      sync_sender.send({}, promise)
+
+      expect(Airbrake::Loggable.instance).to have_received(:error).with(
         /HTTP error: foo/,
       )
-      expect(subject.send({}, promise)).to be_an(Airbrake::Promise)
-      expect(promise.value).to eq('error' => '**Airbrake: HTTP error: foo')
     end
 
     context "when request body is nil" do
+      # rubocop:disable RSpec/MultipleExpectations
       it "doesn't send data" do
-        expect_any_instance_of(Airbrake::Truncator)
+        allow(Airbrake::Loggable.instance).to receive(:error)
+
+        allow_any_instance_of(Airbrake::Truncator)
           .to receive(:reduce_max_size).and_return(0)
 
         encoded = Base64.encode64("\xD3\xE6\xBC\x9D\xBA").encode!('ASCII-8BIT')
@@ -70,16 +99,18 @@ RSpec.describe Airbrake::SyncSender do
 
         notice = Airbrake::Notice.new(ex)
 
-        expect(Airbrake::Loggable.instance).to receive(:error).with(
+        expect(sync_sender.send(notice, promise)).to be_an(Airbrake::Promise)
+        expect(promise.value)
+          .to match('error' => '**Airbrake: data was not sent because of missing body')
+
+        expect(Airbrake::Loggable.instance).to have_received(:error).with(
           /data was not sent/,
         )
-        expect(Airbrake::Loggable.instance).to receive(:error).with(
+        expect(Airbrake::Loggable.instance).to have_received(:error).with(
           /truncation failed/,
         )
-        expect(subject.send(notice, promise)).to be_an(Airbrake::Promise)
-        expect(promise.value)
-          .to match('error' => '**Airbrake: data was not sent because of missing body')
       end
+      # rubocop:enable RSpec/MultipleExpectations
     end
 
     context "when IP is rate limited" do
@@ -93,13 +124,14 @@ RSpec.describe Airbrake::SyncSender do
         )
       end
 
+      # rubocop:disable RSpec/MultipleExpectations
       it "returns error" do
         p1 = Airbrake::Promise.new
-        subject.send({}, p1)
+        sync_sender.send({}, p1)
         expect(p1.value).to match('error' => '**Airbrake: IP is rate limited')
 
         p2 = Airbrake::Promise.new
-        subject.send({}, p2)
+        sync_sender.send({}, p2)
         expect(p2.value).to match('error' => '**Airbrake: IP is rate limited')
 
         # Wait for X-RateLimit-Delay and then make a new request to make sure p2
@@ -107,11 +139,12 @@ RSpec.describe Airbrake::SyncSender do
         sleep 1
 
         p3 = Airbrake::Promise.new
-        subject.send({}, p3)
+        sync_sender.send({}, p3)
         expect(p3.value).to match('error' => '**Airbrake: IP is rate limited')
 
         expect(a_request(:post, endpoint)).to have_been_made.twice
       end
+      # rubocop:enable RSpec/MultipleExpectations
     end
 
     context "when the provided method is :put" do