airbrake-ruby 4.6.0

data/spec/deploy_notifier_spec.rb

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,92 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,12 @@
+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

data/spec/filters/exception_attributes_filter_spec.rb

@@ -0,0 +1,50 @@
+RSpec.describe Airbrake::Filters::ExceptionAttributesFilter do
+  describe "#call" do
+    let(:notice) { Airbrake::Notice.new(ex) }
+
+    context "when #to_airbrake returns a non-Hash object" do
+      let(:ex) do
+        Class.new(AirbrakeTestError) do
+          def to_airbrake
+            Object.new
+          end
+        end.new
+      end
+
+      it "doesn't raise" do
+        expect { subject.call(notice) }.not_to raise_error
+        expect(notice[:params]).to be_empty
+      end
+    end
+
+    context "when #to_airbrake errors out" do
+      let(:ex) do
+        Class.new(AirbrakeTestError) do
+          def to_airbrake
+            1 / 0
+          end
+        end.new
+      end
+
+      it "doesn't raise" do
+        expect { subject.call(notice) }.not_to raise_error
+        expect(notice[:params]).to be_empty
+      end
+    end
+
+    context "when #to_airbrake returns a hash" do
+      let(:ex) do
+        Class.new(AirbrakeTestError) do
+          def to_airbrake
+            { params: { foo: '1' } }
+          end
+        end.new
+      end
+
+      it "merges parameters with the notice" do
+        subject.call(notice)
+        expect(notice[:params]).to eq(foo: '1')
+      end
+    end
+  end
+end

data/spec/filters/gem_root_filter_spec.rb

@@ -0,0 +1,41 @@
+RSpec.describe Airbrake::Filters::GemRootFilter do
+  let(:notice) { Airbrake::Notice.new(AirbrakeTestError.new) }
+  let(:root1) { '/my/gem/root' }
+  let(:root2) { '/my/other/gem/root' }
+
+  before { Gem.path << root1 << root2 }
+  after { 2.times { Gem.path.pop } }
+
+  it "replaces gem root in the backtrace with a label" do
+    # rubocop:disable Metrics/LineLength
+    notice[:errors].first[:backtrace] = [
+      { file: "/home/kyrylo/code/airbrake/ruby/spec/spec_helper.rb" },
+      { file: "#{root1}/gems/rspec-core-3.3.2/lib/rspec/core/configuration.rb" },
+      { file: "/opt/rubies/ruby-2.2.2/lib/ruby/2.2.0/rubygems/core_ext/kernel_require.rb" },
+      { file: "#{root2}/gems/rspec-core-3.3.2/exe/rspec" }
+    ]
+    # rubocop:enable Metrics/LineLength
+
+    subject.call(notice)
+
+    # rubocop:disable Metrics/LineLength
+    expect(notice[:errors].first[:backtrace]).to(
+      eq(
+        [
+          { file: "/home/kyrylo/code/airbrake/ruby/spec/spec_helper.rb" },
+          { file: "/GEM_ROOT/gems/rspec-core-3.3.2/lib/rspec/core/configuration.rb" },
+          { file: "/opt/rubies/ruby-2.2.2/lib/ruby/2.2.0/rubygems/core_ext/kernel_require.rb" },
+          { file: "/GEM_ROOT/gems/rspec-core-3.3.2/exe/rspec" }
+        ]
+      )
+    )
+    # rubocop:enable Metrics/LineLength
+  end
+
+  it "does not filter file when it is nil" do
+    expect(notice[:errors].first[:file]).to be_nil
+    expect { subject.call(notice) }.not_to(
+      change { notice[:errors].first[:file] }
+    )
+  end
+end

data/spec/filters/git_last_checkout_filter_spec.rb

@@ -0,0 +1,46 @@
+RSpec.describe Airbrake::Filters::GitLastCheckoutFilter do
+  subject { described_class.new('.') }
+
+  let(:notice) { Airbrake::Notice.new(AirbrakeTestError.new) }
+
+  context "when context/lastCheckout is defined" do
+    it "doesn't attach anything to context/lastCheckout" do
+      notice[:context][:lastCheckout] = '123'
+      subject.call(notice)
+      expect(notice[:context][:lastCheckout]).to eq('123')
+    end
+  end
+
+  context "when .git directory doesn't exist" do
+    subject { described_class.new('root/dir') }
+
+    it "doesn't attach anything to context/lastCheckout" do
+      subject.call(notice)
+      expect(notice[:context][:lastCheckout]).to be_nil
+    end
+  end
+
+  context "when .git directory exists" do
+    before { subject.call(notice) }
+
+    it "attaches last checkouted username" do
+      expect(notice[:context][:lastCheckout][:username]).not_to be_empty
+    end
+
+    it "attaches last checkouted email" do
+      expect(notice[:context][:lastCheckout][:email]).to(
+        match(/\A\w+[\w.-]*@\w+\.?\w+?\z/)
+      )
+    end
+
+    it "attaches last checkouted revision" do
+      expect(notice[:context][:lastCheckout][:revision]).not_to be_empty
+      expect(notice[:context][:lastCheckout][:revision].size).to eq(40)
+    end
+
+    it "attaches last checkouted time" do
+      expect(notice[:context][:lastCheckout][:time]).not_to be_empty
+      expect(notice[:context][:lastCheckout][:time].size).to eq(25)
+    end
+  end
+end

data/spec/filters/git_repository_filter.rb

@@ -0,0 +1,61 @@
+RSpec.describe Airbrake::Filters::GitRepositoryFilter do
+  subject { described_class.new('.') }
+
+  let(:notice) do
+    Airbrake::Notice.new(Airbrake::Config.new, AirbrakeTestError.new)
+  end
+
+  describe "#initialize" do
+    it "parses standard git version" do
+      allow_any_instance_of(Kernel)
+        .to receive(:`).and_return('git version 2.18.0')
+      expect { subject }.not_to raise_error
+    end
+
+    it "parses release candidate git version" do
+      allow_any_instance_of(Kernel)
+        .to receive(:`).and_return('git version 2.21.0-rc0')
+      expect { subject }.not_to raise_error
+    end
+
+    it "parses git version with brackets" do
+      allow_any_instance_of(Kernel)
+        .to receive(:`).and_return('git version 2.17.2 (Apple Git-113)')
+      expect { subject }.not_to raise_error
+    end
+  end
+
+  context "when context/repository is defined" do
+    it "doesn't attach anything to context/repository" do
+      notice[:context][:repository] = 'git@github.com:kyrylo/test.git'
+      subject.call(notice)
+      expect(notice[:context][:repository]).to eq('git@github.com:kyrylo/test.git')
+    end
+  end
+
+  context "when .git directory doesn't exist" do
+    subject { described_class.new('root/dir') }
+
+    it "doesn't attach anything to context/repository" do
+      subject.call(notice)
+      expect(notice[:context][:repository]).to be_nil
+    end
+  end
+
+  context "when .git directory exists" do
+    it "attaches context/repository" do
+      subject.call(notice)
+      expect(notice[:context][:repository]).to eq(
+        'ssh://git@github.com/airbrake/airbrake-ruby.git'
+      )
+    end
+  end
+
+  context "when git is not in PATH" do
+    it "does not attach context/repository" do
+      ENV['PATH'] = ''
+      subject.call(notice)
+      expect(notice[:context][:repository]).to be_nil
+    end
+  end
+end

data/spec/filters/git_revision_filter_spec.rb

@@ -0,0 +1,126 @@
+RSpec.describe Airbrake::Filters::GitRevisionFilter do
+  subject { described_class.new('root/dir') }
+
+  # 'let!', not 'let' to make sure Notice doesn't call File.exist? with
+  # unexpected arguments.
+  let!(:notice) { Airbrake::Notice.new(AirbrakeTestError.new) }
+
+  context "when context/revision is defined" do
+    it "doesn't attach anything to context/revision" do
+      notice[:context][:revision] = '1.2.3'
+      subject.call(notice)
+      expect(notice[:context][:revision]).to eq('1.2.3')
+    end
+  end
+
+  context "when .git directory doesn't exist" do
+    it "doesn't attach anything to context/revision" do
+      subject.call(notice)
+      expect(notice[:context][:revision]).to be_nil
+    end
+  end
+
+  context "when .git directory exists" do
+    before do
+      expect(File).to receive(:exist?).with('root/dir/.git').and_return(true)
+    end
+
+    context "and when HEAD doesn't exist" do
+      before do
+        expect(File).to receive(:exist?).with('root/dir/.git/HEAD').and_return(false)
+      end
+
+      it "doesn't attach anything to context/revision" do
+        subject.call(notice)
+        expect(notice[:context][:revision]).to be_nil
+      end
+    end
+
+    context "and when HEAD exists" do
+      before do
+        expect(File).to receive(:exist?).with('root/dir/.git/HEAD').and_return(true)
+      end
+
+      context "and also when HEAD doesn't start with 'ref: '" do
+        before do
+          expect(File).to(
+            receive(:read).with('root/dir/.git/HEAD').and_return('refs/foo')
+          )
+        end
+
+        it "attaches the content of HEAD to context/revision" do
+          subject.call(notice)
+          expect(notice[:context][:revision]).to eq('refs/foo')
+        end
+      end
+
+      context "and also when HEAD starts with 'ref: " do
+        before do
+          expect(File).to(
+            receive(:read).with('root/dir/.git/HEAD').and_return("ref: refs/foo\n")
+          )
+        end
+
+        context "when the ref exists" do
+          before do
+            expect(File).to(
+              receive(:exist?).with('root/dir/.git/refs/foo').and_return(true)
+            )
+            expect(File).to(
+              receive(:read).with('root/dir/.git/refs/foo').and_return("d34db33f\n")
+            )
+          end
+
+          it "attaches the revision from the ref to context/revision" do
+            subject.call(notice)
+            expect(notice[:context][:revision]).to eq('d34db33f')
+          end
+        end
+
+        context "when the ref doesn't exist" do
+          before do
+            expect(File).to(
+              receive(:exist?).with('root/dir/.git/refs/foo').and_return(false)
+            )
+          end
+
+          context "and when '.git/packed-refs' exists" do
+            before do
+              expect(File).to(
+                receive(:exist?).with('root/dir/.git/packed-refs').and_return(true)
+              )
+              expect(File).to(
+                receive(:readlines).with('root/dir/.git/packed-refs').and_return(
+                  [
+                    "# pack-refs with: peeled fully-peeled\n",
+                    "ccb316eecff79c7528d1ad43e5fa165f7a44d52e refs/tags/v3.0.30\n",
+                    "^d358900f73ee5bfd6ca3a592cf23ac6e82df83c1",
+                    "d34db33f refs/foo\n"
+                  ]
+                )
+              )
+            end
+
+            it "attaches the revision from 'packed-refs' to context/revision" do
+              subject.call(notice)
+              expect(notice[:context][:revision]).to eq('d34db33f')
+            end
+          end
+
+          context "and when '.git/packed-refs' doesn't exist" do
+            before do
+              expect(File).to(
+                receive(:exist?).with('root/dir/.git/packed-refs').and_return(false)
+              )
+            end
+
+            it "attaches the content of HEAD to context/revision" do
+              subject.call(notice)
+              expect(notice[:context][:revision]).to eq('refs/foo')
+            end
+          end
+        end
+      end
+    end
+  end
+end