bugsnag 6.14.0 → 6.19.0

data/spec/cleaner_spec.rb

@@ -1,350 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Bugsnag::Cleaner do
-  subject { Bugsnag::Cleaner.new(Bugsnag::Configuration.new) }
-
-  describe "#clean_object" do
-    is_jruby = defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
-
-    it "cleans up recursive hashes" do
-      a = {:a => {}}
-      a[:a][:b] = a
-      expect(subject.clean_object(a)).to eq({:a => {:b => "[RECURSION]"}})
-    end
-
-    it "cleans up hashes when keys infinitely recurse in to_s" do
-      skip "JRuby doesn't allow recovery from SystemStackErrors" if is_jruby
-
-      class RecursiveHashKey
-        def to_s
-          to_s
-        end
-      end
-
-      key = RecursiveHashKey.new
-
-      a = {}
-      a[key] = 1
-
-      expect(subject.clean_object(a)).to eq({ "[RECURSION]" => "[FILTERED]" })
-    end
-
-    it "cleans up hashes when a nested key infinitely recurse in to_s" do
-      skip "JRuby doesn't allow recovery from SystemStackErrors" if is_jruby
-
-      class RecursiveHashKey
-        def to_s
-          to_s
-        end
-      end
-
-      key = RecursiveHashKey.new
-
-      a = {}
-      a[:b] = {}
-      a[:b][key] = 1
-
-      expected = { :b => { "[RECURSION]" => "[FILTERED]" } }
-
-      expect(subject.clean_object(a)).to eq(expected)
-    end
-
-    it "cleans up hashes when keys raise in to_s" do
-      class RaisingHashKey
-        def to_s
-          raise "hey!"
-        end
-      end
-
-      key = RaisingHashKey.new
-
-      a = {}
-      a[key] = 1
-
-      expect(subject.clean_object(a)).to eq({ "[RAISED]" => "[FILTERED]" })
-    end
-
-    it "cleans up hashes when nested keys raise in to_s" do
-      class RaisingHashKey
-        def to_s
-          raise "hey!"
-        end
-      end
-
-      key = RaisingHashKey.new
-
-      a = {}
-      a[:b] = {}
-      a[:b][key] = 1
-
-      expected = { :b => { "[RAISED]" => "[FILTERED]" } }
-
-      expect(subject.clean_object(a)).to eq(expected)
-    end
-
-    it "cleans up recursive arrays" do
-      a = []
-      a << a
-      a << "hello"
-      expect(subject.clean_object(a)).to eq(["[RECURSION]", "hello"])
-    end
-
-    it "doesn't remove nil from arrays" do
-      a = ["b", nil, "c"]
-      expect(subject.clean_object(a)).to eq(["b", nil, "c"])
-    end
-
-    it "allows multiple copies of the same string" do
-      a = {:name => "bugsnag"}
-      a[:second] = a[:name]
-      expect(subject.clean_object(a)).to eq({:name => "bugsnag", :second => "bugsnag"})
-    end
-
-    it "allows multiple copies of the same object" do
-      a = []
-      b = ["hello"]
-      a << b; a << b
-      expect(subject.clean_object(a)).to eq([["hello"], ["hello"]])
-    end
-
-    it "cleans up UTF8 strings properly" do
-      obj = "André"
-      expect(subject.clean_object(obj)).to eq("André")
-    end
-
-    it "cleans custom objects" do
-      class Macaron; end
-      a = Macaron.new
-      expect(subject.clean_object(a)).to eq('[OBJECT]')
-    end
-
-    it "cleans custom objects when they infinitely recurse" do
-      skip "JRuby doesn't allow recovery from SystemStackErrors" if is_jruby
-
-      class RecursiveObject
-        def to_s
-          to_s
-        end
-      end
-
-      object = RecursiveObject.new
-
-      expect(subject.clean_object(object)).to eq("[RECURSION]")
-    end
-
-    it "cleans custom objects to show the id of the object if object responds to id method" do
-      class MacaronWithId
-        def id
-          10
-        end
-      end
-
-      a = MacaronWithId.new
-      expect(subject.clean_object(a)).to eq("[OBJECT]: [Class]: #{a.class.name} [ID]: #{a.id}")
-    end
-
-    it "cleans up binary strings properly" do
-      if RUBY_VERSION > "1.9"
-        obj = "Andr\xc7\xff"
-        if obj.respond_to? :force_encoding
-          obj = obj.force_encoding('BINARY')
-        end
-        expect(subject.clean_object(obj)).to eq("Andr��")
-      end
-    end
-
-    it "cleans up strings returned from #to_s properly" do
-      if RUBY_VERSION > "1.9"
-        str = "Andr\xc7\xff"
-        if str.respond_to? :force_encoding
-          str = str.force_encoding('BINARY')
-        end
-        obj = RuntimeError.new(str)
-        expect(subject.clean_object(obj)).to eq("Andr��")
-      end
-    end
-
-    it "filters by string inclusion" do
-      object = { events: { metaData: { foo: 'bar' } } }
-
-      configuration = Bugsnag::Configuration.new
-      configuration.meta_data_filters = ['f']
-
-      cleaner = Bugsnag::Cleaner.new(configuration)
-      expect(cleaner.clean_object(object)).to eq({ events: { metaData: { foo: '[FILTERED]' } } })
-
-      configuration = Bugsnag::Configuration.new
-      configuration.meta_data_filters = ['b']
-
-      cleaner = Bugsnag::Cleaner.new(configuration)
-      expect(cleaner.clean_object(object)).to eq({ events: { metaData: { foo: 'bar' } } })
-    end
-
-    it "filters by regular expression" do
-      object = { events: { metaData: { foo: 'bar' } } }
-
-      configuration = Bugsnag::Configuration.new
-      configuration.meta_data_filters = [/fb?/]
-
-      cleaner = Bugsnag::Cleaner.new(configuration)
-      expect(cleaner.clean_object(object)).to eq({ events: { metaData: { foo: '[FILTERED]' } } })
-
-      configuration = Bugsnag::Configuration.new
-      configuration.meta_data_filters = [/fb+/]
-
-      cleaner = Bugsnag::Cleaner.new(configuration)
-      expect(cleaner.clean_object(object)).to eq({ events: { metaData: { foo: 'bar' } } })
-    end
-
-    it "filters deeply nested keys" do
-      configuration = Bugsnag::Configuration.new
-      configuration.meta_data_filters = [/^foo\.bar/]
-
-      cleaner = Bugsnag::Cleaner.new(configuration)
-
-      params = { events: { metaData: { foo: { bar: 'baz' } } } }
-      expect(cleaner.clean_object(params)).to eq({ events: { metaData: { foo: { bar: '[FILTERED]' } } } })
-    end
-
-    it "filters deeply nested request parameters" do
-      configuration = Bugsnag::Configuration.new
-      configuration.meta_data_filters = [/^foo\.bar/]
-
-      cleaner = Bugsnag::Cleaner.new(configuration)
-
-      params = { events: { metaData: { request: { params: { foo: { bar: 'baz' } } } } } }
-      expect(cleaner.clean_object(params)).to eq({ events: { metaData: { request: { params: { foo: { bar: '[FILTERED]' } } } } } })
-    end
-
-    it "doesn't filter by string inclusion when the scope is not in 'scopes_to_filter'" do
-      object = { foo: 'bar' }
-
-      configuration = Bugsnag::Configuration.new
-      configuration.meta_data_filters = ['f']
-
-      cleaner = Bugsnag::Cleaner.new(configuration)
-
-      expect(cleaner.clean_object(object)).to eq({ foo: 'bar' })
-
-      configuration = Bugsnag::Configuration.new
-      configuration.meta_data_filters = ['b']
-
-      cleaner = Bugsnag::Cleaner.new(configuration)
-
-      expect(cleaner.clean_object(object)).to eq({ foo: 'bar' })
-    end
-
-    it "doesn't filter by regular expression when the scope is not in 'scopes_to_filter'" do
-      object = { foo: 'bar' }
-
-      configuration = Bugsnag::Configuration.new
-      configuration.meta_data_filters = [/fb?/]
-
-      cleaner = Bugsnag::Cleaner.new(configuration)
-
-      expect(cleaner.clean_object(object)).to eq({ foo: 'bar' })
-
-      configuration = Bugsnag::Configuration.new
-      configuration.meta_data_filters = [/fb+/]
-
-      cleaner = Bugsnag::Cleaner.new(configuration)
-
-      expect(cleaner.clean_object(object)).to eq({ foo: 'bar' })
-    end
-
-    it "doesn't filter deeply nested keys when the scope is not in 'scopes_to_filter'" do
-      params = { foo: { bar: 'baz' } }
-
-      configuration = Bugsnag::Configuration.new
-      configuration.meta_data_filters = [/^foo\.bar/]
-
-      cleaner = Bugsnag::Cleaner.new(configuration)
-
-      expect(cleaner.clean_object(params)).to eq({ foo: { bar: 'baz' } })
-    end
-
-    it "doesn't filter deeply nested request parameters when the scope is not in 'scopes_to_filter'" do
-      params = { request: { params: { foo: { bar: 'baz' } } } }
-
-      configuration = Bugsnag::Configuration.new
-      configuration.meta_data_filters = [/^foo\.bar/]
-
-      cleaner = Bugsnag::Cleaner.new(configuration)
-
-      expect(cleaner.clean_object(params)).to eq({ request: { params: { foo: { bar: 'baz' } } } })
-    end
-
-    it "filters objects which can't be stringified" do
-      class StringRaiser
-        def to_s
-          raise 'Oh no you do not!'
-        end
-      end
-      expect(subject.clean_object({ :foo => StringRaiser.new })).to eq({ :foo => '[RAISED]' })
-    end
-  end
-
-  describe "#clean_url" do
-    let(:filters) { [] }
-
-    subject do
-      configuration = Bugsnag::Configuration.new
-      configuration.meta_data_filters = filters
-      described_class.new(configuration).clean_url(url)
-    end
-
-    context "with no filters configured" do
-      let(:url) { "/dir/page?param1=value1&param2=value2" }
-      it { should eq "/dir/page?param1=value1&param2=value2" }
-    end
-
-    context "with no get params" do
-      let(:url) { "/dir/page" }
-      it { should eq "/dir/page" }
-    end
-
-    context "with no matching parameters" do
-      let(:filters) { ["param3"] }
-      let(:url) { "/dir/page?param1=value1&param2=value2" }
-      it { should eq "/dir/page?param1=value1&param2=value2" }
-    end
-
-    context "with a single matching parameter" do
-      let(:filters) { ["param1"] }
-      let(:url) { "/dir/page?param1=value1&param2=value2" }
-      it { should eq "/dir/page?param1=[FILTERED]&param2=value2" }
-    end
-
-    context "with partially matching parameters" do
-      let(:filters) { ["param"] }
-      let(:url) { "/dir/page?param1=value1&param2=value2&bla=yes" }
-      it { should eq "/dir/page?param1=[FILTERED]&param2=[FILTERED]&bla=yes" }
-    end
-
-    context "with multiple matching filters" do
-      let(:filters) { ["param1", "param2"] }
-      let(:url) { "/dir/page?param1=value1&param2=value2&param3=value3" }
-      it { should eq "/dir/page?param1=[FILTERED]&param2=[FILTERED]&param3=value3" }
-    end
-
-    context "with both string and regexp filters" do
-      let(:filters) { ["param1", /param2/] }
-      let(:url) { "/dir/page?param1=value1&param2=value2&param3=value3" }
-      it { should eq "/dir/page?param1=[FILTERED]&param2=[FILTERED]&param3=value3" }
-    end
-
-    context "with matching regexp filters" do
-      let(:filters) { [/\Aaccess_token\z/] }
-      let(:url) { "https://host.example/sessions?access_token=abc123" }
-      it { should eq "https://host.example/sessions?access_token=[FILTERED]" }
-    end
-
-    context "with partially-matching regexp filters" do
-      let(:filters) { [/token/] }
-      let(:url) { "https://host.example/sessions?access_token=abc123" }
-      it { should eq "https://host.example/sessions?access_token=[FILTERED]" }
-    end
-  end
-end

data/spec/configuration_spec.rb

@@ -1,445 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-describe Bugsnag::Configuration do
-  describe "delivery_method" do
-    it "should have the default delivery method" do
-      expect(subject.delivery_method).to eq(:thread_queue)
-    end
-
-    it "should have the defined delivery_method" do
-      subject.delivery_method = :test
-      expect(subject.delivery_method).to eq(:test)
-    end
-
-    it "should allow a new default delivery_method to be set" do
-      subject.default_delivery_method = :test
-      expect(subject.delivery_method).to eq(:test)
-    end
-
-    it "should allow the delivery_method to be set over a default" do
-      subject.default_delivery_method = :test
-      subject.delivery_method = :wow
-      expect(subject.delivery_method).to eq(:wow)
-    end
-  end
-
-  describe "#notify_endpoint" do
-    it "defaults to DEFAULT_NOTIFY_ENDPOINT" do
-      expect(subject.notify_endpoint).to eq(Bugsnag::Configuration::DEFAULT_NOTIFY_ENDPOINT)
-    end
-
-    it "is readonly" do
-      expect{ subject.notify_endpoint = "My Custom Url" }.to raise_error(NoMethodError)
-    end
-
-    it "is the same as endpoint" do
-      expect(subject.notify_endpoint).to equal(subject.endpoint)
-    end
-  end
-
-  describe "#session_endpoint" do
-    it "defaults to DEFAULT_SESSION_ENDPOINT" do
-      expect(subject.session_endpoint).to eq(Bugsnag::Configuration::DEFAULT_SESSION_ENDPOINT)
-    end
-  end
-
-  describe "#auto_capture_sessions" do
-    it "defaults to true" do
-      expect(subject.auto_capture_sessions).to eq(true)
-    end
-  end
-
-  describe "#enable_sessions" do
-    it "defaults to true" do
-      expect(subject.enable_sessions).to eq(true)
-    end
-
-    it "is readonly" do
-      expect{ subject.enable_sessions = true }.to raise_error(NoMethodError)
-    end
-  end
-
-  describe "#endpoint=" do
-    let(:custom_notify_endpoint) { "My custom notify endpoint" }
-    let(:session_endpoint) { "My session endpoint" }
-    it "calls #warn with a deprecation notice" do
-      allow(subject).to receive(:set_endpoints)
-      expect(subject).to receive(:warn).with("The 'endpoint' configuration option is deprecated. The 'set_endpoints' method should be used instead")
-      subject.endpoint = custom_notify_endpoint
-    end
-
-    it "calls #set_endpoints with the new notify_endpoint and existing session endpoint" do
-      allow(subject).to receive(:session_endpoint).and_return(session_endpoint)
-      allow(subject).to receive(:warn)
-      expect(subject).to receive(:set_endpoints).with(custom_notify_endpoint, session_endpoint)
-      subject.endpoint = custom_notify_endpoint
-    end
-  end
-
-  describe "#session_endpoint=" do
-    let(:notify_endpoint) { "My notify endpoint" }
-    let(:custom_session_endpoint) { "My custom session endpoint" }
-    it "calls #warn with a deprecation notice" do
-      allow(subject).to receive(:set_endpoints)
-      expect(subject).to receive(:warn).with("The 'session_endpoint' configuration option is deprecated. The 'set_endpoints' method should be used instead")
-      subject.session_endpoint = custom_session_endpoint
-    end
-
-    it "calls #set_endpoints with the existing notify_endpoint and new session endpoint" do
-      allow(subject).to receive(:notify_endpoint).and_return(notify_endpoint)
-      allow(subject).to receive(:warn)
-      expect(subject).to receive(:set_endpoints).with(notify_endpoint, custom_session_endpoint)
-      subject.session_endpoint = custom_session_endpoint
-    end
-  end
-
-  describe "#set_endpoints" do
-    let(:custom_notify_endpoint) { "My custom notify endpoint" }
-    let(:custom_session_endpoint) { "My custom session endpoint" }
-    it "set notify_endpoint and session_endpoint" do
-      subject.set_endpoints(custom_notify_endpoint, custom_session_endpoint)
-      expect(subject.notify_endpoint).to eq(custom_notify_endpoint)
-      expect(subject.session_endpoint).to eq(custom_session_endpoint)
-    end
-  end
-
-  describe "#disable_sessions" do
-    it "sets #send_session and #auto_capture_sessions to false" do
-      subject.disable_sessions
-      expect(subject.auto_capture_sessions).to be false
-      expect(subject.enable_sessions).to be false
-    end
-  end
-
-  describe "set_proxy" do
-    it "defaults proxy settings to nil" do
-      expect(subject.proxy_host).to be nil
-      expect(subject.proxy_port).to be nil
-      expect(subject.proxy_user).to be nil
-      expect(subject.proxy_password).to be nil
-    end
-
-    it "allows proxy settings to be set directly" do
-      subject.proxy_host = "http://localhost"
-      subject.proxy_port = 34000
-      subject.proxy_user = "user"
-      subject.proxy_password = "password"
-      expect(subject.proxy_host).to eq("http://localhost")
-      expect(subject.proxy_port).to eq(34000)
-      expect(subject.proxy_user).to eq("user")
-      expect(subject.proxy_password).to eq("password")
-    end
-
-    it "parses a uri if provided" do
-      subject.parse_proxy("http://user:password@localhost:34000")
-      expect(subject.proxy_host).to eq("localhost")
-      expect(subject.proxy_port).to eq(34000)
-      expect(subject.proxy_user).to eq("user")
-      expect(subject.proxy_password).to eq("password")
-    end
-
-    it "automatically parses http_proxy environment variable" do
-      ENV['http_proxy'] = "http://user:password@localhost:34000"
-      expect(subject.proxy_host).to eq("localhost")
-      expect(subject.proxy_port).to eq(34000)
-      expect(subject.proxy_user).to eq("user")
-      expect(subject.proxy_password).to eq("password")
-    end
-
-    it "automatically parses https_proxy environment variable" do
-      ENV['https_proxy'] = "https://user:password@localhost:34000"
-      expect(subject.proxy_host).to eq("localhost")
-      expect(subject.proxy_port).to eq(34000)
-      expect(subject.proxy_user).to eq("user")
-      expect(subject.proxy_password).to eq("password")
-    end
-
-    after do
-      ENV['http_proxy'] = nil
-      ENV['https_proxy'] = nil
-    end
-  end
-
-  describe "#hostname" do
-    it "has a default value" do
-      expect(subject.hostname.length).to be > 0
-    end
-
-    it "has a value set by Socket" do
-      expect(subject.hostname).to eq(Socket.gethostname)
-    end
-
-    it "has a value set by DYNO environment variable" do
-      ENV['DYNO'] = 'localhost'
-      expect(subject.hostname).to eq("localhost")
-    end
-
-    after do
-      ENV['DYNO'] = nil
-    end
-  end
-
-  describe "#runtime_versions" do
-    it "has a default value" do
-      expect(subject.runtime_versions.length).to be > 0
-      expect(subject.runtime_versions["ruby"]).to eq(RUBY_VERSION)
-    end
-
-    it "has a settable value" do
-      subject.runtime_versions["ruby"] = '9.9.9'
-      expect(subject.runtime_versions["ruby"]).to eq('9.9.9')
-    end
-  end
-
-  describe "logger" do
-    class TestLogger
-      attr_accessor :logs
-
-      def initialize
-        @logs = []
-      end
-
-      def log(level, name, &block)
-        message = block.call
-        @logs << {
-          :level => level,
-          :name => name,
-          :message => message
-        }
-      end
-
-      def info(name, &block)
-        log('info', name, &block)
-      end
-
-      def warn(name, &block)
-        log('warning', name, &block)
-      end
-
-      def debug(name, &block)
-        log('debug', name, &block)
-      end
-    end
-
-    before do
-      @logger = TestLogger.new
-      Bugsnag.configure do |bugsnag|
-        bugsnag.logger = @logger
-      end
-    end
-
-    context "using configure" do
-      before do
-        Bugsnag.configuration.api_key = nil
-        Bugsnag.instance_variable_set("@key_warning", nil)
-        ENV['BUGSNAG_API_KEY'] = nil
-        expect(@logger.logs.size).to eq(0)
-      end
-
-      context "API key is not specified" do
-        it "skips logging a warning if validate_api_key is false" do
-          Bugsnag.configure(false)
-          expect(@logger.logs.size).to eq(0)
-        end
-
-        it "logs a warning by default" do
-          Bugsnag.configure
-          expect(@logger.logs.size).to eq(1)
-          log = @logger.logs.first
-          expect(log).to eq({
-            :level => "warning",
-            :name => "[Bugsnag]",
-            :message => "No valid API key has been set, notifications will not be sent"
-          })
-        end
-
-        it "logs a warning if validate_api_key is true" do
-          Bugsnag.configure(true)
-          expect(@logger.logs.size).to eq(1)
-          log = @logger.logs.first
-          expect(log).to eq({
-            :level => "warning",
-            :name => "[Bugsnag]",
-            :message => "No valid API key has been set, notifications will not be sent"
-          })
-        end
-      end
-
-      context "API key is set" do
-        it "skips logging a warning when configuring with an API key" do
-          Bugsnag.configure do |config|
-            config.api_key = 'd57a2472bd130ac0ab0f52715bbdc600'
-          end
-          expect(@logger.logs.size).to eq(0)
-        end
-
-        it "logs a warning if the configured API key is invalid" do
-          Bugsnag.configure do |config|
-            config.api_key = 'WARNING: not a real key'
-          end
-          expect(@logger.logs.size).to eq(1)
-          log = @logger.logs.first
-          expect(log).to eq({
-            :level => "warning",
-            :name => "[Bugsnag]",
-            :message => "No valid API key has been set, notifications will not be sent"
-          })
-        end
-      end
-    end
-
-    it "should log info messages to the set logger" do
-      expect(@logger.logs.size).to eq(0)
-      Bugsnag.configuration.info("Info message")
-      expect(@logger.logs.size).to eq(1)
-      log = @logger.logs.first
-      expect(log).to eq({
-        :level => "info",
-        :name => "[Bugsnag]",
-        :message => "Info message"
-      })
-    end
-
-    it "should log warning messages to the set logger" do
-      expect(@logger.logs.size).to eq(0)
-      Bugsnag.configuration.warn("Warning message")
-      expect(@logger.logs.size).to eq(1)
-      log = @logger.logs.first
-      expect(log).to eq({
-        :level => "warning",
-        :name => "[Bugsnag]",
-        :message => "Warning message"
-      })
-    end
-
-    it "should log debug messages to the set logger" do
-      expect(@logger.logs.size).to eq(0)
-      Bugsnag.configuration.debug("Debug message")
-      expect(@logger.logs.size).to eq(1)
-      log = @logger.logs.first
-      expect(log).to eq({
-        :level => "debug",
-        :name => "[Bugsnag]",
-        :message => "Debug message"
-      })
-    end
-
-    after do
-      Bugsnag.configure do |bugsnag|
-        bugsnag.logger = Logger.new(StringIO.new)
-      end
-    end
-  end
-
-  it "should have exit exception classes in ignore_classes by default" do
-    expect(subject.ignore_classes).to eq(Set.new([SystemExit, SignalException]))
-  end
-
-  it "should have nothing in discard_classes by default" do
-    expect(subject.discard_classes).to eq(Set.new([]))
-  end
-
-  describe "#breadcrumbs" do
-    it "first returns a new circular buffer" do
-      buffer = subject.breadcrumbs
-
-      expect(buffer).to be_a(Bugsnag::Utility::CircularBuffer)
-      expect(buffer.to_a).to eq([])
-    end
-
-    it "returns the same buffer in repeated calls" do
-      buffer = subject.breadcrumbs
-      buffer << 1
-      second_buffer = subject.breadcrumbs
-
-      expect(second_buffer.to_a).to eq([1])
-    end
-
-    it "returns a different buffer on different threads" do
-      buffer = subject.breadcrumbs
-      buffer << 1
-
-      second_buffer = nil
-      Thread.new { second_buffer = subject.breadcrumbs; second_buffer << 2 }.join
-
-      expect(buffer.to_a).to eq([1])
-      expect(second_buffer.to_a).to eq([2])
-    end
-
-    it "sets max_items to the current max_breadcrumbs size" do
-      expect(subject.breadcrumbs.max_items).to eq(subject.max_breadcrumbs)
-    end
-  end
-
-  describe "#max_breadcrumbs" do
-    it "defaults to DEFAULT_MAX_BREADCRUMBS" do
-      expect(subject.max_breadcrumbs).to eq(Bugsnag::Configuration::DEFAULT_MAX_BREADCRUMBS)
-    end
-  end
-
-  describe "#max_breadcrumbs=" do
-    it "sets the value of max_breadcrumbs" do
-      subject.max_breadcrumbs = 10
-      expect(subject.max_breadcrumbs).to eq(10)
-    end
-
-    it "sets the max_items property of the breadcrumbs buffer" do
-      buffer = subject.breadcrumbs
-
-      expect(buffer.max_items).to eq(Bugsnag::Configuration::DEFAULT_MAX_BREADCRUMBS)
-
-      subject.max_breadcrumbs = 5
-
-      expect(buffer.max_items).to eq(5)
-    end
-  end
-
-  describe "#enabled_automatic_breadcrumb_types" do
-    it "defaults to Bugsnag::Breadcrumbs::VALID_BREADCRUMB_TYPES" do
-      expect(subject.enabled_automatic_breadcrumb_types).to eq(Bugsnag::Breadcrumbs::VALID_BREADCRUMB_TYPES)
-    end
-
-    it "is an editable array" do
-      subject.enabled_automatic_breadcrumb_types << "Some custom type"
-      expect(subject.enabled_automatic_breadcrumb_types).to include("Some custom type")
-    end
-  end
-
-  describe "#before_breadcrumb_callbacks" do
-    it "initially returns an empty array" do
-      expect(subject.before_breadcrumb_callbacks).to eq([])
-    end
-
-    it "stores the array between subsequent calls" do
-      first_call = subject.before_breadcrumb_callbacks
-      first_call << 1
-
-      second_call = subject.before_breadcrumb_callbacks
-
-      expect(second_call).to eq([1])
-    end
-
-    it "stays the same across threads" do
-      first_array = subject.before_breadcrumb_callbacks
-      first_array << 1
-
-      second_array = nil
-      Thread.new { second_array = subject.before_breadcrumb_callbacks; second_array << 2}.join
-
-      expect(first_array).to eq([1, 2])
-      expect(second_array).to eq([1, 2])
-    end
-  end
-
-  describe "#vendor_path" do
-    it "returns the default vendor path" do
-      expect(subject.vendor_path).to eq(Bugsnag::Configuration::DEFAULT_VENDOR_PATH)
-    end
-
-    it "returns the defined vendor path" do
-      subject.vendor_path = /foo/
-      expect(subject.vendor_path).to eq(/foo/)
-    end
-  end
-end