airbrake-ruby 3.2.2-java

data/spec/filters/keys_blacklist_spec.rb

@@ -0,0 +1,236 @@
+RSpec.describe Airbrake::Filters::KeysBlacklist 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',
+      [/\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
+        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
+
+    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

data/spec/filters/keys_whitelist_spec.rb

@@ -0,0 +1,205 @@
+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) { ['bingo'] }
+
+      it "raises error (MRI)", skip: (
+        # MRI 2.3 & 2.4 may segfault on Circle CI. Example build:
+        # https://circleci.com/workflow-run/c112358c-e7bf-4789-9eb2-4891ea84da68
+        RUBY_ENGINE == 'ruby' && RUBY_VERSION =~ /\A2\.[34]\.\d+\z/
+      ) do
+        bongo = {}
+        bongo[:bingo] = bongo
+        notice[:params] = bongo
+
+        begin
+          expect { subject.call(notice) }.to raise_error(SystemStackError)
+        rescue RSpec::Expectations::ExpectationNotMetError => ex
+          # JRuby might raise two different exceptions, which represent the same
+          # thing. One is a Java exception, the other is a Ruby exception.
+          # Likely a bug: https://github.com/jruby/jruby/issues/1903
+          raise ex unless RUBY_ENGINE == 'jruby'
+          expect { subject.call(notice) }.to raise_error(java.lang.StackOverflowError)
+        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

data/spec/filters/root_directory_filter_spec.rb

@@ -0,0 +1,42 @@
+RSpec.describe Airbrake::Filters::RootDirectoryFilter do
+  subject { described_class.new(root_directory) }
+
+  let(:root_directory) { '/var/www/project' }
+
+  let(:notice) do
+    Airbrake::Notice.new(Airbrake::Config.new, AirbrakeTestError.new)
+  end
+
+  it "replaces root directory 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: "#{root_directory}/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: "#{root_directory}/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: "/PROJECT_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: "/PROJECT_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