rollbar 2.16.2 → 2.22.1

data/spec/rollbar/plugins/active_job_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-require 'active_support/rescuable'
-
-describe Rollbar::ActiveJob do
-  class TestJob
-    # To mix in rescue_from
-    include ActiveSupport::Rescuable
-    include Rollbar::ActiveJob
-
-    attr_reader :job_id
-
-    def perform(exception, job_id)
-      @job_id = job_id
-      # ActiveJob calls rescue_with_handler when a job raises an exception
-      rescue_with_handler(exception) || raise(exception)
-    end
-  end
-
-  before { reconfigure_notifier }
-
-  let(:exception) { StandardError.new('oh no') }
-  let(:job_id) { "123" }
-
-  it "reports the error to Rollbar" do
-    expected_params = {
-      :job => "TestJob",
-      :job_id => job_id,
-      :use_exception_level_filters => true
-    }
-    expect(Rollbar).to receive(:error).with(exception, expected_params)
-    TestJob.new.perform(exception, job_id) rescue nil
-  end
-
-  it "reraises the error so the job backend can handle the failure and retry" do
-    expect { TestJob.new.perform(exception, job_id) }.to raise_error exception
-  end
-end

data/spec/rollbar/plugins/delayed_job/job_data_spec.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-require 'rollbar/plugins/delayed_job/job_data'
-require 'delayed/backend/test'
-
-# In delayed_job/lib/delayed/syck_ext.rb YAML.load_dj
-# is broken cause it's defined as an instance method
-# instead of module/class method. This is breaking
-# the tests for ruby 1.8.7
-if YAML.parser.class.name =~ /syck|yecht/i
-  module YAML
-    def self.load_dj(yaml)
-      # See https://github.com/dtao/safe_yaml
-      # When the method is there, we need to load our YAML like this...
-      respond_to?(:unsafe_load) ? load(yaml, :safe => false) : load(yaml)
-    end
-  end
-end
-
-describe Rollbar::Delayed::JobData do
-  describe '#to_hash' do
-    let(:handler) { { 'foo' => 'bar' } }
-
-    let(:attrs) do
-      {
-        'id' => 1,
-        'priority' => 0,
-        'attempts' => 1,
-        'handler' => handler.to_yaml
-      }
-    end
-
-    let(:job) do
-      ::Delayed::Backend::Test::Job.new(attrs)
-    end
-
-    subject { described_class.new(job) }
-
-    it 'returns the correct job data' do
-      expected_result = attrs.dup
-      expected_result.delete('id')
-      expected_result['handler'] = handler
-
-      result = subject.to_hash
-
-      expect(result).to be_eql(expected_result)
-    end
-  end
-end

data/spec/rollbar/plugins/delayed_job_spec.rb

@@ -1,129 +0,0 @@
-require 'spec_helper'
-require 'rollbar'
-require 'delayed_job'
-require 'delayed/backend/test'
-
-Rollbar.plugins.load!
-
-describe Rollbar::Delayed, :reconfigure_notifier => true do
-  class FailingJob
-    class TestException < Exception; end
-
-    def do_job_please!(a, b)
-      this = will_crash_again!
-    end
-  end
-
-  before do
-    Delayed::Backend::Test.prepare_worker
-
-    Delayed::Worker.backend = :test
-    Delayed::Backend::Test::Job.delete_all
-  end
-
-  let(:expected_args) do
-    [kind_of(NoMethodError), { :use_exception_level_filters => true }]
-  end
-
-  context 'with delayed method without arguments failing' do
-    it 'sends the exception' do
-      expect(Rollbar).to receive(:scope).with(kind_of(Hash)).and_call_original
-      expect_any_instance_of(Rollbar::Notifier).to receive(:error).with(*expected_args)
-
-      FailingJob.new.delay.do_job_please!(:foo, :bar)
-    end
-  end
-
-  context 'with failed deserialization' do
-    let(:expected_args) do
-      [/Delayed::DeserializationError/, {:use_exception_level_filters=>true}]
-    end
-
-    it 'sends the exception' do
-      expect(Rollbar).to receive(:scope).with(kind_of(Hash)).and_call_original
-      allow_any_instance_of(Delayed::Backend::Base).to receive(:payload_object).and_raise(Delayed::DeserializationError)
-      expect_any_instance_of(Rollbar::Notifier).to receive(:error).with(*expected_args)
-
-      FailingJob.new.delay.do_job_please!(:foo, :bar)
-    end
-    
-    context 'with dj_threshold > 0' do
-      before do
-        Rollbar.configure do |config|
-          config.dj_threshold = 1
-        end
-      end
-      
-      it 'sends the exception' do
-        expect(Rollbar).to receive(:scope).with(kind_of(Hash)).and_call_original
-        allow_any_instance_of(Delayed::Backend::Base).to receive(:payload_object).and_raise(Delayed::DeserializationError)
-        expect_any_instance_of(Rollbar::Notifier).to receive(:error).with(*expected_args)
-  
-        FailingJob.new.delay.do_job_please!(:foo, :bar)
-      end
-    end
-  end
-
-  describe '.build_job_data' do
-    let(:job) { double(:payload_object => {}) }
-
-    context 'if report_dj_data is disabled' do
-      before do
-        allow(Rollbar.configuration).to receive(:report_dj_data).and_return(false)
-      end
-
-      it 'returns nil' do
-        expect(described_class.build_job_data(job)).to be_nil
-      end
-    end
-
-    context 'with report_dj_data enabled' do
-      before do
-        allow(Rollbar.configuration).to receive(:report_dj_data).and_return(true)
-      end
-
-      it 'returns a hash' do
-        result = described_class.build_job_data(job)
-        expect(result).to be_kind_of(Hash)
-      end
-    end
-  end
-
-  describe '.skip_report' do
-    let(:configuration) { Rollbar.configuration }
-    let(:threshold) { 5 }
-
-    before do
-      allow(configuration).to receive(:dj_threshold).and_return(threshold)
-    end
-
-    context 'with attempts > configuration.dj_threshold' do
-      let(:object) do
-        double(:to_s => 'foo')
-      end
-      let(:payload_object) do
-        double(:method_name => 'foo',
-               :args => [1, 2],
-               :object => object)
-      end
-      let(:job) do
-        double(
-          :attempts => 6,
-          :job => { :payload_object => payload_object }
-        )
-      end
-
-      it 'returns true' do
-        expect(described_class.skip_report?(job)).to be(false)
-      end
-    end
-
-    context 'with attempts < configuration.dj_threshold' do
-      let(:job) { double(:attempts => 3) }
-
-      it 'returns false' do
-        expect(described_class.skip_report?(job)).to be(true)
-      end
-    end
-  end
-end

data/spec/rollbar/plugins/rack_spec.rb

@@ -1,152 +0,0 @@
-require 'spec_helper'
-require 'rack'
-require 'rack/builder'
-require 'rack/mock'
-require 'rollbar'
-
-Rollbar.plugins.load!
-
-describe Rollbar::Middleware::Rack::Builder, :reconfigure_notifier => true do
-  class RackMockError < Exception; end
-
-  let(:action) do
-    proc { fail(RackMockError, 'the-error') }
-  end
-
-  let(:app) do
-    action_proc = action
-
-    ::Rack::Builder.new { run action_proc }
-  end
-
-  let(:request) do
-    ::Rack::MockRequest.new(app)
-  end
-
-  let(:exception) { kind_of(RackMockError) }
-  let(:uncaught_level) { Rollbar.configuration.uncaught_exception_level }
-
-  it 'reports the error to Rollbar' do
-    expect(Rollbar).to receive(:log).with(uncaught_level, exception, :use_exception_level_filters => true)
-    expect { request.get('/will_crash') }.to raise_error(exception)
-  end
-
-  context 'with GET parameters' do
-    let(:params) do
-      { 'key' => 'value' }
-    end
-
-    it 'sends them to Rollbar' do
-      expect do
-        request.get('/will_crash', :params => params)
-      end.to raise_error(exception)
-
-      expect(Rollbar.last_report[:request][:GET]).to be_eql(params)
-    end
-  end
-
-  context 'with JSON body parameters' do
-    let(:params) do
-      { 'key' => 'value' }
-    end
-
-    it 'sends them to Rollbar' do
-      expect do
-        request.post('/will_crash', :input => params.to_json, 'CONTENT_TYPE' => 'application/json')
-      end.to raise_error(exception)
-
-      expect(Rollbar.last_report[:request][:body]).to be_eql(params.to_json)
-    end
-  end
-
-  context 'with array POST parameters' do
-    let(:params) do
-      [{ :key => 'value'}, 'string', 10]
-    end
-
-    it 'sends a body.multi key in params' do
-      expect do
-        request.post('/will_crash', :input => params.to_json, 'CONTENT_TYPE' => 'application/json')
-      end.to raise_error(exception)
-
-      reported_body = Rollbar.last_report[:request][:body]
-      expect(reported_body).to be_eql({ 'body.multi' => [{'key' => 'value'}, 'string', 10] }.to_json)
-    end
-  end
-
-  context 'with not array or hash POST parameters' do
-    let(:params) { 1000 }
-
-    it 'sends a body.multi key in params' do
-      expect do
-        request.post('/will_crash', :input => params.to_json, 'CONTENT_TYPE' => 'application/json')
-      end.to raise_error(exception)
-
-      reported_body = Rollbar.last_report[:request][:body]
-      expect(reported_body).to be_eql({ 'body.value' => params }.to_json)
-    end
-  end
-
-  context 'with multiple HTTP_X_FORWARDED_PROTO values' do
-    let(:headers) do
-      { 'HTTP_X_FORWARDED_PROTO' => 'https,http' }
-    end
-
-    it 'uses the first scheme to generate the url' do
-      expect do
-        request.post('/will_crash', headers)
-      end.to raise_error(exception)
-
-      last_report = Rollbar.last_report
-      expect(last_report[:request][:url]).to match(/https:/)
-    end
-  end
-
-  context 'without HTTP_X_FORWARDED_PROTO' do
-    it 'uses the the url_scheme set by Rack' do
-      expect do
-        request.post('/will_crash')
-      end.to raise_error(exception)
-
-      last_report = Rollbar.last_report
-      expect(last_report[:request][:url]).to match(/http:/)
-    end
-  end
-
-  context 'with single HTTP_X_FORWARDED_PROTO value' do
-    let(:headers) do
-      { 'HTTP_X_FORWARDED_PROTO' => 'https' }
-    end
-
-    it 'uses the scheme received in X-Forwarded-Proto header' do
-      expect do
-        request.post('/will_crash', headers)
-      end.to raise_error(exception)
-
-      last_report = Rollbar.last_report
-      expect(last_report[:request][:url]).to match(/https:/)
-    end
-  end
-
-  context 'with person data' do
-    let(:person_data) do
-      { 'email' => 'person@example.com' }
-    end
-
-    it 'includes person data from env' do
-      expect do
-        request.get('/will_crash', 'rollbar.person_data' => person_data)
-      end.to raise_error(exception)
-
-      expect(Rollbar.last_report[:person]).to be_eql(person_data)
-    end
-
-    it 'includes empty person data when not in env' do
-      expect do
-        request.get('/will_crash')
-      end.to raise_error(exception)
-
-      expect(Rollbar.last_report[:person]).to be_eql({})
-    end
-  end
-end

data/spec/rollbar/plugins/rails_js_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-describe ApplicationController, :type => 'request' do
-  before do
-    Rollbar.configure do |config|
-      config.js_options = { :foo => :bar }
-      config.js_enabled = true
-    end
-  end
-
-  it 'renders the snippet and config in the response', :type => 'request' do
-    get '/test_rollbar_js'
-
-    snippet_from_submodule = File.read(File.expand_path('../../../../rollbar.js/dist/rollbar.snippet.js', __FILE__))
-
-    expect(response.body).to include("var _rollbarConfig = #{Rollbar::configuration.js_options.to_json};")
-    expect(response.body).to include(snippet_from_submodule)
-  end
-end

data/spec/rollbar/plugins/rake_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-Rollbar.plugins.load!
-
-describe Rollbar::Rake do
-  let(:application) { Rake.application }
-  let(:exception) { Exception.new }
-
-  context 'with supported rake version' do
-    before do
-      allow(Rollbar::Rake).to receive(:rake_version).and_return('0.9.0')
-    end
-
-    it 'reports error to Rollbar' do
-      expect(Rollbar).to receive(:error).with(exception, :use_exception_level_filters => true)
-      expect(application).to receive(:orig_display_error_message).with(exception)
-
-      Rollbar::Rake.patch! # Really here Rake is already patched
-      application.display_error_message(exception)
-    end
-  end
-
-  context 'with unsupported rake version' do
-    before do
-      allow(Rollbar::Rake).to receive(:rake_version).and_return('0.8.7')
-    end
-
-    it 'reports error to Rollbar' do
-      expect(Rollbar::Rake).to receive(:skip_patch)
-
-      Rollbar::Rake.patch!
-    end
-  end
-end

data/spec/rollbar/plugins/resque/failure_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-require 'rollbar/plugins/resque/failure'
-
-describe Resque::Failure::Rollbar do
-  let(:exception) { StandardError.new('BOOM') }
-  let(:worker) { Resque::Worker.new(:test) }
-  let(:queue) { 'test' }
-  let(:payload) { { 'class' => Object, 'args' => 89 } }
-  let(:backend) do
-    Resque::Failure::Rollbar.new(exception, worker, queue, payload)
-  end
-
-  context 'with Rollbar version <= 1.3' do
-    before do
-      allow(backend).to receive(:rollbar_version).and_return('1.3.0')
-    end
-
-    it 'should be notified of an error' do
-      expect_any_instance_of(Rollbar::Notifier).to receive(:log).with('error', exception, payload)
-      backend.save
-    end
-  end
-
-  context 'with Rollbar version > 1.3' do
-    let(:payload_with_options) { payload.merge(:use_exception_level_filters => true) }
-
-    before do
-      allow(backend).to receive(:rollbar_version).and_return('1.4.0')
-    end
-
-    it 'sends the :use_exception_level_filters option' do
-      expect_any_instance_of(Rollbar::Notifier).to receive(:error).with(exception, payload_with_options)
-      backend.save
-    end
-  end
-end