airbrake-ruby 5.1.0-java → 6.0.0-java

data/spec/code_hunk_spec.rb

@@ -1,4 +1,6 @@
 RSpec.describe Airbrake::CodeHunk do
+  subject(:code_hunk) { described_class.new }
+
   after do
     %w[empty_file.rb code.rb banana.rb short_file.rb long_line.txt].each do |f|
       Airbrake::FileCache[project_root_path(f)] = nil
@@ -27,10 +29,12 @@ RSpec.describe Airbrake::CodeHunk do
     end
 
     context "when a file has less than NLINES lines before start line" do
-      subject { described_class.new.get(project_root_path('code.rb'), 1) }
+      subject(:code_hunk) do
+        described_class.new.get(project_root_path('code.rb'), 1)
+      end
 
       it do
-        is_expected.to(
+        expect(code_hunk).to(
           eq(
             1 => 'module Airbrake',
             2 => '  ##',
@@ -43,10 +47,12 @@ RSpec.describe Airbrake::CodeHunk do
     end
 
     context "when a file has less than NLINES lines after end line" do
-      subject { described_class.new.get(project_root_path('code.rb'), 222) }
+      subject(:code_hunk) do
+        described_class.new.get(project_root_path('code.rb'), 222)
+      end
 
       it do
-        is_expected.to(
+        expect(code_hunk).to(
           eq(
             220 => '  end',
             221 => 'end',
@@ -56,12 +62,12 @@ RSpec.describe Airbrake::CodeHunk do
     end
 
     context "when a file has less than NLINES lines before and after" do
-      subject do
+      subject(:code_hunk) do
         described_class.new.get(project_root_path('short_file.rb'), 2)
       end
 
       it do
-        is_expected.to(
+        expect(code_hunk).to(
           eq(
             1 => 'module Banana',
             2 => '  attr_reader :bingo',
@@ -72,10 +78,12 @@ RSpec.describe Airbrake::CodeHunk do
     end
 
     context "when a file has enough lines before and after" do
-      subject { described_class.new.get(project_root_path('code.rb'), 100) }
+      subject(:code_hunk) do
+        described_class.new.get(project_root_path('code.rb'), 100)
+      end
 
       it do
-        is_expected.to(
+        expect(code_hunk).to(
           eq(
             98 => '          return json if json && json.bytesize <= MAX_NOTICE_SIZE',
             99 => '        end',
@@ -88,27 +96,28 @@ RSpec.describe Airbrake::CodeHunk do
     end
 
     context "when a line exceeds the length limit" do
-      subject do
+      subject(:code_hunk) do
         described_class.new.get(project_root_path('long_line.txt'), 1)
       end
 
       it "strips the line" do
-        expect(subject[1]).to eq('l' + 'o' * 196 + 'ng')
+        expect(code_hunk[1]).to eq("l#{'o' * 196}ng")
       end
     end
 
     context "when an error occurrs while fetching code" do
       before do
-        expect(Airbrake::FileCache).to receive(:[]).and_raise(Errno::EACCES)
+        allow(Airbrake::Loggable.instance).to receive(:error)
+        allow(Airbrake::FileCache).to receive(:[]).and_raise(Errno::EACCES)
       end
 
       it "logs error and returns nil" do
-        expect(Airbrake::Loggable.instance).to receive(:error).with(
-          /can't read code hunk.+Permission denied/,
-        )
-        expect(subject.get(project_root_path('code.rb'), 1)).to(
+        expect(code_hunk.get(project_root_path('code.rb'), 1)).to(
           eq(1 => ''),
         )
+        expect(Airbrake::Loggable.instance).to have_received(:error).with(
+          /can't read code hunk.+Permission denied/,
+        )
       end
     end
   end

data/spec/config/processor_spec.rb

@@ -44,12 +44,17 @@ RSpec.describe Airbrake::Config::Processor do
   end
 
   describe "#process_remote_configuration" do
+    before do
+      allow(Airbrake::RemoteSettings).to receive(:poll)
+    end
+
     context "when the config doesn't define a project_id" do
       let(:config) { Airbrake::Config.new(project_id: nil) }
 
       it "doesn't set remote settings" do
-        expect(Airbrake::RemoteSettings).not_to receive(:poll)
         described_class.new(config).process_remote_configuration
+
+        expect(Airbrake::RemoteSettings).not_to have_received(:poll)
       end
     end
 
@@ -57,8 +62,9 @@ RSpec.describe Airbrake::Config::Processor do
       let(:config) { Airbrake::Config.new(project_id: 123, environment: 'test') }
 
       it "doesn't set remote settings" do
-        expect(Airbrake::RemoteSettings).not_to receive(:poll)
         described_class.new(config).process_remote_configuration
+
+        expect(Airbrake::RemoteSettings).not_to have_received(:poll)
       end
     end
 
@@ -68,8 +74,19 @@ RSpec.describe Airbrake::Config::Processor do
       end
 
       it "sets remote settings" do
-        expect(Airbrake::RemoteSettings).to receive(:poll)
         described_class.new(config).process_remote_configuration
+
+        expect(Airbrake::RemoteSettings).to have_received(:poll)
+      end
+    end
+
+    context "when the config disables the remote_config option" do
+      let(:config) { Airbrake::Config.new(project_id: 123, remote_config: false) }
+
+      it "doesn't set remote settings" do
+        described_class.new(config).process_remote_configuration
+
+        expect(Airbrake::RemoteSettings).not_to have_received(:poll)
       end
     end
   end

data/spec/config/validator_spec.rb

@@ -175,9 +175,12 @@ RSpec.describe Airbrake::Config::Validator do
       end
 
       it "warns about 'no effect'" do
-        expect(config.logger).to receive(:warn)
-          .with(/'ignore_environments' has no effect/)
+        allow(config.logger).to receive(:warn)
+
         described_class.check_notify_ability(config)
+
+        expect(config.logger).to have_received(:warn)
+          .with(/'ignore_environments' has no effect/)
       end
     end
 

data/spec/config_spec.rb

@@ -1,4 +1,6 @@
 RSpec.describe Airbrake::Config do
+  subject(:config) { described_class.new }
+
   let(:resolved_promise) { Airbrake::Promise.new.resolve }
   let(:rejected_promise) { Airbrake::Promise.new.reject }
 
@@ -26,26 +28,31 @@ RSpec.describe Airbrake::Config do
   its(:query_stats) { is_expected.to eq(true) }
   its(:job_stats) { is_expected.to eq(true) }
   its(:error_notifications) { is_expected.to eq(true) }
+  its(:remote_config) { is_expected.to eq(true) }
 
   its(:remote_config_host) do
-    is_expected.to eq('https://v1-production-notifier-configs.s3.amazonaws.com')
+    is_expected.to eq('https://notifier-configs.airbrake.io')
   end
 
   describe "#new" do
     context "when user config is passed" do
       subject { described_class.new(logger: StringIO.new) }
+
       its(:logger) { is_expected.to be_a(StringIO) }
     end
   end
 
   describe "#valid?" do
-    context "when #validate returns a resolved promise" do
-      before { expect(subject).to receive(:validate).and_return(resolved_promise) }
+    context "when the config is valid" do
+      before do
+        config.project_id = 123
+        config.project_key = 'abc'
+      end
+
       it { is_expected.to be_valid }
     end
 
-    context "when #validate returns a rejected promise" do
-      before { expect(subject).to receive(:validate).and_return(rejected_promise) }
+    context "when the config is invalid" do
       it { is_expected.not_to be_valid }
     end
   end
@@ -53,7 +60,7 @@ RSpec.describe Airbrake::Config do
   describe "#ignored_environment?" do
     context "when Validator returns a resolved promise" do
       before do
-        expect(Airbrake::Config::Validator).to receive(:check_notify_ability)
+        allow(Airbrake::Config::Validator).to receive(:check_notify_ability)
           .and_return(resolved_promise)
       end
 
@@ -62,7 +69,7 @@ RSpec.describe Airbrake::Config do
 
     context "when Validator returns a rejected promise" do
       before do
-        expect(Airbrake::Config::Validator).to receive(:check_notify_ability)
+        allow(Airbrake::Config::Validator).to receive(:check_notify_ability)
           .and_return(rejected_promise)
       end
 
@@ -95,19 +102,21 @@ RSpec.describe Airbrake::Config do
   end
 
   describe "#check_configuration" do
-    let(:user_config) { {} }
-
     subject { described_class.new(valid_params.merge(user_config)) }
 
+    let(:user_config) { {} }
+
     its(:check_configuration) { is_expected.to be_an(Airbrake::Promise) }
 
     context "when config is invalid" do
       let(:user_config) { { project_id: nil } }
+
       its(:check_configuration) { is_expected.to be_rejected }
     end
 
     context "when current environment is ignored" do
       let(:user_config) { { environment: 'test', ignore_environments: ['test'] } }
+
       its(:check_configuration) { is_expected.to be_rejected }
     end
 
@@ -119,12 +128,12 @@ RSpec.describe Airbrake::Config do
   describe "#check_performance_options" do
     it "returns a promise" do
       resource = Airbrake::Query.new(method: '', route: '', query: '', timing: 1)
-      expect(subject.check_performance_options(resource))
+      expect(config.check_performance_options(resource))
         .to be_an(Airbrake::Promise)
     end
 
     context "when performance stats are disabled" do
-      before { subject.performance_stats = false }
+      before { config.performance_stats = false }
 
       let(:resource) do
         Airbrake::Request.new(
@@ -133,7 +142,7 @@ RSpec.describe Airbrake::Config do
       end
 
       it "returns a rejected promise" do
-        promise = subject.check_performance_options(resource)
+        promise = config.check_performance_options(resource)
         expect(promise.value).to eq(
           'error' => "The Performance Stats feature is disabled",
         )
@@ -141,14 +150,14 @@ RSpec.describe Airbrake::Config do
     end
 
     context "when query stats are disabled" do
-      before { subject.query_stats = false }
+      before { config.query_stats = false }
 
       let(:resource) do
         Airbrake::Query.new(method: 'GET', route: '/foo', query: '', timing: 1)
       end
 
       it "returns a rejected promise" do
-        promise = subject.check_performance_options(resource)
+        promise = config.check_performance_options(resource)
         expect(promise.value).to eq(
           'error' => "The Query Stats feature is disabled",
         )
@@ -156,14 +165,14 @@ RSpec.describe Airbrake::Config do
     end
 
     context "when job stats are disabled" do
-      before { subject.job_stats = false }
+      before { config.job_stats = false }
 
       let(:resource) do
         Airbrake::Queue.new(queue: 'foo_queue', error_count: 0, timing: 1)
       end
 
       it "returns a rejected promise" do
-        promise = subject.check_performance_options(resource)
+        promise = config.check_performance_options(resource)
         expect(promise.value).to eq(
           'error' => "The Job Stats feature is disabled",
         )
@@ -173,7 +182,7 @@ RSpec.describe Airbrake::Config do
 
   describe "#logger" do
     it "sets logger level to Logger::WARN" do
-      expect(subject.logger.level).to eq(Logger::WARN)
+      expect(config.logger.level).to eq(Logger::WARN)
     end
   end
 end

data/spec/context_spec.rb

@@ -0,0 +1,54 @@
+RSpec.describe Airbrake::Context do
+  subject(:context) { described_class.current }
+
+  before { described_class.current.clear }
+
+  after { described_class.current.clear }
+
+  describe "#merge!" do
+    it "merges the given context with the current one" do
+      context.merge!(apples: 'oranges')
+      expect(context.to_h).to match(apples: 'oranges')
+    end
+  end
+
+  describe "#clear" do
+    it "clears the context" do
+      context.merge!(apples: 'oranges')
+      context.clear
+      expect(context.to_h).to be_empty
+    end
+  end
+
+  describe "#to_h" do
+    it "returns a hash representation of the context" do
+      expect(context.to_h).to be_a(Hash)
+    end
+  end
+
+  describe "#empty?" do
+    context "when the context has data" do
+      it "returns true" do
+        context.merge!(apples: 'oranges')
+        expect(context).not_to be_empty
+      end
+    end
+
+    context "when the context has NO data" do
+      it "returns false" do
+        expect(context).to be_empty
+      end
+    end
+  end
+
+  context "when another thread is spawned" do
+    it "doesn't clash with other threads' contexts" do
+      described_class.current.merge!(apples: 'oranges')
+      th = Thread.new do
+        described_class.current.merge!(foos: 'bars')
+      end
+      th.join
+      expect(described_class.current.to_h).to match(apples: 'oranges')
+    end
+  end
+end

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