airbrake-ruby 4.8.0 → 5.2.0

data/spec/query_spec.rb

@@ -2,7 +2,7 @@ RSpec.describe Airbrake::Query do
   describe "#stash" do
     subject do
       described_class.new(
-        method: 'GET', route: '/', query: '', start_time: Time.now
+        method: 'GET', route: '/', query: '',
       )
     end
 

data/spec/queue_spec.rb

@@ -0,0 +1,18 @@
+RSpec.describe Airbrake::Queue do
+  subject { described_class.new(queue: 'bananas', error_count: 0) }
+
+  describe "#ignore" do
+    it { is_expected.to respond_to(:ignore!) }
+  end
+
+  describe "#stash" do
+    it { is_expected.to respond_to(:stash) }
+  end
+
+  describe "#route" do
+    it "always returns an empty route" do
+      queue = described_class.new(queue: 'a', error_count: 0)
+      expect(queue.route).to be_empty
+    end
+  end
+end

data/spec/remote_settings/callback_spec.rb

@@ -0,0 +1,143 @@
+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
+      expect(logger).to receive(:debug) do |&block|
+        expect(block.call).to match(/applying remote settings/)
+      end
+      described_class.new(config).call(data)
+    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
+
+      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
+    end
+
+    context "when the config enables error notifications" do
+      before { config.error_notifications = true }
+
+      it "can disable and enable error notifications" do
+        expect(data).to receive(:error_notifications?).and_return(false)
+
+        callback = described_class.new(config)
+        callback.call(data)
+        expect(config.error_notifications).to eq(false)
+
+        expect(data).to receive(:error_notifications?).and_return(true)
+        callback.call(data)
+        expect(config.error_notifications).to eq(true)
+      end
+    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
+
+      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
+    end
+
+    context "when the config enables performance stats" do
+      before { config.performance_stats = true }
+
+      it "can disable and enable performance_stats" do
+        expect(data).to receive(:performance_stats?).and_return(false)
+
+        callback = described_class.new(config)
+        callback.call(data)
+        expect(config.performance_stats).to eq(false)
+
+        expect(data).to receive(:performance_stats?).and_return(true)
+        callback.call(data)
+        expect(config.performance_stats).to eq(true)
+      end
+    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

@@ -0,0 +1,348 @@
+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, {})
+      settings_data.merge!('poll_sec' => 123, 'config_route' => 'abc')
+
+      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
+    let(:host) { 'http://example.com/' }
+
+    context "when remote config specifies a config route" do
+      let(:data) do
+        { 'config_route' => '123/cfg/321/cfg.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 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 a config route is specified but is set to nil" do
+      let(:data) do
+        { 'config_route' => nil }
+      end
+
+      it "returns the config route with the default location" 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
+    end
+
+    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(
+          "http://example.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