rollbar 2.18.2 → 2.19.0

data/spec/rollbar/scrubbers/url_spec.rb

@@ -1,240 +0,0 @@
-require 'spec_helper'
-require 'rollbar/language_support'
-require 'rollbar/scrubbers/url'
-
-describe Rollbar::Scrubbers::URL do
-  let(:options) do
-    options = {
-      :url => url,
-      :scrub_fields => [:password, :secret],
-      :scrub_user => false,
-      :scrub_password => false,
-      :randomize_scrub_length => true
-    }
-
-    if defined? whitelist
-      options[:whitelist] = whitelist
-    end
-
-    options
-  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
-
-    context 'in whitelist mode' do
-
-      let(:whitelist) { [:user, :secret] }
-
-      context 'with ruby different from 1.8' do
-        next unless Rollbar::LanguageSupport.can_scrub_url?
-
-        context 'cannot scrub URLs' 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
-        end
-
-        context 'scrubbing user and password' do
-
-          let(:options) do
-            {
-              :url => url,
-              :scrub_fields => [],
-              :scrub_password => true,
-              :scrub_user => true,
-              :whitelist => whitelist
-            }
-          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 scrub_all' do
-          let(:options) do
-            {
-              :url => url,
-              :scrub_fields => [:scrub_all],
-              :scrub_password => false,
-              :scrub_user => false,
-              :whitelist => whitelist
-            }
-          end
-          let(:url) { 'http://foo.com/some-interesting-path?foo=bar&password=mypassword&secret=somevalue&dont_scrub=foo#fragment' }
-
-          it 'returns the URL with some params filtered' do
-            expected_url = /http:\/\/foo.com\/some-interesting-path\?foo=\*{3,8}&password=\*{3,8}&secret=somevalue&dont_scrub=\*{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&dont_scrub=foo#fragment' }
-
-            it 'returns the URL with some params filtered' do
-              expected_url = /http:\/\/foo.com\/some-interesting-path\?foo=\*{3,8}&password\[\]=\*{3,8}&password\[\]=\*{3,8}&secret=somevalue&dont_scrub=\*{3,8}#fragment/
-
-              expect(subject.call(options)).to match(expected_url)
-            end
-          end
-        end
-
-        context 'with params to be filtered' do
-          let(:options) do
-            {
-              :url => url,
-              :scrub_fields => [:dont_scrub, :secret, :password, :foo],
-              :scrub_password => false,
-              :scrub_user => false,
-              :whitelist => whitelist
-            }
-          end
-
-          let(:url) { 'http://foo.com/some-interesting-path?foo=bar&password=mypassword&secret=somevalue&dont_scrub=foo#fragment' }
-
-          it 'returns the URL with some params filtered' do
-            expected_url = /http:\/\/foo.com\/some-interesting-path\?foo=\*{3,8}&password=\*{3,8}&secret=somevalue&dont_scrub=\*{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&dont_scrub=foo#fragment' }
-
-            it 'returns the URL with some params filtered' do
-              expected_url = /http:\/\/foo.com\/some-interesting-path\?foo=\*{3,8}&password\[\]=\*{3,8}&password\[\]=\*{3,8}&secret=somevalue&dont_scrub=\*{3,8}#fragment/
-
-              expect(subject.call(options)).to match(expected_url)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/rollbar/scrubbers_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-require 'rollbar/scrubbers'
-
-describe Rollbar::Scrubbers do
-  describe '.scrub_value' do
-    context 'with random scrub length' do
-      before do
-        allow(Rollbar.configuration).to receive(:randomize_scrub_length).and_return(true)
-      end
-
-      let(:value) { 'herecomesaverylongvalue' }
-
-      it 'randomizes the scrubbed string' do
-        expect(described_class.scrub_value(value)).to match(/\*{3,8}/)
-      end
-    end
-
-    context 'with no-random scrub length' do
-      before do
-        allow(Rollbar.configuration).to receive(:randomize_scrub_length).and_return(false)
-      end
-
-      let(:value) { 'herecomesaverylongvalue' }
-
-      it 'randomizes the scrubbed string' do
-        expect(described_class.scrub_value(value)).to match(/\*{#{value.length}}/)
-      end
-    end
-  end
-end

data/spec/rollbar/sidekig/clear_scope_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-unless RUBY_VERSION == '1.8.7'
-  require 'sidekiq'
-end
-
-Rollbar.plugins.load!
-
-describe Rollbar::Sidekiq::ClearScope, :reconfigure_notifier => false do
-  describe '#call' do
-    let(:middleware_block) { proc{} }
-
-    it 'sends the error to Rollbar::Sidekiq.handle_exception' do
-      expect(Rollbar).to receive(:reset_notifier!)
-
-      subject.call(nil, nil, nil, &middleware_block)
-    end
-  end
-end unless RUBY_VERSION == '1.8.7'

data/spec/rollbar/truncation/frames_strategy_spec.rb

@@ -1,70 +0,0 @@
-require 'spec_helper'
-require 'rollbar/truncation/frames_strategy'
-
-describe Rollbar::Truncation::FramesStrategy do
-  def expand_frames(frames)
-    frames * (1 + 300 / frames.count)
-  end
-
-  describe '.call', :fixture => :payload do
-    context 'with trace key' do
-      let(:payload_fixture) { 'payloads/sample.trace.json' }
-      let(:frames) { payload['data']['body']['trace']['frames'].clone }
-
-      before do
-        payload['data']['body']['trace']['frames'] = expand_frames(frames)
-      end
-
-      it 'returns a new payload with 300 frames' do
-        result = Rollbar::JSON.load(described_class.call(payload))
-
-        new_frames = result['data']['body']['trace']['frames']
-
-        expect(new_frames.count).to be_eql(300)
-        expect(new_frames.first).to be_eql(frames.first)
-        expect(new_frames.last).to be_eql(frames.last)
-      end
-    end
-
-    context 'with trace_chain key' do
-      let(:payload_fixture) { 'payloads/sample.trace_chain.json' }
-
-      let(:frames1) { payload['data']['body']['trace_chain'][0]['frames'].clone }
-      let(:frames2) { payload['data']['body']['trace_chain'][1]['frames'].clone }
-
-      before do
-        payload['data']['body']['trace_chain'][0]['frames'] = expand_frames(frames1)
-        payload['data']['body']['trace_chain'][1]['frames'] = expand_frames(frames2)
-      end
-
-      it 'returns a new payload with 300 frames for each chain item' do
-        result = Rollbar::JSON.load(described_class.call(payload))
-
-        new_frames1 = result['data']['body']['trace_chain'][0]['frames']
-        new_frames2 = result['data']['body']['trace_chain'][1]['frames']
-
-        expect(new_frames1.count).to be_eql(300)
-        expect(new_frames1.first).to be_eql(frames1.first)
-        expect(new_frames1.last).to be_eql(frames1.last)
-
-        expect(new_frames2.count).to be_eql(300)
-        expect(new_frames2.first).to be_eql(frames2.first)
-        expect(new_frames2.last).to be_eql(frames2.last)
-      end
-    end
-
-    context 'without trace or trace_chain', :fixture => :payload do
-      let(:payload_fixture) { 'payloads/sample.trace.json' }
-
-      before do
-        payload['data']['body'].delete('trace')
-      end
-
-      it 'returns the original payload' do
-        result = Rollbar::JSON.load(described_class.call(payload))
-
-        expect(result).to be_eql(payload)
-      end
-    end
-  end
-end

data/spec/rollbar/truncation/min_body_strategy_spec.rb

@@ -1,57 +0,0 @@
-require 'spec_helper'
-require 'rollbar/truncation/frames_strategy'
-
-describe Rollbar::Truncation::MinBodyStrategy do
-  describe '.call', :fixture => :payload do
-    let(:message) { 'a' * 1_000 }
-
-    context 'with trace key ' do
-      let(:payload_fixture) { 'payloads/sample.trace.json' }
-      let!(:frames) { payload['data']['body']['trace']['frames'].clone }
-
-      before do
-        payload['data']['body']['trace']['exception']['message'] = message
-      end
-
-      it 'truncates the exception message and frames array' do
-        result = Rollbar::JSON.load(described_class.call(payload))
-
-        trace = result['data']['body']['trace']
-        expect(trace['frames'].count).to eq 2
-        expect(trace['exception']['message']).to be_eql('a' * 255)
-      end
-    end
-
-    context 'with trace_chain key ' do
-      let(:payload_fixture) { 'payloads/sample.trace_chain.json' }
-      let!(:frames1) { payload['data']['body']['trace_chain'][0]['frames'].clone }
-      let!(:frames2) { payload['data']['body']['trace_chain'][1]['frames'].clone }
-
-      before do
-        payload['data']['body']['trace_chain'][0]['exception']['message'] = message
-        payload['data']['body']['trace_chain'][1]['exception']['message'] = message
-      end
-
-      it 'truncates the exception message and frames array' do
-        result = Rollbar::JSON.load(described_class.call(payload))
-
-        traces = result['data']['body']['trace_chain']
-        expect(traces[0]['frames'].count).to eq 2
-        expect(traces[0]['exception']['message']).to be_eql('a' * 255)
-
-        expect(traces[1]['frames'].count).to eq 2
-        expect(traces[1]['exception']['message']).to be_eql('a' * 255)
-      end
-    end
-
-    context 'with a message payload' do
-      let(:payload_fixture) { 'payloads/message.json' }
-
-      it "doesn't truncate anything and returns same payload" do
-        result = Rollbar::JSON.load(described_class.call(payload))
-
-        expect(result).to be_eql(payload)
-      end
-    end
-  end
-end

data/spec/rollbar/truncation/strings_strategy_spec.rb

@@ -1,89 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-require 'rollbar/truncation/frames_strategy'
-
-describe Rollbar::Truncation::StringsStrategy do
-  describe '.call' do
-    let(:long_message) { 'a' * 2000 }
-    let(:payload) do
-      {
-        'truncated' => long_message,
-        'not_truncated' => '123456',
-        'hash' => {
-          'inner_truncated' => long_message,
-          'inner_not_truncated' => '567',
-          'array' => ['12345678', '12', { 'inner_inner' => long_message }]
-        }
-      }
-    end
-
-    it 'should truncate all nested strings in the payload' do
-      result = Rollbar::JSON.load(described_class.call(payload))
-
-      expect(result['truncated'].size).to be_eql(1024)
-      expect(result['hash']['inner_truncated'].size).to be_eql(1024)
-      expect(result['hash']['array'][2]['inner_inner'].size).to be_eql(1024)
-    end
-
-    context 'with utf8 strings' do
-      let(:long_message) { 'Ŝǻмρļẻ śţяịņģ' + 'a' * 2000 }
-      let(:payload) do
-        {
-          'truncated' => long_message,
-          'not_truncated' => '123456',
-        }
-      end
-
-      it 'should truncate utf8 strings properly' do
-        result = Rollbar::JSON.load(described_class.call(payload))
-        expect(result['truncated']).to match(/^Ŝǻмρļẻ śţяịņģa*\.{3}/)
-      end
-    end
-
-    context 'when first threshold is not enough' do
-      let(:payload) do
-        512.times.to_enum.reduce({}) do |hash, i|
-          hash[i.to_s] = 'a' * 1024
-          hash
-        end
-      end
-
-      it 'truncates to 512 size strings' do
-        result = Rollbar::JSON.load(described_class.call(payload))
-
-        expect(result['0'].size).to be_eql(512)
-      end
-    end
-
-    context 'when second threshold is still not enough' do
-      let(:payload) do
-        1024.times.to_enum.reduce({}) do |hash, i|
-          hash[i.to_s] = 'a' * 1024
-          hash
-        end
-      end
-
-      it 'truncates to 256 size strings, the third threshold' do
-        result = Rollbar::JSON.load(described_class.call(payload))
-
-        expect(result['0'].size).to be_eql(256)
-      end
-    end
-
-    context 'when third threshold is still not enough' do
-      let(:payload) do
-        1024.times.to_enum.reduce({}) do |hash, i|
-          hash[i.to_s] = 'a' * 1024
-          hash
-        end
-      end
-
-      it 'just return the value for third threshold' do
-        result = Rollbar::JSON.load(described_class.call(payload))
-
-        expect(result['0'].size).to be_eql(256)
-      end
-    end
-  end
-end