rollbar 2.16.2 → 2.22.1

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

data/spec/rollbar/truncation_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-require 'rollbar/truncation'
-
-describe Rollbar::Truncation do
-  describe '.truncate' do
-    let(:payload) { {} }
-
-    context 'if truncation is not needed' do
-      it 'only calls RawStrategy is truncation is not needed' do
-        allow(described_class).to receive(:truncate?).and_return(false)
-        expect(Rollbar::Truncation::RawStrategy).to receive(:call).with(payload)
-
-        Rollbar::Truncation.truncate(payload)
-      end
-    end
-
-    context 'if truncation is needed' do
-      it 'calls the next strategy, FramesStrategy' do
-        allow(described_class).to receive(:truncate?).and_return(true, false)
-        expect(Rollbar::Truncation::RawStrategy).to receive(:call).with(payload)
-        expect(Rollbar::Truncation::FramesStrategy).to receive(:call).with(payload)
-
-        Rollbar::Truncation.truncate(payload)
-      end
-    end
-  end
-end

data/spec/rollbar/util/hash_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-require 'rollbar/util/hash'
-
-describe Rollbar::Util::Hash do
-  let(:value) do
-    {
-      :foo => 'bar',
-      :bar => {
-        :foo => 'bar',
-        :bar => [{:foo => 'bar'}]
-      },
-    }
-  end
-
-  it 'converts the symbol keys to string' do
-    new_hash = described_class.deep_stringify_keys(value)
-
-    expect(new_hash['foo']).to be_eql('bar')
-    expect(new_hash['bar']['foo']).to be_eql('bar')
-    expect(new_hash['bar']['bar'][0]['foo']).to be_eql('bar')
-  end
-end

data/spec/rollbar/util/ip_anonymizer_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-require 'rollbar/util/ip_anonymizer'
-
-describe Rollbar::Util::IPAnonymizer do
-  
-  before do
-    Rollbar.configuration.anonymize_user_ip = true
-  end
-  
-  context 'with IPv4 address' do
-    let(:ip) { '127.0.0.1' }
-    
-    it 'anonymizes the IP by replacing the last octet with 0' do
-      anonymized_ip = described_class.anonymize_ip(ip)
-  
-      expect(anonymized_ip).to be_eql(IPAddr.new('127.0.0.0').to_s)
-    end
-  end
-  
-  context 'with IPv6 address' do
-    let(:ip) { '2001:0db8:85a3:0000:0000:8a2e:0370:7334' }
-    
-    it 'anonymizes the IP by replacing the last 80 bits with 0' do
-      
-      anonymized_ip = described_class.anonymize_ip(ip)
-  
-      expect(anonymized_ip).to be_eql(IPAddr.new('2001:db8:85a3::').to_s)
-    end
-  end
-end

data/spec/rollbar/util_spec.rb

@@ -1,80 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-require 'rollbar/util'
-
-describe Rollbar::Util do
-  describe '.deep_merge' do
-    context 'with nil arguments' do
-      let(:data) do
-        { :foo => :bar }
-      end
-
-      it 'doesnt fail and returns same hash' do
-        result = Rollbar::Util.deep_merge(nil, data)
-
-        expect(result).to be_eql(data)
-      end
-    end
-  end
-
-  describe '.enforce_valid_utf8' do
-    # TODO(jon): all these tests should be removed since they are in
-    # in spec/rollbar/encoding/encoder.rb.
-    #
-    # This should just check that in payload with simple values and
-    # nested values are each one passed through Rollbar::Encoding.encode
-    context 'with utf8 string and ruby > 1.8' do
-      next unless String.instance_methods.include?(:force_encoding)
-
-      let(:payload) { { :foo => 'Изменение' } }
-
-      it 'just returns the same string' do
-        payload_copy = payload.clone
-        described_class.enforce_valid_utf8(payload_copy)
-
-        expect(payload_copy[:foo]).to be_eql('Изменение')
-      end
-    end
-
-    it 'should replace invalid utf8 values' do
-      bad_key = force_to_ascii("inner \x92bad key")
-
-      payload = {
-        :bad_value => force_to_ascii("bad value 1\255"),
-        :bad_value_2 => force_to_ascii("bad\255 value 2"),
-        force_to_ascii("bad\255 key") => "good value",
-        :hash => {
-          :inner_bad_value => force_to_ascii("\255\255bad value 3"),
-          bad_key.to_sym => 'inner good value',
-          force_to_ascii("bad array key\255") => [
-            'good array value 1',
-            force_to_ascii("bad\255 array value 1\255"),
-            {
-              :inner_inner_bad => force_to_ascii("bad inner \255inner value")
-            }
-          ]
-        }
-      }
-
-
-      payload_copy = payload.clone
-      described_class.enforce_valid_utf8(payload_copy)
-
-      payload_copy[:bad_value].should == "bad value 1"
-      payload_copy[:bad_value_2].should == "bad value 2"
-      payload_copy["bad key"].should == "good value"
-      payload_copy.keys.should_not include("bad\456 key")
-      payload_copy[:hash][:inner_bad_value].should == "bad value 3"
-      payload_copy[:hash][:"inner bad key"].should == 'inner good value'
-      payload_copy[:hash]["bad array key"].should == [
-        'good array value 1',
-        'bad array value 1',
-        {
-          :inner_inner_bad => 'bad inner inner value'
-        }
-      ]
-    end
-  end
-end

data/spec/rollbar_bc_spec.rb

@@ -1,380 +0,0 @@
-# encoding: UTF-8
-
-require 'logger'
-require 'spec_helper'
-
-describe Rollbar do
-  let(:notifier) { Rollbar.notifier }
-
-  context 'bc_report_message' do
-    before do
-      configure
-      Rollbar.configure do |config|
-        config.logger = logger_mock
-      end
-    end
-
-    let(:logger_mock) { double('Rails.logger').as_null_object }
-    let(:user) do
-      User.create(:email => 'email@example.com',
-                  :encrypted_password => '',
-                  :created_at => Time.now,
-                  :updated_at => Time.now)
-    end
-
-    it 'should report simple messages' do
-      logger_mock.should_receive(:info).with('[Rollbar] Scheduling item')
-      logger_mock.should_receive(:info).with('[Rollbar] Success')
-
-      Rollbar.report_message('Test message')
-    end
-
-    it 'should not report anything when disabled' do
-      logger_mock.should_not_receive(:info).with('[Rollbar] Success')
-
-      Rollbar.configure do |config|
-        config.enabled = false
-      end
-
-      Rollbar.report_message('Test message that should be ignored')
-    end
-
-    it 'should report messages with extra data' do
-      logger_mock.should_receive(:info).with('[Rollbar] Success')
-      Rollbar.report_message('Test message with extra data', 'debug', :foo => 'bar',
-                               :hash => { :a => 123, :b => 'xyz' })
-    end
-
-    it 'should not crash with circular extra_data' do
-      a = { :foo => 'bar' }
-      b = { :a => a }
-      c = { :b => b }
-      a[:c] = c
-
-      logger_mock.should_receive(:error).with(/\[Rollbar\] Reporting internal error encountered while sending data to Rollbar./)
-
-      Rollbar.report_message('Test message with circular extra data', 'debug', a)
-    end
-
-    it 'should be able to report form validation errors when they are present' do
-      logger_mock.should_receive(:info).with('[Rollbar] Success')
-      user.errors.add(:example, 'error')
-      user.report_validation_errors_to_rollbar
-    end
-
-    it 'should not report form validation errors when they are not present' do
-      logger_mock.should_not_receive(:info).with('[Rollbar] Success')
-      user.errors.clear
-      user.report_validation_errors_to_rollbar
-    end
-  end
-
-  context 'bc_report_message_with_request' do
-    before(:each) do
-      configure
-      Rollbar.configure do |config|
-        config.logger = logger_mock
-      end
-    end
-
-    after do
-      Rollbar.unconfigure
-      configure
-    end
-
-    let(:logger_mock) { double('Rails.logger').as_null_object }
-    let(:user) { User.create(:email => 'email@example.com', :encrypted_password => '', :created_at => Time.now, :updated_at => Time.now) }
-
-    it 'should report simple messages' do
-      allow(Rollbar).to receive(:notifier).and_return(notifier)
-      logger_mock.should_receive(:info).with('[Rollbar] Scheduling item')
-      logger_mock.should_receive(:info).with('[Rollbar] Success')
-      Rollbar.report_message_with_request('Test message')
-
-      Rollbar.last_report[:request].should be_nil
-      Rollbar.last_report[:person].should be_nil
-    end
-
-    it 'should report messages with request, person data and extra data' do
-      Rollbar.last_report = nil
-
-      logger_mock.should_receive(:info).with('[Rollbar] Scheduling item')
-      logger_mock.should_receive(:info).with('[Rollbar] Success')
-
-      request_data = {
-        :params => {:foo => 'bar'}
-      }
-
-      person_data = {
-        :id => 123,
-        :username => 'username'
-      }
-
-      extra_data = {
-        :extra_foo => 'extra_bar'
-      }
-
-      Rollbar.report_message_with_request('Test message', 'info', request_data, person_data, extra_data)
-
-      Rollbar.last_report[:request].should == request_data
-      Rollbar.last_report[:person].should == person_data
-      Rollbar.last_report[:body][:message][:extra][:extra_foo].should == 'extra_bar'
-    end
-  end
-
-  context 'bc_report_exception' do
-    before(:each) do
-      configure
-      Rollbar.configure do |config|
-        config.logger = logger_mock
-      end
-
-      begin
-        foo = bar
-      rescue => e
-        @exception = e
-      end
-    end
-
-    after do
-      Rollbar.unconfigure
-      configure
-    end
-
-    let(:logger_mock) { double('Rails.logger').as_null_object }
-
-    it 'should report exceptions without person or request data' do
-      logger_mock.should_receive(:info).with('[Rollbar] Success')
-      Rollbar.report_exception(@exception)
-    end
-
-    it 'should not report anything when disabled' do
-      logger_mock.should_not_receive(:info).with('[Rollbar] Success')
-      Rollbar.configure do |config|
-        config.enabled = false
-      end
-
-      Rollbar.report_exception(@exception)
-    end
-
-    it 'should be enabled when freshly configured' do
-      Rollbar.configuration.enabled.should == true
-    end
-
-    it 'should not be enabled when not configured' do
-      Rollbar.clear_notifier!
-
-      Rollbar.configuration.enabled.should be_nil
-      Rollbar.report_exception(@exception).should == 'disabled'
-    end
-
-    it 'should stay disabled if configure is called again' do
-      Rollbar.clear_notifier!
-
-      # configure once, setting enabled to false.
-      Rollbar.configure do |config|
-        config.enabled = false
-      end
-
-      # now configure again (perhaps to change some other values)
-      Rollbar.configure do |config| end
-
-      Rollbar.configuration.enabled.should == false
-      Rollbar.report_exception(@exception).should == 'disabled'
-    end
-
-    it 'should report exceptions with request and person data' do
-      logger_mock.should_receive(:info).with('[Rollbar] Success')
-      request_data = {
-        :params => { :foo => 'bar' },
-        :url => 'http://localhost/',
-        :user_ip => '127.0.0.1',
-        :headers => {},
-        :GET => { 'baz' => 'boz' },
-        :session => { :user_id => 123 },
-        :method => 'GET',
-      }
-      person_data = {
-        :id => 1,
-        :username => 'test',
-        :email => 'test@example.com'
-      }
-      Rollbar.report_exception(@exception, request_data, person_data)
-    end
-
-    # Skip jruby 1.9+ (https://github.com/jruby/jruby/issues/2373)
-    if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby' && (not RUBY_VERSION =~ /^1\.9/)
-      it 'should work with an IO object as rack.errors' do
-        logger_mock.should_receive(:info).with('[Rollbar] Success')
-
-        request_data = {
-          :params => { :foo => 'bar' },
-          :url => 'http://localhost/',
-          :user_ip => '127.0.0.1',
-          :headers => {},
-          :GET => { 'baz' => 'boz' },
-          :session => { :user_id => 123 },
-          :method => 'GET',
-          :env => { :'rack.errors' => IO.new(2, File::WRONLY) },
-        }
-
-        person_data = {
-          :id => 1,
-          :username => 'test',
-          :email => 'test@example.com'
-        }
-
-        Rollbar.report_exception(@exception, request_data, person_data)
-      end
-    end
-
-    it 'should ignore ignored exception classes' do
-      Rollbar.configure do |config|
-        config.exception_level_filters = { 'NameError' => 'ignore' }
-      end
-
-      logger_mock.should_not_receive(:info)
-      logger_mock.should_not_receive(:error)
-
-      Rollbar.report_exception(@exception)
-    end
-
-    it 'should ignore ignored persons' do
-      Rollbar.configure do |config|
-        config.ignored_person_ids += [1]
-      end
-
-      logger_mock.should_not_receive(:info)
-      logger_mock.should_not_receive(:error)
-
-      person_data = {
-        :id => 1,
-        :username => 'test',
-        :email => 'test@example.com'
-      }
-      Rollbar.report_exception(@exception, {}, person_data)
-    end
-
-    it 'should not ignore non-ignored persons' do
-      Rollbar.configure do |config|
-        config.ignored_person_ids += [1]
-      end
-
-      Rollbar.last_report = nil
-
-      person_data = {
-        :id => 1,
-        :username => 'test',
-        :email => 'test@example.com'
-      }
-      Rollbar.report_exception(@exception, {}, person_data)
-      Rollbar.last_report.should be_nil
-
-      person_data = {
-        :id => 2,
-        :username => 'test2',
-        :email => 'test2@example.com'
-      }
-      Rollbar.report_exception(@exception, {}, person_data)
-      Rollbar.last_report.should_not be_nil
-    end
-
-    it 'should allow callables to set exception filtered level with :use_exception_level_filters option' do
-      callable_mock = double
-      Rollbar.configure do |config|
-        config.exception_level_filters = { 'NameError' => callable_mock }
-      end
-
-      callable_mock.should_receive(:call).with(@exception).at_least(:once).and_return('info')
-      logger_mock.should_receive(:info)
-      logger_mock.should_not_receive(:error)
-
-      Rollbar.report_exception(@exception)
-    end
-
-    it 'should not report exceptions when silenced' do
-      notifier.should_not_receive :schedule_payload
-
-      begin
-        test_var = 1
-        Rollbar.silenced do
-          test_var = 2
-          raise
-        end
-      rescue => e
-        Rollbar.report_exception(e)
-      end
-
-      test_var.should == 2
-    end
-
-    it 'should report exception objects with no backtrace' do
-      allow(Rollbar).to receive(:notifier).and_return(notifier)
-
-      payload = nil
-
-      notifier.stub(:schedule_item) do |*args|
-        payload = args[0]
-      end
-
-      Rollbar.report_exception(StandardError.new('oops'))
-
-      payload['data'][:body][:trace][:frames].should == []
-      payload['data'][:body][:trace][:exception][:class].should == 'StandardError'
-      payload['data'][:body][:trace][:exception][:message].should == 'oops'
-    end
-
-    it 'should return the exception data with a uuid, on platforms with SecureRandom' do
-      if defined?(SecureRandom) and SecureRandom.respond_to?(:uuid)
-        notifier.stub(:schedule_payload) do |*args| end
-
-        exception_data = Rollbar.report_exception(StandardError.new('oops'))
-        exception_data[:uuid].should_not be_nil
-      end
-    end
-
-    it 'should report exception objects with nonstandard backtraces' do
-      allow(Rollbar).to receive(:notifier).and_return(notifier)
-
-      payload = nil
-
-      notifier.stub(:schedule_item) do |*args|
-        payload = args[0]
-      end
-
-      class CustomException < StandardError
-        def backtrace
-          ['custom backtrace line']
-        end
-      end
-
-      exception = CustomException.new('oops')
-
-      Rollbar.report_exception(exception)
-
-      payload['data'][:body][:trace][:frames][0][:method].should == 'custom backtrace line'
-    end
-
-    it 'should report exceptions with a custom level' do
-      allow(Rollbar).to receive(:notifier).and_return(notifier)
-      payload = nil
-
-      notifier.stub(:schedule_item) do |*args|
-        payload = args[0]
-      end
-
-      Rollbar.report_exception(@exception)
-
-      payload['data'][:level].should == 'error'
-
-      Rollbar.report_exception(@exception, nil, nil, 'debug')
-
-      payload['data'][:level].should == 'debug'
-    end
-  end
-
-  # configure with some basic params
-  def configure
-    reconfigure_notifier
-  end
-end