rollbar 2.16.2 → 2.22.1

data/spec/fixtures/plugins/dummy1.rb

@@ -1,5 +0,0 @@
-require 'rollbar/plugins'
-
-Rollbar.plugins.define(:dummy1) do
-  dependency { true }
-end

data/spec/fixtures/plugins/dummy2.rb

@@ -1,5 +0,0 @@
-require 'rollbar/plugins'
-
-Rollbar.plugins.define(:dummy2) do
-  dependency { true }
-end

data/spec/generators/rollbar/rollbar_generator_rails30_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-begin
-  require 'genspec'
-rescue LoadError
-end
-
-require 'generators/rollbar/rollbar_generator'
-
-describe :rollbar do
-  context "with no arguments" do
-    it "outputs a help message" do
-      subject.should output(/You'll need to add an environment variable ROLLBAR_ACCESS_TOKEN with your access token/)
-    end
-
-    it "generates a Rollbar initializer with ENV" do
-      subject.should generate("config/initializers/rollbar.rb") { |content|
-        content.should =~ /config.access_token = ENV\['ROLLBAR_ACCESS_TOKEN'\]/
-      }
-    end
-  end
-
-  with_args 'aaaabbbbccccddddeeeeffff00001111' do
-    it "generates a Rollbar initializer with access token" do
-      subject.should generate("config/initializers/rollbar.rb") do |content|
-        content.should =~ /aaaabbbbccccddddeeeeffff00001111/
-        content.should =~ /config.access_token = 'aaaabbbbccccddddeeeeffff00001111'/
-      end
-    end
-  end
-end if Rails::VERSION::STRING.start_with?('3.0')

data/spec/generators/rollbar/rollbar_generator_spec.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-
-begin
-  require 'generator_spec'
-rescue LoadError
-end
-
-require 'generators/rollbar/rollbar_generator'
-
-describe Rollbar::Generators::RollbarGenerator, :type => :generator do
-  destination File.expand_path('../../../tmp', __FILE__)
-
-  before { prepare_destination }
-
-  context 'with no arguments' do
-    before do
-      run_generator
-    end
-
-    it 'outputs a help message and generates Rollbar initializer with ENV' do
-      expect(destination_root).to have_structure {
-        directory 'config' do
-          directory 'initializers' do
-            file 'rollbar.rb' do
-              contains "config.access_token = ENV\['ROLLBAR_ACCESS_TOKEN'\]"
-            end
-          end
-        end
-      }
-    end
-  end
-
-  context 'with arguments' do
-    before do
-      run_generator(%w(aaaabbbbccccddddeeeeffff00001111))
-    end
-
-    it 'generates a Rollbar initializer with access token' do
-      expect(destination_root).to have_structure {
-        directory 'config' do
-          directory 'initializers' do
-            file 'rollbar.rb' do
-              contains 'aaaabbbbccccddddeeeeffff00001111'
-              contains "config.access_token = 'aaaabbbbccccddddeeeeffff00001111'"
-            end
-          end
-        end
-      }
-    end
-  end
-end unless Rails::VERSION::STRING.start_with?('3.0')

data/spec/requests/home_spec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-
-describe HomeController do
-  let(:logger_mock) { double("Rails.logger").as_null_object }
-
-  before(:each) do
-    reset_configuration
-    reconfigure_notifier
-  end
-
-  context "with broken request" do
-    it "should report uncaught exceptions" do
-      # only seems to be relevant in 3.1 and 3.2
-      if ::Rails::VERSION::STRING.starts_with? "3.1" or ::Rails::VERSION::STRING.starts_with? "3.2"
-        expect { get '/current_user', nil, :cookie => '8%B' }.to raise_exception
-
-        Rollbar.last_report.should_not be_nil
-
-        exception_info = Rollbar.last_report[:body][:trace][:exception]
-        exception_info[:class].should == 'ArgumentError'
-        exception_info[:message].should == 'invalid %-encoding (8%B)'
-      end
-    end
-  end
-
-  context "with error hiding deep inside" do
-    let!(:cookie_method_name){ :[] }
-    let!(:original_cookie_method){ ActionDispatch::Cookies::CookieJar.instance_method(cookie_method_name) }
-    let!(:broken_cookie_method){ Proc.new{ |name| "1" - 1 } }
-
-    before(:each) do
-      ActionDispatch::Cookies::CookieJar.send(:define_method, cookie_method_name, broken_cookie_method)
-    end
-
-    after do
-      ActionDispatch::Cookies::CookieJar.send(:define_method, cookie_method_name, original_cookie_method)
-    end
-
-    it "should report uncaught exceptions" do
-      expect { get '/current_user' }.to raise_exception(NoMethodError)
-
-      body = Rollbar.last_report[:body]
-      trace = body[:trace] && body[:trace] || body[:trace_chain][0]
-
-      trace[:exception][:class].should == 'NoMethodError'
-      trace[:exception][:message].should =~ /^undefined method `-'/
-    end
-  end
-end

data/spec/rollbar/configuration_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-require 'rollbar/configuration'
-
-describe Rollbar::Configuration do
-
-  describe '#use_thread' do
-    it 'enables async and sets a Thread as handler' do
-      subject.use_thread
-
-      expect(subject.use_async).to be_eql(true)
-      expect(subject.async_handler).to be_eql(Rollbar::Delay::Thread)
-    end
-  end
-
-  describe '#use_resque' do
-    it 'enables async and sets Resque as the handler' do
-      require 'resque'
-      subject.use_resque(:queue => 'errors')
-
-      expect(subject.use_async).to be_eql(true)
-      expect(subject.async_handler).to be_eql(Rollbar::Delay::Resque)
-    end
-  end
-
-  describe '#merge' do
-    it 'returns a new object with overrided values' do
-      subject.environment = 'foo'
-
-      new_config = subject.merge(:environment => 'bar')
-
-      expect(new_config).not_to be(subject)
-      expect(new_config.environment).to be_eql('bar')
-    end
-  end
-
-  describe '#merge!' do
-    it 'returns the same object with overrided values' do
-      subject.environment = 'foo'
-
-      new_config = subject.merge!(:environment => 'bar')
-
-      expect(new_config).to be(subject)
-      expect(new_config.environment).to be_eql('bar')
-    end
-  end
-end

data/spec/rollbar/delay/delayed_job_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-require 'delayed_job'
-require 'delayed/worker'
-require 'rollbar/delay/delayed_job'
-require 'delayed/backend/test'
-
-describe Rollbar::Delay::DelayedJob do
-  before do
-    Delayed::Backend::Test.prepare_worker
-    Delayed::Worker.backend = :test
-  end
-
-  describe '.call' do
-    let(:payload) { {} }
-    it 'calls Rollbar' do
-      expect(Rollbar).to receive(:process_from_async_handler).with(payload)
-
-      Rollbar::Delay::DelayedJob.call(payload)
-    end
-  end
-end

data/spec/rollbar/delay/girl_friday_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-# require girl_friday in the test instead in the implementation
-# just to let the user decide to load it or not
-require 'girl_friday'
-require 'rollbar/delay/girl_friday'
-
-describe Rollbar::Delay::GirlFriday do
-  before do
-    queue_class = ::GirlFriday::WorkQueue.immediate!
-    allow(::Rollbar::Delay::GirlFriday).to receive(:queue_class).and_return(queue_class)
-  end
-
-  describe '.call' do
-    let(:payload) do
-      { :key => 'value' }
-    end
-
-    it 'push the payload into the queue' do
-      expect(Rollbar).to receive(:process_from_async_handler).with(payload)
-
-      described_class.call(payload)
-    end
-
-    context 'with exceptions processing payload' do
-      let(:exception) { Exception.new }
-
-      before do
-        expect(Rollbar).to receive(:process_from_async_handler).with(payload).and_raise(exception)
-      end
-
-      it 'raises an exception cause we are using immediate queue' do
-        # This will not happen with a norma work queue cause this:
-        # https://github.com/mperham/girl_friday/blob/master/lib/girl_friday/work_queue.rb#L90-L106
-        expect do
-          described_class.call(payload)
-        end.to raise_error(exception)
-      end
-    end
-  end
-end

data/spec/rollbar/delay/resque_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-require 'rollbar/delay/resque'
-
-describe Rollbar::Delay::Resque do
-  describe '.call' do
-    let(:payload) do
-      { :key => 'value' }
-    end
-
-    let(:loaded_hash) do
-      Rollbar::JSON.load(Rollbar::JSON.dump(payload))
-    end
-
-    before do
-      allow(Resque).to receive(:inline?).and_return(true)
-    end
-
-    it 'process the payload' do
-      expect(Rollbar).to receive(:process_from_async_handler).with(loaded_hash)
-      described_class.call(payload)
-    end
-
-    context 'with exceptions processing payload' do
-      let(:exception) { Exception.new }
-
-      before do
-        expect(Rollbar).to receive(:process_from_async_handler).with(loaded_hash).and_raise(exception)
-      end
-
-      it 'raises an exception' do
-        expect do
-          described_class.call(payload)
-        end.to raise_error(exception)
-      end
-    end
-  end
-end

data/spec/rollbar/delay/thread_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe Rollbar::Delay::Thread do
-  describe '.call' do
-    let(:payload) { { :key => 'value' } }
-
-    it 'process the payload in a new thread' do
-      expect(Rollbar).to receive(:process_from_async_handler).with(payload)
-
-      described_class.call(payload).join
-    end
-
-    context 'with exceptions processing payload' do
-      let(:exception) { StandardError.new }
-
-      before do
-        expect(Rollbar).to receive(:process_from_async_handler).with(payload).and_raise(exception)
-      end
-
-      it 'doesnt raise any exception' do
-        expect do
-          described_class.call(payload).join
-        end.not_to raise_error
-      end
-    end
-  end
-end

data/spec/rollbar/encoding/encoder_spec.rb

@@ -1,63 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-unless RUBY_VERSION.start_with?('1.8')
-  require 'rollbar/encoding/encoder'
-
-  describe Rollbar::Encoding::Encoder do
-    subject { described_class.new(object) }
-
-    shared_examples 'encoding' do
-      it 'encodes ir properly' do
-        value = subject.encode
-
-        expect(value).to be_eql(expected)
-      end
-    end
-
-    describe '#encode' do
-      context 'with ascii chars at end of string' do
-        it_behaves_like 'encoding' do
-          let(:object) { force_to_ascii("bad value 1\255") }
-          let(:expected) { 'bad value 1' }
-        end
-      end
-
-      context 'with ascii chars at middle of string' do
-        it_behaves_like 'encoding' do
-          let(:object) { force_to_ascii("bad\255 value 2") }
-          let(:expected) { 'bad value 2' }
-        end
-      end
-
-      context 'with ascii chars at end of string' do
-        it_behaves_like 'encoding' do
-          let(:object) { force_to_ascii("bad value 3\255") }
-          let(:expected) { 'bad value 3' }
-        end
-      end
-
-      context '0xa0 char in exception object' do
-        it_behaves_like 'encoding' do
-          let(:object) { "foo \xa0".force_encoding(::Encoding::ISO_8859_1) }
-          let(:expected) { "foo " }
-        end
-      end
-
-      context 'with bad symbol' do
-        it_behaves_like 'encoding' do
-          let(:bad_string) { force_to_ascii("inner \x92bad key") }
-          let(:object) { bad_string.to_sym }
-          let(:expected) { :"inner bad key" }
-        end
-      end
-
-      context 'with russian chars in string' do
-        it_behaves_like 'encoding' do
-          let(:object) { 'Изменение' }
-          let(:expected) { 'Изменение' }
-        end
-      end
-    end
-  end
-end

data/spec/rollbar/item/backtrace_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-require 'tempfile'
-require 'rollbar/item/backtrace'
-
-describe Rollbar::Item::Backtrace do
-  describe '#get_file_lines' do
-    subject { described_class.new(exception) }
-
-    let(:exception) { Exception.new }
-    let(:file) { Tempfile.new('foo') }
-
-    before do
-      File.open(file.path, 'w') do |f|
-        f << "foo\nbar"
-      end
-    end
-
-    it 'returns the lines of the file' do
-      lines = subject.get_file_lines(file.path)
-
-      expect(lines.size).to be_eql(2)
-      expect(lines[0]).to be_eql('foo')
-      expect(lines[1]).to be_eql('bar')
-    end
-  end
-end

data/spec/rollbar/item/frame_spec.rb

@@ -1,267 +0,0 @@
-require 'spec_helper'
-require 'tempfile'
-require 'rollbar/item/backtrace'
-require 'rollbar/item/frame'
-
-describe Rollbar::Item::Frame do
-  subject { described_class.new(backtrace, frame, options) }
-
-  let(:backtrace) { double('backtrace') }
-  let(:options) { {} }
-
-  describe '#to_h' do
-    context 'with a frame that is not a valid frame' do
-      let(:frame) { 'this frame is not valid' }
-
-      it 'return an unknown frame value' do
-        expected_result = {
-          :filename => '<unknown>',
-          :lineno => 0,
-          :method => frame
-        }
-
-        result = subject.to_h
-        expect(result).to be_eql(expected_result)
-      end
-    end
-
-    context 'with valid frame' do
-      let(:file) do
-        <<-END
-foo1
-foo2
-foo3
-foo4
-foo5
-foo6
-foo7
-foo8
-foo9
-foo10
-foo11
-foo12
-foo13
-        END
-      end
-      let(:filepath) do
-        '/var/www/rollbar/playground/rails4.2/vendor/bundle/gems/actionpack-4.2.0/lib/action_controller/metal/implicit_render.rb'
-      end
-      let(:frame) do
-        "#{filepath}:7:in `send_action'"
-      end
-      let(:options) do
-        { :configuration => configuration }
-      end
-
-      before do
-        allow(backtrace).to receive(:get_file_lines).with(filepath).and_return(file.split("\n"))
-      end
-
-      context 'with send_extra_frame_data = :none' do
-        let(:configuration) do
-          double('configuration',
-                 :send_extra_frame_data => :none,
-                 :root => '/var/www')
-        end
-
-        it 'just return the filename, lineno and method' do
-          expected_result = {
-            :filename => filepath,
-            :lineno => 7,
-            :method => 'send_action'
-          }
-
-          expect(subject.to_h).to be_eql(expected_result)
-        end
-      end
-
-      context 'with send_extra_frame_data = :all' do
-        let(:configuration) do
-          double('configuration',
-                 :send_extra_frame_data => :all,
-                 :root => '/var/www')
-        end
-
-        it 'returns also code and context' do
-          expected_result = {
-            :filename => filepath,
-            :lineno => 7,
-            :method => 'send_action',
-            :code => 'foo7',
-            :context => {
-              :pre => %w(foo3 foo4 foo5 foo6),
-              :post => %w(foo8 foo9 foo10 foo11)
-            }
-          }
-
-          expect(subject.to_h).to be_eql(expected_result)
-        end
-
-        context 'if there is not lines in the file' do
-          let(:file) do
-            ''
-          end
-          it 'just returns the basic data' do
-            expected_result = {
-              :filename => filepath,
-              :lineno => 7,
-              :method => 'send_action'
-            }
-
-            expect(subject.to_h).to be_eql(expected_result)
-          end
-        end
-
-        context 'if the file couldnt be read' do
-          before do
-            allow(backtrace).to receive(:get_file_lines).with(filepath).and_return(nil)
-          end
-
-          it 'just returns the basic data' do
-            expected_result = {
-              :filename => filepath,
-              :lineno => 7,
-              :method => 'send_action'
-            }
-
-            expect(subject.to_h).to be_eql(expected_result)
-          end
-        end
-      end
-
-      context 'with send_extra_frame_data = :app' do
-        context 'with frame outside the root' do
-          let(:configuration) do
-            double('configuration',
-                   :send_extra_frame_data => :app,
-                   :root => '/outside/project',
-                   :project_gem_paths => [])
-          end
-
-          it 'just returns the basic frame data' do
-            expected_result = {
-              :filename => filepath,
-              :lineno => 7,
-              :method => 'send_action'
-            }
-
-            expect(subject.to_h).to be_eql(expected_result)
-          end
-        end
-
-        context 'with frame inside project_gem_paths' do
-          let(:configuration) do
-            double('configuration',
-                   :send_extra_frame_data => :app,
-                   :root => '/var/outside/',
-                   :project_gem_paths => ['/var/www/'])
-          end
-
-          it 'returns also context and code data' do
-            expected_result = {
-              :filename => filepath,
-              :lineno => 7,
-              :method => 'send_action',
-              :code => 'foo7',
-              :context => {
-                :pre => %w(foo3 foo4 foo5 foo6),
-                :post => %w(foo8 foo9 foo10 foo11)
-              }
-            }
-
-            expect(subject.to_h).to be_eql(expected_result)
-          end
-        end
-
-        context 'and frame inside app root' do
-          let(:configuration) do
-            double('configuration',
-                   :send_extra_frame_data => :app,
-                   :root => '/var/www',
-                   :project_gem_paths => [])
-          end
-
-          it 'returns also the context and code data' do
-            expected_result = {
-              :filename => filepath,
-              :lineno => 7,
-              :method => 'send_action',
-              :code => 'foo7',
-              :context => {
-                :pre => %w(foo3 foo4 foo5 foo6),
-                :post => %w(foo8 foo9 foo10 foo11)
-              }
-            }
-
-            expect(subject.to_h).to be_eql(expected_result)
-          end
-
-          context 'but inside Gem.path' do
-            let(:configuration) do
-              double('configuration',
-                     :send_extra_frame_data => :app,
-                     :root => '/var/www/',
-                     :project_gem_paths => [])
-            end
-
-            before do
-              allow(Gem).to receive(:path).and_return(['/var/www/rollbar'])
-            end
-
-            it 'just returns also the basic data' do
-              expected_result = {
-                :filename => filepath,
-                :lineno => 7,
-                :method => 'send_action'
-              }
-
-              expect(subject.to_h).to be_eql(expected_result)
-            end
-          end
-
-          context 'having less pre lines than maximum' do
-            let(:frame) do
-              "#{filepath}:3:in `send_action'"
-            end
-
-            it 'returns up to 2 pre lines' do
-              expected_result = {
-                :filename => filepath,
-                :lineno => 3,
-                :method => 'send_action',
-                :code => 'foo3',
-                :context => {
-                  :pre => %w(foo1 foo2),
-                  :post => %w(foo4 foo5 foo6 foo7)
-                }
-              }
-
-              expect(subject.to_h).to be_eql(expected_result)
-            end
-          end
-
-          context 'having less post lines than maximum' do
-            let(:frame) do
-              "#{filepath}:11:in `send_action'"
-            end
-
-            it 'returns up to 2 post lines' do
-              expected_result = {
-                :filename => filepath,
-                :lineno => 11,
-                :method => 'send_action',
-                :code => 'foo11',
-                :context => {
-                  :pre => %w(foo7 foo8 foo9 foo10),
-                  :post => %w(foo12 foo13)
-                }
-              }
-
-              expect(subject.to_h).to be_eql(expected_result)
-            end
-          end
-        end
-      end
-    end
-  end
-end