rollbar 2.16.2 → 2.22.1

data/spec/rollbar/scrubbers/params_spec.rb

@@ -1,314 +0,0 @@
-require 'spec_helper'
-require 'tempfile'
-require 'rollbar/scrubbers/params'
-
-require 'rspec/expectations'
-
-describe Rollbar::Scrubbers::Params do
-  describe '.call' do
-    it 'calls #call in a new instance' do
-      arguments = [:foo, :bar]
-      expect_any_instance_of(described_class).to receive(:call).with(*arguments)
-
-      described_class.call(*arguments)
-    end
-  end
-
-  describe '#call' do
-    let(:options) do
-      {
-        :params => params,
-        :config => scrub_config
-      }
-    end
-
-    context 'with scrub fields configured' do
-      let(:scrub_config) do
-        [:secret, :password]
-      end
-
-      context 'with Array object' do
-        let(:params) do
-          [
-            {
-              :foo => 'bar',
-              :secret => 'the-secret',
-              :password => 'the-password',
-              :password_confirmation => 'the-password'
-            }
-          ]
-        end
-        let(:result) do
-          [
-            {
-              :foo => 'bar',
-              :secret => /\*+/,
-              :password => /\*+/,
-              :password_confirmation => /\*+/
-            }
-          ]
-        end
-
-        it 'scrubs the required parameters' do
-          expect(subject.call(options).first).to be_eql_hash_with_regexes(result.first)
-        end
-      end
-
-      context 'with simple Hash' do
-        let(:params) do
-          {
-            :foo => 'bar',
-            :secret => 'the-secret',
-            :password => 'the-password',
-            :password_confirmation => 'the-password'
-          }
-        end
-        let(:result) do
-          {
-            :foo => 'bar',
-            :secret => /\*+/,
-            :password => /\*+/,
-            :password_confirmation => /\*+/
-          }
-        end
-
-        it 'scrubs the required parameters' do
-          expect(subject.call(options)).to be_eql_hash_with_regexes(result)
-        end
-      end
-
-      context 'with nested Hash' do
-        let(:scrub_config) do
-          super().push(:other)
-        end
-
-        let(:params) do
-          {
-            :foo => 'bar',
-            :extra => {
-              :secret => 'the-secret',
-              :password => 'the-password',
-              :password_confirmation => 'the-password'
-            },
-            :other => {
-              :param => 'filtered'
-            }
-          }
-        end
-        let(:result) do
-          {
-            :foo => 'bar',
-            :extra => {
-              :secret => /\*+/,
-              :password => /\*+/,
-              :password_confirmation => /\*+/
-            },
-            :other => /\*+/
-          }
-        end
-
-        it 'scrubs the required parameters' do
-          expect(subject.call(options)).to be_eql_hash_with_regexes(result)
-        end
-      end
-
-      context 'with nested Array' do
-        let(:scrub_config) do
-          super().push(:other)
-        end
-
-        let(:params) do
-          {
-            :foo => 'bar',
-            :extra => [{
-              :secret => 'the-secret',
-              :password => 'the-password',
-              :password_confirmation => 'the-password'
-            }],
-            :other => [{
-              :param => 'filtered'
-            }]
-          }
-        end
-        let(:result) do
-          {
-            :foo => 'bar',
-            :extra => [{
-              :secret => /\*+/,
-              :password => /\*+/,
-              :password_confirmation => /\*+/
-            }],
-            :other => /\*+/
-          }
-        end
-
-        it 'scrubs the required parameters' do
-          expect(subject.call(options)).to be_eql_hash_with_regexes(result)
-        end
-      end
-
-      context 'with skipped instance' do
-        let(:tempfile) { Tempfile.new('foo') }
-        let(:params) do
-          {
-            :foo => 'bar',
-            :extra => [{
-              :secret => 'the-secret',
-              :password => 'the-password',
-              :password_confirmation => 'the-password',
-              :skipped => tempfile
-            }]
-          }
-        end
-        let(:result) do
-          {
-            :foo => 'bar',
-            :extra => [{
-              :secret => /\*+/,
-              :password => /\*+/,
-              :password_confirmation => /\*+/,
-              :skipped => "Skipped value of class 'Tempfile'"
-            }]
-          }
-        end
-
-        after { tempfile.close }
-
-        it 'scrubs the required parameters' do
-          expect(subject.call(options)).to be_eql_hash_with_regexes(result)
-        end
-      end
-
-      context 'with attachment instance' do
-        let(:tempfile) { double(:size => 100) }
-        let(:attachment) do
-          double(:class => double(:name => 'ActionDispatch::Http::UploadedFile'),
-                 :tempfile => tempfile,
-                 :content_type => 'content-type',
-                 'original_filename' => 'filename')
-        end
-        let(:params) do
-          {
-            :foo => 'bar',
-            :extra => [{
-              :secret => 'the-secret',
-              :password => 'the-password',
-              :password_confirmation => 'the-password',
-              :attachment => attachment
-            }]
-          }
-        end
-        let(:result) do
-          {
-            :foo => 'bar',
-            :extra => [{
-              :secret => /\*+/,
-              :password => /\*+/,
-              :password_confirmation => /\*+/,
-              :attachment => {
-                :content_type => 'content-type',
-                :original_filename => 'filename',
-                :size => 100
-              }
-            }]
-          }
-        end
-
-        it 'scrubs the required parameters' do
-          expect(subject.call(options)).to be_eql_hash_with_regexes(result)
-        end
-
-        context 'if getting the attachment values fails' do
-          let(:tempfile) { Object.new }
-          let(:attachment) do
-            double(:class => double(:name => 'ActionDispatch::Http::UploadedFile'),
-                   :tempfile => tempfile,
-                   :content_type => 'content-type',
-                   'original_filename' => 'filename')
-          end
-          let(:params) do
-            {
-              :foo => 'bar',
-              :extra => [{
-                :secret => 'the-secret',
-                :password => 'the-password',
-                :password_confirmation => 'the-password',
-                :attachment => attachment
-              }]
-            }
-          end
-          let(:result) do
-            {
-              :foo => 'bar',
-              :extra => [{
-                :secret => /\*+/,
-                :password => /\*+/,
-                :password_confirmation => /\*+/,
-                :attachment => 'Uploaded file'
-              }]
-            }
-          end
-
-          it 'scrubs the required parameters' do
-            expect(subject.call(options)).to be_eql_hash_with_regexes(result)
-          end
-        end
-      end
-
-      context 'without params' do
-        let(:params) do
-          nil
-        end
-        let(:result) do
-          {}
-        end
-
-        it 'scrubs the required parameters' do
-          expect(subject.call(options)).to be_eql_hash_with_regexes(result)
-        end
-      end
-    end
-
-    context 'with :scrub_all option' do
-      let(:scrub_config) { :scrub_all }
-      let(:params) do
-        {
-          :foo => 'bar',
-          :password => 'the-password',
-          :bar => 'foo',
-          :extra => {
-            :foo => 'more-foo',
-            :bar => 'more-bar'
-          }
-        }
-      end
-      let(:result) do
-        {
-          :foo => /\*+/,
-          :password => /\*+/,
-          :bar => /\*+/,
-          :extra => {
-            :foo => /\*+/,
-            :bar => /\*+/
-          }
-        }
-      end
-
-      it 'scrubs the required parameters' do
-        expect(subject.call(options)).to be_eql_hash_with_regexes(result)
-      end
-    end
-  end
-end
-
-describe Rollbar::Scrubbers::Params::ATTACHMENT_CLASSES do
-  it 'has the correct values' do
-    expect(described_class).to be_eql(%w(ActionDispatch::Http::UploadedFile Rack::Multipart::UploadedFile).freeze)
-  end
-end
-
-describe Rollbar::Scrubbers::Params::SKIPPED_CLASSES do
-  it 'has the correct values' do
-    expect(described_class).to be_eql([Tempfile])
-  end
-end

data/spec/rollbar/scrubbers/url_spec.rb

@@ -1,136 +0,0 @@
-require 'spec_helper'
-require 'rollbar/language_support'
-require 'rollbar/scrubbers/url'
-
-describe Rollbar::Scrubbers::URL do
-  let(:options) do
-    {
-      :url => url,
-      :scrub_fields => [:password, :secret],
-      :scrub_user => false,
-      :scrub_password => false,
-      :randomize_scrub_length => true
-    }
-  end
-
-  describe '#call' do
-    context 'cannot scrub URLs' do
-      next if Rollbar::LanguageSupport.can_scrub_url?
-
-      let(:url) { 'http://user:password@foo.com/some-interesting-path#fragment' }
-
-      it 'returns the URL without any change' do
-        expect(subject.call(options)).to be_eql(url)
-      end
-    end
-
-    context 'with ruby different from 1.8' do
-      next unless Rollbar::LanguageSupport.can_scrub_url?
-
-      context 'without data to be scrubbed' do
-        let(:url) { 'http://user:password@foo.com/some-interesting-path#fragment' }
-
-        it 'returns the URL without any change' do
-          expect(subject.call(options)).to be_eql(url)
-        end
-
-        context 'with arrays in params' do
-          let(:url) { 'http://user:password@foo.com/some-interesting-path?foo[]=1&foo[]=2' }
-
-          it 'returns the URL without any change' do
-            expect(subject.call(options)).to be_eql(url)
-          end
-        end
-      end
-
-      context 'scrubbing user and password' do
-        let(:options) do
-          {
-            :url => url,
-            :scrub_fields => [],
-            :scrub_password => true,
-            :scrub_user => true
-          }
-        end
-
-        let(:url) { 'http://user:password@foo.com/some-interesting-path#fragment' }
-
-        it 'returns the URL without any change' do
-          expected_url = /http:\/\/\*{3,8}:\*{3,8}@foo.com\/some-interesting\-path#fragment/
-
-          expect(subject.call(options)).to match(expected_url)
-        end
-      end
-
-      context 'with params to be filtered' do
-        let(:url) { 'http://foo.com/some-interesting-path?foo=bar&password=mypassword&secret=somevalue#fragment' }
-
-        it 'returns the URL with some params filtered' do
-          expected_url = /http:\/\/foo.com\/some-interesting-path\?foo=bar&password=\*{3,8}&secret=\*{3,8}#fragment/
-
-          expect(subject.call(options)).to match(expected_url)
-        end
-
-        context 'having array params' do
-          let(:url) { 'http://foo.com/some-interesting-path?foo=bar&password[]=mypassword&password[]=otherpassword&secret=somevalue#fragment' }
-
-          it 'returns the URL with some params filtered' do
-            expected_url = /http:\/\/foo.com\/some-interesting-path\?foo=bar&password\[\]=\*{3,8}&password\[\]=\*{3,8}&secret=\*{3,8}#fragment/
-
-            expect(subject.call(options)).to match(expected_url)
-          end
-        end
-      end
-
-      context 'with no-random scrub length' do
-        let(:options) do
-          {
-            :url => url,
-            :scrub_fields => [:password, :secret],
-            :scrub_user => false,
-            :scrub_password => false,
-            :randomize_scrub_length => false
-          }
-        end
-        let(:password) { 'longpasswordishere' }
-        let(:url) { "http://foo.com/some-interesting-path?foo=bar&password=#{password}#fragment" }
-
-        it 'scrubs with same length than the scrubbed param' do
-          expected_url = /http:\/\/foo.com\/some-interesting-path\?foo=bar&password=\*{#{password.length}}#fragment/
-
-          expect(subject.call(options)).to match(expected_url)
-        end
-      end
-
-      context 'with malformed URL or not able to be parsed' do
-        let(:url) { '\this\is\not\a\valid\url' }
-        before { reconfigure_notifier }
-
-        it 'return the same url' do
-          expect(Rollbar.logger).to receive(:error).and_call_original
-          expect(subject.call(options)).to be_eql(url)
-        end
-      end
-
-      context 'with URL with spaces and arrays' do
-        let(:url) do
-          'https://server.com/api/v1/assignments/4430038?user_id=1&assignable_id=2&starts_at=Wed%20Jul%2013%202016%2000%3A00%3A00%20GMT-0700%20(PDT)&ends_at=Fri%20Jul%2029%202016%2000%3A00%3A00%20GMT-0700%20(PDT)&allocation_mode=hours_per_day&percent=&fixed_hours=&hours_per_day=0&auth=REMOVED&___uidh=2228207862&password[]=mypassword'
-        end
-        let(:options) do
-          {
-            :url => url,
-            :scrub_fields => [:passwd, :password, :password_confirmation, :secret, :confirm_password, :secret_token, :api_key, :access_token, :auth, :SAMLResponse, :password, :auth],
-            :scrub_user => true,
-            :scrub_password => true,
-            :randomize_scrub_length => true
-          }
-        end
-
-        it 'doesnt logs error' do
-          expect(Rollbar.logger).not_to receive(:error).and_call_original
-          subject.call(options)
-        end
-      end
-    end
-  end
-end