rollbar 2.18.2 → 2.19.0

data/spec/rollbar/plugins/sidekiq_spec.rb

@@ -1,169 +0,0 @@
-require 'spec_helper'
-
-require 'sidekiq' unless RUBY_VERSION == '1.8.7'
-
-Rollbar.plugins.load!
-
-describe Rollbar::Sidekiq, :reconfigure_notifier => false do
-  describe '.handle_exception' do
-    let(:exception) { StandardError.new('oh noes') }
-    let(:rollbar) { double }
-
-    let(:job_hash) do
-      {
-        'class' => 'FooWorker',
-        'args' => %w(foo bar),
-        'queue' => 'default',
-        'jid' => '96aa59723946616dff537e97',
-        'enqueued_at' => Time.now.to_f,
-        'error_message' => exception.message,
-        'error_class' => exception.class,
-        'created_at' => Time.now.to_f,
-        'failed_at' => Time.now.to_f,
-        'retry' => 3,
-        'retry_count' => 0
-      }
-    end
-
-    let(:ctx_hash) do
-      { :context => 'Job raised exception', :job => job_hash }
-    end
-
-    let(:expected_scope) do
-      {
-        :request => {
-          :params => job_hash.reject { |k| described_class::PARAM_BLACKLIST.include?(k) }
-        },
-        :framework => "Sidekiq: #{Sidekiq::VERSION}",
-        :context => job_hash['class'],
-        :queue => job_hash['queue']
-      }
-    end
-
-    it 'constructs scope from ctx hash' do
-      allow(rollbar).to receive(:error)
-      expect(Rollbar).to receive(:scope).with(expected_scope) { rollbar }
-
-      described_class.handle_exception(ctx_hash, exception)
-    end
-
-    context 'sidekiq < 4.2.3 ctx hash' do
-      let(:ctx_hash) { job_hash }
-
-      it 'constructs scope from ctx hash' do
-        allow(rollbar).to receive(:error)
-        expect(Rollbar).to receive(:scope).with(expected_scope) { rollbar }
-
-        described_class.handle_exception(ctx_hash, exception)
-      end
-    end
-
-    context 'sidekiq < 4.0.0 nil ctx hash from Launcher#actor_died' do
-      let(:ctx_hash) { nil }
-
-      it 'constructs scope from ctx hash' do
-        allow(rollbar).to receive(:error)
-        expect(Rollbar).to receive(:scope).with(
-          :framework => "Sidekiq: #{Sidekiq::VERSION}"
-        ) { rollbar }
-
-        described_class.handle_exception(ctx_hash, exception)
-      end
-    end
-
-    it 'sends the passed-in error to rollbar' do
-      allow(Rollbar).to receive(:scope).and_return(rollbar)
-      expect(rollbar).to receive(:error).with(exception, :use_exception_level_filters => true)
-
-      described_class.handle_exception(ctx_hash, exception)
-    end
-
-    context 'with fields in job hash to be scrubbed' do
-      let(:ctx_hash) do
-        {
-          :context => 'Job raised exception',
-          :job => job_hash.merge(
-            'foo' => 'bar',
-            'secret' => 'foo',
-            'password' => 'foo',
-            'password_confirmation' => 'foo'
-          )
-        }
-      end
-
-      before { reconfigure_notifier }
-
-      it 'sends a report with the scrubbed fields' do
-        described_class.handle_exception(ctx_hash, exception)
-
-        expect(Rollbar.last_report[:request][:params]).to be_eql_hash_with_regexes(
-          'foo' => 'bar',
-          'secret' => /\*+/,
-          'password' => /\*+/,
-          'password_confirmation' => /\*+/
-        )
-      end
-    end
-
-    context 'with a sidekiq_threshold set' do
-      before do
-        Rollbar.configuration.sidekiq_threshold = 3
-      end
-
-      it 'does not send error to rollbar under the threshold' do
-        allow(Rollbar).to receive(:scope).and_return(rollbar)
-        expect(rollbar).to receive(:error).never
-
-        described_class.handle_exception(
-          { :job => { 'retry' => true, 'retry_count' => 1 } },
-          exception
-        )
-      end
-
-      it 'sends the error to rollbar above the threshold' do
-        allow(Rollbar).to receive(:scope).and_return(rollbar)
-        expect(rollbar).to receive(:error)
-
-        described_class.handle_exception(
-          { :job => { 'retry' => true, 'retry_count' => 2 } },
-          exception
-        )
-      end
-
-      it 'sends the error to rollbar if not retry' do
-        allow(Rollbar).to receive(:scope).and_return(rollbar)
-        expect(rollbar).to receive(:error)
-
-        described_class.handle_exception(
-          { :job => { 'retry' => false } },
-          exception
-        )
-      end
-
-      it "does not blow up and doesn't send the error to rollbar if retry is true but there is no retry count" do
-        allow(Rollbar).to receive(:scope).and_return(rollbar)
-        expect(rollbar).to receive(:error).never
-
-        described_class.handle_exception(
-          { :job => { 'retry' => true } },
-          exception
-        )
-      end
-    end
-  end
-
-  describe '#call' do
-    let(:msg) { ['hello'] }
-    let(:exception) { StandardError.new('oh noes') }
-    let(:middleware_block) { proc { raise exception } }
-
-    subject { Rollbar::Sidekiq.new }
-
-    it 'sends the error to Rollbar::Sidekiq.handle_exception' do
-      expect(Rollbar).to receive(:reset_notifier!)
-      expect(Rollbar::Sidekiq).to receive(:handle_exception).with(msg, exception)
-
-      expect { subject.call(nil, msg, nil, &middleware_block) }.to raise_error(exception)
-    end
-  end
-end unless RUBY_VERSION == '1.8.7'

data/spec/rollbar/plugins/validations_spec.rb

@@ -1,56 +0,0 @@
-require 'spec_helper'
-require 'rollbar'
-
-Rollbar.plugins.load!
-
-describe Rollbar::ActiveRecordExtension do
-  it 'has the extensions loaded into ActiveRecord::Base' do
-    expect(ActiveModel::Validations.ancestors).to include(described_class)
-    expect(ActiveModel::Validations.instance_methods.map(&:to_sym)).to include(:report_validation_errors_to_rollbar)
-  end
-
-  context 'with an ActiveRecord::Base instance' do
-    let(:user) { User.new }
-
-    it 'calls report_validation_errors_to_rollbar' do
-      expect(user).to receive(:report_validation_errors_to_rollbar)
-
-      user.valid?
-    end
-
-    context 'using Rails 5.0' do
-      next unless Gem::Version.new(Rails.version) >= Gem::Version.new('5.0')
-
-      context 'with belongs_to' do
-        let(:book) { Book.new }
-
-        it 'report validations error' do
-          expect(book).to receive(:report_validation_errors_to_rollbar)
-          book.valid?
-        end
-      end
-    end
-  end
-
-  context 'with class using ActiveModel::Validations' do
-    let(:post) { Post.new }
-
-    it 'calls report_validation_errors_to_rollbar' do
-      expect(post).to receive(:report_validation_errors_to_rollbar)
-
-      post.valid?
-    end
-  end
-
-  describe '#report_validation_errors_to_rollbar', :reconfigure_notifier => true do
-    context 'having validation errors' do
-      let(:user) { User.new }
-
-      it 'send the errors to Rollbar' do
-        expect(Rollbar).to receive(:warning)
-
-        user.valid?
-      end
-    end
-  end
-end

data/spec/rollbar/plugins_spec.rb

@@ -1,68 +0,0 @@
-require 'spec_helper'
-require 'rollbar/plugins'
-require 'rollbar/plugin'
-
-describe Rollbar::Plugins do
-  let(:plugin_files_path) do
-    File.expand_path('../../fixtures/plugins/**/*.rb', __FILE__)
-  end
-  let!(:current_plugins) do
-    Rollbar.plugins
-  end
-
-  let(:plugin1_proc) do
-    proc do
-      dependency { true }
-    end
-  end
-
-  before do
-    Rollbar.plugins = nil
-    allow_any_instance_of(described_class).to receive(:plugin_files).and_return(plugin_files_path)
-  end
-
-  after do
-    Rollbar.plugins = current_plugins
-  end
-
-  describe '#require_all' do
-    it 'loads the plugins' do
-      expect(Rollbar.plugins).to receive(:define).with(:dummy1)
-      expect(Rollbar.plugins).to receive(:define).with(:dummy2)
-
-      subject.require_all
-    end
-  end
-
-  describe '#define' do
-    it 'evals the plugin DSL and adds it to the collection' do
-      expect_any_instance_of(Rollbar::Plugin).to receive(:dependency)
-      expect do
-        subject.define(:name, &plugin1_proc)
-      end.to change(subject.collection, :size).by(1)
-    end
-
-    context 'with a plugin already defined' do
-      it 'doesnt load the plugin twice' do
-        subject.define(:name, &plugin1_proc)
-
-        expect_any_instance_of(Rollbar::Plugin).not_to receive(:instance_eval)
-        expect do
-          subject.define(:name, &plugin1_proc)
-        end.to change(subject.collection, :size).by(0)
-      end
-    end
-  end
-
-  describe '#load!' do
-    before do
-      subject.define(:plugin1, &plugin1_proc)
-    end
-
-    it 'calls load! in the plugins' do
-      expect_any_instance_of(Rollbar::Plugin).to receive(:load!).once
-
-      subject.load!
-    end
-  end
-end

data/spec/rollbar/request_data_extractor_spec.rb

@@ -1,321 +0,0 @@
-require 'spec_helper'
-require 'rack/mock'
-
-require 'rollbar/request_data_extractor'
-
-class ExtractorDummy
-  include Rollbar::RequestDataExtractor
-end
-
-describe Rollbar::RequestDataExtractor do
-  subject { ExtractorDummy.new }
-
-  let(:env) do
-    Rack::MockRequest.env_for('/', 'HTTP_HOST' => 'localhost:81', 'HTTP_X_FORWARDED_HOST' => 'example.org:9292')
-  end
-
-  describe '#scrub_url' do
-    let(:url) { 'http://this-is-the-url.com/foobar?param1=value1' }
-    let(:sensitive_params) { [:param1, :param2] }
-    let(:scrub_fields) { [:password, :secret] }
-    let(:scrub_whitelist) { false }
-
-    before do
-      allow(Rollbar.configuration).to receive(:scrub_fields).and_return(scrub_fields)
-      allow(Rollbar.configuration).to receive(:scrub_user).and_return(true)
-      allow(Rollbar.configuration).to receive(:scrub_password).and_return(true)
-      allow(Rollbar.configuration).to receive(:randomize_secret_length).and_return(true)
-      allow(Rollbar.configuration).to receive(:scrub_whitelist).and_return(false)
-    end
-
-    it 'calls the scrubber with the correct options' do
-      expected_options = {
-        :url => url,
-        :scrub_fields => [:password, :secret, :param1, :param2],
-        :scrub_user => true,
-        :scrub_password => true,
-        :randomize_scrub_length => true,
-        :whitelist => false
-      }
-
-      expect(Rollbar::Scrubbers::URL).to receive(:call).with(expected_options)
-
-      subject.scrub_url(url, sensitive_params)
-    end
-  end
-
-  describe '#scrub_params' do
-    let(:params) do
-      {
-        :param1 => 'value1',
-        :param2 => 'value2'
-      }
-    end
-    let(:sensitive_params) { [:param1, :param2] }
-    let(:scrub_fields) { [:password, :secret] }
-    let(:scrub_whitelist) { false }
-
-    before do
-      allow(Rollbar.configuration).to receive(:scrub_fields).and_return(scrub_fields)
-      allow(Rollbar.configuration).to receive(:scrub_whitelist).and_return(scrub_whitelist)
-    end
-
-    it 'calls the scrubber with the correct options' do
-      expected_options = {
-        :params => params,
-        :config => scrub_fields,
-        :extra_fields => sensitive_params,
-        :whitelist => scrub_whitelist
-      }
-
-      expect(Rollbar::Scrubbers::Params).to receive(:call).with(expected_options)
-
-      subject.scrub_params(params, sensitive_params)
-    end
-  end
-
-  describe '#extract_request_data_from_rack' do
-    it 'returns a Hash object' do
-      expect(Rollbar::Scrubbers::URL).to receive(:call).with(kind_of(Hash)).and_call_original
-      expect(Rollbar::Scrubbers::Params).to receive(:call).with(kind_of(Hash)).and_call_original.exactly(6)
-
-      result = subject.extract_request_data_from_rack(env)
-
-      expect(result).to be_kind_of(Hash)
-    end
-
-    context 'with invalid utf8 sequence in key', :if => RUBY_VERSION != '1.8.7'  do
-      let(:data) do
-        File.read(File.expand_path('../../support/encodings/iso_8859_9', __FILE__)).force_encoding(Encoding::ISO_8859_9)
-      end
-      let(:env) do
-        env = Rack::MockRequest.env_for('/',
-                                         'HTTP_HOST' => 'localhost:81',
-                                         'HTTP_X_FORWARDED_HOST' => 'example.org:9292',
-                                         'CONTENT_TYPE' => 'application/json')
-
-        env['rack.session'] = { data => 'foo' }
-        env
-      end
-
-      it 'doesnt crash' do
-        result = subject.extract_request_data_from_rack(env)
-
-        expect(result).to be_kind_of(Hash)
-      end
-
-      context 'with CONTENT_TYPE and CONTENT_LENGTH headers' do
-        let(:env) do
-          Rack::MockRequest.env_for('/',
-                                    'HTTP_HOST' => 'localhost:81',
-                                    'HTTP_X_FORWARDED_HOST' => 'example.org:9292',
-                                    'CONTENT_TYPE' => 'application/json',
-                                    'CONTENT_LENGTH' => 20)
-
-
-        end
-
-        it 'adds the content type header to the headers key' do
-          result = subject.extract_request_data_from_rack(env)
-
-          expect(result[:headers]['Content-Type']).to be_eql('application/json')
-          expect(result[:headers]['Content-Length']).to be_eql(20)
-        end
-      end
-    end
-
-    context 'with multiple IP addresses in headers and in user ip' do
-      let(:env) do
-        Rack::MockRequest.env_for('/',
-                                  'HTTP_HOST' => 'localhost:81',
-                                  'HTTP_X_FORWARDED_FOR' => x_forwarded_for,
-                                  'HTTP_X_REAL_IP' => x_real_ip,
-                                  'REMOTE_ADDR' => '3.3.3.3',
-                                  'CONTENT_TYPE' => 'application/json',
-                                  'CONTENT_LENGTH' => 20)
-
-
-      end
-
-      context 'with public client IP' do
-        let(:x_forwarded_for) { '2.2.2.2, 3.3.3.3' }
-        let(:x_real_ip) { '2.2.2.2' }
-
-        it 'extracts the correct user IP' do
-          result = subject.extract_request_data_from_rack(env)
-
-          expect(result[:user_ip]).to be_eql('2.2.2.2')
-        end
-        
-        it 'extracts the correct X-Forwarded-For' do
-          result = subject.extract_request_data_from_rack(env)
-
-          expect(result[:headers]['X-Forwarded-For']).to be_eql('2.2.2.2, 3.3.3.3')
-        end
-        
-        it 'extracts the correct X-Real-Ip' do
-          result = subject.extract_request_data_from_rack(env)
-
-          expect(result[:headers]['X-Real-Ip']).to be_eql('2.2.2.2')
-        end
-        
-        context 'with collect_user_ip configuration option disabled' do
-          before do
-            Rollbar.configuration.collect_user_ip = false
-          end
-          
-          it 'does not extract user\'s IP' do
-            result = subject.extract_request_data_from_rack(env)
-  
-            expect(result[:user_ip]).to be_nil
-          end
-          
-          it 'does not extract user\'s IP on X-Forwarded-For header' do
-            result = subject.extract_request_data_from_rack(env)
-
-            expect(result[:headers]['X-Forwarded-For']).to be_nil
-          end
-        
-          it 'does not extract user\'s IP on X-Real-Ip header' do
-            result = subject.extract_request_data_from_rack(env)
-  
-            expect(result[:headers]['X-Real-Ip']).to be_nil
-          end
-        end
-        
-        context 'with anonymize_user_ip configuration option enabled' do
-          before do
-            Rollbar.configuration.anonymize_user_ip = true
-          end
-          
-          it 'it anonymizes the IPv4 address' do
-            result = subject.extract_request_data_from_rack(env)
-  
-            expect(result[:user_ip]).to be_eql('2.2.2.0')
-          end
-          
-          it 'it anonymizes IP addresses in X-Forwarded-For' do
-            result = subject.extract_request_data_from_rack(env)
-  
-            expect(result[:headers]['X-Forwarded-For']).to be_eql('2.2.2.0, 3.3.3.0')
-          end
-          
-          it 'it anonymizes IP addresses in X-Real-Ip' do
-            result = subject.extract_request_data_from_rack(env)
-  
-            expect(result[:headers]['X-Real-Ip']).to be_eql('2.2.2.0')
-          end
-        end
-      end
-
-      context 'with private first client IP' do
-        let(:x_forwarded_for) { '192.168.1.1, 2.2.2.2, 3.3.3.3' }
-        let(:x_real_ip) { '2.2.2.2' }
-
-        it 'extracts the correct user IP' do
-          result = subject.extract_request_data_from_rack(env)
-
-          expect(result[:user_ip]).to be_eql('2.2.2.2')
-        end
-        
-        it 'extracts the correct X-Forwarded-For' do
-          result = subject.extract_request_data_from_rack(env)
-
-          expect(result[:headers]['X-Forwarded-For']).to be_eql('192.168.1.1, 2.2.2.2, 3.3.3.3')
-        end
-        
-        it 'extracts the correct X-Real-Ip' do
-          result = subject.extract_request_data_from_rack(env)
-
-          expect(result[:headers]['X-Real-Ip']).to be_eql('2.2.2.2')
-        end
-      end
-    end
-
-    context 'with JSON POST body' do
-      let(:params) { { 'key' => 'value' } }
-      let(:body) { params.to_json }
-      let(:env) do
-        Rack::MockRequest.env_for('/?foo=bar',
-                                  'CONTENT_TYPE' => 'application/json',
-                                  :input => body,
-                                  :method => 'POST')
-
-
-      end
-
-      it 'extracts the correct user IP' do
-        result = subject.extract_request_data_from_rack(env)
-        expect(result[:body]).to be_eql(body)
-      end
-    end
-
-    context 'with JSON DELETE body' do
-      let(:params) { { 'key' => 'value' } }
-      let(:body) { params.to_json }
-      let(:env) do
-        Rack::MockRequest.env_for('/?foo=bar',
-                                  'CONTENT_TYPE' => 'application/json',
-                                  :input => body,
-                                  :method => 'DELETE')
-
-
-      end
-
-      it 'extracts the correct user IP' do
-        result = subject.extract_request_data_from_rack(env)
-        expect(result[:body]).to be_eql(body)
-      end
-    end
-
-    context 'with JSON PUT body' do
-      let(:params) { { 'key' => 'value' } }
-      let(:body) { params.to_json }
-      let(:env) do
-        Rack::MockRequest.env_for('/?foo=bar',
-                                  'CONTENT_TYPE' => 'application/json',
-                                  :input => body,
-                                  :method => 'PUT')
-
-
-      end
-
-      it 'extracts the correct user IP' do
-        result = subject.extract_request_data_from_rack(env)
-        expect(result[:body]).to be_eql(body)
-      end
-    end
-
-    context 'with POST params' do
-      let(:params) { { 'key' => 'value' } }
-      let(:env) do
-        Rack::MockRequest.env_for('/?foo=bar',
-                                  :params => params,
-                                  :method => 'POST')
-
-
-      end
-
-      it 'extracts the correct user IP' do
-        result = subject.extract_request_data_from_rack(env)
-        expect(result[:POST]).to be_eql(params)
-      end
-    end
-
-    context 'with GET params' do
-      let(:params) { { 'key' => 'value' } }
-      let(:env) do
-        Rack::MockRequest.env_for('/?foo=bar',
-                                  :params => params,
-                                  :method => 'GET')
-
-
-      end
-
-      it 'extracts the correct user IP' do
-        result = subject.extract_request_data_from_rack(env)
-        expect(result[:GET]).to be_eql(params)
-      end
-    end
-  end
-end