rollbar 2.16.2 → 2.22.1

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

data/spec/rollbar/logger_proxy_spec.rb

@@ -1,50 +0,0 @@
-require 'spec_helper'
-
-describe Rollbar::LoggerProxy do
-  let(:logger) { double(:logger) }
-  let(:message) { 'the-message' }
-
-  subject { described_class.new(logger) }
-
-  before do
-    allow(Rollbar.configuration).to receive(:enabled).and_return(true)
-  end
-
-  shared_examples 'delegate to logger' do
-    it 'logs with correct level' do
-      expect(logger).to receive(level).with(message)
-
-      subject.send(level, message)
-    end
-  end
-
-  %w(info error warn debug).each do |level|
-    describe "#{level}" do
-      it_should_behave_like 'delegate to logger' do
-        let(:level) { level }
-      end
-    end
-  end
-
-  describe '#log' do
-    context 'if Rollbar is disabled' do
-      before do
-        expect(Rollbar.configuration).to receive(:enabled).and_return(false)
-      end
-
-      it 'doesnt call the logger' do
-        expect(logger).to_not receive(:error)
-
-        subject.log('error', 'foo')
-      end
-    end
-
-    context 'if the logger fails' do
-      it 'doesnt raise' do
-        allow(logger).to receive(:info).and_raise(StandardError.new)
-
-        expect { subject.log('info', message) }.not_to raise_error
-      end
-    end
-  end
-end

data/spec/rollbar/logger_spec.rb

@@ -1,124 +0,0 @@
-require 'spec_helper'
-require 'rollbar/logger'
-
-describe Rollbar::Logger do
-  describe '#add' do
-    context 'with severity under level' do
-      it 'returns true' do
-        result = subject.add(Logger::DEBUG, 'foo')
-
-        expect(result).to be_truthy
-      end
-    end
-
-    context 'with blank message' do
-      it 'returns true' do
-        result = subject.add(subject.level)
-
-        expect(result).to be_truthy
-      end
-    end
-
-    context 'with ERROR severity' do
-      let(:message) { 'foo' }
-
-      it 'calls Rollbar to send the message' do
-        expect_any_instance_of(Rollbar::Notifier).to receive(:log).with(:error, message)
-
-        subject.add(Logger::ERROR, message)
-      end
-    end
-
-    context 'with FATAL severity' do
-      let(:message) { 'foo' }
-
-      it 'calls Rollbar to send the message with critical level' do
-        expect_any_instance_of(Rollbar::Notifier).to receive(:log).with(:critical, message)
-
-        subject.add(Logger::FATAL, message)
-      end
-    end
-
-    context 'with UNKNOWN severity' do
-      let(:message) { 'foo' }
-
-      it 'calls Rollbar to send the message with error level' do
-        expect_any_instance_of(Rollbar::Notifier).to receive(:log).with(:error, message)
-
-        subject.add(Logger::UNKNOWN, message)
-      end
-    end
-
-    context 'with out of range severity' do
-      let(:message) { 'foo' }
-
-      it 'calls Rollbar to send the message with error level' do
-        expect_any_instance_of(Rollbar::Notifier).to receive(:log).with(:error, message)
-
-        subject.add(10, message)
-      end
-    end
-
-    context 'without active_support/core_ext/object/blank' do
-      let(:message) { 'foo'.tap { |message| message.instance_eval('undef :blank?') } }
-
-      it 'calls Rollbar to send the message' do
-        expect_any_instance_of(Rollbar::Notifier).to receive(:log).with(:error, message)
-
-        subject.add(Logger::ERROR, message)
-      end
-    end
-  end
-
-  describe '#<<' do
-    let(:message) { 'foo' }
-
-    it 'calls #error' do
-      expect(subject).to receive(:error).with(message)
-
-      subject << message
-    end
-  end
-
-  describe '#formatter=' do
-    it 'fails with FormatterNotSupported' do
-      expect do
-        subject.formatter = double
-      end.to raise_error(Rollbar::Logger::FormatterNotSupported)
-    end
-  end
-
-  describe '#formatter' do
-    it 'fails with FormatterNotSupported' do
-      expect do
-        subject.formatter
-      end.to raise_error(Rollbar::Logger::FormatterNotSupported)
-    end
-  end
-
-  describe '#datetime_format=' do
-    it 'fails with DatetimeFormatNotSupported' do
-      expect do
-        subject.datetime_format = double
-      end.to raise_error(Rollbar::Logger::DatetimeFormatNotSupported)
-    end
-  end
-
-  describe '#datetime_format' do
-    it 'fails with DatetimeFormatNotSupported' do
-      expect do
-        subject.datetime_format
-      end.to raise_error(Rollbar::Logger::DatetimeFormatNotSupported)
-    end
-  end
-
-  describe '#rollbar' do
-    it 'returns a Rollbar notifier with a logger pointing to /dev/null' do
-      notifier = subject.rollbar
-      logger = notifier.configuration.logger
-      logdev = logger.instance_eval { @logdev }
-
-      expect(logdev.filename).to be_eql('/dev/null')
-    end
-  end
-end

data/spec/rollbar/middleware/js_spec.rb

@@ -1,421 +0,0 @@
-require 'spec_helper'
-require 'rollbar/middleware/js'
-
-describe Rollbar::Middleware::Js 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(:minified_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(:meta_charset_html) do
-    <<-END
-<html>
-  <head>
-    <meta charset="UTF-8"/>
-    <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(:meta_content_html) do
-    <<-END
-<html>
-  <head>
-    <meta content="origin" id="mref" name="referrer">
-    <link rel="stylesheet" href="url" type="text/css" media="screen" />
-    <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
-    <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
-    reconfigure_notifier
-    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_not include('>>')
-          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 with minified body' do
-        let(:body) { [minified_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_not include('>>')
-          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 resposne with meta charset tag' do
-        let(:body) { [meta_charset_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_not include('>>')
-          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)
-          meta_tag = '<meta charset="UTF-8"/>'
-          expect(new_body.index(snippet)).to be > new_body.index(meta_tag)
-        end
-      end
-
-      context 'having a html 200 resposne with meta content-type tag' do
-        let(:body) { [meta_content_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_not include('>>')
-          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)
-          meta_tag = '<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>'
-          expect(new_body.index(snippet)).to be > new_body.index(meta_tag)
-        end
-      end
-
-      context 'having a html 200 response and SecureHeaders >= 3.0.0 defined' do
-        let(:body) { [html] }
-        let(:status) { 200 }
-        let(:headers) do
-          { 'Content-Type' => content_type }
-        end
-
-        before do
-          Object.const_set('SecureHeaders', Module.new)
-          SecureHeaders.const_set('VERSION', '3.0.0')
-          SecureHeaders.const_set('Configuration', Module.new {
-            def self.get
-            end
-          })
-          allow(SecureHeaders).to receive(:content_security_policy_script_nonce) { 'lorem-ipsum-nonce' }
-        end
-
-        after do
-          Object.send(:remove_const, 'SecureHeaders')
-        end
-
-        it 'renders the snippet and config in the response with nonce in script tag when SecureHeaders installed' do
-          secure_headers_config = double(:configuration, :current_csp => {}, :csp => double(:opt_out? => false))
-          allow(SecureHeaders::Configuration).to receive(:get).and_return(secure_headers_config)
-          res_status, res_headers, response = subject.call(env)
-
-          new_body = response.body.join
-
-          expect(new_body).to include('<script type="text/javascript" nonce="lorem-ipsum-nonce">')
-          expect(new_body).to include("var _rollbarConfig = #{config[:options].to_json};")
-          expect(new_body).to include(snippet)
-        end
-
-        it 'renders the snippet in the response without nonce if SecureHeaders script_src includes \'unsafe-inline\'' do
-          secure_headers_config = double(:configuration,
-                                         :current_csp => {
-                                           :script_src => %w('unsafe-inline')
-                                         },
-                                         :csp => double(:opt_out? => false))
-          allow(SecureHeaders::Configuration).to receive(:get).and_return(secure_headers_config)
-
-          res_status, res_headers, response = subject.call(env)
-          new_body = response.body.join
-
-          expect(new_body).to include('<script type="text/javascript">')
-          expect(new_body).to include("var _rollbarConfig = #{config[:options].to_json};")
-          expect(new_body).to include(snippet)
-
-          SecureHeaders.send(:remove_const, 'Configuration')
-        end
-
-        it 'renders the snippet in the response without nonce if SecureHeaders CSP is OptOut' do
-          secure_headers_config = double(:configuration, :csp => double(:opt_out? => true))
-          allow(SecureHeaders::Configuration).to receive(:get).and_return(secure_headers_config)
-
-          res_status, res_headers, response = subject.call(env)
-          new_body = response.body.join
-
-          expect(new_body).to include('<script type="text/javascript">')
-          expect(new_body).to include("var _rollbarConfig = #{config[:options].to_json};")
-          expect(new_body).to include(snippet)
-
-          SecureHeaders.send(:remove_const, 'Configuration')
-        end
-      end
-
-      context 'having a html 200 response and SecureHeaders < 3.0.0 defined' do
-        let(:body) { [html] }
-        let(:status) { 200 }
-        let(:headers) do
-          { 'Content-Type' => content_type }
-        end
-
-        before do
-          Object.const_set('SecureHeaders', Module.new)
-          SecureHeaders.const_set('VERSION', '2.4.0')
-        end
-
-        after do
-          Object.send(:remove_const, 'SecureHeaders')
-        end
-
-        it 'renders the snippet and config in the response without nonce in script tag when too old SecureHeaders installed' do
-          res_status, res_headers, response = subject.call(env)
-          new_body = response.body.join
-
-          expect(new_body).to include('<script type="text/javascript">')
-          expect(new_body).to include("var _rollbarConfig = #{config[:options].to_json};")
-          expect(new_body).to include(snippet)
-        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
-
-      context 'with person data' do
-        let(:body) { [html] }
-        let(:status) { 200 }
-        let(:headers) do
-          { 'Content-Type' => content_type }
-        end
-        let(:config) do
-          {
-            :enabled => true,
-            :options => { :foo => :bar, :payload => { :a => 42 } }
-          }
-        end
-        let(:env) do
-          {
-            'rollbar.person_data' => {
-              :id => 100,
-              :username => 'foo',
-              :email => 'foo@bar.com'
-            }
-          }
-        end
-        let(:expected_js_options) do
-          {
-            :foo => :bar,
-            :payload => {
-              :a => 42,
-              :person => {
-                :id => 100,
-                :username => 'foo',
-                :email => 'foo@bar.com'
-              }
-            }
-          }
-        end
-
-        it 'adds the person data to the configuration' do
-          _, _, response = subject.call(env)
-          new_body = response.body.join
-
-          expect(new_body).to include(expected_js_options.to_json)
-        end
-
-        context 'when the person data is nil' do
-          let(:env) do
-            {
-              'rollbar.person_data' => nil
-            }
-          end
-
-          it 'works correctly and doesnt add anything about person data' do
-            _, _, response = subject.call(env)
-            new_body = response.body.join
-
-            expect(new_body).not_to include('person')
-          end
-
-          it 'doesnt include old data when called a second time' do
-            _, _, _ = subject.call({
-                'rollbar.person_data' => {
-                  :id => 100,
-                  :username => 'foo',
-                  :email => 'foo@bar.com'
-                }
-            })
-            _, _, response = subject.call(env)
-            new_body = response.body.join
-
-            expect(new_body).not_to include('person')
-          end
-        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