airbrake-ruby 3.2.6 → 4.0.0

data/spec/backtrace_spec.rb

@@ -1,8 +1,4 @@
 RSpec.describe Airbrake::Backtrace do
-  let(:config) do
-    Airbrake::Config.new.tap { |c| c.logger = Logger.new('/dev/null') }
-  end
-
   describe ".parse" do
     context "UNIX backtrace" do
       let(:parsed_backtrace) do
@@ -24,9 +20,8 @@ RSpec.describe Airbrake::Backtrace do
       end
 
       it "returns a properly formatted array of hashes" do
-        expect(
-          described_class.parse(config, AirbrakeTestError.new)
-        ).to eq(parsed_backtrace)
+        expect(described_class.parse(AirbrakeTestError.new)).
+          to eq(parsed_backtrace)
       end
     end
 
@@ -46,7 +41,7 @@ RSpec.describe Airbrake::Backtrace do
       end
 
       it "returns a properly formatted array of hashes" do
-        expect(described_class.parse(config, ex)).to eq(parsed_backtrace)
+        expect(described_class.parse(ex)).to eq(parsed_backtrace)
       end
     end
 
@@ -70,9 +65,8 @@ RSpec.describe Airbrake::Backtrace do
       it "returns a properly formatted array of hashes" do
         allow(described_class).to receive(:java_exception?).and_return(true)
 
-        expect(
-          described_class.parse(config, JavaAirbrakeTestError.new)
-        ).to eq(backtrace_array)
+        expect(described_class.parse(JavaAirbrakeTestError.new)).
+          to eq(backtrace_array)
       end
     end
 
@@ -99,7 +93,7 @@ RSpec.describe Airbrake::Backtrace do
 
       it "returns a properly formatted array of hashes" do
         allow(described_class).to receive(:java_exception?).and_return(true)
-        expect(described_class.parse(config, ex)).to eq(parsed_backtrace)
+        expect(described_class.parse(ex)).to eq(parsed_backtrace)
       end
     end
 
@@ -123,7 +117,7 @@ RSpec.describe Airbrake::Backtrace do
       let(:ex) { AirbrakeTestError.new.tap { |e| e.set_backtrace(backtrace) } }
 
       it "returns a properly formatted array of hashes" do
-        expect(described_class.parse(config, ex)).to eq(parsed_backtrace)
+        expect(described_class.parse(ex)).to eq(parsed_backtrace)
       end
     end
 
@@ -148,7 +142,7 @@ RSpec.describe Airbrake::Backtrace do
         end
 
         it "returns a properly formatted array of hashes" do
-          expect(described_class.parse(config, ex)).to eq(parsed_backtrace)
+          expect(described_class.parse(ex)).to eq(parsed_backtrace)
         end
       end
 
@@ -166,7 +160,7 @@ RSpec.describe Airbrake::Backtrace do
         end
 
         it "returns a properly formatted array of hashes" do
-          expect(described_class.parse(config, ex)).to eq(parsed_backtrace)
+          expect(described_class.parse(ex)).to eq(parsed_backtrace)
         end
       end
     end
@@ -178,18 +172,15 @@ RSpec.describe Airbrake::Backtrace do
 
       it "returns array of hashes where each unknown frame is marked as 'function'" do
         expect(
-          described_class.parse(config, ex)
+          described_class.parse(ex)
         ).to eq([file: nil, line: nil, function: 'a b c 1 23 321 .rb'])
       end
 
-      it "logs unknown frames as errors" do
-        out = StringIO.new
-        config.logger = Logger.new(out)
-
-        expect { described_class.parse(config, ex) }.
-          to change { out.string }.
-          from('').
-          to(/ERROR -- : can't parse 'a b c 1 23 321 .rb'/)
+      it "logs frames that cannot be parsed" do
+        expect(Airbrake::Loggable.instance).to receive(:error).with(
+          /can't parse 'a b c 1 23 321 .rb'/
+        )
+        described_class.parse(ex)
       end
     end
 
@@ -207,7 +198,7 @@ RSpec.describe Airbrake::Backtrace do
       end
 
       it "returns a properly formatted array of hashes" do
-        expect(described_class.parse(config, ex)).to eq(parsed_backtrace)
+        expect(described_class.parse(ex)).to eq(parsed_backtrace)
       end
     end
 
@@ -230,7 +221,7 @@ RSpec.describe Airbrake::Backtrace do
 
       it "returns a properly formatted array of hashes" do
         stub_const('OCIError', AirbrakeTestError)
-        expect(described_class.parse(config, ex)).to eq(parsed_backtrace)
+        expect(described_class.parse(ex)).to eq(parsed_backtrace)
       end
     end
 
@@ -263,20 +254,17 @@ RSpec.describe Airbrake::Backtrace do
 
       it "returns a properly formatted array of hashes" do
         stub_const('ExecJS::RuntimeError', AirbrakeTestError)
-        expect(described_class.parse(config, ex)).to eq(parsed_backtrace)
+        expect(described_class.parse(ex)).to eq(parsed_backtrace)
       end
     end
 
     context "when code hunks are enabled" do
-      let(:config) do
-        config = Airbrake::Config.new
-        config.logger = Logger.new('/dev/null')
-        config.code_hunks = true
-        config
-      end
+      before { Airbrake::Config.instance.merge(code_hunks: true) }
 
       context "and when root_directory is configured" do
-        before { config.root_directory = project_root_path('') }
+        before do
+          Airbrake::Config.instance.merge(root_directory: project_root_path(''))
+        end
 
         let(:parsed_backtrace) do
           [
@@ -315,12 +303,16 @@ RSpec.describe Airbrake::Backtrace do
             project_root_path('vendor/bundle/ignored_file.rb') + ":2:in `ignore_me'"
           ]
           ex.set_backtrace(backtrace)
-          expect(described_class.parse(config, ex)).to eq(parsed_backtrace)
+          expect(described_class.parse(ex)).to eq(parsed_backtrace)
         end
       end
 
       context "and when root_directory is a Pathname" do
-        before { config.root_directory = Pathname.new(project_root_path('')) }
+        before do
+          Airbrake::Config.instance.merge(
+            root_directory: Pathname.new(project_root_path(''))
+          )
+        end
 
         let(:parsed_backtrace) do
           [
@@ -344,13 +336,13 @@ RSpec.describe Airbrake::Backtrace do
         it "attaches code to those frames files of which match root_directory" do
           ex = RuntimeError.new
           ex.set_backtrace([project_root_path('code.rb') + ":94:in `to_json'"])
-          expect(described_class.parse(config, ex)).to eq(parsed_backtrace)
+          expect(described_class.parse(ex)).to eq(parsed_backtrace)
         end
       end
 
       context "and when root_directory isn't configured" do
         before do
-          config.root_directory = nil
+          Airbrake::Config.instance.merge(root_directory: nil)
           stub_const('Airbrake::Backtrace::CODE_FRAME_LIMIT', 2)
         end
 
@@ -400,21 +392,18 @@ RSpec.describe Airbrake::Backtrace do
             project_root_path('code.rb') + ":96:in `to_json'"
           ]
           ex.set_backtrace(backtrace)
-          expect(described_class.parse(config, ex)).to eq(parsed_backtrace)
+          expect(described_class.parse(ex)).to eq(parsed_backtrace)
         end
       end
     end
 
     context "when code hunks are disabled" do
-      let(:config) do
-        config = Airbrake::Config.new
-        config.logger = Logger.new('/dev/null')
-        config.code_hunks = false
-        config
-      end
+      before { Airbrake::Config.instance.merge(code_hunks: false) }
 
       context "and when root_directory is configured" do
-        before { config.root_directory = project_root_path('') }
+        before do
+          Airbrake::Config.instance.merge(root_directory: project_root_path(''))
+        end
 
         let(:parsed_backtrace) do
           [
@@ -430,7 +419,7 @@ RSpec.describe Airbrake::Backtrace do
           ex = RuntimeError.new
           backtrace = [project_root_path('code.rb') + ":94:in `to_json'"]
           ex.set_backtrace(backtrace)
-          expect(described_class.parse(config, ex)).to eq(parsed_backtrace)
+          expect(described_class.parse(ex)).to eq(parsed_backtrace)
         end
       end
     end

data/spec/code_hunk_spec.rb

@@ -1,6 +1,4 @@
 RSpec.describe Airbrake::CodeHunk do
-  let(:config) { Airbrake::Config.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
@@ -10,26 +8,26 @@ RSpec.describe Airbrake::CodeHunk do
   describe "#to_h" do
     context "when file is empty" do
       subject do
-        described_class.new(config).get(project_root_path('empty_file.rb'), 1)
+        described_class.new.get(project_root_path('empty_file.rb'), 1)
       end
 
       it { is_expected.to eq(1 => '') }
     end
 
     context "when line is nil" do
-      subject { described_class.new(config).get(project_root_path('code.rb'), nil) }
+      subject { described_class.new.get(project_root_path('code.rb'), nil) }
 
       it { is_expected.to be_nil }
     end
 
     context "when a file doesn't exist" do
-      subject { described_class.new(config).get(project_root_path('banana.rb'), 1) }
+      subject { described_class.new.get(project_root_path('banana.rb'), 1) }
 
       it { is_expected.to be_nil }
     end
 
     context "when a file has less than NLINES lines before start line" do
-      subject { described_class.new(config).get(project_root_path('code.rb'), 1) }
+      subject { described_class.new.get(project_root_path('code.rb'), 1) }
 
       it do
         is_expected.to(
@@ -45,7 +43,7 @@ RSpec.describe Airbrake::CodeHunk do
     end
 
     context "when a file has less than NLINES lines after end line" do
-      subject { described_class.new(config).get(project_root_path('code.rb'), 222) }
+      subject { described_class.new.get(project_root_path('code.rb'), 222) }
 
       it do
         is_expected.to(
@@ -59,7 +57,7 @@ RSpec.describe Airbrake::CodeHunk do
 
     context "when a file has less than NLINES lines before and after" do
       subject do
-        described_class.new(config).get(project_root_path('short_file.rb'), 2)
+        described_class.new.get(project_root_path('short_file.rb'), 2)
       end
 
       it do
@@ -74,7 +72,7 @@ RSpec.describe Airbrake::CodeHunk do
     end
 
     context "when a file has enough lines before and after" do
-      subject { described_class.new(config).get(project_root_path('code.rb'), 100) }
+      subject { described_class.new.get(project_root_path('code.rb'), 100) }
 
       it do
         is_expected.to(
@@ -91,7 +89,7 @@ RSpec.describe Airbrake::CodeHunk do
 
     context "when a line exceeds the length limit" do
       subject do
-        described_class.new(config).get(project_root_path('long_line.txt'), 1)
+        described_class.new.get(project_root_path('long_line.txt'), 1)
       end
 
       it "strips the line" do
@@ -105,13 +103,12 @@ RSpec.describe Airbrake::CodeHunk do
       end
 
       it "logs error and returns nil" do
-        out = StringIO.new
-        config = Airbrake::Config.new
-        config.logger = Logger.new(out)
-        expect(described_class.new(config).get(project_root_path('code.rb'), 1)).to(
+        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(
           eq(1 => '')
         )
-        expect(out.string).to match(/can't read code hunk.+Permission denied/)
       end
     end
   end

data/spec/config_spec.rb

@@ -1,43 +1,41 @@
 RSpec.describe Airbrake::Config do
-  let(:config) { described_class.new }
-
   describe "#new" do
     describe "options" do
       it "doesn't set the default project_id" do
-        expect(config.project_id).to be_nil
+        expect(subject.project_id).to be_nil
       end
 
       it "doesn't set the default project_key" do
-        expect(config.project_key).to be_nil
+        expect(subject.project_key).to be_nil
       end
 
       it "doesn't set the default proxy" do
-        expect(config.proxy).to be_empty
+        expect(subject.proxy).to be_empty
       end
 
       it "sets the default logger" do
-        expect(config.logger).to be_a Logger
+        expect(subject.logger).to be_a Logger
       end
 
       it "doesn't set the default app_version" do
-        expect(config.app_version).to be_nil
+        expect(subject.app_version).to be_nil
       end
 
       it "sets the default versions" do
-        expect(config.versions).to be_empty
+        expect(subject.versions).to be_empty
       end
 
       it "sets the default host" do
-        expect(config.host).to eq('https://api.airbrake.io')
+        expect(subject.host).to eq('https://api.airbrake.io')
       end
 
       it "sets the default endpoint" do
-        expect(config.endpoint).not_to be_nil
+        expect(subject.endpoint).not_to be_nil
       end
 
       it "creates a new Config and merges it with the user config" do
-        cfg = described_class.new(logger: StringIO.new)
-        expect(cfg.logger).to be_a StringIO
+        config = described_class.new(logger: StringIO.new)
+        expect(config.logger).to be_a(StringIO)
       end
 
       it "raises error on unknown config options" do
@@ -46,57 +44,43 @@ RSpec.describe Airbrake::Config do
       end
 
       it "sets the default number of workers" do
-        expect(config.workers).to eq(1)
+        expect(subject.workers).to eq(1)
       end
 
       it "sets the default number of queue size" do
-        expect(config.queue_size).to eq(100)
+        expect(subject.queue_size).to eq(100)
       end
 
       it "sets the default root_directory" do
-        expect(config.root_directory).to eq Bundler.root.realpath.to_s
+        expect(subject.root_directory).to eq Bundler.root.realpath.to_s
       end
 
       it "doesn't set the default environment" do
-        expect(config.environment).to be_nil
+        expect(subject.environment).to be_nil
       end
 
       it "doesn't set default notify_environments" do
-        expect(config.ignore_environments).to be_empty
+        expect(subject.ignore_environments).to be_empty
       end
 
       it "doesn't set default timeout" do
-        expect(config.timeout).to be_nil
+        expect(subject.timeout).to be_nil
       end
 
       it "doesn't set default blacklist" do
-        expect(config.blacklist_keys).to be_empty
+        expect(subject.blacklist_keys).to be_empty
       end
 
       it "doesn't set default whitelist" do
-        expect(config.whitelist_keys).to be_empty
-      end
-
-      it "disables route stats by default (deprecated)" do
-        out = StringIO.new
-        config.logger = Logger.new(out)
-        expect(config.route_stats).to be_falsey
-        expect(out.string).to match(/'route_stats'.+is deprecated/)
+        expect(subject.whitelist_keys).to be_empty
       end
 
       it "disables performance stats by default" do
-        expect(config.performance_stats).to be_falsey
-      end
-
-      it "sets the default route_stats_flush_period (deprecated)" do
-        out = StringIO.new
-        config.logger = Logger.new(out)
-        expect(config.route_stats_flush_period).to eq(15)
-        expect(out.string).to match(/'route_stats_flush_period'.+is deprecated/)
+        expect(subject.performance_stats).to be_falsey
       end
 
       it "sets the default performance_stats_flush_period" do
-        expect(config.performance_stats_flush_period).to eq(15)
+        expect(subject.performance_stats_flush_period).to eq(15)
       end
     end
   end
@@ -104,18 +88,20 @@ RSpec.describe Airbrake::Config do
   describe "#valid?" do
     context "when project_id is nil" do
       it "returns false" do
-        config.project_id = nil
-        config.project_key = '123'
-
+        config = described_class.new(
+          project_id: nil,
+          project_key: '123'
+        )
         expect(config).not_to be_valid
       end
     end
 
     context "when project_key is nil" do
       it "returns false" do
-        config.project_id = 123
-        config.project_key = nil
-
+        config = described_class.new(
+          project_id: 123,
+          project_key: nil
+        )
         expect(config).not_to be_valid
       end
     end
@@ -123,22 +109,24 @@ RSpec.describe Airbrake::Config do
     context "when the current environment is ignored" do
       context "and when the notifier misconfigures configure project_key & project_id" do
         it "returns true" do
-          config.project_id = Object.new
-          config.project_key = Object.new
-          config.environment = :bingo
-          config.ignore_environments = [:bingo]
-
+          config = described_class.new(
+            project_id: Object.new,
+            project_key: Object.new,
+            environment: :bingo,
+            ignore_environments: [:bingo]
+          )
           expect(config).to be_valid
         end
       end
 
       context "and when the notifier configures project_key & project_id" do
         it "returns true" do
-          config.project_id = 123
-          config.project_key = '321'
-          config.environment = :bingo
-          config.ignore_environments = [:bingo]
-
+          config = described_class.new(
+            project_id: 123,
+            project_key: '321',
+            environment: :bingo,
+            ignore_environments: [:bingo]
+          )
           expect(config).to be_valid
         end
       end
@@ -146,52 +134,54 @@ RSpec.describe Airbrake::Config do
 
     context "when the project_id value is not a number" do
       it "returns false" do
-        config.project_id = 'bingo'
-        config.project_key = '321'
-
+        config = described_class.new(
+          project_id: 'bingo',
+          project_key: '321'
+        )
         expect(config).not_to be_valid
       end
     end
 
     context "when the project_id value is a String number" do
       it "returns true" do
-        config.project_id = '123'
-        config.project_key = '321'
-
+        config = described_class.new(
+          project_id: '123',
+          project_key: '321'
+        )
         expect(config).to be_valid
       end
     end
 
     context "when the project_key value is not a String" do
       it "returns false" do
-        config.project_id = 123
-        config.project_key = 321
-
+        config = described_class.new(
+          project_id: 123,
+          project_key: 321
+        )
         expect(config).not_to be_valid
       end
     end
 
     context "when the project_key value is an empty String" do
       it "returns false" do
-        config.project_id = 123
-        config.project_key = ''
-
+        config = described_class.new(
+          project_id: 123,
+          project_key: ''
+        )
         expect(config).not_to be_valid
       end
     end
 
     context "when the environment value is not a String" do
-      let(:out) { StringIO.new }
-      let(:config) { described_class.new(logger: Logger.new(out)) }
-
       before do
-        config.project_id = 123
-        config.project_key = '321'
-
-        config.environment = ['bingo']
       end
 
       it "returns false" do
+        config = described_class.new(
+          project_id: 123,
+          project_key: '321',
+          environment: ['bingo']
+        )
         expect(config).not_to be_valid
       end
     end
@@ -199,32 +189,26 @@ RSpec.describe Airbrake::Config do
 
   describe "#ignored_environment?" do
     describe "warnings" do
-      let(:out) { StringIO.new }
-      let(:config) { described_class.new(logger: Logger.new(out)) }
-
       context "when 'ignore_environments' is set and 'environment' isn't" do
         it "prints a warning" do
-          config.ignore_environments = [:bingo]
+          config = described_class.new(ignore_environments: [:bingo])
 
+          expect(config.logger).to receive(:warn).with(
+            /'ignore_environments' has no effect/
+          )
           expect(config.ignored_environment?).to be_falsey
-          expect(out.string).to match(/ignore_environments' has no effect/)
         end
       end
 
       context "when 'ignore_environments' is set along with 'environment'" do
         it "doesn't print a warning" do
-          config.environment = :bango
-          config.ignore_environments = [:bingo]
-
-          expect(config.ignored_environment?).to be_falsey
-          expect(out.string).to be_empty
-        end
-      end
+          config = described_class.new(
+            environment: :bango,
+            ignore_environments: [:bingo]
+          )
 
-      context "when 'ignore_environments' isn't set and 'environment' isn't set too" do
-        it "doesn't print a warning" do
+          expect(config.logger).not_to receive(:warn)
           expect(config.ignored_environment?).to be_falsey
-          expect(out.string).to be_empty
         end
       end
     end
@@ -233,9 +217,10 @@ RSpec.describe Airbrake::Config do
       context "when 'environment' is a String" do
         context "and when 'ignore_environments' contains Symbols" do
           it "returns true" do
-            config.environment = 'bango'
-            config.ignore_environments = [:bango]
-
+            config = described_class.new(
+              environment: 'bango',
+              ignore_environments: [:bango]
+            )
             expect(config.ignored_environment?).to be_truthy
           end
         end
@@ -244,9 +229,10 @@ RSpec.describe Airbrake::Config do
       context "when 'environment' is a Symbol" do
         context "and when 'ignore_environments' contains Strings" do
           it "returns true" do
-            config.environment = :bango
-            config.ignore_environments = %w[bango]
-
+            config = described_class.new(
+              environment: :bango,
+              ignore_environments: %w[bango]
+            )
             expect(config.ignored_environment?).to be_truthy
           end
         end
@@ -256,10 +242,7 @@ RSpec.describe Airbrake::Config do
 
   describe "#endpoint" do
     context "when host is configured with a URL with a slug" do
-      before do
-        config.project_id = 1
-        config.project_key = '2'
-      end
+      let(:config) { described_class.new(project_id: 1, project_key: '2') }
 
       context "and with a trailing slash" do
         it "sets the endpoint with the slug" do