airbrake-ruby 5.2.0 → 5.2.1

data/spec/promise_spec.rb

@@ -1,15 +1,17 @@
 RSpec.describe Airbrake::Promise do
+  subject(:promise) { described_class.new }
+
   describe ".then" do
     let(:resolved_with) { [] }
     let(:rejected_with) { [] }
 
     context "when it is not resolved" do
       it "returns self" do
-        expect(subject.then {}).to eq(subject)
+        expect(promise.then { anything }).to eq(promise)
       end
 
       it "doesn't call the resolve callbacks yet" do
-        subject.then { resolved_with << 1 }.then { resolved_with << 2 }
+        promise.then { resolved_with << 1 }.then { resolved_with << 2 }
         expect(resolved_with).to be_empty
       end
     end
@@ -17,12 +19,12 @@ RSpec.describe Airbrake::Promise do
     context "when it is resolved" do
       shared_examples "then specs" do
         it "returns self" do
-          expect(subject.then {}).to eq(subject)
+          expect(promise.then { anything }).to eq(promise)
         end
 
         it "yields the resolved value" do
           yielded = nil
-          subject.then { |value| yielded = value }
+          promise.then { |value| yielded = value }
           expect(yielded).to eq('id' => '123')
         end
 
@@ -37,29 +39,29 @@ RSpec.describe Airbrake::Promise do
 
       context "and there are some resolve and reject callbacks in place" do
         before do
-          subject.then { resolved_with << 1 }.then { resolved_with << 2 }
-          subject.rescue { rejected_with << 1 }.rescue { rejected_with << 2 }
-          subject.resolve('id' => '123')
+          promise.then { resolved_with << 1 }.then { resolved_with << 2 }
+          promise.rescue { rejected_with << 1 }.rescue { rejected_with << 2 }
+          promise.resolve('id' => '123')
         end
 
         include_examples "then specs"
 
         it "registers the resolve callbacks" do
-          subject.resolve('id' => '456')
+          promise.resolve('id' => '456')
           expect(resolved_with).to match_array([1, 2, 1, 2])
         end
       end
 
       context "and additional then callbacks are added" do
         before do
-          subject.resolve('id' => '123')
-          subject.then { resolved_with << 1 }.then { resolved_with << 2 }
+          promise.resolve('id' => '123')
+          promise.then { resolved_with << 1 }.then { resolved_with << 2 }
         end
 
         include_examples "then specs"
 
         it "doesn't register new resolve callbacks" do
-          subject.resolve('id' => '456')
+          promise.resolve('id' => '456')
           expect(resolved_with).to match_array([1, 2])
         end
       end
@@ -72,11 +74,11 @@ RSpec.describe Airbrake::Promise do
 
     context "when it is not rejected" do
       it "returns self" do
-        expect(subject.then {}).to eq(subject)
+        expect(promise.then { anything }).to eq(promise)
       end
 
       it "doesn't call the reject callbacks yet" do
-        subject.rescue { rejected_with << 1 }.rescue { rejected_with << 2 }
+        promise.rescue { rejected_with << 1 }.rescue { rejected_with << 2 }
         expect(rejected_with).to be_empty
       end
     end
@@ -84,12 +86,12 @@ RSpec.describe Airbrake::Promise do
     context "when it is rejected" do
       shared_examples "rescue specs" do
         it "returns self" do
-          expect(subject.rescue {}).to eq(subject)
+          expect(promise.rescue { anything }).to eq(promise)
         end
 
         it "yields the rejected value" do
           yielded = nil
-          subject.rescue { |value| yielded = value }
+          promise.rescue { |value| yielded = value }
           expect(yielded).to eq('bingo')
         end
 
@@ -104,29 +106,29 @@ RSpec.describe Airbrake::Promise do
 
       context "and there are some resolve and reject callbacks in place" do
         before do
-          subject.then { resolved_with << 1 }.then { resolved_with << 2 }
-          subject.rescue { rejected_with << 1 }.rescue { rejected_with << 2 }
-          subject.reject('bingo')
+          promise.then { resolved_with << 1 }.then { resolved_with << 2 }
+          promise.rescue { rejected_with << 1 }.rescue { rejected_with << 2 }
+          promise.reject('bingo')
         end
 
         include_examples "rescue specs"
 
         it "registers the reject callbacks" do
-          subject.reject('bingo again')
+          promise.reject('bingo again')
           expect(rejected_with).to match_array([1, 2, 1, 2])
         end
       end
 
       context "and additional reject callbacks are added" do
         before do
-          subject.reject('bingo')
-          subject.rescue { rejected_with << 1 }.rescue { rejected_with << 2 }
+          promise.reject('bingo')
+          promise.rescue { rejected_with << 1 }.rescue { rejected_with << 2 }
         end
 
         include_examples "rescue specs"
 
         it "doesn't register new reject callbacks" do
-          subject.reject('bingo again')
+          promise.reject('bingo again')
           expect(rejected_with).to match_array([1, 2])
         end
       end
@@ -135,37 +137,38 @@ RSpec.describe Airbrake::Promise do
 
   describe ".resolve" do
     it "returns self" do
-      expect(subject.resolve(1)).to eq(subject)
+      expect(promise.resolve(1)).to eq(promise)
     end
 
     it "executes callbacks attached with .then" do
       array = []
-      subject.then { |notice_id| array << notice_id }.rescue { array << 999 }
+      promise.then { |notice_id| array << notice_id }.rescue { array << 999 }
 
       expect(array.size).to be_zero
-      subject.resolve(1)
+      promise.resolve(1)
       expect(array).to match_array([1])
     end
   end
 
   describe ".reject" do
     it "returns self" do
-      expect(subject.reject(1)).to eq(subject)
+      expect(promise.reject(1)).to eq(promise)
     end
 
     it "executes callbacks attached with .rescue" do
       array = []
-      subject.then { array << 1 }.rescue { |error| array << error }
+      promise.then { array << 1 }.rescue { |error| array << error }
 
       expect(array.size).to be_zero
-      subject.reject(999)
+      promise.reject(999)
       expect(array).to match_array([999])
     end
   end
 
   describe "#rejected?" do
     context "when it was rejected" do
-      before { subject.reject(1) }
+      before { promise.reject(1) }
+
       it { is_expected.to be_rejected }
     end
 
@@ -174,14 +177,16 @@ RSpec.describe Airbrake::Promise do
     end
 
     context "when it was resolved" do
-      before { subject.resolve }
+      before { promise.resolve }
+
       it { is_expected.not_to be_rejected }
     end
   end
 
   describe "#resolved?" do
     context "when it was resolved" do
-      before { subject.resolve }
+      before { promise.resolve }
+
       it { is_expected.to be_resolved }
     end
 
@@ -190,7 +195,8 @@ RSpec.describe Airbrake::Promise do
     end
 
     context "when it was rejected" do
-      before { subject.reject(1) }
+      before { promise.reject(1) }
+
       it { is_expected.not_to be_resolved }
     end
   end

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,6 +81,7 @@ 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
@@ -136,11 +139,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 +156,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 +183,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 +192,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