airbrake-ruby 4.6.0 → 6.2.2

data/spec/filters/exception_attributes_filter_spec.rb

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

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

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

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

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

data/spec/filters/keys_blacklist_spec.rb

@@ -1,225 +0,0 @@
-RSpec.describe Airbrake::Filters::KeysBlacklist do
-  subject { described_class.new(patterns) }
-
-  let(:notice) { Airbrake::Notice.new(AirbrakeTestError.new) }
-
-  shared_examples 'pattern matching' do |patts, params|
-    let(:patterns) { patts }
-
-    it "filters out the matching values" do
-      notice[:params] = params.first
-      subject.call(notice)
-      expect(notice[:params]).to eq(params.last)
-    end
-  end
-
-  context "when a pattern is a Regexp" do
-    include_examples(
-      'pattern matching',
-      [/\Abon/],
-      [
-        { bongo: 'bango' },
-        { bongo: '[Filtered]' }
-      ]
-    )
-
-    context "and when a key is a hash" do
-      let(:patterns) { [/bango/] }
-
-      # https://github.com/airbrake/airbrake/issues/739
-      it "doesn't fail" do
-        notice[:params] = { bingo: { {} => 'unfiltered' } }
-        expect { subject.call(notice) }.not_to raise_error
-      end
-    end
-  end
-
-  context "when a pattern is a Symbol" do
-    include_examples(
-      'pattern matching',
-      [:bingo],
-      [
-        { bingo: 'bango' },
-        { bingo: '[Filtered]' }
-      ]
-    )
-  end
-
-  context "when a pattern is a String" do
-    include_examples(
-      'pattern matching',
-      ['bingo'],
-      [
-        { bingo: 'bango' },
-        { bingo: '[Filtered]' }
-      ]
-    )
-  end
-
-  context "when a pattern is a Array of Hash" do
-    include_examples(
-      'pattern matching',
-      ['bingo'],
-      [
-        { array: [{ bingo: 'bango' }, []] },
-        { array: [{ bingo: '[Filtered]' }, []] }
-      ]
-    )
-  end
-
-  context "when a Proc pattern was provided" do
-    context "along with normal keys" do
-      include_examples(
-        'pattern matching',
-        [proc { 'bongo' }, :bash],
-        [
-          { bingo: 'bango', bongo: 'bish', bash: 'bosh' },
-          { bingo: 'bango', bongo: '[Filtered]', bash: '[Filtered]' }
-        ]
-      )
-    end
-
-    context "which doesn't return an array of keys" do
-      include_examples(
-        'pattern matching',
-        [proc { Object.new }],
-        [
-          { bingo: 'bango', bongo: 'bish' },
-          { bingo: 'bango', bongo: 'bish' }
-        ]
-      )
-
-      it "logs an error" do
-        expect(Airbrake::Loggable.instance).to receive(:error).with(
-          /KeysBlacklist is invalid.+patterns: \[#<Object:.+>\]/
-        )
-        keys_blacklist = described_class.new(patterns)
-        keys_blacklist.call(notice)
-      end
-    end
-
-    context "which returns another Proc" do
-      let(:patterns) { [proc { proc { ['bingo'] } }] }
-
-      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:.+>\]/
-          )
-          keys_blacklist = described_class.new(patterns)
-          keys_blacklist.call(notice)
-        end
-      end
-
-      context "and when the filter is called twice" do
-        it "unwinds procs and filters keys" do
-          notice[:params] = { bingo: 'bango', bongo: 'bish' }
-          2.times { subject.call(notice) }
-          expect(notice[:params]).to eq(bingo: '[Filtered]', bongo: 'bish')
-        end
-      end
-    end
-  end
-
-  context "when a pattern is invalid" do
-    include_examples(
-      'pattern matching',
-      [Object.new],
-      [
-        { bingo: 'bango', bongo: 'bish' },
-        { bingo: 'bango', bongo: 'bish' }
-      ]
-    )
-
-    it "logs an error" do
-      expect(Airbrake::Loggable.instance).to receive(:error).with(
-        /KeysBlacklist is invalid.+patterns: \[#<Object:.+>\]/
-      )
-      keys_blacklist = described_class.new(patterns)
-      keys_blacklist.call(notice)
-    end
-  end
-
-  context "when a value contains a nested hash" do
-    context "and it is non-recursive" do
-      include_examples(
-        'pattern matching',
-        ['bish'],
-        [
-          { bongo: { bish: 'bash' } },
-          { bongo: { bish: '[Filtered]' } }
-        ]
-      )
-    end
-
-    context "and it is recursive" do
-      bongo = { bingo: {} }
-      bongo[:bingo][:bango] = bongo
-
-      include_examples(
-        'pattern matching',
-        ['bango'],
-        [
-          bongo,
-          { bingo: { bango: '[Filtered]' } }
-        ]
-      )
-    end
-  end
-
-  describe "context payload" do
-    context "when a URL with query params is present" do
-      let(:patterns) { ['bish'] }
-
-      it "filters the params" do
-        notice[:context][:url] =
-          'http://localhost:3000/crash?foo=bar&baz=bongo&bish=bash&color=%23FFAAFF'
-
-        subject.call(notice)
-        expect(notice[:context][:url]).to(
-          eq 'http://localhost:3000/crash?foo=bar&baz=bongo&bish=[Filtered]&color=%23FFAAFF'
-        )
-      end
-    end
-
-    context "when the user key is present" do
-      let(:patterns) { ['user'] }
-
-      it "filters out the user" do
-        notice[:context][:user] = { id: 1337, name: 'Bingo Bango' }
-        subject.call(notice)
-        expect(notice[:context][:user]).to eq('[Filtered]')
-      end
-    end
-
-    context "and when it is a hash" do
-      let(:patterns) { ['name'] }
-
-      it "filters out individual user fields" do
-        notice[:context][:user] = { id: 1337, name: 'Bingo Bango' }
-        subject.call(notice)
-        expect(notice[:context][:user][:name]).to eq('[Filtered]')
-      end
-    end
-  end
-
-  context "when the headers key is present" do
-    let(:patterns) { ['headers'] }
-
-    it "filters out the headers" do
-      notice[:context][:headers] = { 'HTTP_COOKIE' => 'banana' }
-      subject.call(notice)
-      expect(notice[:context][:headers]).to eq('[Filtered]')
-    end
-
-    context "and when it is a hash" do
-      let(:patterns) { ['HTTP_COOKIE'] }
-
-      it "filters out individual header fields" do
-        notice[:context][:headers] = { 'HTTP_COOKIE' => 'banana' }
-        subject.call(notice)
-        expect(notice[:context][:headers]['HTTP_COOKIE']).to eq('[Filtered]')
-      end
-    end
-  end
-end