rollbar 2.8.3 → 3.6.0

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(exception)
-      end
-    end
-  end
-end

data/spec/rollbar/delayed_job/job_data.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-
-require 'rollbar/delayed_job'
-require 'delayed/backend/test'
-
-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/delayed_job_spec.rb

@@ -1,90 +0,0 @@
-require 'spec_helper'
-require 'delayed_job'
-require 'rollbar/delayed_job'
-require 'delayed/backend/test'
-
-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(:all) do
-    # technically, this is called once when rollbar hooks are required
-    Rollbar::Delayed.wrap_worker!
-  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
-
-
-  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(:job) { double(:attempts => 6) }
-
-      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/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/js/frameworks/rails_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/js/middleware_spec.rb

@@ -1,162 +0,0 @@
-require 'spec_helper'
-require 'rollbar/js/middleware'
-
-describe Rollbar::Js::Middleware do
-  subject { described_class.new(app, config) }
-
-  let(:env) { {} }
-  let(:config) { {} }
-  let(:app) do
-    proc do |_|
-      [status, headers, body]
-    end
-  end
-  let(:html) do
-    <<-END
-<html>
-  <head>
-    <link rel="stylesheet" href="url" type="text/css" media="screen" />
-    <script type="text/javascript" src="foo"></script>
-  </head>
-  <body>
-    <h1>Testing the middleware</h1>
-  </body>
-</html>
-END
-  end
-  let(:snippet) { 'THIS IS THE SNIPPET' }
-  let(:content_type) { 'text/html' }
-
-  before do
-    allow(subject).to receive(:js_snippet).and_return(snippet)
-  end
-
-  shared_examples "doesn't add the snippet or config", :add_js => false do
-    it "doesn't add the snippet or config" do
-      res_status, res_headers, response = subject.call(env)
-      new_body = response.join
-
-      expect(new_body).not_to include(snippet)
-      expect(new_body).not_to include(config[:options].to_json)
-      expect(new_body).to be_eql(body.join)
-      expect(res_status).to be_eql(status)
-      expect(res_headers['Content-Type']).to be_eql(content_type)
-    end
-  end
-
-  describe '#call' do
-    context 'with enabled config' do
-      let(:config) do
-        {
-          :enabled => true,
-          :options => { :foo => :bar }
-        }
-      end
-
-      context 'having a html 200 response' do
-        let(:body) { [html] }
-        let(:status) { 200 }
-        let(:headers) do
-          { 'Content-Type' => content_type }
-        end
-
-        it 'adds the config and the snippet to the response' do
-          res_status, res_headers, response = subject.call(env)
-          new_body = response.body.join
-
-          expect(new_body).to include(snippet)
-          expect(new_body).to include(config[:options].to_json)
-          expect(res_status).to be_eql(status)
-          expect(res_headers['Content-Type']).to be_eql(content_type)
-        end
-      end
-
-      context 'having a html 200 response without head', :add_js => false do
-        let(:body) { ['foobar'] }
-        let(:status) { 200 }
-        let(:headers) do
-          { 'Content-Type' => content_type }
-        end
-      end
-
-      context 'having a html 200 response without head but with an header tag', :add_js => false do
-        let(:body) { ['<header>foobar</header>'] }
-        let(:status) { 200 }
-        let(:headers) do
-          { 'Content-Type' => content_type }
-        end
-      end
-
-      context 'having a html 302 response', :add_js => false do
-        let(:body) { ['foobar'] }
-        let(:status) { 302 }
-        let(:headers) do
-          { 'Content-Type' => content_type }
-        end
-      end
-
-      context 'having the js already injected key in env', :add_js => false do
-        let(:body) { ['foobar'] }
-        let(:status) { 200 }
-        let(:headers) do
-          { 'Content-Type' => content_type }
-        end
-        let(:env) do
-          { described_class::JS_IS_INJECTED_KEY => true }
-        end
-      end
-
-      context 'having an attachment', :add_js => false do
-        let(:content_type) { 'text/plain' }
-        let(:body) { ['foobar'] }
-        let(:status) { 200 }
-        let(:headers) do
-          { 'Content-Disposition' => 'attachment',
-            'Content-Type' => content_type
-          }
-        end
-      end
-
-      context 'with an exception raised while adding the js', :add_js => false do
-        let(:body) { [html] }
-        let(:status) { 200 }
-        let(:headers) do
-          { 'Content-Type' => content_type }
-        end
-
-        before do
-          allow(subject).to receive(:add_js).and_raise(StandardError.new)
-        end
-      end
-    end
-
-    context 'having the config disabled', :add_js => false do
-      let(:body) { ['foobar'] }
-      let(:status) { 302 }
-      let(:headers) do
-        { 'Content-Type' => content_type }
-      end
-      let(:config) do
-        {
-          :enabled => false,
-          :options => { :foo => :bar }
-        }
-      end
-    end
-
-    context 'if the app raises' do
-      let(:exception) { StandardError.new }
-      let(:app) do
-        proc do |_|
-          raise exception
-        end
-      end
-
-      it 'propagates the exception' do
-        expect do
-          app.call(env)
-        end.to raise_exception(exception)
-      end
-    end
-  end
-end

data/spec/rollbar/json/oj_spec.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-require 'rollbar/json/oj'
-
-describe Rollbar::JSON::Oj do
-  let(:options) do
-    {
-      :mode => :compat,
-      :use_to_json => false,
-      :symbol_keys => false,
-      :circular => false
-    }
-  end
-
-  it 'returns correct options' do
-    expect(described_class.options).to be_eql(options)
-  end
-end

data/spec/rollbar/json_spec.rb

@@ -1,110 +0,0 @@
-require 'spec_helper'
-
-require 'multi_json'
-require 'rollbar/json'
-require 'rollbar/configuration'
-
-class Rollbar::JSON::MockAdapter
-  def self.options
-    { 'mock' => 'adapter' }
-  end
-end
-
-module MultiJson
-  module Adapters
-    module MockAdapter
-    end
-  end
-end
-
-module MultiJson
-  module Adapters
-    module MissingCustomOptions
-    end
-  end
-end
-
-module MissingCustomOptions
-  # Consider the fact that there's MultiJson::Adapters::Yajl but not
-  # Rollbar::JSON::Yajl, it should not look for ::Yajl but only
-  # Rollbar::JSON::Yajl.
-end
-
-describe Rollbar::JSON do
-  let(:payload) do
-    { :foo => :bar }
-  end
-  let(:adapter_options) { { 'option' => 'value' } }
-
-  describe '.dump' do
-    before do
-      allow(described_class).to receive(:adapter_options).and_return(adapter_options)
-    end
-
-    it 'calls MultiJson.dump' do
-      expect(::MultiJson).to receive(:dump).once.with(payload, adapter_options)
-
-      described_class.dump(payload)
-    end
-  end
-
-  describe '.load' do
-    before do
-      allow(described_class).to receive(:adapter_options).and_return(adapter_options)
-    end
-
-    it 'calls MultiJson.load' do
-      expect(::MultiJson).to receive(:load).once.with(payload, adapter_options)
-
-      described_class.load(payload)
-    end
-  end
-
-  describe '.with_adapter' do
-    let(:object) { double(:foo => 'bar') }
-    let(:callback) do
-      proc { object.foo }
-    end
-    let(:adapter) { described_class.detect_multi_json_adapter }
-
-    it 'calls mock.something with an adapter' do
-      expect(MultiJson).to receive(:with_adapter).with(adapter).and_call_original
-      expect(object).to receive(:foo).once
-
-      described_class.with_adapter(&callback)
-    end
-  end
-
-  describe '.adapter_options' do
-    it 'calls .options in adapter module' do
-      expect(described_class.options_module).to receive(:options)
-
-      described_class.adapter_options
-    end
-  end
-
-  describe '.options_module' do
-    before do
-      described_class.options_module = nil
-      allow(MultiJson).to receive(:current_adapter).and_return(multi_json_module)
-    end
-
-    context 'with a defined rollbar adapter' do
-      let(:multi_json_module) { MultiJson::Adapters::MockAdapter }
-      let(:expected_adapter) { Rollbar::JSON::MockAdapter }
-
-      it 'returns the correct options' do
-        expect(described_class.options_module).to be(expected_adapter)
-      end
-    end
-
-    context 'without a defined rollbar adapter' do
-      let(:multi_json_module) { MultiJson::Adapters::MissingCustomOptions }
-      let(:expected_adapter) { Rollbar::JSON::Default }
-
-      it 'returns the correct options' do
-        expect(described_class.options_module).to be(expected_adapter)
-      end
-    end
-  end
-end

data/spec/rollbar/lazy_store_spec.rb

@@ -1,99 +0,0 @@
-require 'spec_helper'
-
-require 'rollbar/lazy_store'
-
-
-describe Rollbar::LazyStore do
-  subject { Rollbar::LazyStore.new(data) }
-  let(:lazy_value) do
-    proc { :bar }
-  end
-  let(:data) do
-    {
-      :somekey => :value,
-      :foo => lazy_value
-    }
-  end
-
-  describe '#[]' do
-    it 'gets the regular values' do
-      expect(subject[:somekey]).to be_eql(:value)
-    end
-
-    it 'gets the lazy values and evaluates them just once' do
-      expect(lazy_value).to receive(:call).once.and_call_original
-
-      value1 = subject[:foo]
-      value2 = subject[:foo]
-
-      expect(value1).to be_eql(:bar)
-      expect(value2).to be_eql(:bar)
-    end
-  end
-
-  describe '#[]=' do
-    before do
-      # load data in :foo
-      subject[:foo]
-    end
-
-    it 'sets the data and clears the loaded data' do
-      subject[:foo] = 'something-else'
-
-      expect(subject[:foo]).to be_eql('something-else')
-    end
-  end
-
-  describe '#eql?' do
-    context 'passing a Hash' do
-      it 'checks correctly eql?' do
-        expect(subject.eql?(data)).to be(true)
-        expect(subject.eql?({})).to be(false)
-      end
-    end
-
-    context 'passing a LazyStore' do
-      it 'checks correctly eql?' do
-        expect(subject.eql?(Rollbar::LazyStore.new(data))).to be(true)
-        expect(subject.eql?(Rollbar::LazyStore.new({}))).to be(false)
-      end
-    end
-  end
-
-  describe '#==' do
-    context 'passing a Hash' do
-      it 'checks correctly eql?' do
-        expect(subject == data).to be(true)
-        expect(subject == {}).to be(false)
-      end
-    end
-
-    context 'passing a LazyStore' do
-      it 'checks correctly eql?' do
-        expect(subject == Rollbar::LazyStore.new(data)).to be(true)
-        expect(subject == Rollbar::LazyStore.new({})).to be(false)
-      end
-    end
-  end
-
-  describe '#data' do
-    it 'returns the data with lazy values loaded' do
-      value = subject.data
-
-      expected_value = {
-        :somekey => :value,
-        :foo => :bar
-      }
-      expect(value).to be_eql(expected_value)
-    end
-  end
-
-  describe '#clone' do
-    it 'returns a new object, with same data and empty loaded_data' do
-      new_scope = subject.clone
-
-      expect(new_scope.instance_variable_get('@loaded_data')).to be_empty
-      expect(new_scope.raw).to be_eql(subject.raw)
-    end
-  end
-end