airbrake-ruby 4.13.3 → 5.0.0.rc.1

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
 

data/spec/filters/sql_filter_spec.rb

@@ -10,7 +10,7 @@ RSpec.describe Airbrake::Filters::SqlFilter do
     end
   end
 
-  shared_examples "query blacklisting" do |query, opts|
+  shared_examples "query blocklisting" do |query, opts|
     it "ignores '#{query}'" do
       filter = described_class.new('postgres')
       q = Airbrake::Query.new(query: query, method: 'GET', route: '/', timing: 1)
@@ -263,12 +263,12 @@ RSpec.describe Airbrake::Filters::SqlFilter do
 
     'SELECT t.oid, t.typname FROM pg_type as t WHERE t.typname IN (?)',
   ].each do |query|
-    include_examples 'query blacklisting', query, should_ignore: true
+    include_examples 'query blocklisting', query, should_ignore: true
   end
 
   [
     'UPDATE "users" SET "last_sign_in_at" = ? WHERE "users"."id" = ?',
   ].each do |query|
-    include_examples 'query blacklisting', query, should_ignore: false
+    include_examples 'query blocklisting', query, should_ignore: false
   end
 end

data/spec/notice_notifier/options_spec.rb

@@ -234,14 +234,14 @@ RSpec.describe Airbrake::NoticeNotifier do
       end
     end
 
-    describe ":blacklist_keys" do
+    describe ":blocklist_keys" do
       # Fixes https://github.com/airbrake/airbrake-ruby/issues/276
-      context "when specified along with :whitelist_keys" do
+      context "when specified along with :allowlist_keys" do
         context "and when context payload is present" do
           before do
             Airbrake::Config.instance.merge(
-              blacklist_keys: %i[password password_confirmation],
-              whitelist_keys: [:email, /user/i, 'account_id'],
+              blocklist_keys: %i[password password_confirmation],
+              allowlist_keys: [:email, /user/i, 'account_id'],
             )
           end
 

data/spec/performance_notifier_spec.rb

@@ -389,7 +389,7 @@ RSpec.describe Airbrake::PerformanceNotifier do
       subject.close
 
       expect(promise).to be_an(Airbrake::Promise)
-      expect(promise.value).to eq('' => nil)
+      expect(promise.value).to eq('' => '')
     end
 
     it "checks performance stat configuration" do
@@ -601,7 +601,7 @@ RSpec.describe Airbrake::PerformanceNotifier do
           body: %r|\A{"queries":\[{"method":"POST","route":"/foo"|,
         ),
       ).to have_been_made
-      expect(retval).to eq('' => nil)
+      expect(retval).to eq('' => '')
     end
   end
 

data/spec/remote_settings/settings_data_spec.rb

@@ -0,0 +1,327 @@
+RSpec.describe Airbrake::RemoteSettings::SettingsData do
+  let(:project_id) { 123 }
+
+  describe "#merge!" do
+    it "returns self" do
+      settings_data = described_class.new(project_id, {})
+      expect(settings_data.merge!({})).to eql(settings_data)
+    end
+
+    it "merges the given hash with the data" do
+      settings_data = described_class.new(project_id, {})
+      # rubocop:disable Performance/RedundantMerge
+      settings_data.merge!('poll_sec' => 123, 'config_route' => 'abc')
+      # rubocop:enable Performance/RedundantMerge
+
+      expect(settings_data.interval).to eq(123)
+      expect(settings_data.config_route).to eq('abc')
+    end
+  end
+
+  describe "#interval" do
+    context "when given data has zero interval" do
+      let(:data) do
+        { 'poll_sec' => 0 }
+      end
+
+      it "returns the default interval" do
+        expect(described_class.new(project_id, data).interval).to eq(600)
+      end
+    end
+
+    context "when given data has negative interval" do
+      let(:data) do
+        { 'poll_sec' => -1 }
+      end
+
+      it "returns the default interval" do
+        expect(described_class.new(project_id, data).interval).to eq(600)
+      end
+    end
+
+    context "when given data has nil interval" do
+      let(:data) do
+        { 'poll_sec' => nil }
+      end
+
+      it "returns the default interval" do
+        expect(described_class.new(project_id, data).interval).to eq(600)
+      end
+    end
+
+    context "when given data has a positive interval" do
+      let(:data) do
+        { 'poll_sec' => 123 }
+      end
+
+      it "returns the interval from data" do
+        expect(described_class.new(project_id, data).interval).to eq(123)
+      end
+    end
+  end
+
+  describe "#config_route" do
+    context "when given a pathname" do
+      let(:data) do
+        { 'config_route' => 'http://example.com' }
+      end
+
+      it "returns the given pathname" do
+        expect(described_class.new(project_id, data).config_route)
+          .to eq('http://example.com')
+      end
+    end
+
+    context "when the pathname is nil" do
+      let(:data) do
+        { 'config_route' => nil }
+      end
+
+      it "returns the default pathname" do
+        expect(described_class.new(project_id, data).config_route).to eq(
+          'https://staging-notifier-configs.s3.amazonaws.com/' \
+          "2020-06-18/config/#{project_id}/config.json",
+        )
+      end
+    end
+  end
+
+  describe "#error_notifications?" do
+    context "when the 'errors' setting is present" do
+      context "and when it is enabled" do
+        let(:data) do
+          {
+            'settings' => [
+              {
+                'name' => 'errors',
+                'enabled' => true,
+              },
+            ],
+          }
+        end
+
+        it "returns true" do
+          expect(described_class.new(project_id, data).error_notifications?)
+            .to eq(true)
+        end
+      end
+
+      context "and when it is disabled" do
+        let(:data) do
+          {
+            'settings' => [
+              {
+                'name' => 'errors',
+                'enabled' => false,
+              },
+            ],
+          }
+        end
+
+        it "returns false" do
+          expect(described_class.new(project_id, data).error_notifications?)
+            .to eq(false)
+        end
+      end
+    end
+
+    context "when the 'errors' setting is missing" do
+      let(:data) do
+        { 'settings' => [] }
+      end
+
+      it "returns true" do
+        expect(described_class.new(project_id, data).error_notifications?)
+          .to eq(true)
+      end
+    end
+  end
+
+  describe "#performance_stats?" do
+    context "when the 'apm' setting is present" do
+      context "and when it is enabled" do
+        let(:data) do
+          {
+            'settings' => [
+              {
+                'name' => 'apm',
+                'enabled' => true,
+              },
+            ],
+          }
+        end
+
+        it "returns true" do
+          expect(described_class.new(project_id, data).performance_stats?)
+            .to eq(true)
+        end
+      end
+
+      context "and when it is disabled" do
+        let(:data) do
+          {
+            'settings' => [
+              {
+                'name' => 'apm',
+                'enabled' => false,
+              },
+            ],
+          }
+        end
+
+        it "returns false" do
+          expect(described_class.new(project_id, data).performance_stats?)
+            .to eq(false)
+        end
+      end
+    end
+
+    context "when the 'apm' setting is missing" do
+      let(:data) do
+        { 'settings' => [] }
+      end
+
+      it "returns true" do
+        expect(described_class.new(project_id, data).performance_stats?)
+          .to eq(true)
+      end
+    end
+  end
+
+  describe "#error_host" do
+    context "when the 'errors' setting is present" do
+      context "and when 'endpoint' is specified" do
+        let(:endpoint) { 'https://api.example.com/' }
+
+        let(:data) do
+          {
+            'settings' => [
+              {
+                'name' => 'errors',
+                'enabled' => true,
+                'endpoint' => endpoint,
+              },
+            ],
+          }
+        end
+
+        it "returns the endpoint" do
+          expect(described_class.new(project_id, data).error_host).to eq(endpoint)
+        end
+      end
+
+      context "and when an endpoint is NOT specified" do
+        let(:data) do
+          {
+            'settings' => [
+              {
+                'name' => 'errors',
+                'enabled' => true,
+              },
+            ],
+          }
+        end
+
+        it "returns nil" do
+          expect(described_class.new(project_id, data).error_host).to be_nil
+        end
+      end
+    end
+
+    context "when the 'errors' setting is missing" do
+      let(:data) do
+        { 'settings' => [] }
+      end
+
+      it "returns nil" do
+        expect(described_class.new(project_id, data).error_host).to be_nil
+      end
+    end
+  end
+
+  describe "#apm_host" do
+    context "when the 'apm' setting is present" do
+      context "and when 'endpoint' is specified" do
+        let(:endpoint) { 'https://api.example.com/' }
+
+        let(:data) do
+          {
+            'settings' => [
+              {
+                'name' => 'apm',
+                'enabled' => true,
+                'endpoint' => endpoint,
+              },
+            ],
+          }
+        end
+
+        it "returns the endpoint" do
+          expect(described_class.new(project_id, data).apm_host).to eq(endpoint)
+        end
+      end
+
+      context "and when an endpoint is NOT specified" do
+        let(:data) do
+          {
+            'settings' => [
+              {
+                'name' => 'apm',
+                'enabled' => true,
+              },
+            ],
+          }
+        end
+
+        it "returns nil" do
+          expect(described_class.new(project_id, data).apm_host).to be_nil
+        end
+      end
+    end
+
+    context "when the 'apm' setting is missing" do
+      let(:data) do
+        { 'settings' => [] }
+      end
+
+      it "returns nil" do
+        expect(described_class.new(project_id, data).apm_host).to be_nil
+      end
+    end
+  end
+
+  describe "#to_h" do
+    let(:data) do
+      {
+        'poll_sec' => 123,
+        'settings' => [
+          {
+            'name' => 'apm',
+            'enabled' => false,
+          },
+        ],
+      }
+    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['poll_sec'] = 0
+
+      expect(subject.to_h).to eq(
+        'poll_sec' => 123,
+        'settings' => [
+          {
+            'name' => 'apm',
+            'enabled' => false,
+          },
+        ],
+      )
+    end
+  end
+end

data/spec/remote_settings_spec.rb

@@ -0,0 +1,212 @@
+RSpec.describe Airbrake::RemoteSettings do
+  let(:project_id) { 123 }
+
+  let(:endpoint) do
+    "https://staging-notifier-configs.s3.amazonaws.com/2020-06-18/config/" \
+    "#{project_id}/config.json"
+  end
+
+  let(:body) do
+    {
+      'poll_sec' => 1,
+      'settings' => [
+        {
+          'name' => 'apm',
+          'enabled' => false,
+        },
+        {
+          'name' => 'errors',
+          'enabled' => true,
+        },
+      ],
+    }
+  end
+
+  let(:config_path) { described_class::CONFIG_DUMP_PATH }
+  let(:config_dir) { File.dirname(config_path) }
+
+  before do
+    stub_request(:get, endpoint).to_return(status: 200, body: body.to_json)
+
+    # Do not create config dumps on disk.
+    allow(Dir).to receive(:mkdir).with(config_dir)
+    allow(File).to receive(:write).with(config_path, anything)
+  end
+
+  describe ".poll" do
+    describe "config loading" do
+      let(:settings_data) { described_class::SettingsData.new(project_id, body) }
+
+      before do
+        allow(File).to receive(:exist?).with(config_path).and_return(true)
+        allow(File).to receive(:read).with(config_path).and_return(body.to_json)
+
+        allow(described_class::SettingsData).to receive(:new).and_return(settings_data)
+      end
+
+      it "loads the config from disk" do
+        expect(File).to receive(:read).with(config_path)
+        expect(settings_data).to receive(:merge!).with(body).twice
+
+        remote_settings = described_class.poll(project_id) {}
+        sleep(0.2)
+        remote_settings.stop_polling
+
+        expect(a_request(:get, endpoint)).to have_been_made.once
+      end
+
+      it "yields the config to the block twice" do
+        block = proc {}
+        expect(block).to receive(:call).twice
+
+        remote_settings = described_class.poll(project_id, &block)
+        sleep(0.2)
+        remote_settings.stop_polling
+
+        expect(a_request(:get, endpoint)).to have_been_made.once
+      end
+
+      context "when config loading fails" do
+        it "logs an error" do
+          expect(File).to receive(:read).and_raise(StandardError)
+          expect(Airbrake::Loggable.instance).to receive(:error).with(
+            '**Airbrake: config loading failed: StandardError',
+          )
+
+          remote_settings = described_class.poll(project_id) {}
+          sleep(0.2)
+          remote_settings.stop_polling
+
+          expect(a_request(:get, endpoint)).to have_been_made.once
+        end
+      end
+    end
+
+    context "when no errors are raised" do
+      it "makes a request to AWS S3" do
+        remote_settings = described_class.poll(project_id) {}
+        sleep(0.1)
+        remote_settings.stop_polling
+
+        expect(a_request(:get, endpoint)).to have_been_made.at_least_once
+      end
+
+      it "fetches remote settings" do
+        settings = nil
+        remote_settings = described_class.poll(project_id) do |data|
+          settings = data
+        end
+        sleep(0.1)
+        remote_settings.stop_polling
+
+        expect(settings.error_notifications?).to eq(true)
+        expect(settings.performance_stats?).to eq(false)
+        expect(settings.interval).to eq(1)
+      end
+    end
+
+    context "when an error is raised while making a HTTP request" do
+      before do
+        allow(Net::HTTP).to receive(:get).and_raise(StandardError)
+      end
+
+      it "doesn't fetch remote settings" do
+        settings = nil
+        remote_settings = described_class.poll(project_id) do |data|
+          settings = data
+        end
+        sleep(0.1)
+        remote_settings.stop_polling
+
+        expect(a_request(:get, endpoint)).not_to have_been_made
+        expect(settings.interval).to eq(600)
+      end
+    end
+
+    context "when an error is raised while parsing returned JSON" do
+      before do
+        allow(JSON).to receive(:parse).and_raise(JSON::ParserError)
+      end
+
+      it "doesn't update settings data" do
+        settings = nil
+        remote_settings = described_class.poll(project_id) do |data|
+          settings = data
+        end
+        sleep(0.1)
+        remote_settings.stop_polling
+
+        expect(a_request(:get, endpoint)).to have_been_made.once
+        expect(settings.interval).to eq(600)
+      end
+    end
+
+    context "when API returns an XML response" do
+      before do
+        stub_request(:get, endpoint).to_return(status: 200, body: '<?xml ...')
+      end
+
+      it "doesn't update settings data" do
+        settings = nil
+        remote_settings = described_class.poll(project_id) do |data|
+          settings = data
+        end
+        sleep(0.1)
+        remote_settings.stop_polling
+
+        expect(a_request(:get, endpoint)).to have_been_made.once
+        expect(settings.interval).to eq(600)
+      end
+    end
+
+    context "when a config route is specified in the returned data" do
+      let(:new_endpoint) { 'http://example.com' }
+
+      let(:body) do
+        { 'config_route' => new_endpoint, 'poll_sec' => 0.1 }
+      end
+
+      before do
+        stub_request(:get, new_endpoint).to_return(status: 200, body: body.to_json)
+      end
+
+      it "makes the next request to the specified config route" do
+        remote_settings = described_class.poll(project_id) {}
+        sleep(0.2)
+
+        remote_settings.stop_polling
+
+        expect(a_request(:get, endpoint)).to have_been_made.once
+        expect(a_request(:get, new_endpoint)).to have_been_made.once
+      end
+    end
+  end
+
+  describe "#stop_polling" do
+    it "dumps config data to disk" do
+      expect(Dir).to receive(:mkdir).with(config_dir)
+      expect(File).to receive(:write).with(config_path, body.to_json)
+
+      remote_settings = described_class.poll(project_id) {}
+      sleep(0.2)
+      remote_settings.stop_polling
+
+      expect(a_request(:get, endpoint)).to have_been_made.once
+    end
+
+    context "when config dumping fails" do
+      it "logs an error" do
+        expect(File).to receive(:write).and_raise(StandardError)
+        expect(Airbrake::Loggable.instance).to receive(:error).with(
+          '**Airbrake: config dumping failed: StandardError',
+        )
+
+        remote_settings = described_class.poll(project_id) {}
+        sleep(0.2)
+        remote_settings.stop_polling
+
+        expect(a_request(:get, endpoint)).to have_been_made.once
+      end
+    end
+  end
+end