airbrake-ruby 5.0.1-java → 5.2.1-java

data/spec/remote_settings_spec.rb

@@ -22,72 +22,35 @@ RSpec.describe Airbrake::RemoteSettings do
     }
   end
 
-  let(:config_path) { described_class::CONFIG_DUMP_PATH }
-  let(:config_dir) { File.dirname(config_path) }
-
   let!(:stub) do
     stub_request(:get, Regexp.new(endpoint))
       .to_return(status: 200, body: body.to_json)
   end
 
-  before do
-    # Do not create config dumps on disk.
-    allow(Dir).to receive(:mkdir).with(config_dir)
-    allow(File).to receive(:write).with(config_path, anything)
-  end
-
   describe ".poll" do
     describe "config loading" do
       let(:settings_data) { described_class::SettingsData.new(project_id, body) }
 
       before do
-        allow(File).to receive(:exist?).with(config_path).and_return(true)
-        allow(File).to receive(:read).with(config_path).and_return(body.to_json)
-
         allow(described_class::SettingsData).to receive(:new).and_return(settings_data)
       end
 
-      it "loads the config from disk" do
-        expect(File).to receive(:read).with(config_path)
-        expect(settings_data).to receive(:merge!).with(body).twice
-
-        remote_settings = described_class.poll(project_id, host) {}
-        sleep(0.2)
-        remote_settings.stop_polling
-
-        expect(stub).to have_been_requested.once
-      end
-
       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
-      end
-
-      context "when config loading fails" do
-        it "logs an error" do
-          expect(File).to receive(:read).and_raise(StandardError)
-          expect(Airbrake::Loggable.instance).to receive(:error).with(
-            '**Airbrake: config loading failed: StandardError',
-          )
-
-          remote_settings = described_class.poll(project_id, host) {}
-          sleep(0.2)
-          remote_settings.stop_polling
-
-          expect(stub).to have_been_requested.once
-        end
+        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
 
@@ -95,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
 
@@ -105,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|
@@ -117,11 +81,12 @@ 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
       before do
-        allow(Net::HTTP).to receive(:get).and_raise(StandardError)
+        allow(Net::HTTP).to receive(:get_response).and_raise(StandardError)
       end
 
       it "doesn't fetch remote settings" do
@@ -155,10 +120,10 @@ RSpec.describe Airbrake::RemoteSettings do
       end
     end
 
-    context "when API returns an XML response" do
+    context "when API returns a non-200 response" do
       let!(:stub) do
         stub_request(:get, Regexp.new(endpoint))
-          .to_return(status: 200, body: '<?xml ...')
+          .to_return(status: 201, body: body.to_json)
       end
 
       it "doesn't update settings data" do
@@ -172,59 +137,61 @@ RSpec.describe Airbrake::RemoteSettings do
         expect(stub).to have_been_requested.once
         expect(settings.interval).to eq(600)
       end
-    end
 
-    context "when a config route is specified in the returned data" do
-      let(:new_endpoint) do
-        "http://example.com"
-      end
+      it "logs error" do
+        allow(Airbrake::Loggable.instance).to receive(:error)
 
-      let(:body) do
-        { 'config_route' => new_endpoint, 'poll_sec' => 0.1 }
+        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
 
-      let!(:new_stub) do
-        stub_request(:get, Regexp.new(new_endpoint))
+    context "when API returns a 200 response" do
+      let!(:stub) do
+        stub_request(:get, Regexp.new(endpoint))
           .to_return(status: 200, body: body.to_json)
       end
 
-      it "makes the next request to the specified config route" do
-        remote_settings = described_class.poll(project_id, host) {}
-        sleep(0.2)
+      it "doesn't log errors" do
+        allow(Airbrake::Loggable.instance).to receive(:error)
 
+        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
-        expect(new_stub).to have_been_requested.once
       end
     end
-  end
 
-  describe "#stop_polling" do
-    it "dumps config data to disk" do
-      expect(Dir).to receive(:mkdir).with(config_dir)
-      expect(File).to receive(:write).with(config_path, body.to_json)
-
-      remote_settings = described_class.poll(project_id, host) {}
-      sleep(0.2)
-      remote_settings.stop_polling
+    # 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'
+      end
 
-      expect(stub).to have_been_requested.once
-    end
+      let(:body) do
+        { 'config_route' => new_config_route, 'poll_sec' => 0.1 }
+      end
 
-    context "when config dumping fails" do
-      it "logs an error" do
-        expect(File).to receive(:write).and_raise(StandardError)
-        expect(Airbrake::Loggable.instance).to receive(:error).with(
-          '**Airbrake: config dumping failed: StandardError',
-        )
+      let!(:new_stub) do
+        stub_request(:get, Regexp.new(new_config_route))
+          .to_return(status: 200, body: body.to_json)
+      end
 
-        remote_settings = described_class.poll(project_id, host) {}
+      it "makes the next request to the specified config route" do
+        remote_settings = described_class.poll(project_id, host) { anything }
         sleep(0.2)
+
         remote_settings.stop_polling
 
         expect(stub).to have_been_requested.once
+        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