airbrake-ruby 5.0.1 → 5.2.1

data/spec/promise_spec.rb

@@ -1,15 +1,17 @@
 RSpec.describe Airbrake::Promise do
+  subject(:promise) { described_class.new }
+
   describe ".then" do
     let(:resolved_with) { [] }
     let(:rejected_with) { [] }
 
     context "when it is not resolved" do
       it "returns self" do
-        expect(subject.then {}).to eq(subject)
+        expect(promise.then { anything }).to eq(promise)
       end
 
       it "doesn't call the resolve callbacks yet" do
-        subject.then { resolved_with << 1 }.then { resolved_with << 2 }
+        promise.then { resolved_with << 1 }.then { resolved_with << 2 }
         expect(resolved_with).to be_empty
       end
     end
@@ -17,12 +19,12 @@ RSpec.describe Airbrake::Promise do
     context "when it is resolved" do
       shared_examples "then specs" do
         it "returns self" do
-          expect(subject.then {}).to eq(subject)
+          expect(promise.then { anything }).to eq(promise)
         end
 
         it "yields the resolved value" do
           yielded = nil
-          subject.then { |value| yielded = value }
+          promise.then { |value| yielded = value }
           expect(yielded).to eq('id' => '123')
         end
 
@@ -37,29 +39,29 @@ RSpec.describe Airbrake::Promise do
 
       context "and there are some resolve and reject callbacks in place" do
         before do
-          subject.then { resolved_with << 1 }.then { resolved_with << 2 }
-          subject.rescue { rejected_with << 1 }.rescue { rejected_with << 2 }
-          subject.resolve('id' => '123')
+          promise.then { resolved_with << 1 }.then { resolved_with << 2 }
+          promise.rescue { rejected_with << 1 }.rescue { rejected_with << 2 }
+          promise.resolve('id' => '123')
         end
 
         include_examples "then specs"
 
         it "registers the resolve callbacks" do
-          subject.resolve('id' => '456')
+          promise.resolve('id' => '456')
           expect(resolved_with).to match_array([1, 2, 1, 2])
         end
       end
 
       context "and additional then callbacks are added" do
         before do
-          subject.resolve('id' => '123')
-          subject.then { resolved_with << 1 }.then { resolved_with << 2 }
+          promise.resolve('id' => '123')
+          promise.then { resolved_with << 1 }.then { resolved_with << 2 }
         end
 
         include_examples "then specs"
 
         it "doesn't register new resolve callbacks" do
-          subject.resolve('id' => '456')
+          promise.resolve('id' => '456')
           expect(resolved_with).to match_array([1, 2])
         end
       end
@@ -72,11 +74,11 @@ RSpec.describe Airbrake::Promise do
 
     context "when it is not rejected" do
       it "returns self" do
-        expect(subject.then {}).to eq(subject)
+        expect(promise.then { anything }).to eq(promise)
       end
 
       it "doesn't call the reject callbacks yet" do
-        subject.rescue { rejected_with << 1 }.rescue { rejected_with << 2 }
+        promise.rescue { rejected_with << 1 }.rescue { rejected_with << 2 }
         expect(rejected_with).to be_empty
       end
     end
@@ -84,12 +86,12 @@ RSpec.describe Airbrake::Promise do
     context "when it is rejected" do
       shared_examples "rescue specs" do
         it "returns self" do
-          expect(subject.rescue {}).to eq(subject)
+          expect(promise.rescue { anything }).to eq(promise)
         end
 
         it "yields the rejected value" do
           yielded = nil
-          subject.rescue { |value| yielded = value }
+          promise.rescue { |value| yielded = value }
           expect(yielded).to eq('bingo')
         end
 
@@ -104,29 +106,29 @@ RSpec.describe Airbrake::Promise do
 
       context "and there are some resolve and reject callbacks in place" do
         before do
-          subject.then { resolved_with << 1 }.then { resolved_with << 2 }
-          subject.rescue { rejected_with << 1 }.rescue { rejected_with << 2 }
-          subject.reject('bingo')
+          promise.then { resolved_with << 1 }.then { resolved_with << 2 }
+          promise.rescue { rejected_with << 1 }.rescue { rejected_with << 2 }
+          promise.reject('bingo')
         end
 
         include_examples "rescue specs"
 
         it "registers the reject callbacks" do
-          subject.reject('bingo again')
+          promise.reject('bingo again')
           expect(rejected_with).to match_array([1, 2, 1, 2])
         end
       end
 
       context "and additional reject callbacks are added" do
         before do
-          subject.reject('bingo')
-          subject.rescue { rejected_with << 1 }.rescue { rejected_with << 2 }
+          promise.reject('bingo')
+          promise.rescue { rejected_with << 1 }.rescue { rejected_with << 2 }
         end
 
         include_examples "rescue specs"
 
         it "doesn't register new reject callbacks" do
-          subject.reject('bingo again')
+          promise.reject('bingo again')
           expect(rejected_with).to match_array([1, 2])
         end
       end
@@ -135,37 +137,38 @@ RSpec.describe Airbrake::Promise do
 
   describe ".resolve" do
     it "returns self" do
-      expect(subject.resolve(1)).to eq(subject)
+      expect(promise.resolve(1)).to eq(promise)
     end
 
     it "executes callbacks attached with .then" do
       array = []
-      subject.then { |notice_id| array << notice_id }.rescue { array << 999 }
+      promise.then { |notice_id| array << notice_id }.rescue { array << 999 }
 
       expect(array.size).to be_zero
-      subject.resolve(1)
+      promise.resolve(1)
       expect(array).to match_array([1])
     end
   end
 
   describe ".reject" do
     it "returns self" do
-      expect(subject.reject(1)).to eq(subject)
+      expect(promise.reject(1)).to eq(promise)
     end
 
     it "executes callbacks attached with .rescue" do
       array = []
-      subject.then { array << 1 }.rescue { |error| array << error }
+      promise.then { array << 1 }.rescue { |error| array << error }
 
       expect(array.size).to be_zero
-      subject.reject(999)
+      promise.reject(999)
       expect(array).to match_array([999])
     end
   end
 
   describe "#rejected?" do
     context "when it was rejected" do
-      before { subject.reject(1) }
+      before { promise.reject(1) }
+
       it { is_expected.to be_rejected }
     end
 
@@ -174,14 +177,16 @@ RSpec.describe Airbrake::Promise do
     end
 
     context "when it was resolved" do
-      before { subject.resolve }
+      before { promise.resolve }
+
       it { is_expected.not_to be_rejected }
     end
   end
 
   describe "#resolved?" do
     context "when it was resolved" do
-      before { subject.resolve }
+      before { promise.resolve }
+
       it { is_expected.to be_resolved }
     end
 
@@ -190,7 +195,8 @@ RSpec.describe Airbrake::Promise do
     end
 
     context "when it was rejected" do
-      before { subject.reject(1) }
+      before { promise.reject(1) }
+
       it { is_expected.not_to be_resolved }
     end
   end

data/spec/remote_settings/callback_spec.rb

@@ -0,0 +1,162 @@
+RSpec.describe Airbrake::RemoteSettings::Callback do
+  describe "#call" do
+    let(:logger) { Logger.new(File::NULL) }
+
+    let(:config) do
+      Airbrake::Config.new(
+        project_id: 123,
+        logger: logger,
+      )
+    end
+
+    let(:data) do
+      instance_double(Airbrake::RemoteSettings::SettingsData)
+    end
+
+    before do
+      allow(data).to receive(:to_h)
+      allow(data).to receive(:error_host)
+      allow(data).to receive(:apm_host)
+      allow(data).to receive(:error_notifications?)
+      allow(data).to receive(:performance_stats?)
+    end
+
+    it "logs given data" do
+      allow(logger).to receive(:debug)
+
+      described_class.new(config).call(data)
+
+      expect(logger).to have_received(:debug) do |&block|
+        expect(block.call).to match(/applying remote settings/)
+      end
+    end
+
+    context "when the config disables error notifications" do
+      before do
+        config.error_notifications = false
+        allow(data).to receive(:error_notifications?).and_return(true)
+      end
+
+      # rubocop:disable RSpec/MultipleExpectations
+      it "keeps the option disabled forever" do
+        callback = described_class.new(config)
+
+        callback.call(data)
+        expect(config.error_notifications).to eq(false)
+
+        callback.call(data)
+        expect(config.error_notifications).to eq(false)
+
+        callback.call(data)
+        expect(config.error_notifications).to eq(false)
+      end
+      # rubocop:enable RSpec/MultipleExpectations
+    end
+
+    context "when the config enables error notifications" do
+      before { config.error_notifications = true }
+
+      # rubocop:disable RSpec/MultipleExpectations
+      it "can disable and enable error notifications" do
+        callback = described_class.new(config)
+
+        allow(data).to receive(:error_notifications?).and_return(false)
+
+        callback.call(data)
+        expect(config.error_notifications).to eq(false)
+
+        allow(data).to receive(:error_notifications?).and_return(true)
+
+        callback.call(data)
+        expect(config.error_notifications).to eq(true)
+
+        expect(data).to have_received(:error_notifications?).twice
+      end
+      # rubocop:enable RSpec/MultipleExpectations
+    end
+
+    context "when the config disables performance_stats" do
+      before do
+        config.performance_stats = false
+        allow(data).to receive(:performance_stats?).and_return(true)
+      end
+
+      # rubocop:disable RSpec/MultipleExpectations
+      it "keeps the option disabled forever" do
+        callback = described_class.new(config)
+
+        callback.call(data)
+        expect(config.performance_stats).to eq(false)
+
+        callback.call(data)
+        expect(config.performance_stats).to eq(false)
+
+        callback.call(data)
+        expect(config.performance_stats).to eq(false)
+      end
+      # rubocop:enable RSpec/MultipleExpectations
+    end
+
+    context "when the config enables performance stats" do
+      before { config.performance_stats = true }
+
+      # rubocop:disable RSpec/MultipleExpectations
+      it "can disable and enable performance_stats" do
+        callback = described_class.new(config)
+
+        allow(data).to receive(:performance_stats?).and_return(false)
+
+        callback.call(data)
+        expect(config.performance_stats).to eq(false)
+
+        allow(data).to receive(:performance_stats?).and_return(true)
+
+        callback.call(data)
+        expect(config.performance_stats).to eq(true)
+
+        expect(data).to have_received(:performance_stats?).twice
+      end
+      # rubocop:enable RSpec/MultipleExpectations
+    end
+
+    context "when error_host returns a value" do
+      it "sets the error_host option" do
+        config.error_host = 'http://api.airbrake.io'
+        allow(data).to receive(:error_host).and_return('https://api.example.com')
+
+        described_class.new(config).call(data)
+        expect(config.error_host).to eq('https://api.example.com')
+      end
+    end
+
+    context "when error_host returns nil" do
+      it "doesn't modify the error_host option" do
+        config.error_host = 'http://api.airbrake.io'
+        allow(data).to receive(:error_host).and_return(nil)
+
+        described_class.new(config).call(data)
+        expect(config.error_host).to eq('http://api.airbrake.io')
+      end
+    end
+
+    context "when apm_host returns a value" do
+      it "sets the apm_host option" do
+        config.apm_host = 'http://api.airbrake.io'
+        allow(data).to receive(:apm_host).and_return('https://api.example.com')
+
+        described_class.new(config).call(data)
+        expect(config.apm_host).to eq('https://api.example.com')
+      end
+    end
+
+    context "when apm_host returns nil" do
+      it "doesn't modify the apm_host option" do
+        config.apm_host = 'http://api.airbrake.io'
+        allow(data).to receive(:apm_host).and_return(nil)
+
+        described_class.new(config).call(data)
+        expect(config.apm_host).to eq('http://api.airbrake.io')
+      end
+    end
+  end
+end

data/spec/remote_settings/settings_data_spec.rb

@@ -13,7 +13,7 @@ RSpec.describe Airbrake::RemoteSettings::SettingsData do
 
       expect(settings_data.interval).to eq(123)
       expect(settings_data.config_route(''))
-        .to eq('abc/2020-06-18/config/123/config.json')
+        .to eq('/abc')
     end
   end
 
@@ -60,78 +60,48 @@ RSpec.describe Airbrake::RemoteSettings::SettingsData do
   end
 
   describe "#config_route" do
-    let(:host) { 'https://v1-production-notifier-configs.s3.amazonaws.com' }
+    let(:host) { 'http://example.com/' }
 
-    context "when given a remote host through the remote config" do
-      context "and when the remote host ends with a slash" do
-        let(:data) do
-          { 'config_route' => 'http://example.com/' }
-        end
-
-        it "returns the route with the host" do
-          expect(described_class.new(project_id, data).config_route(host)).to eq(
-            "http://example.com/2020-06-18/config/#{project_id}/config.json",
-          )
-        end
+    context "when remote config specifies a config route" do
+      let(:data) do
+        { 'config_route' => '123/cfg/321/cfg.json' }
       end
 
-      context "and when the remote host doesn't with a slash" do
-        let(:data) do
-          { 'config_route' => 'http://example.com' }
-        end
-
-        it "returns the route with the host" do
-          expect(described_class.new(project_id, data).config_route(host)).to eq(
-            "http://example.com/2020-06-18/config/#{project_id}/config.json",
-          )
-        end
+      it "returns the config route with the provided location" do
+        expect(described_class.new(project_id, data).config_route(host)).to eq(
+          'http://example.com/123/cfg/321/cfg.json',
+        )
       end
     end
 
-    context "when given a remote host through local configuration" do
-      context "and when the remote host ends with a slash" do
-        let(:host) { 'http://example.com/' }
-
-        it "returns the route with the host" do
-          expect(described_class.new(project_id, {}).config_route(host)).to eq(
-            "http://example.com/2020-06-18/config/#{project_id}/config.json",
-          )
-        end
-      end
-
-      context "and when the remote host doesn't with a slash" do
-        let(:host) { 'http://example.com' }
-
-        it "returns the route with the given host" do
-          expect(described_class.new(project_id, {}).config_route(host)).to eq(
-            "http://example.com/2020-06-18/config/#{project_id}/config.json",
-          )
-        end
+    context "when remote config DOES NOT specify a config route" do
+      it "returns the config route with the default location" do
+        expect(described_class.new(project_id, {}).config_route(host)).to eq(
+          "http://example.com/2020-06-18/config/#{project_id}/config.json",
+        )
       end
     end
 
-    context "when the given remote host in the remote config is nil" do
+    context "when a config route is specified but is set to nil" do
       let(:data) do
         { 'config_route' => nil }
       end
 
-      it "returns the route with the given host instead" do
+      it "returns the config route with the default location" do
         expect(described_class.new(project_id, data).config_route(host)).to eq(
-          'https://v1-production-notifier-configs.s3.amazonaws.com/' \
-          "2020-06-18/config/#{project_id}/config.json",
+          "http://example.com/2020-06-18/config/#{project_id}/config.json",
         )
       end
     end
 
-    context "when the given remote host in the remote config is an empty string" do
+    context "when a config route is specified but is set to an empty string" do
       let(:data) do
         { 'config_route' => '' }
       end
 
       it "returns the route with the default instead" do
         expect(described_class.new(project_id, data).config_route(host)).to eq(
-          'https://v1-production-notifier-configs.s3.amazonaws.com/' \
-          "2020-06-18/config/#{project_id}/config.json",
+          "http://example.com/2020-06-18/config/#{project_id}/config.json",
         )
       end
     end
@@ -342,6 +312,8 @@ RSpec.describe Airbrake::RemoteSettings::SettingsData do
   end
 
   describe "#to_h" do
+    subject(:settings_data) { described_class.new(project_id, data) }
+
     let(:data) do
       {
         'poll_sec' => 123,
@@ -354,17 +326,15 @@ RSpec.describe Airbrake::RemoteSettings::SettingsData do
       }
     end
 
-    subject { described_class.new(project_id, data) }
-
     it "returns a hash representation of settings" do
       expect(described_class.new(project_id, data).to_h).to eq(data)
     end
 
     it "doesn't allow mutation of the original data object" do
-      hash = subject.to_h
+      hash = settings_data.to_h
       hash['poll_sec'] = 0
 
-      expect(subject.to_h).to eq(
+      expect(settings_data.to_h).to eq(
         'poll_sec' => 123,
         'settings' => [
           {