airbrake-ruby 6.0.1 → 6.1.1

data/spec/remote_settings/settings_data_spec.rb

@@ -1,348 +0,0 @@
-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
-    subject(:settings_data) { described_class.new(project_id, data) }
-
-    let(:data) do
-      {
-        'poll_sec' => 123,
-        'settings' => [
-          {
-            'name' => 'apm',
-            'enabled' => false,
-          },
-        ],
-      }
-    end
-
-    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 = settings_data.to_h
-      hash['poll_sec'] = 0
-
-      expect(settings_data.to_h).to eq(
-        'poll_sec' => 123,
-        'settings' => [
-          {
-            'name' => 'apm',
-            'enabled' => false,
-          },
-        ],
-      )
-    end
-  end
-end

data/spec/remote_settings_spec.rb

@@ -1,201 +0,0 @@
-RSpec.describe Airbrake::RemoteSettings do
-  let(:project_id) { 123 }
-  let(:host) { 'https://v1-production-notifier-configs.s3.amazonaws.com' }
-
-  let(:endpoint) do
-    "#{host}/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!(:stub) do
-    stub_request(:get, Regexp.new(endpoint))
-      .to_return(status: 200, body: body.to_json)
-  end
-
-  describe ".poll" do
-    describe "config loading" do
-      let(:settings_data) { described_class::SettingsData.new(project_id, body) }
-
-      before do
-        allow(described_class::SettingsData).to receive(:new).and_return(settings_data)
-      end
-
-      it "yields the config to the block twice" do
-        block = proc {}
-        allow(block).to receive(:call)
-
-        remote_settings = described_class.poll(project_id, host, &block)
-        sleep(0.2)
-        remote_settings.stop_polling
-
-        expect(stub).to have_been_requested.once
-        expect(block).to have_received(:call).twice
-      end
-    end
-
-    context "when no errors are raised" do
-      it "makes a request to AWS S3" do
-        remote_settings = described_class.poll(project_id, host) { anything }
-        sleep(0.1)
-        remote_settings.stop_polling
-
-        expect(stub).to have_been_requested.at_least_once
-      end
-
-      it "sends params about the environment with the request" do
-        remote_settings = described_class.poll(project_id, host) { anything }
-        sleep(0.1)
-        remote_settings.stop_polling
-
-        stub_with_query_params = stub.with(
-          query: URI.decode_www_form(described_class::QUERY_PARAMS).to_h,
-        )
-        expect(stub_with_query_params).to have_been_requested.at_least_once
-      end
-
-      # rubocop:disable RSpec/MultipleExpectations
-      it "fetches remote settings" do
-        settings = nil
-        remote_settings = described_class.poll(project_id, host) 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
-      # rubocop:enable RSpec/MultipleExpectations
-    end
-
-    context "when an error is raised while making a HTTP request" do
-      let(:https) { instance_double(Net::HTTP) }
-
-      before do
-        allow(Net::HTTP).to receive(:new).and_return(https)
-        allow(https).to receive(:use_ssl=).with(true)
-        allow(https).to receive(:request).and_raise(StandardError)
-      end
-
-      it "doesn't fetch remote settings" do
-        settings = nil
-        remote_settings = described_class.poll(project_id, host) do |data|
-          settings = data
-        end
-        sleep(0.1)
-        remote_settings.stop_polling
-
-        expect(stub).not_to have_been_requested
-        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, host) do |data|
-          settings = data
-        end
-        sleep(0.1)
-        remote_settings.stop_polling
-
-        expect(stub).to have_been_requested.once
-        expect(settings.interval).to eq(600)
-      end
-    end
-
-    context "when API returns a non-200 response" do
-      let!(:stub) do
-        stub_request(:get, Regexp.new(endpoint))
-          .to_return(status: 201, body: body.to_json)
-      end
-
-      it "doesn't update settings data" do
-        settings = nil
-        remote_settings = described_class.poll(project_id, host) do |data|
-          settings = data
-        end
-        sleep(0.1)
-        remote_settings.stop_polling
-
-        expect(stub).to have_been_requested.once
-        expect(settings.interval).to eq(600)
-      end
-
-      it "logs error" do
-        allow(Airbrake::Loggable.instance).to receive(:error)
-
-        remote_settings = described_class.poll(project_id, host) { anything }
-        sleep(0.1)
-        remote_settings.stop_polling
-
-        expect(Airbrake::Loggable.instance).to have_received(:error).with(body.to_json)
-      end
-    end
-
-    context "when API returns a 200 response" do
-      let!(:stub) do
-        stub_request(:get, Regexp.new(endpoint))
-          .to_return(status: 200, body: body.to_json)
-      end
-
-      it "doesn't log errors" do
-        allow(Airbrake::Loggable.instance).to receive(:error)
-
-        remote_settings = described_class.poll(project_id, host) { anything }
-        sleep(0.1)
-        remote_settings.stop_polling
-
-        expect(Airbrake::Loggable.instance).not_to have_received(:error)
-        expect(stub).to have_been_requested.once
-      end
-    end
-
-    # rubocop:disable RSpec/MultipleMemoizedHelpers
-    context "when a config route is specified in the returned data" do
-      let(:new_config_route) do
-        '213/config/111/config.json'
-      end
-
-      let(:body) do
-        { 'config_route' => new_config_route, 'poll_sec' => 0.1 }
-      end
-
-      let!(:new_stub) do
-        stub_request(:get, Regexp.new(new_config_route))
-          .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, host) { anything }
-        sleep(0.2)
-
-        remote_settings.stop_polling
-
-        expect(stub).to have_been_requested.once
-        expect(new_stub).to have_been_requested.once
-      end
-    end
-    # rubocop:enable RSpec/MultipleMemoizedHelpers
-  end
-end

data/spec/request_spec.rb

@@ -1,9 +0,0 @@
-RSpec.describe Airbrake::Request do
-  describe "#stash" do
-    subject do
-      described_class.new(method: 'GET', route: '/', status_code: 200)
-    end
-
-    it { is_expected.to respond_to(:stash) }
-  end
-end

data/spec/response_spec.rb

@@ -1,110 +0,0 @@
-RSpec.describe Airbrake::Response do
-  describe ".parse" do
-    [200, 201, 204].each do |code|
-      context "when response code is #{code}" do
-        before do
-          allow(Airbrake::Loggable.instance).to receive(:debug)
-        end
-
-        it "logs response body" do
-          described_class.parse(OpenStruct.new(code: code, body: '{}'))
-
-          expect(Airbrake::Loggable.instance).to have_received(:debug).with(
-            /Airbrake::Response \(#{code}\): {}/,
-          )
-        end
-      end
-    end
-
-    [400, 401, 403, 420].each do |code|
-      context "when response code is #{code}" do
-        before do
-          allow(Airbrake::Loggable.instance).to receive(:error)
-        end
-
-        it "logs response message" do
-          described_class.parse(
-            OpenStruct.new(code: code, body: '{"message":"foo"}'),
-          )
-
-          expect(Airbrake::Loggable.instance).to have_received(:error).with(
-            /Airbrake: foo/,
-          )
-        end
-      end
-    end
-
-    context "when response code is 429" do
-      let(:response) { OpenStruct.new(code: 429, body: '{"message":"rate limited"}') }
-
-      before do
-        allow(Airbrake::Loggable.instance).to receive(:error)
-      end
-
-      it "logs response message" do
-        described_class.parse(response)
-        expect(Airbrake::Loggable.instance).to have_received(:error).with(
-          /Airbrake: rate limited/,
-        )
-      end
-
-      it "returns an error response" do
-        time = Time.now
-        allow(Time).to receive(:now).and_return(time)
-
-        resp = described_class.parse(response)
-        expect(resp).to include(
-          'error' => '**Airbrake: rate limited',
-          'rate_limit_reset' => time,
-        )
-      end
-    end
-
-    context "when response code is unhandled" do
-      let(:response) { OpenStruct.new(code: 500, body: 'foo') }
-
-      before do
-        allow(Airbrake::Loggable.instance).to receive(:error)
-      end
-
-      it "logs response body" do
-        described_class.parse(response)
-        expect(Airbrake::Loggable.instance).to have_received(:error).with(
-          /Airbrake: unexpected code \(500\)\. Body: foo/,
-        )
-      end
-
-      it "returns an error response" do
-        resp = described_class.parse(response)
-        expect(resp).to eq('error' => 'foo')
-      end
-
-      it "truncates body" do
-        response.body *= 1000
-        resp = described_class.parse(response)
-        expect(resp).to eq('error' => "#{'foo' * 33}fo...")
-      end
-    end
-
-    context "when response body can't be parsed as JSON" do
-      let(:response) { OpenStruct.new(code: 201, body: 'foo') }
-
-      before do
-        allow(Airbrake::Loggable.instance).to receive(:error)
-      end
-
-      it "logs response body" do
-        described_class.parse(response)
-        expect(Airbrake::Loggable.instance).to have_received(:error).with(
-          /Airbrake: error while parsing body \(.*unexpected token.*\)\. Body: foo/,
-        )
-      end
-
-      it "returns an error message" do
-        expect(described_class.parse(response)['error']).to match(
-          /\A#<JSON::ParserError.+>/,
-        )
-      end
-    end
-  end
-end