airbrake-ruby 4.15.0 → 6.0.2

data/spec/airbrake_spec.rb

@@ -1,4 +1,13 @@
 RSpec.describe Airbrake do
+  let(:remote_settings) { instance_double(Airbrake::RemoteSettings) }
+
+  before do
+    allow(Airbrake::RemoteSettings).to receive(:poll).and_return(remote_settings)
+    allow(remote_settings).to receive(:stop_polling)
+  end
+
+  after { described_class.instance_variable_set(:@remote_settings, nil) }
+
   it "gets initialized with a performance notifier" do
     expect(described_class.performance_notifier).not_to be_nil
   end
@@ -21,11 +30,9 @@ RSpec.describe Airbrake do
 
     it "yields the config" do
       expect do |b|
-        begin
-          described_class.configure(&b)
-        rescue Airbrake::Error
-          nil
-        end
+        described_class.configure(&b)
+      rescue Airbrake::Error
+        nil
       end.to yield_with_args(Airbrake::Config)
     end
 
@@ -53,26 +60,26 @@ RSpec.describe Airbrake do
 
     context "when called multiple times" do
       it "doesn't overwrite performance notifier" do
-        described_class.configure {}
+        described_class.configure { anything }
         performance_notifier = described_class.performance_notifier
 
-        described_class.configure {}
+        described_class.configure { anything }
         expect(described_class.performance_notifier).to eql(performance_notifier)
       end
 
       it "doesn't overwrite notice notifier" do
-        described_class.configure {}
+        described_class.configure { anything }
         notice_notifier = described_class.notice_notifier
 
-        described_class.configure {}
+        described_class.configure { anything }
         expect(described_class.notice_notifier).to eql(notice_notifier)
       end
 
       it "doesn't overwrite deploy notifier" do
-        described_class.configure {}
+        described_class.configure { anything }
         deploy_notifier = described_class.deploy_notifier
 
-        described_class.configure {}
+        described_class.configure { anything }
         expect(described_class.deploy_notifier).to eql(deploy_notifier)
       end
 
@@ -82,128 +89,155 @@ RSpec.describe Airbrake do
           c.project_key = '2'
         end
 
-        expect(described_class.notice_notifier).not_to receive(:add_filter)
-        10.times { described_class.configure {} }
+        allow(described_class.notice_notifier).to receive(:add_filter)
+
+        10.times { described_class.configure { anything } }
+
+        expect(described_class.notice_notifier).not_to have_received(:add_filter)
       end
 
       it "appends some default filters" do
         allow(described_class.notice_notifier).to receive(:add_filter)
-        expect(described_class.notice_notifier).to receive(:add_filter).with(
-          an_instance_of(Airbrake::Filters::RootDirectoryFilter),
-        )
 
         described_class.configure do |c|
           c.project_id = 1
           c.project_key = '2'
         end
+
+        expect(described_class.notice_notifier).to have_received(:add_filter).with(
+          an_instance_of(Airbrake::Filters::RootDirectoryFilter),
+        )
       end
     end
 
     context "when blocklist_keys gets configured" do
-      before { allow(Airbrake.notice_notifier).to receive(:add_filter) }
+      before { allow(described_class.notice_notifier).to receive(:add_filter) }
 
       it "adds blocklist filter" do
-        expect(Airbrake.notice_notifier).to receive(:add_filter)
-          .with(an_instance_of(Airbrake::Filters::KeysBlocklist))
+        allow(described_class.notice_notifier).to receive(:add_filter)
+
         described_class.configure { |c| c.blocklist_keys = %w[password] }
+
+        expect(described_class.notice_notifier).to have_received(:add_filter)
+          .with(an_instance_of(Airbrake::Filters::KeysBlocklist))
       end
 
       it "initializes blocklist with specified parameters" do
-        expect(Airbrake::Filters::KeysBlocklist).to receive(:new).with(%w[password])
+        allow(Airbrake::Filters::KeysBlocklist).to receive(:new)
+
         described_class.configure { |c| c.blocklist_keys = %w[password] }
+
+        expect(Airbrake::Filters::KeysBlocklist)
+          .to have_received(:new).with(%w[password])
       end
     end
 
     context "when allowlist_keys gets configured" do
-      before { allow(Airbrake.notice_notifier).to receive(:add_filter) }
+      before { allow(described_class.notice_notifier).to receive(:add_filter) }
 
       it "adds allowlist filter" do
-        expect(Airbrake.notice_notifier).to receive(:add_filter)
-          .with(an_instance_of(Airbrake::Filters::KeysAllowlist))
         described_class.configure { |c| c.allowlist_keys = %w[banana] }
+        expect(described_class.notice_notifier).to have_received(:add_filter)
+          .with(an_instance_of(Airbrake::Filters::KeysAllowlist))
       end
 
       it "initializes allowlist with specified parameters" do
-        expect(Airbrake::Filters::KeysAllowlist).to receive(:new).with(%w[banana])
+        allow(Airbrake::Filters::KeysAllowlist).to receive(:new)
+
         described_class.configure { |c| c.allowlist_keys = %w[banana] }
+        expect(Airbrake::Filters::KeysAllowlist)
+          .to have_received(:new).with(%w[banana])
       end
     end
 
     context "when root_directory gets configured" do
-      before { allow(Airbrake.notice_notifier).to receive(:add_filter) }
+      before { allow(described_class.notice_notifier).to receive(:add_filter) }
 
       it "adds root directory filter" do
-        expect(Airbrake.notice_notifier).to receive(:add_filter)
-          .with(an_instance_of(Airbrake::Filters::RootDirectoryFilter))
         described_class.configure { |c| c.root_directory = '/my/path' }
+
+        expect(described_class.notice_notifier).to have_received(:add_filter)
+          .with(an_instance_of(Airbrake::Filters::RootDirectoryFilter))
       end
 
       it "initializes root directory filter with specified path" do
-        expect(Airbrake::Filters::RootDirectoryFilter)
-          .to receive(:new).with('/my/path')
+        allow(Airbrake::Filters::RootDirectoryFilter).to receive(:new)
         described_class.configure { |c| c.root_directory = '/my/path' }
+
+        expect(Airbrake::Filters::RootDirectoryFilter)
+          .to have_received(:new).with('/my/path')
       end
 
       it "adds git revision filter" do
-        expect(Airbrake.notice_notifier).to receive(:add_filter)
-          .with(an_instance_of(Airbrake::Filters::GitRevisionFilter))
         described_class.configure { |c| c.root_directory = '/my/path' }
+        expect(described_class.notice_notifier).to have_received(:add_filter)
+          .with(an_instance_of(Airbrake::Filters::GitRevisionFilter))
       end
 
       it "initializes git revision filter with correct root directory" do
-        expect(Airbrake::Filters::GitRevisionFilter)
-          .to receive(:new).with('/my/path')
+        allow(Airbrake::Filters::GitRevisionFilter).to receive(:new)
         described_class.configure { |c| c.root_directory = '/my/path' }
+
+        expect(Airbrake::Filters::GitRevisionFilter)
+          .to have_received(:new).with('/my/path')
       end
 
       it "adds git repository filter" do
-        expect(Airbrake.notice_notifier).to receive(:add_filter)
-          .with(an_instance_of(Airbrake::Filters::GitRepositoryFilter))
         described_class.configure { |c| c.root_directory = '/my/path' }
+
+        expect(described_class.notice_notifier).to have_received(:add_filter)
+          .with(an_instance_of(Airbrake::Filters::GitRepositoryFilter))
       end
 
       it "initializes git repository filter with correct root directory" do
-        expect(Airbrake::Filters::GitRepositoryFilter)
-          .to receive(:new).with('/my/path')
+        allow(Airbrake::Filters::GitRepositoryFilter).to receive(:new)
+
         described_class.configure { |c| c.root_directory = '/my/path' }
+
+        expect(Airbrake::Filters::GitRepositoryFilter)
+          .to have_received(:new).with('/my/path')
       end
 
       it "adds git last checkout filter" do
-        expect(Airbrake.notice_notifier).to receive(:add_filter)
-          .with(an_instance_of(Airbrake::Filters::GitLastCheckoutFilter))
         described_class.configure { |c| c.root_directory = '/my/path' }
+        expect(described_class.notice_notifier).to have_received(:add_filter)
+          .with(an_instance_of(Airbrake::Filters::GitLastCheckoutFilter))
       end
 
       it "initializes git last checkout filter with correct root directory" do
-        expect(Airbrake::Filters::GitLastCheckoutFilter)
-          .to receive(:new).with('/my/path')
+        allow(Airbrake::Filters::GitLastCheckoutFilter).to receive(:new)
         described_class.configure { |c| c.root_directory = '/my/path' }
+
+        expect(Airbrake::Filters::GitLastCheckoutFilter)
+          .to have_received(:new).with('/my/path')
       end
     end
   end
 
-  describe "#notify_request" do
+  describe ".notify_request" do
+    before do
+      allow(described_class.performance_notifier).to receive(:notify)
+    end
+
     context "when :stash key is not provided" do
       it "doesn't add anything to the stash of the request" do
-        expect(described_class.performance_notifier).to receive(:notify) do |request|
-          expect(request.stash).to be_empty
-        end
-
         described_class.notify_request(
           method: 'GET',
           route: '/',
           status_code: 200,
           timing: 1,
         )
+
+        expect(
+          described_class.performance_notifier,
+        ).to have_received(:notify) do |request|
+          expect(request.stash).to be_empty
+        end
       end
     end
 
     context "when :stash key is provided" do
       it "adds the value as the stash of the request" do
-        expect(described_class.performance_notifier).to receive(:notify) do |request|
-          expect(request.stash).to eq(request_id: 1)
-        end
-
         described_class.notify_request(
           {
             method: 'GET',
@@ -213,13 +247,19 @@ RSpec.describe Airbrake do
           },
           request_id: 1,
         )
+
+        expect(
+          described_class.performance_notifier,
+        ).to have_received(:notify) do |request|
+          expect(request.stash).to eq(request_id: 1)
+        end
       end
     end
   end
 
-  describe "#notify_request_sync" do
+  describe ".notify_request_sync" do
     it "notifies request synchronously" do
-      expect(described_class.performance_notifier).to receive(:notify_sync)
+      allow(described_class.performance_notifier).to receive(:notify_sync)
 
       described_class.notify_request_sync(
         {
@@ -230,31 +270,35 @@ RSpec.describe Airbrake do
         },
         request_id: 1,
       )
+
+      expect(described_class.performance_notifier).to have_received(:notify_sync)
     end
   end
 
-  describe "#notify_query" do
+  describe ".notify_query" do
+    before do
+      allow(described_class.performance_notifier).to receive(:notify)
+    end
+
     context "when :stash key is not provided" do
       it "doesn't add anything to the stash of the query" do
-        expect(described_class.performance_notifier).to receive(:notify) do |query|
-          expect(query.stash).to be_empty
-        end
-
         described_class.notify_query(
           method: 'GET',
           route: '/',
           query: '',
           timing: 1,
         )
+
+        expect(
+          described_class.performance_notifier,
+        ).to have_received(:notify) do |query|
+          expect(query.stash).to be_empty
+        end
       end
     end
 
     context "when :stash key is provided" do
       it "adds the value as the stash of the query" do
-        expect(described_class.performance_notifier).to receive(:notify) do |query|
-          expect(query.stash).to eq(request_id: 1)
-        end
-
         described_class.notify_query(
           {
             method: 'GET',
@@ -264,13 +308,19 @@ RSpec.describe Airbrake do
           },
           request_id: 1,
         )
+
+        expect(
+          described_class.performance_notifier,
+        ).to have_received(:notify) do |query|
+          expect(query.stash).to eq(request_id: 1)
+        end
       end
     end
   end
 
-  describe "#notify_query_sync" do
+  describe ".notify_query_sync" do
     it "notifies query synchronously" do
-      expect(described_class.performance_notifier).to receive(:notify_sync)
+      allow(described_class.performance_notifier).to receive(:notify_sync)
 
       described_class.notify_query_sync(
         {
@@ -281,33 +331,35 @@ RSpec.describe Airbrake do
         },
         request_id: 1,
       )
+
+      expect(described_class.performance_notifier).to have_received(:notify_sync)
     end
   end
 
-  describe "#notify_performance_breakdown" do
+  describe ".notify_performance_breakdown" do
+    before do
+      allow(described_class.performance_notifier).to receive(:notify)
+    end
+
     context "when :stash key is not provided" do
       it "doesn't add anything to the stash of the performance breakdown" do
-        expect(described_class.performance_notifier).to receive(:notify) do |query|
-          expect(query.stash).to be_empty
-        end
-
         described_class.notify_query(
           method: 'GET',
           route: '/',
           query: '',
           timing: 1,
         )
-      end
-    end
 
-    context "when :stash key is provided" do
-      it "adds the value as the stash of the performance breakdown" do
         expect(
           described_class.performance_notifier,
-        ).to receive(:notify) do |performance_breakdown|
-          expect(performance_breakdown.stash).to eq(request_id: 1)
+        ).to have_received(:notify) do |query|
+          expect(query.stash).to be_empty
         end
+      end
+    end
 
+    context "when :stash key is provided" do
+      it "adds the value as the stash of the performance breakdown" do
         described_class.notify_performance_breakdown(
           {
             method: 'GET',
@@ -318,13 +370,19 @@ RSpec.describe Airbrake do
           },
           request_id: 1,
         )
+
+        expect(
+          described_class.performance_notifier,
+        ).to have_received(:notify) do |performance_breakdown|
+          expect(performance_breakdown.stash).to eq(request_id: 1)
+        end
       end
     end
   end
 
-  describe "#notify_performance_breakdown_sync" do
+  describe ".notify_performance_breakdown_sync" do
     it "notifies performance breakdown synchronously" do
-      expect(described_class.performance_notifier).to receive(:notify_sync)
+      allow(described_class.performance_notifier).to receive(:notify_sync)
 
       described_class.notify_performance_breakdown_sync(
         {
@@ -336,29 +394,33 @@ RSpec.describe Airbrake do
         },
         request_id: 1,
       )
+
+      expect(described_class.performance_notifier).to have_received(:notify_sync)
     end
   end
 
-  describe "#notify_queue" do
+  describe ".notify_queue" do
+    before do
+      allow(described_class.performance_notifier).to receive(:notify)
+    end
+
     context "when :stash key is not provided" do
       it "doesn't add anything to the stash of the queue" do
-        expect(described_class.performance_notifier).to receive(:notify) do |queue|
-          expect(queue.stash).to be_empty
-        end
-
         described_class.notify_queue(
           queue: 'bananas',
           error_count: 10,
         )
+
+        expect(
+          described_class.performance_notifier,
+        ).to have_received(:notify) do |queue|
+          expect(queue.stash).to be_empty
+        end
       end
     end
 
     context "when :stash key is provided" do
       it "adds the value as the stash of the queue" do
-        expect(described_class.performance_notifier).to receive(:notify) do |queue|
-          expect(queue.stash).to eq(request_id: 1)
-        end
-
         described_class.notify_queue(
           {
             queue: 'bananas',
@@ -366,13 +428,19 @@ RSpec.describe Airbrake do
           },
           request_id: 1,
         )
+
+        expect(
+          described_class.performance_notifier,
+        ).to have_received(:notify) do |queue|
+          expect(queue.stash).to eq(request_id: 1)
+        end
       end
     end
   end
 
-  describe "#notify_queue_sync" do
+  describe ".notify_queue_sync" do
     it "notifies queue synchronously" do
-      expect(described_class.performance_notifier).to receive(:notify_sync)
+      allow(described_class.performance_notifier).to receive(:notify_sync)
 
       described_class.notify_queue_sync(
         {
@@ -381,6 +449,8 @@ RSpec.describe Airbrake do
         },
         request_id: 1,
       )
+
+      expect(described_class.performance_notifier).to have_received(:notify_sync)
     end
   end
 
@@ -403,34 +473,50 @@ RSpec.describe Airbrake do
     end
   end
 
+  # rubocop:disable RSpec/MessageSpies
   describe ".close" do
-    after { Airbrake.reset }
+    after { described_class.reset }
 
     context "when notice_notifier is defined" do
       it "gets closed" do
-        expect(Airbrake.notice_notifier).to receive(:close)
+        expect(described_class.notice_notifier).to receive(:close)
       end
     end
 
     context "when notice_notifier is undefined" do
       it "doesn't get closed (because it wasn't initialized)" do
-        Airbrake.instance_variable_set(:@notice_notifier, nil)
+        described_class.instance_variable_set(:@notice_notifier, nil)
         expect_any_instance_of(Airbrake::NoticeNotifier).not_to receive(:close)
       end
     end
 
     context "when performance_notifier is defined" do
       it "gets closed" do
-        expect(Airbrake.performance_notifier).to receive(:close)
+        expect(described_class.performance_notifier).to receive(:close)
       end
     end
 
     context "when perforance_notifier is undefined" do
       it "doesn't get closed (because it wasn't initialized)" do
-        Airbrake.instance_variable_set(:@performance_notifier, nil)
+        described_class.instance_variable_set(:@performance_notifier, nil)
         expect_any_instance_of(Airbrake::PerformanceNotifier)
           .not_to receive(:close)
       end
     end
+
+    context "when remote settings are defined" do
+      it "stops polling" do
+        described_class.instance_variable_set(:@remote_settings, remote_settings)
+        expect(remote_settings).to receive(:stop_polling)
+      end
+    end
+
+    context "when remote settings are undefined" do
+      it "doesn't stop polling (because they weren't initialized)" do
+        described_class.instance_variable_set(:@remote_settings, nil)
+        expect(remote_settings).not_to receive(:stop_polling)
+      end
+    end
   end
+  # rubocop:enable RSpec/MessageSpies
 end

data/spec/async_sender_spec.rb

@@ -13,18 +13,20 @@ RSpec.describe Airbrake::AsyncSender do
   end
 
   describe "#send" do
+    subject(:async_sender) { described_class.new }
+
     context "when sender has the capacity to send" do
       it "sends notices to Airbrake" do
-        2.times { subject.send(notice, Airbrake::Promise.new) }
-        subject.close
+        2.times { async_sender.send(notice, Airbrake::Promise.new) }
+        async_sender.close
 
         expect(a_request(:post, endpoint)).to have_been_made.twice
       end
 
       it "returns a resolved promise" do
         promise = Airbrake::Promise.new
-        subject.send(notice, promise)
-        subject.close
+        async_sender.send(notice, promise)
+        async_sender.close
 
         expect(promise).to be_resolved
       end
@@ -40,8 +42,8 @@ RSpec.describe Airbrake::AsyncSender do
       end
 
       it "doesn't send the exceeded notices to Airbrake" do
-        15.times { subject.send(notice, Airbrake::Promise.new) }
-        subject.close
+        15.times { async_sender.send(notice, Airbrake::Promise.new) }
+        async_sender.close
 
         expect(a_request(:post, endpoint)).not_to have_been_made
       end
@@ -49,9 +51,9 @@ RSpec.describe Airbrake::AsyncSender do
       it "returns a rejected promise" do
         promise = nil
         15.times do
-          promise = subject.send(notice, Airbrake::Promise.new)
+          promise = async_sender.send(notice, Airbrake::Promise.new)
         end
-        subject.close
+        async_sender.close
 
         expect(promise).to be_rejected
         expect(promise.value).to eq(