airbrake-ruby 4.6.0 → 6.2.2

data/spec/code_hunk_spec.rb

@@ -1,115 +0,0 @@
-RSpec.describe Airbrake::CodeHunk do
-  after do
-    %w[empty_file.rb code.rb banana.rb short_file.rb long_line.txt].each do |f|
-      Airbrake::FileCache[project_root_path(f)] = nil
-    end
-  end
-
-  describe "#to_h" do
-    context "when file is empty" do
-      subject do
-        described_class.new.get(project_root_path('empty_file.rb'), 1)
-      end
-
-      it { is_expected.to eq(1 => '') }
-    end
-
-    context "when line is nil" do
-      subject { described_class.new.get(project_root_path('code.rb'), nil) }
-
-      it { is_expected.to be_nil }
-    end
-
-    context "when a file doesn't exist" do
-      subject { described_class.new.get(project_root_path('banana.rb'), 1) }
-
-      it { is_expected.to be_nil }
-    end
-
-    context "when a file has less than NLINES lines before start line" do
-      subject { described_class.new.get(project_root_path('code.rb'), 1) }
-
-      it do
-        is_expected.to(
-          eq(
-            1 => 'module Airbrake',
-            2 => '  ##',
-            # rubocop:disable Metrics/LineLength
-            3 => '  # Represents a chunk of information that is meant to be either sent to',
-            # rubocop:enable Metrics/LineLength
-          )
-        )
-      end
-    end
-
-    context "when a file has less than NLINES lines after end line" do
-      subject { described_class.new.get(project_root_path('code.rb'), 222) }
-
-      it do
-        is_expected.to(
-          eq(
-            220 => '  end',
-            221 => 'end'
-          )
-        )
-      end
-    end
-
-    context "when a file has less than NLINES lines before and after" do
-      subject do
-        described_class.new.get(project_root_path('short_file.rb'), 2)
-      end
-
-      it do
-        is_expected.to(
-          eq(
-            1 => 'module Banana',
-            2 => '  attr_reader :bingo',
-            3 => 'end'
-          )
-        )
-      end
-    end
-
-    context "when a file has enough lines before and after" do
-      subject { described_class.new.get(project_root_path('code.rb'), 100) }
-
-      it do
-        is_expected.to(
-          eq(
-            98 => '          return json if json && json.bytesize <= MAX_NOTICE_SIZE',
-            99 => '        end',
-            100 => '',
-            101 => '        break if truncate == 0',
-            102 => '      end'
-          )
-        )
-      end
-    end
-
-    context "when a line exceeds the length limit" do
-      subject do
-        described_class.new.get(project_root_path('long_line.txt'), 1)
-      end
-
-      it "strips the line" do
-        expect(subject[1]).to eq('l' + 'o' * 196 + 'ng')
-      end
-    end
-
-    context "when an error occurrs while fetching code" do
-      before do
-        expect(Airbrake::FileCache).to receive(:[]).and_raise(Errno::EACCES)
-      end
-
-      it "logs error and returns nil" do
-        expect(Airbrake::Loggable.instance).to receive(:error).with(
-          /can't read code hunk.+Permission denied/
-        )
-        expect(subject.get(project_root_path('code.rb'), 1)).to(
-          eq(1 => '')
-        )
-      end
-    end
-  end
-end

data/spec/config/validator_spec.rb

@@ -1,184 +0,0 @@
-RSpec.describe Airbrake::Config::Validator do
-  let(:valid_id) { 123 }
-  let(:valid_key) { '123' }
-  let(:config) { Airbrake::Config.new(config_params) }
-
-  describe ".validate" do
-    context "when project_id is numerical" do
-      let(:config_params) { { project_id: valid_id, project_key: valid_key } }
-
-      it "returns a resolved promise" do
-        promise = described_class.validate(config)
-        expect(promise).to be_resolved
-      end
-    end
-
-    context "when project_id is a numerical String" do
-      let(:config_params) { { project_id: '123', project_key: valid_key } }
-
-      it "returns a resolved promise" do
-        promise = described_class.validate(config)
-        expect(promise).to be_resolved
-      end
-    end
-
-    context "when project_id is zero" do
-      let(:config_params) { { project_id: 0, project_key: valid_key } }
-
-      it "returns a rejected promise" do
-        promise = described_class.validate(config)
-        expect(promise.value).to eq('error' => ':project_id is required')
-      end
-    end
-
-    context "when project_id consists of letters" do
-      let(:config_params) { { project_id: 'foo', project_key: valid_key } }
-
-      it "returns a rejected promise" do
-        promise = described_class.validate(config)
-        expect(promise.value).to eq('error' => ':project_id is required')
-      end
-    end
-
-    context "when project_id is less than zero" do
-      let(:config_params) { { project_id: -123, project_key: valid_key } }
-
-      it "returns a rejected promise" do
-        promise = described_class.validate(config)
-        expect(promise.value).to eq('error' => ':project_id is required')
-      end
-    end
-
-    context "when project_key is a non-empty String" do
-      let(:config_params) { { project_id: valid_id, project_key: '123' } }
-
-      it "returns a resolved promise" do
-        promise = described_class.validate(config)
-        expect(promise).to be_resolved
-      end
-    end
-
-    context "when project_key is an empty String" do
-      let(:config_params) { { project_id: valid_id, project_key: '' } }
-
-      it "returns a rejected promise" do
-        promise = described_class.validate(config)
-        expect(promise.value).to eq('error' => ':project_key is required')
-      end
-    end
-
-    context "when project_key is a non-String" do
-      let(:config_params) { { project_id: valid_id, project_key: 123 } }
-
-      it "returns a rejected promise" do
-        promise = described_class.validate(config)
-        expect(promise.value).to eq('error' => ':project_key is required')
-      end
-    end
-
-    context "when environment is nil" do
-      let(:config_params) do
-        { project_id: valid_id, project_key: valid_key, environment: nil }
-      end
-
-      it "returns a resolved promise" do
-        promise = described_class.validate(config)
-        expect(promise).to be_resolved
-      end
-    end
-
-    context "when environment is a String" do
-      let(:config_params) do
-        { project_id: valid_id, project_key: valid_key, environment: 'test' }
-      end
-
-      it "returns a resolved promise" do
-        promise = described_class.validate(config)
-        expect(promise).to be_resolved
-      end
-    end
-
-    context "when environment is a Symbol" do
-      let(:config_params) do
-        { project_id: valid_id, project_key: valid_key, environment: :test }
-      end
-
-      it "returns a resolved promise" do
-        promise = described_class.validate(config)
-        expect(promise).to be_resolved
-      end
-    end
-
-    context "when environment is non-String and non-Symbol" do
-      let(:config_params) do
-        { project_id: valid_id, project_key: valid_key, environment: 1.0 }
-      end
-
-      it "returns a rejected promise" do
-        promise = described_class.validate(config)
-        expect(promise.value).to eq(
-          'error' => "the 'environment' option must be configured with a " \
-                     "Symbol (or String), but 'Float' was provided: 1.0"
-        )
-      end
-    end
-
-    context "when environment is String-like" do
-      let(:string_inquirer) { Class.new(String) }
-
-      let(:config_params) do
-        {
-          project_id: valid_id,
-          project_key: valid_key,
-          environment: string_inquirer.new('test')
-        }
-      end
-
-      it "returns a resolved promise" do
-        promise = described_class.validate(config)
-        expect(promise).to be_resolved
-      end
-    end
-  end
-
-  describe "#check_notify_ability" do
-    context "when current environment is ignored" do
-      let(:config_params) do
-        {
-          project_id: valid_id,
-          project_key: valid_key,
-          environment: 'test',
-          ignore_environments: ['test']
-        }
-      end
-
-      it "returns a rejected promise" do
-        promise = described_class.check_notify_ability(config)
-        expect(promise.value).to eq(
-          'error' => "current environment 'test' is ignored"
-        )
-      end
-    end
-
-    context "when no environment is specified but ignore_environments is" do
-      let(:config_params) do
-        {
-          project_id: valid_id,
-          project_key: valid_key,
-          ignore_environments: ['test']
-        }
-      end
-
-      it "returns a rejected promise" do
-        promise = described_class.check_notify_ability(config)
-        expect(promise).to be_resolved
-      end
-
-      it "warns about 'no effect'" do
-        expect(config.logger).to receive(:warn)
-          .with(/'ignore_environments' has no effect/)
-        described_class.check_notify_ability(config)
-      end
-    end
-  end
-end

data/spec/config_spec.rb

@@ -1,154 +0,0 @@
-RSpec.describe Airbrake::Config do
-  let(:resolved_promise) { Airbrake::Promise.new.resolve }
-  let(:rejected_promise) { Airbrake::Promise.new.reject }
-
-  let(:valid_params) { { project_id: 1, project_key: '2' } }
-
-  its(:project_id) { is_expected.to be_nil }
-  its(:project_key) { is_expected.to be_nil }
-  its(:logger) { is_expected.to be_a(Logger) }
-  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(: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(:performance_stats) { is_expected.to eq(true) }
-  its(:performance_stats_flush_period) { is_expected.to eq(15) }
-  its(:query_stats) { is_expected.to eq(false) }
-
-  describe "#new" do
-    context "when user config is passed" do
-      subject { described_class.new(logger: StringIO.new) }
-      its(:logger) { is_expected.to be_a(StringIO) }
-    end
-  end
-
-  describe "#valid?" do
-    context "when #validate returns a resolved promise" do
-      before { expect(subject).to receive(:validate).and_return(resolved_promise) }
-      it { is_expected.to be_valid }
-    end
-
-    context "when #validate returns a rejected promise" do
-      before { expect(subject).to receive(:validate).and_return(rejected_promise) }
-      it { is_expected.not_to be_valid }
-    end
-  end
-
-  describe "#ignored_environment?" do
-    context "when Validator returns a resolved promise" do
-      before do
-        expect(Airbrake::Config::Validator).to receive(:check_notify_ability)
-          .and_return(resolved_promise)
-      end
-
-      its(:ignored_environment?) { is_expected.to be_falsey }
-    end
-
-    context "when Validator returns a rejected promise" do
-      before do
-        expect(Airbrake::Config::Validator).to receive(:check_notify_ability)
-          .and_return(rejected_promise)
-      end
-
-      its(:ignored_environment?) { is_expected.to be_truthy }
-    end
-  end
-
-  describe "#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
-        is_expected.to eq(URI('https://localhost/bingo/api/v3/projects/1/notices'))
-      end
-    end
-
-    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
-        is_expected.to eq(URI('https://localhost/api/v3/projects/1/notices'))
-      end
-    end
-  end
-
-  describe "#validate" do
-    its(:validate) { is_expected.to be_an(Airbrake::Promise) }
-  end
-
-  describe "#check_configuration" do
-    let(:user_config) { {} }
-
-    subject { described_class.new(valid_params.merge(user_config)) }
-
-    its(:check_configuration) { is_expected.to be_an(Airbrake::Promise) }
-
-    context "when config is invalid" do
-      let(:user_config) { { project_id: nil } }
-      its(:check_configuration) { is_expected.to be_rejected }
-    end
-
-    context "when current environment is ignored" do
-      let(:user_config) { { environment: 'test', ignore_environments: ['test'] } }
-      its(:check_configuration) { is_expected.to be_rejected }
-    end
-
-    context "when config is valid and allows notifying" do
-      its(:check_configuration) { is_expected.not_to be_rejected }
-    end
-  end
-
-  describe "#check_performance_options" do
-    it "returns a promise" do
-      resource = Airbrake::Query.new(
-        method: '', route: '', query: '', start_time: Time.now
-      )
-      expect(subject.check_performance_options(resource))
-        .to be_an(Airbrake::Promise)
-    end
-
-    context "when performance stats are disabled" do
-      before { subject.performance_stats = false }
-
-      let(:resource) do
-        Airbrake::Request.new(
-          method: 'GET', route: '/foo', status_code: 200, start_time: Time.new
-        )
-      end
-
-      it "returns a rejected promise" do
-        promise = subject.check_performance_options(resource)
-        expect(promise.value).to eq(
-          'error' => "The Performance Stats feature is disabled"
-        )
-      end
-    end
-
-    context "when query stats are disabled" do
-      before { subject.query_stats = false }
-
-      let(:resource) do
-        Airbrake::Query.new(
-          method: 'GET', route: '/foo', query: '', start_time: Time.new
-        )
-      end
-
-      it "returns a rejected promise" do
-        promise = subject.check_performance_options(resource)
-        expect(promise.value).to eq(
-          'error' => "The Query Stats feature is disabled"
-        )
-      end
-    end
-  end
-end

data/spec/deploy_notifier_spec.rb

@@ -1,48 +0,0 @@
-RSpec.describe Airbrake::DeployNotifier do
-  before do
-    Airbrake::Config.instance = Airbrake::Config.new(project_id: 1, project_key: '123')
-  end
-
-  describe "#notify" do
-    it "returns a promise" do
-      stub_request(:post, 'https://api.airbrake.io/api/v4/projects/1/deploys')
-        .to_return(status: 201, body: '{}')
-      expect(subject.notify({})).to be_an(Airbrake::Promise)
-    end
-
-    context "when config is invalid" do
-      before { Airbrake::Config.instance.merge(project_id: nil) }
-
-      it "returns a rejected promise" do
-        promise = subject.notify({})
-        expect(promise).to be_rejected
-      end
-    end
-
-    context "when environment is configured" do
-      before { Airbrake::Config.instance.merge(environment: 'fooenv') }
-
-      it "prefers the passed environment to the config env" do
-        expect_any_instance_of(Airbrake::SyncSender).to receive(:send).with(
-          { environment: 'barenv' },
-          instance_of(Airbrake::Promise),
-          URI('https://api.airbrake.io/api/v4/projects/1/deploys')
-        )
-        subject.notify(environment: 'barenv')
-      end
-    end
-
-    context "when environment is not configured" do
-      before { Airbrake::Config.instance.merge(environment: 'fooenv') }
-
-      it "sets the environment from the config" do
-        expect_any_instance_of(Airbrake::SyncSender).to receive(:send).with(
-          { environment: 'fooenv' },
-          instance_of(Airbrake::Promise),
-          URI('https://api.airbrake.io/api/v4/projects/1/deploys')
-        )
-        subject.notify({})
-      end
-    end
-  end
-end

data/spec/file_cache.rb

@@ -1,36 +0,0 @@
-RSpec.describe Airbrake::FileCache do
-  after do
-    %i[banana mango].each { |k| described_class.delete(k) }
-    expect(described_class).to be_empty
-  end
-
-  describe ".[]=" do
-    context "when cache limit isn't reached" do
-      before do
-        stub_const("#{described_class.name}::MAX_SIZE", 10)
-      end
-
-      it "adds objects" do
-        described_class[:banana] = 1
-        described_class[:mango] = 2
-
-        expect(described_class[:banana]).to eq(1)
-        expect(described_class[:mango]).to eq(2)
-      end
-    end
-
-    context "when cache limit is reached" do
-      before do
-        stub_const("#{described_class.name}::MAX_SIZE", 1)
-      end
-
-      it "replaces old objects with new ones" do
-        described_class[:banana] = 1
-        described_class[:mango] = 2
-
-        expect(described_class[:banana]).to be_nil
-        expect(described_class[:mango]).to eq(2)
-      end
-    end
-  end
-end

data/spec/filter_chain_spec.rb

@@ -1,92 +0,0 @@
-RSpec.describe Airbrake::FilterChain do
-  let(:notice) { Airbrake::Notice.new(AirbrakeTestError.new) }
-
-  describe "#refine" do
-    let(:filter) do
-      Class.new do
-        attr_reader :weight
-
-        def initialize(weight)
-          @weight = weight
-        end
-
-        def call(notice)
-          notice[:params][:bingo] << @weight
-        end
-      end
-    end
-
-    it "executes filters from heaviest to lightest" do
-      notice[:params][:bingo] = []
-
-      (0...3).reverse_each { |i| subject.add_filter(filter.new(i)) }
-      subject.refine(notice)
-
-      expect(notice[:params][:bingo]).to eq([2, 1, 0])
-    end
-
-    it "stops execution once a notice was ignored" do
-      f2 = filter.new(2)
-      expect(f2).to receive(:call)
-
-      f1 = proc { |notice| notice.ignore! }
-
-      f0 = filter.new(-1)
-      expect(f0).not_to receive(:call)
-
-      [f2, f1, f0].each { |f| subject.add_filter(f) }
-
-      subject.refine(notice)
-    end
-  end
-
-  describe "#delete_filter" do
-    let(:filter) do
-      Class.new do
-        class << self
-          def name
-            'FooFilter'
-          end
-        end
-
-        def initialize(foo)
-          @foo = foo
-        end
-
-        def call(notice)
-          notice[:params][:foo] << @foo
-        end
-      end
-    end
-
-    it "deletes a class filter" do
-      notice[:params][:foo] = []
-
-      f1 = filter.new(1)
-      subject.add_filter(f1)
-
-      foo_filter_mock = double
-      expect(foo_filter_mock).to(
-        receive(:name).at_least(:once).and_return('FooFilter')
-      )
-      subject.delete_filter(foo_filter_mock)
-
-      f2 = filter.new(2)
-      subject.add_filter(f2)
-
-      subject.refine(notice)
-      expect(notice[:params][:foo]).to eq([2])
-    end
-  end
-
-  describe "#inspect" do
-    it "returns a string representation of an empty FilterChain" do
-      expect(subject.inspect).to eq('[]')
-    end
-
-    it "returns a string representation of a non-empty FilterChain" do
-      subject.add_filter(proc {})
-      expect(subject.inspect).to eq('[Proc]')
-    end
-  end
-end

data/spec/filters/context_filter_spec.rb

@@ -1,23 +0,0 @@
-RSpec.describe Airbrake::Filters::ContextFilter do
-  let(:notice) { Airbrake::Notice.new(AirbrakeTestError.new) }
-
-  context "when the current context is empty" do
-    it "doesn't merge anything with params" do
-      described_class.new({}).call(notice)
-      expect(notice[:params]).to be_empty
-    end
-  end
-
-  context "when the current context has some data" do
-    it "merges the data with params" do
-      described_class.new(apples: 'oranges').call(notice)
-      expect(notice[:params]).to eq(airbrake_context: { apples: 'oranges' })
-    end
-
-    it "clears the data from the provided context" do
-      context = { apples: 'oranges' }
-      described_class.new(context).call(notice)
-      expect(context).to be_empty
-    end
-  end
-end

data/spec/filters/dependency_filter_spec.rb

@@ -1,12 +0,0 @@
-RSpec.describe Airbrake::Filters::DependencyFilter do
-  let(:notice) { Airbrake::Notice.new(AirbrakeTestError.new) }
-
-  describe "#call" do
-    it "attaches loaded dependencies to context/versions/dependencies" do
-      subject.call(notice)
-      expect(notice[:context][:versions][:dependencies]).to include(
-        'airbrake-ruby' => Airbrake::AIRBRAKE_RUBY_VERSION
-      )
-    end
-  end
-end