rollbar 2.18.2 → 2.19.0

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,74 +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
-  
-  describe '#hook' do
-    it "assigns and returns the appropriate hook" do
-      subject.hook :on_error_response do
-        puts "foo hook"
-      end
-      
-      expect(subject.hook(:on_error_response).is_a?(Proc)).to be_eql(true)
-    end
-    
-    it "raises a StandardError if requested hook is not supported" do
-      expect{ subject.hook(:foo) }.to raise_error(StandardError)
-    end
-  end
-  
-  describe '#execute_hook' do
-    it "executes the approriate hook" do
-      bar = "test value"
-      
-      subject.hook :on_error_response do
-        bar = "changed value"
-      end
-      
-      subject.execute_hook :on_error_response
-      
-      expect(bar).to be_eql("changed value")
-    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/shoryuken_spec.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-
-begin
-  require 'rollbar/delay/shoryuken'
-rescue LoadError
-  module Rollbar
-    module Delay
-      class Shoryuken; end
-    end
-  end
-end
-
-describe Rollbar::Delay::Shoryuken, :if => RUBY_VERSION != '1.8.7' && RUBY_VERSION != '1.9.2' do
-  describe '.call' do
-    let(:payload) do
-      { :key => 'value' }
-    end
-
-    let(:loaded_hash) do
-      Rollbar::JSON.load(Rollbar::JSON.dump(payload))
-    end
-
-    it 'process the payload' do
-      Shoryuken.worker_executor = Shoryuken::Worker::InlineExecutor
-      expect(Rollbar).to receive(:process_from_async_handler).with(loaded_hash)
-      described_class.call(payload)
-      Shoryuken.worker_executor = Shoryuken::Worker::DefaultExecutor
-    end
-
-    context 'with non-default queue name' do
-      let(:sqs_queue) { double('non_default_queue') }
-
-      before do
-        Rollbar.configure { |config| config.use_shoryuken(:queue => 'non_default_queue') }
-      end
-
-      it 'uses specified queue' do
-        expect(Shoryuken::Client).to receive(:queues).with('non_default_queue').and_return(sqs_queue)
-        expect(sqs_queue).to receive(:send_message)
-        described_class.call(payload)
-      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