airbrake-ruby 2.2.3 → 2.2.4

data/spec/filters/gem_root_filter_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+RSpec.describe Airbrake::Filters::GemRootFilter do
+  let(:notice) do
+    Airbrake::Notice.new(Airbrake::Config.new, AirbrakeTestError.new)
+  end
+
+  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/keys_blacklist_spec.rb

@@ -1,22 +1,197 @@
 require 'spec_helper'
 
 RSpec.describe Airbrake::Filters::KeysBlacklist do
-  subject do
-    described_class.new(Logger.new('/dev/null'), patterns)
+  subject { described_class.new(Logger.new('/dev/null'), patterns) }
+
+  let(:notice) do
+    Airbrake::Notice.new(Airbrake::Config.new, AirbrakeTestError.new)
   end
 
-  describe "#call" do
-    let(:notice) do
-      Airbrake::Notice.new(Airbrake::Config.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 and when a key is a hash" do
+  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 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
+        out = StringIO.new
+        logger = Logger.new(out)
+        keys_blacklist = described_class.new(logger, patterns)
+        keys_blacklist.call(notice)
+
+        expect(out.string).to(
+          match(/ERROR.+KeysBlacklist is invalid.+patterns: \[#<Object:.+>\]/)
+        )
+      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
+          out = StringIO.new
+          logger = Logger.new(out)
+          keys_blacklist = described_class.new(logger, patterns)
+          keys_blacklist.call(notice)
+
+          expect(out.string).to(
+            match(/ERROR.+KeysBlacklist is invalid.+patterns: \[#<Proc:.+>\]/)
+          )
+        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
+      out = StringIO.new
+      logger = Logger.new(out)
+      keys_blacklist = described_class.new(logger, patterns)
+      keys_blacklist.call(notice)
+
+      expect(out.string).to(
+        match(/ERROR.+KeysBlacklist is invalid.+patterns: \[#<Object:.+>\]/)
+      )
+    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
+  end
 end

data/spec/filters/keys_whitelist_spec.rb

@@ -0,0 +1,213 @@
+require 'spec_helper'
+
+RSpec.describe Airbrake::Filters::KeysWhitelist do
+  subject { described_class.new(Logger.new('/dev/null'), patterns) }
+
+  let(:notice) do
+    Airbrake::Notice.new(Airbrake::Config.new, AirbrakeTestError.new)
+  end
+
+  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',
+      [/\Abin/],
+      [
+        { bingo: 'bango', bongo: 'bish', bash: 'bosh' },
+        { bingo: 'bango', bongo: '[Filtered]', bash: '[Filtered]' }
+      ]
+    )
+  end
+
+  context "when a pattern is a Symbol" do
+    include_examples(
+      'pattern matching',
+      [:bongo],
+      [
+        { bongo: 'bish', bash: 'bosh', bbashh: 'bboshh' },
+        { bongo: 'bish', bash: '[Filtered]', bbashh: '[Filtered]' }
+      ]
+    )
+  end
+
+  context "when a pattern is a String" do
+    include_examples(
+      'pattern matching',
+      ['bash'],
+      [
+        { bingo: 'bango', bongo: 'bish', bash: 'bosh' },
+        { bingo: '[Filtered]', bongo: '[Filtered]', bash: 'bosh' }
+      ]
+    )
+  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: '[Filtered]', bongo: 'bish', bash: 'bosh' }
+        ]
+      )
+    end
+
+    context "which doesn't return an array of keys" do
+      include_examples(
+        'pattern matching',
+        [proc { Object.new }],
+        [
+          { bingo: 'bango', bongo: 'bish', bash: 'bosh' },
+          { bingo: '[Filtered]', bongo: '[Filtered]', bash: '[Filtered]' }
+        ]
+      )
+
+      it "logs an error" do
+        out = StringIO.new
+        logger = Logger.new(out)
+        keys_whitelist = described_class.new(logger, patterns)
+        keys_whitelist.call(notice)
+
+        expect(out.string).to(
+          match(/ERROR.+KeysWhitelist is invalid.+patterns: \[#<Object:.+>\]/)
+        )
+      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
+          out = StringIO.new
+          logger = Logger.new(out)
+          keys_whitelist = described_class.new(logger, patterns)
+          keys_whitelist.call(notice)
+
+          expect(out.string).to(
+            match(/ERROR.+KeysWhitelist is invalid.+patterns: \[#<Proc:.+>\]/)
+          )
+        end
+
+        include_examples(
+          'pattern matching',
+          [proc { proc { ['bingo'] } }],
+          [
+            { bingo: 'bango', bongo: 'bish', bash: 'bosh' },
+            { bingo: '[Filtered]', bongo: '[Filtered]', bash: '[Filtered]' }
+          ]
+        )
+      end
+    end
+  end
+
+  context "when a pattern is invalid" do
+    include_examples(
+      'pattern matching',
+      [Object.new],
+      [
+        { bingo: 'bango', bongo: 'bish', bash: 'bosh' },
+        { bingo: '[Filtered]', bongo: '[Filtered]', bash: '[Filtered]' }
+      ]
+    )
+
+    it "logs an error" do
+      out = StringIO.new
+      logger = Logger.new(out)
+      keys_whitelist = described_class.new(logger, patterns)
+      keys_whitelist.call(notice)
+
+      expect(out.string).to(
+        match(/ERROR.+KeysWhitelist is invalid.+patterns: \[#<Object:.+>\]/)
+      )
+    end
+  end
+
+  context "when a value contains a nested hash" do
+    context "and it is non-recursive" do
+      include_examples(
+        'pattern matching',
+        %w[bongo bish],
+        [
+          { bingo: 'bango', bongo: { bish: 'bash' } },
+          { bingo: '[Filtered]', bongo: { bish: 'bash' } }
+        ]
+      )
+    end
+
+    context "and it is recursive" do
+      let(:patterns) { %w[bingo bango] }
+
+      it "errors when nested hashes are not filtered" do
+        bongo = { bingo: {} }
+        bongo[:bingo][:bango] = bongo
+        notice[:params] = bongo
+
+        if RUBY_ENGINE == 'jruby'
+          # JRuby might raise two different exceptions, which represent the
+          # same thing. One is a Java exception, the other is a Ruby
+          # exception. It's probably a JRuby bug:
+          # https://github.com/jruby/jruby/issues/1903
+          begin
+            expect do
+              subject.call(notice)
+            end.to raise_error(SystemStackError)
+          rescue RSpec::Expectations::ExpectationNotMetError
+            expect do
+              subject.call(notice)
+            end.to raise_error(java.lang.StackOverflowError)
+          end
+        else
+          expect do
+            subject.call(notice)
+          end.to raise_error(SystemStackError)
+        end
+      end
+    end
+  end
+
+  describe "context payload" do
+    describe "URL" do
+      let(:patterns) { ['bish'] }
+
+      context "when it contains query params" do
+        it "filters the params" do
+          notice[:context][:url] = 'http://localhost:3000/crash?foo=bar&baz=bongo&bish=bash'
+          subject.call(notice)
+          expect(notice[:context][:url]).to(
+            eq('http://localhost:3000/crash?foo=[Filtered]&baz=[Filtered]&bish=bash')
+          )
+        end
+      end
+
+      context "when it is invalid" do
+        it "leaves the URL unfiltered" do
+          notice[:context][:url] =
+            'http://localhost:3000/cra]]]sh?foo=bar&baz=bongo&bish=bash'
+          subject.call(notice)
+          expect(notice[:context][:url]).to(
+            eq('http://localhost:3000/cra]]]sh?foo=bar&baz=bongo&bish=bash')
+          )
+        end
+      end
+
+      context "when it is without a query" do
+        it "leaves the URL untouched" do
+          notice[:context][:url] = 'http://localhost:3000/crash'
+          subject.call(notice)
+          expect(notice[:context][:url]).to(eq('http://localhost:3000/crash'))
+        end
+      end
+    end
+  end
+end