airbrake-ruby 4.13.4 → 5.0.0.rc.2

data/spec/config/processor_spec.rb

@@ -0,0 +1,223 @@
+RSpec.describe Airbrake::Config::Processor do
+  let(:notifier) { Airbrake::NoticeNotifier.new }
+
+  describe "#process_blocklist" do
+    let(:config) { Airbrake::Config.new(blocklist_keys: %w[a b c]) }
+
+    context "when there ARE blocklist keys" do
+      it "adds the blocklist filter" do
+        described_class.new(config).process_blocklist(notifier)
+        expect(notifier.has_filter?(Airbrake::Filters::KeysBlocklist)).to eq(true)
+      end
+    end
+
+    context "when there are NO blocklist keys" do
+      let(:config) { Airbrake::Config.new(blocklist_keys: %w[]) }
+
+      it "doesn't add the blocklist filter" do
+        described_class.new(config).process_blocklist(notifier)
+        expect(notifier.has_filter?(Airbrake::Filters::KeysBlocklist))
+          .to eq(false)
+      end
+    end
+  end
+
+  describe "#process_allowlist" do
+    let(:config) { Airbrake::Config.new(allowlist_keys: %w[a b c]) }
+
+    context "when there ARE allowlist keys" do
+      it "adds the allowlist filter" do
+        described_class.new(config).process_allowlist(notifier)
+        expect(notifier.has_filter?(Airbrake::Filters::KeysAllowlist)).to eq(true)
+      end
+    end
+
+    context "when there are NO allowlist keys" do
+      let(:config) { Airbrake::Config.new(allowlist_keys: %w[]) }
+
+      it "doesn't add the allowlist filter" do
+        described_class.new(config).process_allowlist(notifier)
+        expect(notifier.has_filter?(Airbrake::Filters::KeysAllowlist))
+          .to eq(false)
+      end
+    end
+  end
+
+  describe "#process_remote_configuration" do
+    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
+      end
+    end
+
+    context "when the config defines a project_id" do
+      context "and when remote configuration is false" do
+        let(:config) do
+          Airbrake::Config.new(project_id: 123, __remote_configuration: false)
+        end
+
+        it "doesn't set remote settings" do
+          expect(Airbrake::RemoteSettings).not_to receive(:poll)
+          described_class.new(config).process_remote_configuration
+        end
+      end
+
+      context "and when remote configuration is true" do
+        let(:config) do
+          Airbrake::Config.new(project_id: 123, __remote_configuration: true)
+        end
+
+        it "sets remote settings" do
+          expect(Airbrake::RemoteSettings).to receive(:poll)
+          described_class.new(config).process_remote_configuration
+        end
+      end
+    end
+  end
+
+  describe "#add_filters" do
+    context "when there's a root directory" do
+      let(:config) { Airbrake::Config.new(root_directory: '/abc') }
+
+      it "adds RootDirectoryFilter" do
+        described_class.new(config).add_filters(notifier)
+        expect(notifier.has_filter?(Airbrake::Filters::RootDirectoryFilter))
+          .to eq(true)
+      end
+
+      it "adds GitRevisionFilter" do
+        described_class.new(config).add_filters(notifier)
+        expect(notifier.has_filter?(Airbrake::Filters::GitRevisionFilter))
+          .to eq(true)
+      end
+
+      it "adds GitRepositoryFilter" do
+        described_class.new(config).add_filters(notifier)
+        expect(notifier.has_filter?(Airbrake::Filters::GitRepositoryFilter))
+          .to eq(true)
+      end
+
+      it "adds GitLastCheckoutFilter" do
+        described_class.new(config).add_filters(notifier)
+        expect(notifier.has_filter?(Airbrake::Filters::GitLastCheckoutFilter))
+          .to eq(true)
+      end
+    end
+
+    context "when there's NO root directory" do
+      let(:config) { Airbrake::Config.new(root_directory: nil) }
+
+      it "doesn't add RootDirectoryFilter" do
+        described_class.new(config).add_filters(notifier)
+        expect(notifier.has_filter?(Airbrake::Filters::RootDirectoryFilter))
+          .to eq(false)
+      end
+
+      it "doesn't add GitRevisionFilter" do
+        described_class.new(config).add_filters(notifier)
+        expect(notifier.has_filter?(Airbrake::Filters::GitRevisionFilter))
+          .to eq(false)
+      end
+
+      it "doesn't add GitRepositoryFilter" do
+        described_class.new(config).add_filters(notifier)
+        expect(notifier.has_filter?(Airbrake::Filters::GitRepositoryFilter))
+          .to eq(false)
+      end
+
+      it "doesn't add GitLastCheckoutFilter" do
+        described_class.new(config).add_filters(notifier)
+        expect(notifier.has_filter?(Airbrake::Filters::GitLastCheckoutFilter))
+          .to eq(false)
+      end
+    end
+  end
+
+  describe "#poll_callback" do
+    let(:logger) { Logger.new(File::NULL) }
+
+    let(:config) do
+      Airbrake::Config.new(
+        project_id: 123,
+        __remote_configuration: true,
+        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
+      expect(logger).to receive(:debug).with(/applying remote settings/)
+      described_class.new(config).poll_callback(data)
+    end
+
+    it "sets the error_notifications option" do
+      config.error_notifications = false
+      expect(data).to receive(:error_notifications?).and_return(true)
+
+      described_class.new(config).poll_callback(data)
+      expect(config.error_notifications).to eq(true)
+    end
+
+    it "sets the performance_stats option" do
+      config.performance_stats = false
+      expect(data).to receive(:performance_stats?).and_return(true)
+
+      described_class.new(config).poll_callback(data)
+      expect(config.performance_stats).to eq(true)
+    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).poll_callback(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).poll_callback(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).poll_callback(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).poll_callback(data)
+        expect(config.apm_host).to eq('http://api.airbrake.io')
+      end
+    end
+  end
+end

data/spec/config/validator_spec.rb

@@ -169,7 +169,7 @@ RSpec.describe Airbrake::Config::Validator do
         }
       end
 
-      it "returns a rejected promise" do
+      it "returns a resolved promise" do
         promise = described_class.check_notify_ability(config)
         expect(promise).to be_resolved
       end
@@ -180,5 +180,22 @@ RSpec.describe Airbrake::Config::Validator do
         described_class.check_notify_ability(config)
       end
     end
+
+    context "when the error_notifications option is false" do
+      let(:config_params) do
+        {
+          project_id: valid_id,
+          project_key: valid_key,
+          error_notifications: false,
+        }
+      end
+
+      it "returns a rejected promise" do
+        promise = described_class.check_notify_ability(config)
+        expect(promise.value).to eq(
+          'error' => "error notifications are disabled",
+        )
+      end
+    end
   end
 end

data/spec/config_spec.rb

@@ -10,19 +10,23 @@ RSpec.describe Airbrake::Config do
   its(:app_version) { is_expected.to be_nil }
   its(:versions) { is_expected.to be_empty }
   its(:host) { is_expected.to eq('https://api.airbrake.io') }
-  its(:endpoint) { is_expected.not_to be_nil }
+  its(:error_host) { is_expected.to eq('https://api.airbrake.io') }
+  its(:apm_host) { is_expected.to eq('https://api.airbrake.io') }
+  its(:error_endpoint) { is_expected.not_to be_nil }
   its(:workers) { is_expected.to eq(1) }
   its(:queue_size) { is_expected.to eq(100) }
   its(:root_directory) { is_expected.to eq(Bundler.root.realpath.to_s) }
   its(:environment) { is_expected.to be_nil }
   its(:ignore_environments) { is_expected.to be_empty }
   its(:timeout) { is_expected.to be_nil }
-  its(:blacklist_keys) { is_expected.to be_empty }
-  its(:whitelist_keys) { is_expected.to be_empty }
+  its(:blocklist_keys) { is_expected.to be_empty }
+  its(:allowlist_keys) { is_expected.to be_empty }
   its(:performance_stats) { is_expected.to eq(true) }
   its(:performance_stats_flush_period) { is_expected.to eq(15) }
   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_configuration) { is_expected.to eq(false) }
 
   describe "#new" do
     context "when user config is passed" do
@@ -63,13 +67,13 @@ RSpec.describe Airbrake::Config do
     end
   end
 
-  describe "#endpoint" do
+  describe "#error_endpoint" do
     subject { described_class.new(valid_params.merge(user_config)) }
 
     context "when host ends with a URL with a slug with a trailing slash" do
       let(:user_config) { { host: 'https://localhost/bingo/' } }
 
-      its(:endpoint) do
+      its(:error_endpoint) do
         is_expected.to eq(URI('https://localhost/bingo/api/v3/projects/1/notices'))
       end
     end
@@ -77,7 +81,7 @@ RSpec.describe Airbrake::Config do
     context "when host ends with a URL with a slug without a trailing slash" do
       let(:user_config) { { host: 'https://localhost/bingo' } }
 
-      its(:endpoint) do
+      its(:error_endpoint) do
         is_expected.to eq(URI('https://localhost/api/v3/projects/1/notices'))
       end
     end
@@ -169,4 +173,32 @@ RSpec.describe Airbrake::Config do
       expect(subject.logger.level).to eq(Logger::WARN)
     end
   end
+
+  describe "#blacklist_keys=" do
+    before { allow(Kernel).to receive(:warn) }
+
+    it "sets blocklist_keys instead" do
+      subject.blacklist_keys = [1, 2, 3]
+      expect(subject.blocklist_keys).to eq([1, 2, 3])
+    end
+
+    it "prints a warning" do
+      expect(Kernel).to receive(:warn).with(/use blocklist_keys= instead/)
+      subject.blacklist_keys = [1, 2, 3]
+    end
+  end
+
+  describe "#whitelist_keys=" do
+    before { allow(Kernel).to receive(:warn) }
+
+    it "sets allowlist_keys instead" do
+      subject.whitelist_keys = [1, 2, 3]
+      expect(subject.allowlist_keys).to eq([1, 2, 3])
+    end
+
+    it "prints a warning" do
+      expect(Kernel).to receive(:warn).with(/use allowlist_keys= instead/)
+      subject.whitelist_keys = [1, 2, 3]
+    end
+  end
 end

data/spec/filter_chain_spec.rb

@@ -89,4 +89,31 @@ RSpec.describe Airbrake::FilterChain do
       expect(subject.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 {}
+
+        subject.add_filter(klass.new)
+        expect(subject.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)
+      end
+    end
+
+    context "when filter class is NOT included in the filter chain" do
+      it "returns false" do
+        klass = Class.new {}
+
+        subject.add_filter(proc {})
+        expect(subject.includes?(klass)).to eq(false)
+      end
+    end
+  end
 end

data/spec/filters/{keys_whitelist_spec.rb → keys_allowlist_spec.rb}

@@ -1,4 +1,4 @@
-RSpec.describe Airbrake::Filters::KeysWhitelist do
+RSpec.describe Airbrake::Filters::KeysAllowlist do
   subject { described_class.new(patterns) }
 
   let(:notice) { Airbrake::Notice.new(AirbrakeTestError.new) }
@@ -70,10 +70,10 @@ RSpec.describe Airbrake::Filters::KeysWhitelist do
 
       it "logs an error" do
         expect(Airbrake::Loggable.instance).to receive(:error).with(
-          /KeysWhitelist is invalid.+patterns: \[#<Object:.+>\]/,
+          /KeysAllowlist is invalid.+patterns: \[#<Object:.+>\]/,
         )
-        keys_whitelist = described_class.new(patterns)
-        keys_whitelist.call(notice)
+        keys_allowlist = described_class.new(patterns)
+        keys_allowlist.call(notice)
       end
     end
 
@@ -83,10 +83,10 @@ RSpec.describe Airbrake::Filters::KeysWhitelist do
       context "and when the filter is called once" do
         it "logs an error" do
           expect(Airbrake::Loggable.instance).to receive(:error).with(
-            /KeysWhitelist is invalid.+patterns: \[#<Proc:.+>\]/,
+            /KeysAllowlist is invalid.+patterns: \[#<Proc:.+>\]/,
           )
-          keys_whitelist = described_class.new(patterns)
-          keys_whitelist.call(notice)
+          keys_allowlist = described_class.new(patterns)
+          keys_allowlist.call(notice)
         end
 
         include_examples(
@@ -113,10 +113,10 @@ RSpec.describe Airbrake::Filters::KeysWhitelist do
 
     it "logs an error" do
       expect(Airbrake::Loggable.instance).to receive(:error).with(
-        /KeysWhitelist is invalid.+patterns: \[#<Object:.+>\]/,
+        /KeysAllowlist is invalid.+patterns: \[#<Object:.+>\]/,
       )
-      keys_whitelist = described_class.new(patterns)
-      keys_whitelist.call(notice)
+      keys_allowlist = described_class.new(patterns)
+      keys_allowlist.call(notice)
     end
   end
 

data/spec/filters/{keys_blacklist_spec.rb → keys_blocklist_spec.rb}

@@ -1,4 +1,4 @@
-RSpec.describe Airbrake::Filters::KeysBlacklist do
+RSpec.describe Airbrake::Filters::KeysBlocklist do
   subject { described_class.new(patterns) }
 
   let(:notice) { Airbrake::Notice.new(AirbrakeTestError.new) }
@@ -91,10 +91,10 @@ RSpec.describe Airbrake::Filters::KeysBlacklist do
 
       it "logs an error" do
         expect(Airbrake::Loggable.instance).to receive(:error).with(
-          /KeysBlacklist is invalid.+patterns: \[#<Object:.+>\]/,
+          /KeysBlocklist is invalid.+patterns: \[#<Object:.+>\]/,
         )
-        keys_blacklist = described_class.new(patterns)
-        keys_blacklist.call(notice)
+        keys_blocklist = described_class.new(patterns)
+        keys_blocklist.call(notice)
       end
     end
 
@@ -104,10 +104,10 @@ RSpec.describe Airbrake::Filters::KeysBlacklist do
       context "and when the filter is called once" do
         it "logs an error" do
           expect(Airbrake::Loggable.instance).to receive(:error).with(
-            /KeysBlacklist is invalid.+patterns: \[#<Proc:.+>\]/,
+            /KeysBlocklist is invalid.+patterns: \[#<Proc:.+>\]/,
           )
-          keys_blacklist = described_class.new(patterns)
-          keys_blacklist.call(notice)
+          keys_blocklist = described_class.new(patterns)
+          keys_blocklist.call(notice)
         end
       end
 
@@ -133,10 +133,10 @@ RSpec.describe Airbrake::Filters::KeysBlacklist do
 
     it "logs an error" do
       expect(Airbrake::Loggable.instance).to receive(:error).with(
-        /KeysBlacklist is invalid.+patterns: \[#<Object:.+>\]/,
+        /KeysBlocklist is invalid.+patterns: \[#<Object:.+>\]/,
       )
-      keys_blacklist = described_class.new(patterns)
-      keys_blacklist.call(notice)
+      keys_blocklist = described_class.new(patterns)
+      keys_blocklist.call(notice)
     end
   end