airbrake-ruby 5.2.0 → 5.2.1

data/spec/deploy_notifier_spec.rb

@@ -4,17 +4,19 @@ RSpec.describe Airbrake::DeployNotifier do
   end
 
   describe "#notify" do
+    subject(:deploy_notifier) { described_class.new }
+
     it "returns a promise" do
       stub_request(:post, 'https://api.airbrake.io/api/v4/projects/1/deploys')
         .to_return(status: 201, body: '{}')
-      expect(subject.notify({})).to be_an(Airbrake::Promise)
+      expect(deploy_notifier.notify({})).to be_an(Airbrake::Promise)
     end
 
     context "when config is invalid" do
       before { Airbrake::Config.instance.merge(project_id: nil) }
 
       it "returns a rejected promise" do
-        promise = subject.notify({})
+        promise = deploy_notifier.notify({})
         expect(promise).to be_rejected
       end
     end
@@ -28,7 +30,7 @@ RSpec.describe Airbrake::DeployNotifier do
           instance_of(Airbrake::Promise),
           URI('https://api.airbrake.io/api/v4/projects/1/deploys'),
         )
-        subject.notify(environment: 'barenv')
+        deploy_notifier.notify(environment: 'barenv')
       end
     end
 
@@ -41,7 +43,7 @@ RSpec.describe Airbrake::DeployNotifier do
           instance_of(Airbrake::Promise),
           URI('https://api.airbrake.io/api/v4/projects/1/deploys'),
         )
-        subject.notify({})
+        deploy_notifier.notify({})
       end
     end
   end

data/spec/file_cache_spec.rb

@@ -1,5 +1,6 @@
 RSpec.describe Airbrake::FileCache do
   before { described_class.reset }
+
   after { described_class.reset }
 
   describe ".[]=" do

data/spec/filter_chain_spec.rb

@@ -1,4 +1,6 @@
 RSpec.describe Airbrake::FilterChain do
+  subject(:filter_chain) { described_class.new }
+
   let(:notice) { Airbrake::Notice.new(AirbrakeTestError.new) }
 
   describe "#refine" do
@@ -19,24 +21,27 @@ RSpec.describe Airbrake::FilterChain do
     it "executes filters from heaviest to lightest" do
       notice[:params][:bingo] = []
 
-      (0...3).reverse_each { |i| subject.add_filter(filter.new(i)) }
-      subject.refine(notice)
+      (0...3).reverse_each { |i| filter_chain.add_filter(filter.new(i)) }
+      filter_chain.refine(notice)
 
       expect(notice[:params][:bingo]).to eq([2, 1, 0])
     end
 
     it "stops execution once a notice was ignored" do
       f2 = filter.new(2)
-      expect(f2).to receive(:call)
+      allow(f2).to receive(:call)
 
       f1 = proc { |notice| notice.ignore! }
 
       f0 = filter.new(-1)
-      expect(f0).not_to receive(:call)
+      allow(f0).to receive(:call)
+
+      [f2, f1, f0].each { |f| filter_chain.add_filter(f) }
 
-      [f2, f1, f0].each { |f| subject.add_filter(f) }
+      filter_chain.refine(notice)
 
-      subject.refine(notice)
+      expect(f2).to have_received(:call)
+      expect(f0).not_to have_received(:call)
     end
   end
 
@@ -63,56 +68,56 @@ RSpec.describe Airbrake::FilterChain do
       notice[:params][:foo] = []
 
       f1 = filter.new(1)
-      subject.add_filter(f1)
+      filter_chain.add_filter(f1)
 
       foo_filter_mock = double
-      expect(foo_filter_mock).to(
-        receive(:name).at_least(:once).and_return('FooFilter'),
-      )
-      subject.delete_filter(foo_filter_mock)
+      allow(foo_filter_mock).to receive(:name).at_least(:once).and_return('FooFilter')
+      filter_chain.delete_filter(foo_filter_mock)
+
+      expect(foo_filter_mock).to have_received(:name)
 
       f2 = filter.new(2)
-      subject.add_filter(f2)
+      filter_chain.add_filter(f2)
 
-      subject.refine(notice)
+      filter_chain.refine(notice)
       expect(notice[:params][:foo]).to eq([2])
     end
   end
 
   describe "#inspect" do
     it "returns a string representation of an empty FilterChain" do
-      expect(subject.inspect).to eq('[]')
+      expect(filter_chain.inspect).to eq('[]')
     end
 
     it "returns a string representation of a non-empty FilterChain" do
-      subject.add_filter(proc {})
-      expect(subject.inspect).to eq('[Proc]')
+      filter_chain.add_filter(proc {})
+      expect(filter_chain.inspect).to eq('[Proc]')
     end
   end
 
   describe "#includes?" do
     context "when a custom filter class is included in the filter chain" do
       it "returns true" do
-        klass = Class.new {}
+        klass = Class.new
 
-        subject.add_filter(klass.new)
-        expect(subject.includes?(klass)).to eq(true)
+        filter_chain.add_filter(klass.new)
+        expect(filter_chain.includes?(klass)).to eq(true)
       end
     end
 
     context "when Proc filter class is included in the filter chain" do
       it "returns true" do
-        subject.add_filter(proc {})
-        expect(subject.includes?(Proc)).to eq(true)
+        filter_chain.add_filter(proc {})
+        expect(filter_chain.includes?(Proc)).to eq(true)
       end
     end
 
     context "when filter class is NOT included in the filter chain" do
       it "returns false" do
-        klass = Class.new {}
+        klass = Class.new
 
-        subject.add_filter(proc {})
-        expect(subject.includes?(klass)).to eq(false)
+        filter_chain.add_filter(proc {})
+        expect(filter_chain.includes?(klass)).to eq(false)
       end
     end
   end

data/spec/filters/context_filter_spec.rb

@@ -3,21 +3,30 @@ RSpec.describe Airbrake::Filters::ContextFilter do
 
   context "when the current context is empty" do
     it "doesn't merge anything with params" do
-      described_class.new({}).call(notice)
+      described_class.new.call(notice)
       expect(notice[:params]).to be_empty
     end
   end
 
   context "when the current context has some data" do
     it "merges the data with params" do
-      described_class.new(apples: 'oranges').call(notice)
+      Airbrake.merge_context(apples: 'oranges')
+      described_class.new.call(notice)
       expect(notice[:params]).to eq(airbrake_context: { apples: 'oranges' })
     end
 
-    it "clears the data from the provided context" do
+    it "clears the data from the current context" do
       context = { apples: 'oranges' }
-      described_class.new(context).call(notice)
-      expect(context).to be_empty
+      Airbrake.merge_context(context)
+      described_class.new.call(notice)
+      expect(Airbrake::Context.current).to be_empty
+    end
+
+    it "does not mutate the provided context object" do
+      context = { apples: 'oranges' }
+      Airbrake.merge_context(context)
+      described_class.new.call(notice)
+      expect(context).to match(apples: 'oranges')
     end
   end
 end

data/spec/filters/dependency_filter_spec.rb

@@ -1,9 +1,11 @@
 RSpec.describe Airbrake::Filters::DependencyFilter do
+  subject(:dependency_filter) { described_class.new }
+
   let(:notice) { Airbrake::Notice.new(AirbrakeTestError.new) }
 
   describe "#call" do
     it "attaches loaded dependencies to context/versions/dependencies" do
-      subject.call(notice)
+      dependency_filter.call(notice)
       expect(notice[:context][:versions][:dependencies]).to include(
         'airbrake-ruby' => Airbrake::AIRBRAKE_RUBY_VERSION,
       )

data/spec/filters/exception_attributes_filter_spec.rb

@@ -1,4 +1,6 @@
 RSpec.describe Airbrake::Filters::ExceptionAttributesFilter do
+  subject(:exception_attributes_filter) { described_class.new }
+
   describe "#call" do
     let(:notice) { Airbrake::Notice.new(ex) }
 
@@ -12,7 +14,7 @@ RSpec.describe Airbrake::Filters::ExceptionAttributesFilter do
       end
 
       it "doesn't raise" do
-        expect { subject.call(notice) }.not_to raise_error
+        expect { exception_attributes_filter.call(notice) }.not_to raise_error
         expect(notice[:params]).to be_empty
       end
     end
@@ -27,7 +29,7 @@ RSpec.describe Airbrake::Filters::ExceptionAttributesFilter do
       end
 
       it "doesn't raise" do
-        expect { subject.call(notice) }.not_to raise_error
+        expect { exception_attributes_filter.call(notice) }.not_to raise_error
         expect(notice[:params]).to be_empty
       end
     end
@@ -42,7 +44,7 @@ RSpec.describe Airbrake::Filters::ExceptionAttributesFilter do
       end
 
       it "merges parameters with the notice" do
-        subject.call(notice)
+        exception_attributes_filter.call(notice)
         expect(notice[:params]).to eq(foo: '1')
       end
     end

data/spec/filters/gem_root_filter_spec.rb

@@ -1,9 +1,12 @@
 RSpec.describe Airbrake::Filters::GemRootFilter do
+  subject(:gem_root_filter) { described_class.new }
+
   let(:notice) { Airbrake::Notice.new(AirbrakeTestError.new) }
   let(:root1) { '/my/gem/root' }
   let(:root2) { '/my/other/gem/root' }
 
   before { Gem.path << root1 << root2 }
+
   after { 2.times { Gem.path.pop } }
 
   it "replaces gem root in the backtrace with a label" do
@@ -16,7 +19,7 @@ RSpec.describe Airbrake::Filters::GemRootFilter do
     ]
     # rubocop:enable Layout/LineLength
 
-    subject.call(notice)
+    gem_root_filter.call(notice)
 
     # rubocop:disable Layout/LineLength
     expect(notice[:errors].first[:backtrace]).to(
@@ -34,7 +37,7 @@ RSpec.describe Airbrake::Filters::GemRootFilter do
 
   it "does not filter file when it is nil" do
     expect(notice[:errors].first[:file]).to be_nil
-    expect { subject.call(notice) }.not_to(
+    expect { gem_root_filter.call(notice) }.not_to(
       change { notice[:errors].first[:file] },
     )
   end

data/spec/filters/git_last_checkout_filter_spec.rb

@@ -1,21 +1,21 @@
 RSpec.describe Airbrake::Filters::GitLastCheckoutFilter do
-  subject { described_class.new('.') }
+  subject(:git_last_checkout_filter) { described_class.new('.') }
 
   let(:notice) { Airbrake::Notice.new(AirbrakeTestError.new) }
 
   context "when context/lastCheckout is defined" do
     it "doesn't attach anything to context/lastCheckout" do
       notice[:context][:lastCheckout] = '123'
-      subject.call(notice)
+      git_last_checkout_filter.call(notice)
       expect(notice[:context][:lastCheckout]).to eq('123')
     end
   end
 
   context "when .git directory doesn't exist" do
-    subject { described_class.new('root/dir') }
+    subject(:git_last_checkout_without_git_dir_filter) { described_class.new('root/dir') }
 
     it "doesn't attach anything to context/lastCheckout" do
-      subject.call(notice)
+      git_last_checkout_without_git_dir_filter.call(notice)
       expect(notice[:context][:lastCheckout]).to be_nil
     end
   end
@@ -25,7 +25,7 @@ RSpec.describe Airbrake::Filters::GitLastCheckoutFilter do
       before { ENV['AIRBRAKE_DEPLOY_USERNAME'] = 'deployer' }
 
       it "attaches username from the environment" do
-        subject.call(notice)
+        git_last_checkout_filter.call(notice)
         expect(notice[:context][:lastCheckout][:username]).to eq('deployer')
       end
     end
@@ -34,7 +34,7 @@ RSpec.describe Airbrake::Filters::GitLastCheckoutFilter do
       before { ENV['AIRBRAKE_DEPLOY_USERNAME'] = nil }
 
       it "attaches last checkouted username" do
-        subject.call(notice)
+        git_last_checkout_filter.call(notice)
         username = notice[:context][:lastCheckout][:username]
         expect(username).not_to be_empty
         expect(username).not_to be_nil
@@ -42,20 +42,18 @@ RSpec.describe Airbrake::Filters::GitLastCheckoutFilter do
     end
 
     it "attaches last checkouted email" do
-      subject.call(notice)
-      expect(notice[:context][:lastCheckout][:email]).to(
-        match(/\A\w+[\w.-]*@(\w+\.)*\w+\z/),
-      )
+      git_last_checkout_filter.call(notice)
+      expect(notice[:context][:lastCheckout][:email]).to(match(/\A\w+@[\w\-.]+\z/))
     end
 
     it "attaches last checkouted revision" do
-      subject.call(notice)
+      git_last_checkout_filter.call(notice)
       expect(notice[:context][:lastCheckout][:revision]).not_to be_empty
       expect(notice[:context][:lastCheckout][:revision].size).to eq(40)
     end
 
     it "attaches last checkouted time" do
-      subject.call(notice)
+      git_last_checkout_filter.call(notice)
       expect(notice[:context][:lastCheckout][:time]).not_to be_empty
       expect(notice[:context][:lastCheckout][:time].size).to eq(25)
     end

data/spec/filters/git_repository_filter.rb

@@ -1,5 +1,5 @@
 RSpec.describe Airbrake::Filters::GitRepositoryFilter do
-  subject { described_class.new('.') }
+  subject(:git_repository_filter) { described_class.new('.') }
 
   let(:notice) do
     Airbrake::Notice.new(Airbrake::Config.new, AirbrakeTestError.new)
@@ -9,42 +9,42 @@ RSpec.describe Airbrake::Filters::GitRepositoryFilter do
     it "parses standard git version" do
       allow_any_instance_of(Kernel)
         .to receive(:`).and_return('git version 2.18.0')
-      expect { subject }.not_to raise_error
+      expect { git_repository_filter }.not_to raise_error
     end
 
     it "parses release candidate git version" do
       allow_any_instance_of(Kernel)
         .to receive(:`).and_return('git version 2.21.0-rc0')
-      expect { subject }.not_to raise_error
+      expect { git_repository_filter }.not_to raise_error
     end
 
     it "parses git version with brackets" do
       allow_any_instance_of(Kernel)
         .to receive(:`).and_return('git version 2.17.2 (Apple Git-113)')
-      expect { subject }.not_to raise_error
+      expect { git_repository_filter }.not_to raise_error
     end
   end
 
   context "when context/repository is defined" do
     it "doesn't attach anything to context/repository" do
       notice[:context][:repository] = 'git@github.com:kyrylo/test.git'
-      subject.call(notice)
+      git_repository_filter.call(notice)
       expect(notice[:context][:repository]).to eq('git@github.com:kyrylo/test.git')
     end
   end
 
   context "when .git directory doesn't exist" do
-    subject { described_class.new('root/dir') }
+    git_repository_filter { described_class.new('root/dir') }
 
     it "doesn't attach anything to context/repository" do
-      subject.call(notice)
+      git_repository_filter.call(notice)
       expect(notice[:context][:repository]).to be_nil
     end
   end
 
   context "when .git directory exists" do
     it "attaches context/repository" do
-      subject.call(notice)
+      git_repository_filter.call(notice)
       expect(notice[:context][:repository]).to eq(
         'ssh://git@github.com/airbrake/airbrake-ruby.git',
       )
@@ -54,7 +54,7 @@ RSpec.describe Airbrake::Filters::GitRepositoryFilter do
   context "when git is not in PATH" do
     it "does not attach context/repository" do
       ENV['PATH'] = ''
-      subject.call(notice)
+      git_repository_filter.call(notice)
       expect(notice[:context][:repository]).to be_nil
     end
   end

data/spec/filters/git_revision_filter_spec.rb

@@ -1,5 +1,5 @@
 RSpec.describe Airbrake::Filters::GitRevisionFilter do
-  subject { described_class.new('root/dir') }
+  subject(:git_revision_filter) { described_class.new('root/dir') }
 
   # 'let!', not 'let' to make sure Notice doesn't call File.exist? with
   # unexpected arguments.
@@ -8,88 +8,88 @@ RSpec.describe Airbrake::Filters::GitRevisionFilter do
   context "when context/revision is defined" do
     it "doesn't attach anything to context/revision" do
       notice[:context][:revision] = '1.2.3'
-      subject.call(notice)
+      git_revision_filter.call(notice)
       expect(notice[:context][:revision]).to eq('1.2.3')
     end
   end
 
   context "when .git directory doesn't exist" do
     it "doesn't attach anything to context/revision" do
-      subject.call(notice)
+      git_revision_filter.call(notice)
       expect(notice[:context][:revision]).to be_nil
     end
   end
 
   context "when .git directory exists" do
     before do
-      expect(File).to receive(:exist?).with('root/dir/.git').and_return(true)
+      allow(File).to receive(:exist?).with('root/dir/.git').and_return(true)
     end
 
     context "and when HEAD doesn't exist" do
       before do
-        expect(File).to receive(:exist?).with('root/dir/.git/HEAD').and_return(false)
+        allow(File).to receive(:exist?).with('root/dir/.git/HEAD').and_return(false)
       end
 
       it "doesn't attach anything to context/revision" do
-        subject.call(notice)
+        git_revision_filter.call(notice)
         expect(notice[:context][:revision]).to be_nil
       end
     end
 
     context "and when HEAD exists" do
       before do
-        expect(File).to receive(:exist?).with('root/dir/.git/HEAD').and_return(true)
+        allow(File).to receive(:exist?).with('root/dir/.git/HEAD').and_return(true)
       end
 
       context "and also when HEAD doesn't start with 'ref: '" do
         before do
-          expect(File).to(
+          allow(File).to(
             receive(:read).with('root/dir/.git/HEAD').and_return('refs/foo'),
           )
         end
 
         it "attaches the content of HEAD to context/revision" do
-          subject.call(notice)
+          git_revision_filter.call(notice)
           expect(notice[:context][:revision]).to eq('refs/foo')
         end
       end
 
       context "and also when HEAD starts with 'ref: " do
         before do
-          expect(File).to(
+          allow(File).to(
             receive(:read).with('root/dir/.git/HEAD').and_return("ref: refs/foo\n"),
           )
         end
 
         context "when the ref exists" do
           before do
-            expect(File).to(
+            allow(File).to(
               receive(:exist?).with('root/dir/.git/refs/foo').and_return(true),
             )
-            expect(File).to(
+            allow(File).to(
               receive(:read).with('root/dir/.git/refs/foo').and_return("d34db33f\n"),
             )
           end
 
           it "attaches the revision from the ref to context/revision" do
-            subject.call(notice)
+            git_revision_filter.call(notice)
             expect(notice[:context][:revision]).to eq('d34db33f')
           end
         end
 
         context "when the ref doesn't exist" do
           before do
-            expect(File).to(
+            allow(File).to(
               receive(:exist?).with('root/dir/.git/refs/foo').and_return(false),
             )
           end
 
           context "and when '.git/packed-refs' exists" do
             before do
-              expect(File).to(
+              allow(File).to(
                 receive(:exist?).with('root/dir/.git/packed-refs').and_return(true),
               )
-              expect(File).to(
+              allow(File).to(
                 receive(:readlines).with('root/dir/.git/packed-refs').and_return(
                   [
                     "# pack-refs with: peeled fully-peeled\n",
@@ -102,20 +102,20 @@ RSpec.describe Airbrake::Filters::GitRevisionFilter do
             end
 
             it "attaches the revision from 'packed-refs' to context/revision" do
-              subject.call(notice)
+              git_revision_filter.call(notice)
               expect(notice[:context][:revision]).to eq('d34db33f')
             end
           end
 
           context "and when '.git/packed-refs' doesn't exist" do
             before do
-              expect(File).to(
+              allow(File).to(
                 receive(:exist?).with('root/dir/.git/packed-refs').and_return(false),
               )
             end
 
             it "attaches the content of HEAD to context/revision" do
-              subject.call(notice)
+              git_revision_filter.call(notice)
               expect(notice[:context][:revision]).to eq('refs/foo')
             end
           end