airbrake-ruby 5.2.0 → 5.2.1

data/spec/filters/thread_filter_spec.rb

@@ -1,4 +1,6 @@
 RSpec.describe Airbrake::Filters::ThreadFilter do
+  subject(:thread_filter) { described_class.new }
+
   let(:notice) { Airbrake::Notice.new(AirbrakeTestError.new) }
 
   def new_thread
@@ -17,7 +19,7 @@ RSpec.describe Airbrake::Filters::ThreadFilter do
       it "attaches the thread variable" do
         new_thread do |th|
           th.thread_variable_set(:bingo, var)
-          subject.call(notice)
+          thread_filter.call(notice)
         end
 
         expect(notice[:params][:thread][:thread_variables][:bingo]).to eq(var)
@@ -60,7 +62,7 @@ RSpec.describe Airbrake::Filters::ThreadFilter do
       it "converts it to a String and attaches" do
         new_thread do |th|
           th.thread_variable_set(:bingo, Object.new)
-          subject.call(notice)
+          thread_filter.call(notice)
         end
 
         vars = notice[:params][:thread][:thread_variables]
@@ -90,7 +92,7 @@ RSpec.describe Airbrake::Filters::ThreadFilter do
       it "converts objects to a safe objects" do
         new_thread do |th|
           th.thread_variable_set(:bingo, var)
-          subject.call(notice)
+          thread_filter.call(notice)
         end
 
         vars = notice[:params][:thread][:thread_variables]
@@ -121,7 +123,7 @@ RSpec.describe Airbrake::Filters::ThreadFilter do
 
       new_thread do |th|
         th.thread_variable_set(var, :bingo)
-        subject.call(notice)
+        thread_filter.call(notice)
       end
 
       thread_variables = notice[:params][:thread][:thread_variables]
@@ -134,7 +136,7 @@ RSpec.describe Airbrake::Filters::ThreadFilter do
       it "attaches the fiber variable" do
         new_thread do |th|
           th[:bingo] = var
-          subject.call(notice)
+          thread_filter.call(notice)
         end
 
         expect(notice[:params][:thread][:fiber_variables][:bingo]).to eq(var)
@@ -177,7 +179,7 @@ RSpec.describe Airbrake::Filters::ThreadFilter do
       it "converts it to a String and attaches" do
         new_thread do |th|
           th[:bingo] = Object.new
-          subject.call(notice)
+          thread_filter.call(notice)
         end
 
         vars = notice[:params][:thread][:fiber_variables]
@@ -207,7 +209,7 @@ RSpec.describe Airbrake::Filters::ThreadFilter do
       it "converts objects to a safe objects" do
         new_thread do |th|
           th[:bingo] = var
-          subject.call(notice)
+          thread_filter.call(notice)
         end
 
         vars = notice[:params][:thread][:fiber_variables]
@@ -237,31 +239,31 @@ RSpec.describe Airbrake::Filters::ThreadFilter do
   it "appends name" do
     new_thread do |th|
       th.name = 'bingo'
-      subject.call(notice)
+      thread_filter.call(notice)
     end
 
     expect(notice[:params][:thread][:name]).to eq('bingo')
   end
 
   it "appends thread inspect (self)" do
-    subject.call(notice)
+    thread_filter.call(notice)
     expect(notice[:params][:thread][:self]).to match(/\A#<Thread:.+>\z/)
   end
 
   it "appends thread group" do
-    subject.call(notice)
+    thread_filter.call(notice)
     expect(notice[:params][:thread][:group][0]).to match(/\A#<Thread:.+>\z/)
   end
 
   it "appends priority" do
-    subject.call(notice)
+    thread_filter.call(notice)
     expect(notice[:params][:thread][:priority]).to eq(0)
   end
 
   it "appends safe_level", skip: (
     "Not supported on this version of Ruby." unless Airbrake::HAS_SAFE_LEVEL
   ) do
-    subject.call(notice)
+    thread_filter.call(notice)
     expect(notice[:params][:thread][:safe_level]).to eq(0)
   end
 
@@ -270,7 +272,7 @@ RSpec.describe Airbrake::Filters::ThreadFilter do
 
     new_thread do |th|
       th[key] = :bingo
-      subject.call(notice)
+      thread_filter.call(notice)
     end
 
     fiber_variables = notice[:params][:thread][:fiber_variables]

data/spec/loggable_spec.rb

@@ -6,12 +6,12 @@ RSpec.describe Airbrake::Loggable do
   end
 
   describe "#logger" do
-    let(:subject) do
+    subject(:class_with_logger) do
       Class.new { include Airbrake::Loggable }.new
     end
 
     it "returns a logger that has Logger::WARN severity" do
-      expect(subject.logger.level).to eq(Logger::WARN)
+      expect(class_with_logger.logger.level).to eq(Logger::WARN)
     end
   end
 end

data/spec/monotonic_time_spec.rb

@@ -1,23 +1,25 @@
 RSpec.describe Airbrake::MonotonicTime do
+  subject(:monotonic_time) { described_class }
+
   describe ".time_in_ms" do
     it "returns monotonic time in milliseconds" do
-      expect(subject.time_in_ms).to be_a(Float)
+      expect(monotonic_time.time_in_ms).to be_a(Float)
     end
 
     it "always returns time in the future" do
-      old_time = subject.time_in_ms
-      expect(subject.time_in_ms).to be > old_time
+      old_time = monotonic_time.time_in_ms
+      expect(monotonic_time.time_in_ms).to be > old_time
     end
   end
 
   describe ".time_in_s" do
     it "returns monotonic time in seconds" do
-      expect(subject.time_in_s).to be_a(Float)
+      expect(monotonic_time.time_in_s).to be_a(Float)
     end
 
     it "always returns time in the future" do
-      old_time = subject.time_in_s
-      expect(subject.time_in_s).to be > old_time
+      old_time = monotonic_time.time_in_s
+      expect(monotonic_time.time_in_s).to be > old_time
     end
   end
 end

data/spec/nested_exception_spec.rb

@@ -1,73 +1,73 @@
 RSpec.describe Airbrake::NestedException do
   describe "#as_json" do
     context "given exceptions with backtraces" do
+      # rubocop:disable RSpec/MultipleExpectations
       it "unwinds nested exceptions" do
         begin
-          begin
-            raise AirbrakeTestError
-          rescue AirbrakeTestError
-            Ruby21Error.raise_error('bingo')
-          end
-        rescue Ruby21Error => ex
-          nested_exception = described_class.new(ex)
-          exceptions = nested_exception.as_json
-
-          expect(exceptions.size).to eq(2)
-          expect(exceptions[0][:message]).to eq('bingo')
-          expect(exceptions[1][:message]).to eq('App crashed!')
-          expect(exceptions[0][:backtrace]).not_to be_empty
-          expect(exceptions[1][:backtrace]).not_to be_empty
+          raise AirbrakeTestError
+        rescue AirbrakeTestError
+          Ruby21Error.raise_error('bingo')
         end
+      rescue Ruby21Error => ex
+        nested_exception = described_class.new(ex)
+        exceptions = nested_exception.as_json
+
+        expect(exceptions.size).to eq(2)
+        expect(exceptions[0][:message]).to eq('bingo')
+        expect(exceptions[1][:message]).to eq('App crashed!')
+        expect(exceptions[0][:backtrace]).not_to be_empty
+        expect(exceptions[1][:backtrace]).not_to be_empty
       end
+      # rubocop:enable RSpec/MultipleExpectations
 
+      # rubocop:disable RSpec/MultipleExpectations
       it "unwinds no more than 3 nested exceptions" do
         begin
+          raise AirbrakeTestError
+        rescue AirbrakeTestError
           begin
-            raise AirbrakeTestError
-          rescue AirbrakeTestError
+            Ruby21Error.raise_error('bongo')
+          rescue Ruby21Error
             begin
-              Ruby21Error.raise_error('bongo')
+              Ruby21Error.raise_error('bango')
             rescue Ruby21Error
-              begin
-                Ruby21Error.raise_error('bango')
-              rescue Ruby21Error
-                Ruby21Error.raise_error('bingo')
-              end
+              Ruby21Error.raise_error('bingo')
             end
           end
-        rescue Ruby21Error => ex
-          nested_exception = described_class.new(ex)
-          exceptions = nested_exception.as_json
-
-          expect(exceptions.size).to eq(3)
-          expect(exceptions[0][:message]).to eq('bingo')
-          expect(exceptions[1][:message]).to eq('bango')
-          expect(exceptions[2][:message]).to eq('bongo')
-          expect(exceptions[0][:backtrace]).not_to be_empty
-          expect(exceptions[1][:backtrace]).not_to be_empty
         end
+      rescue Ruby21Error => ex
+        nested_exception = described_class.new(ex)
+        exceptions = nested_exception.as_json
+
+        expect(exceptions.size).to eq(3)
+        expect(exceptions[0][:message]).to eq('bingo')
+        expect(exceptions[1][:message]).to eq('bango')
+        expect(exceptions[2][:message]).to eq('bongo')
+        expect(exceptions[0][:backtrace]).not_to be_empty
+        expect(exceptions[1][:backtrace]).not_to be_empty
       end
+      # rubocop:enable RSpec/MultipleExpectations
     end
 
     context "given exceptions without backtraces" do
+      # rubocop:disable RSpec/MultipleExpectations
       it "sets backtrace to nil" do
         begin
-          begin
-            raise AirbrakeTestError
-          rescue AirbrakeTestError => ex2
-            ex2.set_backtrace([])
-            Ruby21Error.raise_error('bingo')
-          end
-        rescue Ruby21Error => ex1
-          ex1.set_backtrace([])
-          nested_exception = described_class.new(ex1)
-          exceptions = nested_exception.as_json
-
-          expect(exceptions.size).to eq(2)
-          expect(exceptions[0][:backtrace]).to be_empty
-          expect(exceptions[1][:backtrace]).to be_empty
+          raise AirbrakeTestError
+        rescue AirbrakeTestError => ex2
+          ex2.set_backtrace([])
+          Ruby21Error.raise_error('bingo')
         end
+      rescue Ruby21Error => ex1
+        ex1.set_backtrace([])
+        nested_exception = described_class.new(ex1)
+        exceptions = nested_exception.as_json
+
+        expect(exceptions.size).to eq(2)
+        expect(exceptions[0][:backtrace]).to be_empty
+        expect(exceptions[1][:backtrace]).to be_empty
       end
+      # rubocop:enable RSpec/MultipleExpectations
     end
   end
 end

data/spec/notice_notifier/options_spec.rb

@@ -1,4 +1,6 @@
 RSpec.describe Airbrake::NoticeNotifier do
+  subject(:notice_notifier) { described_class.new }
+
   let(:project_id) { 105138 }
   let(:project_key) { 'fd04e13d806a90f96614ad8e529b2822' }
   let(:localhost) { 'http://localhost:8080' }
@@ -27,7 +29,7 @@ RSpec.describe Airbrake::NoticeNotifier do
 
           example(title) do
             stub_request(:post, endpoint).to_return(status: 201, body: '{}')
-            subject.notify_sync(ex)
+            notice_notifier.notify_sync(ex)
 
             expect(a_request(:post, endpoint)).to have_been_made.once
           end
@@ -35,7 +37,7 @@ RSpec.describe Airbrake::NoticeNotifier do
 
         path = '/api/v3/projects/105138/notices'
 
-        context "given a full host" do
+        context "given a full host with port" do
           include_examples('endpoint', localhost = 'http://localhost:8080',
                            URI.join(localhost, path),
                            "sends notices to the specified host's endpoint")
@@ -63,13 +65,13 @@ RSpec.describe Airbrake::NoticeNotifier do
 
     describe ":root_directory" do
       before do
-        subject.add_filter(
+        notice_notifier.add_filter(
           Airbrake::Filters::RootDirectoryFilter.new('/home/kyrylo/code'),
         )
       end
 
       it "filters out frames" do
-        subject.notify_sync(ex)
+        notice_notifier.notify_sync(ex)
 
         expect(
           a_request(:post, endpoint)
@@ -82,7 +84,7 @@ RSpec.describe Airbrake::NoticeNotifier do
           before { Airbrake::Config.instance.merge(root_directory: dir) }
 
           it "being included into the notice's payload" do
-            subject.notify_sync(ex)
+            notice_notifier.notify_sync(ex)
             expect(
               a_request(:post, endpoint)
               .with(body: %r{"rootDirectory":"/bingo/bango"}),
@@ -100,6 +102,7 @@ RSpec.describe Airbrake::NoticeNotifier do
       end
     end
 
+    # rubocop:disable RSpec/MultipleMemoizedHelpers
     describe ":proxy" do
       let(:proxy) do
         WEBrick::HTTPServer.new(
@@ -142,7 +145,7 @@ RSpec.describe Airbrake::NoticeNotifier do
             "safe to run this test on 2.6+ once we upgrade to Webmock 3.5+",
           )
         end
-        subject.notify_sync(ex)
+        notice_notifier.notify_sync(ex)
 
         proxied_request = requests.pop(true)
 
@@ -155,13 +158,14 @@ RSpec.describe Airbrake::NoticeNotifier do
         # rubocop:enable Layout/LineLength
       end
     end
+    # rubocop:enable RSpec/MultipleMemoizedHelpers
 
     describe ":environment" do
       context "when present" do
         before { Airbrake::Config.instance.merge(environment: :production) }
 
         it "being included into the notice's payload" do
-          subject.notify_sync(ex)
+          notice_notifier.notify_sync(ex)
           expect(
             a_request(:post, endpoint)
             .with(body: /"context":{.*"environment":"production".*}/),
@@ -175,7 +179,7 @@ RSpec.describe Airbrake::NoticeNotifier do
         before { Airbrake::Config.instance.merge(params) }
 
         it "sends a notice" do
-          subject.notify_sync(ex)
+          notice_notifier.notify_sync(ex)
           expect(a_request(:post, endpoint)).to have_been_made
         end
       end
@@ -184,7 +188,7 @@ RSpec.describe Airbrake::NoticeNotifier do
         before { Airbrake::Config.instance.merge(params) }
 
         it "ignores exceptions occurring in envs that were not configured" do
-          subject.notify_sync(ex)
+          notice_notifier.notify_sync(ex)
           expect(a_request(:post, endpoint)).not_to have_been_made
         end
       end
@@ -207,9 +211,15 @@ RSpec.describe Airbrake::NoticeNotifier do
         include_examples 'ignored notice', params
 
         it "returns early and doesn't try to parse the given exception" do
-          expect(Airbrake::Notice).not_to receive(:new)
-          expect(subject.notify_sync(ex))
+          allow(Airbrake::Notice).to receive(:new)
+
+          expect(notice_notifier.notify_sync(ex))
             .to eq('error' => "current environment 'development' is ignored")
+
+          expect(Airbrake::Notice).not_to have_received(:new)
+        end
+
+        it "doesn't make an HTTP request" do
           expect(a_request(:post, endpoint)).not_to have_been_made
         end
       end
@@ -246,9 +256,9 @@ RSpec.describe Airbrake::NoticeNotifier do
           end
 
           it "sends a notice" do
-            notice = subject.build_notice(ex)
+            notice = notice_notifier.build_notice(ex)
             notice[:context][:headers] = 'banana'
-            subject.notify_sync(notice)
+            notice_notifier.notify_sync(notice)
 
             expect(a_request(:post, endpoint)).to have_been_made
           end

data/spec/notice_notifier_spec.rb

@@ -1,4 +1,6 @@
 RSpec.describe Airbrake::NoticeNotifier do
+  subject(:notice_notifier) { described_class.new }
+
   before do
     Airbrake::Config.instance = Airbrake::Config.new(
       project_id: 1,
@@ -15,13 +17,13 @@ RSpec.describe Airbrake::NoticeNotifier do
       it "appends the context filter" do
         expect_any_instance_of(Airbrake::FilterChain).to receive(:add_filter)
           .with(instance_of(Airbrake::Filters::ContextFilter))
-        subject
+        notice_notifier
       end
 
       it "appends the exception attributes filter" do
         expect_any_instance_of(Airbrake::FilterChain).to receive(:add_filter)
           .with(instance_of(Airbrake::Filters::ExceptionAttributesFilter))
-        subject
+        notice_notifier
       end
     end
   end
@@ -39,14 +41,14 @@ RSpec.describe Airbrake::NoticeNotifier do
     before { stub_request(:post, endpoint).to_return(status: 201, body: body) }
 
     it "returns a promise" do
-      expect(subject.notify('ex')).to be_an(Airbrake::Promise)
+      expect(notice_notifier.notify('ex')).to be_an(Airbrake::Promise)
       sleep 1
     end
 
     it "refines the notice object" do
-      subject.add_filter { |n| n[:params] = { foo: 'bar' } }
-      notice = subject.build_notice('ex')
-      subject.notify(notice)
+      notice_notifier.add_filter { |n| n[:params] = { foo: 'bar' } }
+      notice = notice_notifier.build_notice('ex')
+      notice_notifier.notify(notice)
       expect(notice[:params]).to eq(foo: 'bar')
       sleep 1
     end
@@ -55,54 +57,55 @@ RSpec.describe Airbrake::NoticeNotifier do
       before { Airbrake::Config.instance.merge(project_id: nil) }
 
       it "returns a rejected promise" do
-        promise = subject.notify({})
+        promise = notice_notifier.notify({})
         expect(promise).to be_rejected
       end
     end
 
     context "when a notice is not ignored" do
       it "yields the notice" do
-        expect { |b| subject.notify('ex', &b) }
+        expect { |b| notice_notifier.notify('ex', &b) }
           .to yield_with_args(Airbrake::Notice)
         sleep 1
       end
     end
 
     context "when a notice is ignored via a filter" do
-      before { subject.add_filter(&:ignore!) }
+      before { notice_notifier.add_filter(&:ignore!) }
 
       it "yields the notice" do
-        expect { |b| subject.notify('ex', &b) }
+        expect { |b| notice_notifier.notify('ex', &b) }
           .to yield_with_args(Airbrake::Notice)
       end
 
       it "returns a rejected promise" do
-        value = subject.notify('ex').value
+        value = notice_notifier.notify('ex').value
         expect(value['error']).to match(/was marked as ignored/)
       end
     end
 
     context "when a notice is ignored via an inline filter" do
-      before { subject.add_filter { raise AirbrakeTestError } }
+      before { notice_notifier.add_filter { raise AirbrakeTestError } }
 
       it "doesn't invoke regular filters" do
-        expect { subject.notify('ex', &:ignore!) }.not_to raise_error
+        expect { notice_notifier.notify('ex', &:ignore!) }.not_to raise_error
       end
     end
 
     context "when async sender has workers" do
       it "sends an exception asynchronously" do
         expect_any_instance_of(Airbrake::AsyncSender).to receive(:send)
-        subject.notify('foo', bingo: 'bango')
+        notice_notifier.notify('foo', bingo: 'bango')
       end
     end
 
     context "when async sender doesn't have workers" do
       it "sends an exception synchronously" do
-        expect_any_instance_of(Airbrake::AsyncSender)
+        allow_any_instance_of(Airbrake::AsyncSender)
           .to receive(:has_workers?).and_return(false)
         expect_any_instance_of(Airbrake::SyncSender).to receive(:send)
-        subject.notify('foo', bingo: 'bango')
+
+        notice_notifier.notify('foo', bingo: 'bango')
       end
     end
 
@@ -116,11 +119,11 @@ RSpec.describe Airbrake::NoticeNotifier do
 
       it "doesn't send an notice" do
         expect_any_instance_of(Airbrake::AsyncSender).not_to receive(:send)
-        subject.notify('foo', bingo: 'bango')
+        notice_notifier.notify('foo', bingo: 'bango')
       end
 
       it "returns a rejected promise" do
-        promise = subject.notify('foo', bingo: 'bango')
+        promise = notice_notifier.notify('foo', bingo: 'bango')
         expect(promise.value).to eq('error' => "current environment 'test' is ignored")
       end
     end
@@ -139,18 +142,18 @@ RSpec.describe Airbrake::NoticeNotifier do
     before { stub_request(:post, endpoint).to_return(status: 201, body: body.to_json) }
 
     it "returns a reponse hash" do
-      expect(subject.notify_sync('ex')).to eq(body)
+      expect(notice_notifier.notify_sync('ex')).to eq(body)
     end
 
     it "refines the notice object" do
-      subject.add_filter { |n| n[:params] = { foo: 'bar' } }
-      notice = subject.build_notice('ex')
-      subject.notify_sync(notice)
+      notice_notifier.add_filter { |n| n[:params] = { foo: 'bar' } }
+      notice = notice_notifier.build_notice('ex')
+      notice_notifier.notify_sync(notice)
       expect(notice[:params]).to eq(foo: 'bar')
     end
 
     it "sends an exception synchronously" do
-      subject.notify_sync('foo', bingo: 'bango')
+      notice_notifier.notify_sync('foo', bingo: 'bango')
       expect(
         a_request(:post, endpoint).with(
           body: /"params":{.*"bingo":"bango".*}/,
@@ -160,30 +163,30 @@ RSpec.describe Airbrake::NoticeNotifier do
 
     context "when a notice is not ignored" do
       it "yields the notice" do
-        expect { |b| subject.notify_sync('ex', &b) }
+        expect { |b| notice_notifier.notify_sync('ex', &b) }
           .to yield_with_args(Airbrake::Notice)
       end
     end
 
     context "when a notice is ignored via a filter" do
-      before { subject.add_filter(&:ignore!) }
+      before { notice_notifier.add_filter(&:ignore!) }
 
       it "yields the notice" do
-        expect { |b| subject.notify_sync('ex', &b) }
+        expect { |b| notice_notifier.notify_sync('ex', &b) }
           .to yield_with_args(Airbrake::Notice)
       end
 
       it "returns an error hash" do
-        response = subject.notify_sync('ex')
+        response = notice_notifier.notify_sync('ex')
         expect(response['error']).to match(/was marked as ignored/)
       end
     end
 
     context "when a notice is ignored via an inline filter" do
-      before { subject.add_filter { raise AirbrakeTestError } }
+      before { notice_notifier.add_filter { raise AirbrakeTestError } }
 
       it "doesn't invoke regular filters" do
-        expect { subject.notify('ex', &:ignore!) }.not_to raise_error
+        expect { notice_notifier.notify('ex', &:ignore!) }.not_to raise_error
       end
     end
 
@@ -196,11 +199,11 @@ RSpec.describe Airbrake::NoticeNotifier do
 
       it "doesn't send an notice" do
         expect_any_instance_of(Airbrake::SyncSender).not_to receive(:send)
-        subject.notify_sync('foo', bingo: 'bango')
+        notice_notifier.notify_sync('foo', bingo: 'bango')
       end
 
       it "returns an error hash" do
-        expect(subject.notify_sync('foo'))
+        expect(notice_notifier.notify_sync('foo'))
           .to eq('error' => "current environment 'test' is ignored")
       end
     end
@@ -209,17 +212,19 @@ RSpec.describe Airbrake::NoticeNotifier do
   describe "#add_filter" do
     context "given a block" do
       it "appends a new filter to the filter chain" do
-        notifier = subject
+        notifier = notice_notifier
         b = proc {}
+        # rubocop:disable RSpec/StubbedMock
         expect_any_instance_of(Airbrake::FilterChain)
           .to receive(:add_filter) { |*args| expect(args.last).to be(b) }
+        # rubocop:enable RSpec/StubbedMock
         notifier.add_filter(&b)
       end
     end
 
     context "given a class" do
       it "appends a new filter to the filter chain" do
-        notifier = subject
+        notifier = notice_notifier
         klass = Class.new
         expect_any_instance_of(Airbrake::FilterChain)
           .to receive(:add_filter).with(klass)
@@ -231,14 +236,14 @@ RSpec.describe Airbrake::NoticeNotifier do
   describe "#build_notice" do
     context "when given exception is another notice" do
       it "merges params with the notice" do
-        notice = subject.build_notice('ex')
-        other = subject.build_notice(notice, foo: 'bar')
+        notice = notice_notifier.build_notice('ex')
+        other = notice_notifier.build_notice(notice, foo: 'bar')
         expect(other[:params]).to eq(foo: 'bar')
       end
 
-      it "it returns the provided notice" do
-        notice = subject.build_notice('ex')
-        other = subject.build_notice(notice, foo: 'bar')
+      it "returns the provided notice" do
+        notice = notice_notifier.build_notice('ex')
+        other = notice_notifier.build_notice(notice, foo: 'bar')
         expect(other).to eq(notice)
       end
     end
@@ -246,7 +251,7 @@ RSpec.describe Airbrake::NoticeNotifier do
     context "when given exception is an Exception" do
       it "prevents mutation of passed-in params hash" do
         params = { immutable: true }
-        notice = subject.build_notice('ex', params)
+        notice = notice_notifier.build_notice('ex', params)
         notice[:params][:mutable] = true
         expect(params).to eq(immutable: true)
       end
@@ -260,7 +265,7 @@ RSpec.describe Airbrake::NoticeNotifier do
             ]
             allow(Kernel).to receive(:caller).and_return(backtrace)
 
-            notice = subject.build_notice(Exception.new)
+            notice = notice_notifier.build_notice(Exception.new)
 
             expect(notice[:errors].first[:backtrace]).to eq(
               [
@@ -280,7 +285,7 @@ RSpec.describe Airbrake::NoticeNotifier do
             ]
             allow(Kernel).to receive(:caller).and_return(backtrace)
 
-            notice = subject.build_notice(Exception.new)
+            notice = notice_notifier.build_notice(Exception.new)
 
             expect(notice[:errors].first[:backtrace]).to eq(
               [
@@ -296,7 +301,7 @@ RSpec.describe Airbrake::NoticeNotifier do
     # TODO: this seems to be bugged. Fix later.
     context "when given exception is a Java exception", skip: true do
       before do
-        expect(Airbrake::Backtrace).to receive(:java_exception?).and_return(true)
+        allow(Airbrake::Backtrace).to receive(:java_exception?).and_return(true)
       end
 
       it "automatically generates the backtrace" do
@@ -307,7 +312,7 @@ RSpec.describe Airbrake::NoticeNotifier do
         ]
         allow(Kernel).to receive(:caller).and_return(backtrace)
 
-        notice = subject.build_notice(Exception.new)
+        notice = notice_notifier.build_notice(Exception.new)
 
         # rubocop:disable Layout/LineLength
         expect(notice[:errors].first[:backtrace]).to eq(
@@ -323,12 +328,12 @@ RSpec.describe Airbrake::NoticeNotifier do
 
     context "when async sender is closed" do
       before do
-        expect_any_instance_of(Airbrake::AsyncSender)
+        allow_any_instance_of(Airbrake::AsyncSender)
           .to receive(:closed?).and_return(true)
       end
 
       it "raises error" do
-        expect { subject.build_notice(Exception.new('oops')) }.to raise_error(
+        expect { notice_notifier.build_notice(Exception.new('oops')) }.to raise_error(
           Airbrake::Error,
           "Airbrake is closed; can't build exception: Exception: oops",
         )
@@ -339,7 +344,7 @@ RSpec.describe Airbrake::NoticeNotifier do
   describe "#close" do
     it "sends the close message to async sender" do
       expect_any_instance_of(Airbrake::AsyncSender).to receive(:close)
-      subject.close
+      notice_notifier.close
     end
   end
 
@@ -350,7 +355,7 @@ RSpec.describe Airbrake::NoticeNotifier do
   describe "#merge_context" do
     it "merges the provided context with the notice object" do
       expect_any_instance_of(Hash).to receive(:merge!).with(apples: 'oranges')
-      subject.merge_context(apples: 'oranges')
+      notice_notifier.merge_context(apples: 'oranges')
     end
   end
 end