airbrake-ruby 3.2.6 → 4.0.0

data/spec/notice_notifier_spec/options_spec.rb

@@ -11,27 +11,23 @@ RSpec.describe Airbrake::NoticeNotifier do
     "https://api.airbrake.io/api/v3/projects/#{project_id}/notices"
   end
 
-  let(:user_params) do
-    { project_id: project_id,
-      project_key: project_key,
-      logger: Logger.new(StringIO.new) }
-  end
-
   let(:params) { {} }
   let(:ex) { AirbrakeTestError.new }
-  let(:config) { Airbrake::Config.new(user_params.merge(params)) }
-
-  subject { described_class.new(config) }
 
   before do
     stub_request(:post, endpoint).to_return(status: 201, body: '{}')
+
+    Airbrake::Config.instance = Airbrake::Config.new(
+      project_id: project_id,
+      project_key: project_key
+    )
   end
 
   describe "options" do
     describe ":host" do
       context "when custom" do
         shared_examples 'endpoint' do |host, endpoint, title|
-          let(:params) { { host: host } }
+          before { Airbrake::Config.instance.merge(host: host) }
 
           example(title) do
             stub_request(:post, endpoint).to_return(status: 201, body: '{}')
@@ -70,11 +66,12 @@ RSpec.describe Airbrake::NoticeNotifier do
     end
 
     describe ":root_directory" do
-      let(:params) { { root_directory: '/home/kyrylo/code' } }
+      before do
+        Airbrake::Config.instance.merge(root_directory: '/home/kyrylo/code')
+      end
 
       it "filters out frames" do
-        airbrake = described_class.new(config)
-        airbrake.notify_sync(ex)
+        subject.notify_sync(ex)
 
         expect(
           a_request(:post, endpoint).
@@ -84,7 +81,7 @@ RSpec.describe Airbrake::NoticeNotifier do
 
       context "when present and is a" do
         shared_examples 'root directory' do |dir|
-          let(:params) { { root_directory: dir } }
+          before { Airbrake::Config.instance.merge(root_directory: dir) }
 
           it "being included into the notice's payload" do
             subject.notify_sync(ex)
@@ -123,14 +120,12 @@ RSpec.describe Airbrake::NoticeNotifier do
           password: 'password' }
       end
 
-      let(:params) do
-        {
+      before do
+        Airbrake::Config.instance.merge(
           proxy: proxy_params,
           host: "http://localhost:#{proxy.config[:Port]}"
-        }
-      end
+        )
 
-      before do
         proxy.mount_proc '/' do |req, res|
           requests << req
           res.status = 201
@@ -165,7 +160,7 @@ RSpec.describe Airbrake::NoticeNotifier do
 
     describe ":environment" do
       context "when present" do
-        let(:params) { { environment: :production } }
+        before { Airbrake::Config.instance.merge(environment: :production) }
 
         it "being included into the notice's payload" do
           subject.notify_sync(ex)
@@ -179,7 +174,7 @@ RSpec.describe Airbrake::NoticeNotifier do
 
     describe ":ignore_environments" do
       shared_examples 'sent notice' do |params|
-        let(:params) { params }
+        before { Airbrake::Config.instance.merge(params) }
 
         it "sends a notice" do
           subject.notify_sync(ex)
@@ -188,7 +183,7 @@ RSpec.describe Airbrake::NoticeNotifier do
       end
 
       shared_examples 'ignored notice' do |params|
-        let(:params) { params }
+        before { Airbrake::Config.instance.merge(params) }
 
         it "ignores exceptions occurring in envs that were not configured" do
           subject.notify_sync(ex)
@@ -245,11 +240,11 @@ RSpec.describe Airbrake::NoticeNotifier do
       # Fixes https://github.com/airbrake/airbrake-ruby/issues/276
       context "when specified along with :whitelist_keys" do
         context "and when context payload is present" do
-          let(:params) do
-            {
+          before do
+            Airbrake::Config.instance.merge(
               blacklist_keys: %i[password password_confirmation],
               whitelist_keys: [:email, /user/i, 'account_id']
-            }
+            )
           end
 
           it "sends a notice" do

data/spec/notice_spec.rb

@@ -1,22 +1,25 @@
 RSpec.describe Airbrake::Notice do
-  let(:notice) do
-    described_class.new(Airbrake::Config.new, AirbrakeTestError.new, bingo: '1')
-  end
+  let(:notice) { described_class.new(AirbrakeTestError.new, bingo: '1') }
 
   describe "#to_json" do
     context "app_version" do
       context "when missing" do
+        before { Airbrake::Config.instance.merge(app_version: nil) }
+
         it "doesn't include app_version" do
           expect(notice.to_json).not_to match(/"context":{"version":"1.2.3"/)
         end
       end
 
       context "when present" do
-        let(:config) do
-          Airbrake::Config.new(app_version: '1.2.3', root_directory: '/one/two')
-        end
+        let(:notice) { described_class.new(AirbrakeTestError.new) }
 
-        let(:notice) { described_class.new(config, AirbrakeTestError.new) }
+        before do
+          Airbrake::Config.instance.merge(
+            app_version: "1.2.3",
+            root_directory: "/one/two"
+          )
+        end
 
         it "includes app_version" do
           expect(notice.to_json).to match(/"context":{"version":"1.2.3"/)
@@ -54,7 +57,7 @@ RSpec.describe Airbrake::Notice do
           size.times { backtrace << "bin/rails:3:in `<main>'" }
           ex.set_backtrace(backtrace)
 
-          notice = described_class.new(Airbrake::Config.new, ex)
+          notice = described_class.new(ex)
 
           expect(notice.to_json.bytesize).to be < 64000
         end
@@ -94,9 +97,7 @@ RSpec.describe Airbrake::Notice do
           10.times { backtrace << "bin/rails:3:in `<#{bad_string}>'" }
           ex.set_backtrace(backtrace)
 
-          config = Airbrake::Config.new(logger: Logger.new('/dev/null'))
-          notice = described_class.new(config, ex)
-
+          notice = described_class.new(ex)
           expect(notice.to_json).to be_nil
         end
       end
@@ -105,7 +106,7 @@ RSpec.describe Airbrake::Notice do
         let(:klass) { Class.new {} }
         let(:ex) { AirbrakeTestError.new }
         let(:params) { { bingo: [Object.new, klass.new] } }
-        let(:notice) { described_class.new(Airbrake::Config.new, ex, params) }
+        let(:notice) { described_class.new(ex, params) }
 
         before do
           backtrace = []

data/spec/performance_notifier_spec.rb

@@ -2,8 +2,11 @@ RSpec.describe Airbrake::PerformanceNotifier do
   let(:routes) { 'https://api.airbrake.io/api/v5/projects/1/routes-stats' }
   let(:queries) { 'https://api.airbrake.io/api/v5/projects/1/queries-stats' }
 
-  let(:config) do
-    Airbrake::Config.new(
+  before do
+    stub_request(:put, routes).to_return(status: 200, body: '')
+    stub_request(:put, queries).to_return(status: 200, body: '')
+
+    Airbrake::Config.instance = Airbrake::Config.new(
       project_id: 1,
       project_key: 'banana',
       performance_stats: true,
@@ -11,13 +14,6 @@ RSpec.describe Airbrake::PerformanceNotifier do
     )
   end
 
-  subject { described_class.new(config) }
-
-  before do
-    stub_request(:put, routes).to_return(status: 200, body: '')
-    stub_request(:put, queries).to_return(status: 200, body: '')
-  end
-
   describe "#notify" do
     it "sends full query" do
       subject.notify(
@@ -195,16 +191,14 @@ RSpec.describe Airbrake::PerformanceNotifier do
     end
 
     it "doesn't send route stats when performance stats are disabled" do
-      notifier = described_class.new(
-        Airbrake::Config.new(
-          project_id: 1, project_key: '2', performance_stats: false
-        )
-      )
-      promise = notifier.notify(
+      Airbrake::Config.instance.merge(performance_stats: false)
+
+      promise = subject.notify(
         Airbrake::Request.new(
           method: 'GET', route: '/foo', status_code: 200, start_time: Time.new
         )
       )
+
       expect(a_request(:put, routes)).not_to have_been_made
       expect(promise.value).to eq(
         'error' => "The Performance Stats feature is disabled"
@@ -212,28 +206,24 @@ RSpec.describe Airbrake::PerformanceNotifier do
     end
 
     it "doesn't send route stats when current environment is ignored" do
-      notifier = described_class.new(
-        config.merge(
-          environment: 'test', ignore_environments: %w[test]
-        )
+      Airbrake::Config.instance.merge(
+        performance_stats: true, environment: 'test', ignore_environments: %w[test]
       )
-      promise = notifier.notify(
+
+      promise = subject.notify(
         Airbrake::Request.new(
           method: 'GET', route: '/foo', status_code: 200, start_time: Time.new
         )
       )
+
       expect(a_request(:put, routes)).not_to have_been_made
       expect(promise.value).to eq('error' => "The 'test' environment is ignored")
     end
 
     it "sends environment when it's specified" do
-      notifier = described_class.new(
-        config.merge(
-          project_id: 1, project_key: '2', performance_stats: true,
-          environment: 'test'
-        )
-      )
-      notifier.notify(
+      Airbrake::Config.instance.merge(performance_stats: true, environment: 'test')
+
+      subject.notify(
         Airbrake::Request.new(
           method: 'POST',
           route: '/foo',
@@ -251,16 +241,14 @@ RSpec.describe Airbrake::PerformanceNotifier do
     describe "payload grouping" do
       let(:flush_period) { 0.5 }
 
-      let(:config) do
-        Airbrake::Config.new(
+      it "groups payload by performance name and sends it separately" do
+        Airbrake::Config.instance.merge(
           project_id: 1,
           project_key: 'banana',
           performance_stats: true,
           performance_stats_flush_period: flush_period
         )
-      end
 
-      it "groups payload by performance name and sends it separately" do
         subject.notify(
           Airbrake::Request.new(
             method: 'GET',

data/spec/response_spec.rb

@@ -1,13 +1,12 @@
 RSpec.describe Airbrake::Response do
   describe ".parse" do
-    let(:out) { StringIO.new }
-    let(:logger) { Logger.new(out) }
-
     [200, 201, 204].each do |code|
       context "when response code is #{code}" do
         it "logs response body" do
-          described_class.parse(OpenStruct.new(code: code, body: '{}'), logger)
-          expect(out.string).to match(/Airbrake: Airbrake::Response \(#{code}\): {}/)
+          expect(Airbrake::Loggable.instance).to receive(:debug).with(
+            /Airbrake::Response \(#{code}\): {}/
+          )
+          described_class.parse(OpenStruct.new(code: code, body: '{}'))
         end
       end
     end
@@ -15,26 +14,31 @@ RSpec.describe Airbrake::Response do
     [400, 401, 403, 420].each do |code|
       context "when response code is #{code}" do
         it "logs response message" do
+          expect(Airbrake::Loggable.instance).to receive(:error).with(
+            /Airbrake: foo/
+          )
           described_class.parse(
-            OpenStruct.new(code: code, body: '{"message":"foo"}'), logger
+            OpenStruct.new(code: code, body: '{"message":"foo"}')
           )
-          expect(out.string).to match(/Airbrake: foo/)
         end
       end
     end
 
     context "when response code is 429" do
       let(:response) { OpenStruct.new(code: 429, body: '{"message":"rate limited"}') }
+
       it "logs response message" do
-        described_class.parse(response, logger)
-        expect(out.string).to match(/Airbrake: rate limited/)
+        expect(Airbrake::Loggable.instance).to receive(:error).with(
+          /Airbrake: rate limited/
+        )
+        described_class.parse(response)
       end
 
       it "returns an error response" do
         time = Time.now
         allow(Time).to receive(:now).and_return(time)
 
-        resp = described_class.parse(response, logger)
+        resp = described_class.parse(response)
         expect(resp).to include(
           'error' => '**Airbrake: rate limited',
           'rate_limit_reset' => time
@@ -46,18 +50,20 @@ RSpec.describe Airbrake::Response do
       let(:response) { OpenStruct.new(code: 500, body: 'foo') }
 
       it "logs response body" do
-        described_class.parse(response, logger)
-        expect(out.string).to match(/Airbrake: unexpected code \(500\)\. Body: foo/)
+        expect(Airbrake::Loggable.instance).to receive(:error).with(
+          /Airbrake: unexpected code \(500\)\. Body: foo/
+        )
+        described_class.parse(response)
       end
 
       it "returns an error response" do
-        resp = described_class.parse(response, logger)
+        resp = described_class.parse(response)
         expect(resp).to eq('error' => 'foo')
       end
 
       it "truncates body" do
         response.body *= 1000
-        resp = described_class.parse(response, logger)
+        resp = described_class.parse(response)
         expect(resp).to eq('error' => ('foo' * 33) + 'fo...')
       end
     end
@@ -66,14 +72,14 @@ RSpec.describe Airbrake::Response do
       let(:response) { OpenStruct.new(code: 201, body: 'foo') }
 
       it "logs response body" do
-        described_class.parse(response, logger)
-        expect(out.string).to match(
+        expect(Airbrake::Loggable.instance).to receive(:error).with(
           /Airbrake: error while parsing body \(.*unexpected token.*\)\. Body: foo/
         )
+        described_class.parse(response)
       end
 
       it "returns an error message" do
-        expect(described_class.parse(response, logger)['error']).to match(
+        expect(described_class.parse(response)['error']).to match(
           /\A#<JSON::ParserError.+>/
         )
       end

data/spec/sync_sender_spec.rb

@@ -1,34 +1,20 @@
 RSpec.describe Airbrake::SyncSender do
-  describe "#build_https" do
-    it "overrides Net::HTTP's open_timeout and read_timeout if timeout is specified" do
-      config = Airbrake::Config.new(timeout: 10)
-      sender = described_class.new(config)
-      https = sender.__send__(:build_https, config.endpoint)
-      expect(https.open_timeout).to eq(10)
-      expect(https.read_timeout).to eq(10)
-    end
+  before do
+    Airbrake::Config.instance = Airbrake::Config.new(
+      project_id: 1, project_key: 'banana'
+    )
   end
 
   describe "#send" do
     let(:promise) { Airbrake::Promise.new }
-    let(:stdout) { StringIO.new }
-
-    let(:config) do
-      Airbrake::Config.new(
-        project_id: 1,
-        project_key: 'banana',
-        logger: Logger.new(stdout)
-      )
-    end
 
-    let(:sender) { described_class.new(config) }
-    let(:notice) { Airbrake::Notice.new(config, AirbrakeTestError.new) }
+    let(:notice) { Airbrake::Notice.new(AirbrakeTestError.new) }
     let(:endpoint) { 'https://api.airbrake.io/api/v3/projects/1/notices' }
 
     before { stub_request(:post, endpoint).to_return(body: '{}') }
 
     it "sets the Content-Type header to JSON" do
-      sender.send({}, promise)
+      subject.send({}, promise)
       expect(
         a_request(:post, endpoint).with(
           headers: { 'Content-Type' => 'application/json' }
@@ -37,7 +23,7 @@ RSpec.describe Airbrake::SyncSender do
     end
 
     it "sets the User-Agent header to the notifier slug" do
-      sender.send({}, promise)
+      subject.send({}, promise)
       expect(
         a_request(:post, endpoint).with(
           headers: {
@@ -48,7 +34,7 @@ RSpec.describe Airbrake::SyncSender do
     end
 
     it "sets the Authorization header to the project key" do
-      sender.send({}, promise)
+      subject.send({}, promise)
       expect(
         a_request(:post, endpoint).with(
           headers: { 'Authorization' => 'Bearer banana' }
@@ -58,11 +44,13 @@ RSpec.describe Airbrake::SyncSender do
 
     it "catches exceptions raised while sending" do
       https = double("foo")
-      allow(sender).to receive(:build_https).and_return(https)
+      allow(subject).to receive(:build_https).and_return(https)
       allow(https).to receive(:request).and_raise(StandardError.new('foo'))
-      expect(sender.send({}, promise)).to be_an(Airbrake::Promise)
+      expect(Airbrake::Loggable.instance).to receive(:error).with(
+        /HTTP error: foo/
+      )
+      expect(subject.send({}, promise)).to be_an(Airbrake::Promise)
       expect(promise.value).to eq('error' => '**Airbrake: HTTP error: foo')
-      expect(stdout.string).to match(/ERROR -- : .+ HTTP error: foo/)
     end
 
     context "when request body is nil" do
@@ -78,12 +66,17 @@ RSpec.describe Airbrake::SyncSender do
         10.times { backtrace << "bin/rails:3:in `<#{bad_string}>'" }
         ex.set_backtrace(backtrace)
 
-        notice = Airbrake::Notice.new(config, ex)
+        notice = Airbrake::Notice.new(ex)
 
-        expect(sender.send(notice, promise)).to be_an(Airbrake::Promise)
+        expect(Airbrake::Loggable.instance).to receive(:error).with(
+          /data was not sent/
+        )
+        expect(Airbrake::Loggable.instance).to receive(:error).with(
+          /truncation failed/
+        )
+        expect(subject.send(notice, promise)).to be_an(Airbrake::Promise)
         expect(promise.value).
           to match('error' => '**Airbrake: data was not sent because of missing body')
-        expect(stdout.string).to match(/ERROR -- : .+ data was not sent/)
       end
     end
 
@@ -100,11 +93,11 @@ RSpec.describe Airbrake::SyncSender do
 
       it "returns error" do
         p1 = Airbrake::Promise.new
-        sender.send({}, p1)
+        subject.send({}, p1)
         expect(p1.value).to match('error' => '**Airbrake: IP is rate limited')
 
         p2 = Airbrake::Promise.new
-        sender.send({}, p2)
+        subject.send({}, p2)
         expect(p2.value).to match('error' => '**Airbrake: IP is rate limited')
 
         # Wait for X-RateLimit-Delay and then make a new request to make sure p2
@@ -112,7 +105,7 @@ RSpec.describe Airbrake::SyncSender do
         sleep 1
 
         p3 = Airbrake::Promise.new
-        sender.send({}, p3)
+        subject.send({}, p3)
         expect(p3.value).to match('error' => '**Airbrake: IP is rate limited')
 
         expect(a_request(:post, endpoint)).to have_been_made.twice
@@ -123,7 +116,7 @@ RSpec.describe Airbrake::SyncSender do
       before { stub_request(:put, endpoint).to_return(status: 200, body: '') }
 
       it "PUTs the request" do
-        sender = described_class.new(config, :put)
+        sender = described_class.new(:put)
         sender.send({}, promise)
         expect(a_request(:put, endpoint)).to have_been_made
       end
@@ -131,7 +124,7 @@ RSpec.describe Airbrake::SyncSender do
 
     context "when the provided method is :post" do
       it "POSTs the request" do
-        sender = described_class.new(config, :post)
+        sender = described_class.new(:post)
         sender.send({}, promise)
         expect(a_request(:post, endpoint)).to have_been_made
       end