RubyGems - bugsnag - Versions diffs - 6.15.0 → 6.16.0 - Mend

bugsnag 6.15.0 → 6.16.0

Files changed (646) hide show

@@ -1,23 +0,0 @@
-require 'fileutils'
-def install_fixture_gems
-  throw Error.new("Bugsnag.gem not found. Is this running in a docker-container?") unless File.exist?("/app/bugsnag.gem")
-  Dir.entries('features/fixtures').reject { |entry| ['.', '..'].include?(entry) }.each do |entry|
-    target_dir = "features/fixtures/#{entry}"
-    if File.directory?(target_dir)
-      `cp /app/bugsnag.gem #{target_dir}`
-      `gem unpack #{target_dir}/bugsnag.gem --target #{target_dir}/temp-bugsnag-lib`
-    end
-  end
-end
-AfterConfiguration do |config|
-  install_fixture_gems
-end
-Before do
-  Docker.compose_project_name = "#{rand.to_s}:#{Time.new.strftime("%s")}"
-  Runner.environment.clear
-  Runner.environment["BUGSNAG_API_KEY"] = $api_key
-  Runner.environment["BUGSNAG_ENDPOINT"] = "http://maze-runner:#{MOCK_API_PORT}"
-end

data/issue_template.md DELETED

@@ -1,48 +0,0 @@
-### Description
-<!-- A quick description of what you're trying to accomplish -->
-### Issue
-<!--
-  What went wrong? (If this issue is a general question or a proposed change,
-  feel free to delete this and subsequent sections.
--->
-### Environment
-Library versions:
-<!--
-  Paste the output of this command into the code block below:
-    bundle list | grep -E "(bugsnag|rails|sidekiq|que|sinatra|resque|shoryuken|mailman|delayed_job)"
--->
-```
-```
-- OS / OS version:
-- debug mode or production?:
-<!--
-  Below are a few approaches you might take to communicate the issue, in
-  descending order of awesomeness. Please choose one and feel free to delete
-  the others from this template.
--->
-### Example Repo
-- [ ] Create a minimal repository that can reproduce the issue after running
-  `bundle install` and `rackup` (or `rails server`, or `ruby some-script.rb`,
-  etc)
-- [ ] Link to it here:
-### Example code snippet
-```ruby
-require 'bugsnag'
-# (Insert code sample to reproduce the problem)
-```
-<!-- Error messages, if any -->
-```
-```

data/spec/breadcrumbs/breadcrumb_spec.rb DELETED

@@ -1,93 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-require 'bugsnag/breadcrumbs/breadcrumb'
-RSpec.describe Bugsnag::Breadcrumbs::Breadcrumb do
-  describe "#name" do
-    it "is assigned in #initialize" do
-      breadcrumb = Bugsnag::Breadcrumbs::Breadcrumb.new("my message", nil, nil, nil)
-      expect(breadcrumb.name).to eq("my message")
-    end
-  end
-  describe "#type" do
-    it "is assigned in #initialize" do
-      breadcrumb = Bugsnag::Breadcrumbs::Breadcrumb.new(nil, "test type", nil, nil)
-      expect(breadcrumb.type).to eq("test type")
-    end
-  end
-  describe "#meta_data" do
-    it "is assigned in #initialize" do
-      breadcrumb = Bugsnag::Breadcrumbs::Breadcrumb.new(nil, nil, {:a => 1, :b => 2}, nil)
-      expect(breadcrumb.meta_data).to eq({:a => 1, :b => 2})
-    end
-  end
-  describe "#auto" do
-    it "defaults to false" do
-      breadcrumb = Bugsnag::Breadcrumbs::Breadcrumb.new(nil, nil, nil, nil)
-      expect(breadcrumb.auto).to eq(false)
-    end
-    it "is true if auto argument == :auto" do
-      breadcrumb = Bugsnag::Breadcrumbs::Breadcrumb.new(nil, nil, nil, :auto)
-      expect(breadcrumb.auto).to eq(true)
-    end
-    it "is false if auto argument is anything else" do
-      breadcrumb = Bugsnag::Breadcrumbs::Breadcrumb.new(nil, nil, nil, :manual)
-      expect(breadcrumb.auto).to eq(false)
-    end
-  end
-  describe "#timestamp" do
-    it "is stored as a timestamp" do
-      breadcrumb = Bugsnag::Breadcrumbs::Breadcrumb.new(nil, nil, nil, nil)
-      expect(breadcrumb.timestamp).to be_within(0.5).of Time.now.utc
-    end
-  end
-  describe "#ignore?" do
-    it "is not true by default" do
-      breadcrumb = Bugsnag::Breadcrumbs::Breadcrumb.new("my message", "test type", {:a => 1, :b => 2}, :manual)
-      expect(breadcrumb.ignore?).to eq(false)
-    end
-    it "is able to be set" do
-      breadcrumb = Bugsnag::Breadcrumbs::Breadcrumb.new("my message", "test type", {:a => 1, :b => 2}, :manual)
-      breadcrumb.ignore!
-      expect(breadcrumb.ignore?).to eq(true)
-    end
-  end
-  describe "#to_h" do
-    it "outputs as a hash" do
-      breadcrumb = Bugsnag::Breadcrumbs::Breadcrumb.new("my message", "test type", {:a => 1, :b => 2}, :manual)
-      output = breadcrumb.to_h
-      timestamp_regex = /^\d{4}\-\d{2}\-\d{2}T\d{2}:\d{2}:[\d\.]+Z$/
-      expect(output).to match(
-        :name => "my message",
-        :type => "test type",
-        :metaData => {
-          :a => 1,
-          :b => 2
-        },
-        :timestamp => eq(breadcrumb.timestamp.iso8601)
-      )
-    end
-  end
-end

data/spec/breadcrumbs/validator_spec.rb DELETED

@@ -1,176 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-require 'bugsnag/breadcrumbs/breadcrumb'
-require 'bugsnag/breadcrumbs/validator'
-RSpec.describe Bugsnag::Breadcrumbs::Validator do
-  let(:enabled_automatic_breadcrumb_types) { Bugsnag::Breadcrumbs::VALID_BREADCRUMB_TYPES }
-  let(:auto) { false }
-  let(:name) { "Valid message" }
-  let(:type) { Bugsnag::Breadcrumbs::ERROR_BREADCRUMB_TYPE }
-  let(:meta_data) { {} }
-  describe "#validate" do
-    it "does not 'ignore!' a valid breadcrumb" do
-      config = instance_double(Bugsnag::Configuration)
-      allow(config).to receive(:enabled_automatic_breadcrumb_types).and_return(enabled_automatic_breadcrumb_types)
-      validator = Bugsnag::Breadcrumbs::Validator.new(config)
-      breadcrumb = instance_double(Bugsnag::Breadcrumbs::Breadcrumb, {
-        :auto => auto,
-        :name => name,
-        :type => type,
-        :meta_data => meta_data,
-        :meta_data= => nil
-      })
-      expect(breadcrumb).to_not receive(:ignore!)
-      expect(config).to_not receive(:debug)
-      validator.validate(breadcrumb)
-    end
-    describe "tests meta_data types" do
-      it "accepts Strings, Numerics, Booleans, & nil" do
-        config = instance_double(Bugsnag::Configuration)
-        allow(config).to receive(:enabled_automatic_breadcrumb_types).and_return(enabled_automatic_breadcrumb_types)
-        validator = Bugsnag::Breadcrumbs::Validator.new(config)
-        meta_data = {
-          :string => "This is a string",
-          :symbol => :this_is_a_symbol,
-          :integer => 12345,
-          :float => 12345.6789,
-          :false => false,
-          :true => true,
-          :nil => nil
-        }
-        breadcrumb = instance_double(Bugsnag::Breadcrumbs::Breadcrumb, {
-          :auto => auto,
-          :name => name,
-          :type => type,
-          :meta_data => meta_data,
-          :meta_data= => nil
-        })
-        expect(breadcrumb).to_not receive(:ignore!)
-        expect(config).to_not receive(:debug)
-        validator.validate(breadcrumb)
-      end
-      it "rejects Arrays, Hashes, and non-primitive objects" do
-        config = instance_double(Bugsnag::Configuration)
-        allow(config).to receive(:enabled_automatic_breadcrumb_types).and_return(enabled_automatic_breadcrumb_types)
-        validator = Bugsnag::Breadcrumbs::Validator.new(config)
-        class TestClass
-        end
-        meta_data = {
-          :fine => 1,
-          :array => [1, 2, 3],
-          :hash => {
-            :a => 1
-          },
-          :object => TestClass.new
-        }
-        breadcrumb = instance_double(Bugsnag::Breadcrumbs::Breadcrumb, {
-          :auto => auto,
-          :name => name,
-          :type => type,
-          :meta_data => meta_data
-        })
-        expect(breadcrumb).to_not receive(:ignore!)
-        expected_string_1 = "Breadcrumb #{breadcrumb.name} meta_data array:Array has been dropped for having an invalid data type"
-        expected_string_2 = "Breadcrumb #{breadcrumb.name} meta_data hash:Hash has been dropped for having an invalid data type"
-        expected_string_3 = "Breadcrumb #{breadcrumb.name} meta_data object:TestClass has been dropped for having an invalid data type"
-        expect(config).to receive(:debug).with(expected_string_1)
-        expect(config).to receive(:debug).with(expected_string_2)
-        expect(config).to receive(:debug).with(expected_string_3)
-        # Confirms that the meta_data is being filtered
-        expect(breadcrumb).to receive(:meta_data=).with({
-          :fine => 1
-        })
-        validator.validate(breadcrumb)
-      end
-    end
-    it "tests type, defaulting to 'manual' if invalid" do
-      config = instance_double(Bugsnag::Configuration)
-      allow(config).to receive(:enabled_automatic_breadcrumb_types).and_return(enabled_automatic_breadcrumb_types)
-      validator = Bugsnag::Breadcrumbs::Validator.new(config)
-      type = "Not a valid type"
-      breadcrumb = instance_double(Bugsnag::Breadcrumbs::Breadcrumb, {
-        :auto => auto,
-        :name => name,
-        :type => type,
-        :meta_data => meta_data,
-        :meta_data= => nil
-      })
-      expect(breadcrumb).to receive(:type=).with(Bugsnag::Breadcrumbs::MANUAL_BREADCRUMB_TYPE)
-      expect(breadcrumb).to_not receive(:ignore!)
-      expected_string = "Invalid type: #{type} for breadcrumb: #{breadcrumb.name}, defaulting to #{Bugsnag::Breadcrumbs::MANUAL_BREADCRUMB_TYPE}"
-      expect(config).to receive(:debug).with(expected_string)
-      validator.validate(breadcrumb)
-    end
-    describe "with enabled_automatic_breadcrumb_types set" do
-      it "rejects automatic breadcrumbs with rejected types" do
-        config = instance_double(Bugsnag::Configuration)
-        allowed_breadcrumb_types = []
-        allow(config).to receive(:enabled_automatic_breadcrumb_types).and_return(allowed_breadcrumb_types)
-        validator = Bugsnag::Breadcrumbs::Validator.new(config)
-        auto = true
-        type = Bugsnag::Breadcrumbs::ERROR_BREADCRUMB_TYPE
-        breadcrumb = instance_double(Bugsnag::Breadcrumbs::Breadcrumb, {
-          :auto => auto,
-          :name => name,
-          :type => type,
-          :meta_data => meta_data,
-          :meta_data= => nil
-        })
-        expect(breadcrumb).to receive(:ignore!)
-        expected_string = "Automatic breadcrumb of type #{Bugsnag::Breadcrumbs::ERROR_BREADCRUMB_TYPE} ignored: #{breadcrumb.name}"
-        expect(config).to receive(:debug).with(expected_string)
-        validator.validate(breadcrumb)
-      end
-      it "does not reject manual breadcrumbs with rejected types" do
-        config = instance_double(Bugsnag::Configuration)
-        allowed_breadcrumb_types = []
-        allow(config).to receive(:enabled_automatic_breadcrumb_types).and_return(allowed_breadcrumb_types)
-        validator = Bugsnag::Breadcrumbs::Validator.new(config)
-        type = Bugsnag::Breadcrumbs::ERROR_BREADCRUMB_TYPE
-        breadcrumb = instance_double(Bugsnag::Breadcrumbs::Breadcrumb, {
-          :auto => auto,
-          :name => name,
-          :type => type,
-          :meta_data => meta_data,
-          :meta_data= => nil
-        })
-        expect(breadcrumb).to_not receive(:ignore!)
-        expect(config).to_not receive(:debug)
-        validator.validate(breadcrumb)
-      end
-    end
-  end
-end

data/spec/bugsnag_spec.rb DELETED

@@ -1,366 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-describe Bugsnag do
-  let(:breadcrumbs) { Bugsnag.configuration.breadcrumbs }
-  let(:timestamp_regex) { /^\d{4}\-\d{2}\-\d{2}T\d{2}:\d{2}:[\d\.]+Z$/ }
-  describe 'notify' do
-    before do
-      Bugsnag.configuration.logger = spy('logger')
-    end
-    it 'does not log an error when sending valid arguments as auto_notify' do
-      notify_test_exception(true)
-      expect(Bugsnag.configuration.logger).to_not have_received(:warn)
-    end
-    it 'logs an error when sending invalid arguments as auto_notify' do
-      notify_test_exception({severity: 'info'})
-      expect(Bugsnag.configuration.logger).to have_received(:warn)
-    end
-    it 'leaves a breadcrumb after exception delivery' do
-      begin
-        1/0
-      rescue ZeroDivisionError => e
-        Bugsnag.notify(e)
-        sent_time = Time.now.utc
-      end
-      expect(breadcrumbs.to_a.size).to eq(1)
-      breadcrumb = breadcrumbs.to_a.first
-      expect(breadcrumb.name).to eq('ZeroDivisionError')
-      expect(breadcrumb.type).to eq(Bugsnag::Breadcrumbs::ERROR_BREADCRUMB_TYPE)
-      expect(breadcrumb.auto).to eq(true)
-      expect(breadcrumb.meta_data).to eq({
-        :error_class => 'ZeroDivisionError',
-        :message => 'divided by 0',
-        :severity => 'warning'
-      })
-      expect(breadcrumb.timestamp).to be_within(1).of(sent_time)
-    end
-    it 'leave a RuntimeError breadcrumb after string delivery' do
-      Bugsnag.notify('notified string')
-      sent_time = Time.now.utc
-      expect(breadcrumbs.to_a.size).to eq(1)
-      breadcrumb = breadcrumbs.to_a.first
-      expect(breadcrumb.name).to eq('RuntimeError')
-      expect(breadcrumb.type).to eq(Bugsnag::Breadcrumbs::ERROR_BREADCRUMB_TYPE)
-      expect(breadcrumb.auto).to eq(true)
-      expect(breadcrumb.meta_data).to eq({
-        :error_class => 'RuntimeError',
-        :message => 'notified string',
-        :severity => 'warning'
-      })
-      expect(breadcrumb.timestamp).to be_within(1).of(sent_time)
-    end
-  end
-  describe '#configure' do
-    it 'calls #check_endpoint_setup every time' do
-      expect(Bugsnag).to receive(:check_endpoint_setup).twice
-      Bugsnag.configure
-      Bugsnag.configure
-    end
-  end
-  describe '#check_endpoint_setup' do
-    let(:custom_notify_endpoint) { "Custom notify endpoint" }
-    let(:custom_session_endpoint) { "Custom session endpoint" }
-    it "does nothing for default endpoints or if both endpoints are set" do
-      expect(Bugsnag.configuration).not_to receive(:warn)
-      Bugsnag.send(:check_endpoint_setup)
-      Bugsnag.configuration.set_endpoints(custom_notify_endpoint, custom_session_endpoint)
-      Bugsnag.send(:check_endpoint_setup)
-    end
-    it "warns and disables sessions if a notify endpoint is set without a session endpoint" do
-      expect(Bugsnag.configuration).to receive(:warn).with("The session endpoint has not been set, all further session capturing will be disabled")
-      expect(Bugsnag.configuration).to receive(:disable_sessions)
-      Bugsnag.configuration.set_endpoints(custom_notify_endpoint, nil)
-      Bugsnag.send(:check_endpoint_setup)
-    end
-    it "raises an ArgumentError if a session endpoint is set without a notify endpoint" do
-      Bugsnag.configuration.set_endpoints(nil, "custom session endpoint")
-      expect{ Bugsnag.send(:check_endpoint_setup) }.to raise_error(ArgumentError, "The session endpoint cannot be modified without the notify endpoint")
-    end
-    it "is called after the configuration block has returned" do
-      expect(Bugsnag.configuration).to receive(:warn).with("The 'endpoint' configuration option is deprecated. The 'set_endpoints' method should be used instead").once
-      expect(Bugsnag.configuration).to receive(:warn).with("The 'session_endpoint' configuration option is deprecated. The 'set_endpoints' method should be used instead").once
-      expect(Bugsnag.configuration).not_to receive(:warn).with("The session endpoint has not been set, all further session capturing will be disabled")
-      Bugsnag.configure do |configuration|
-        configuration.endpoint = custom_notify_endpoint
-        configuration.session_endpoint = custom_session_endpoint
-      end
-    end
-  end
-  describe "add_exit_handler" do
-    before do
-      Bugsnag.instance_variable_set(:@exit_handler_added, false)
-    end
-    it "automatically adds an exit handler" do
-      expect(Bugsnag).to receive(:register_at_exit)
-      Bugsnag.configure do |conf|
-        conf.api_key = "TEST KEY"
-      end
-    end
-    it "calls at_exit when register_at_exit is called" do
-      expect(Bugsnag).to receive(:at_exit)
-      Bugsnag.register_at_exit
-    end
-    it "doesn't call at_exit on subsequent calls" do
-      expect(Bugsnag).to receive(:at_exit).once
-      Bugsnag.register_at_exit
-      Bugsnag.register_at_exit
-    end
-    context 'with aliased at_exit' do
-      before do
-        module Kernel
-          alias_method :old_at_exit, :at_exit
-          def at_exit
-            begin
-              raise BugsnagTestException.new("Oh no")
-            rescue
-              yield
-            end
-          end
-        end
-      end
-      it "sends an exception when at_exit is called" do
-        report_mock = double('report')
-        expect(report_mock).to receive(:severity=).with('error')
-        expect(report_mock).to receive(:severity_reason=).with({
-          :type => Bugsnag::Report::UNHANDLED_EXCEPTION
-        })
-        expect(Bugsnag).to receive(:notify).with(kind_of(BugsnagTestException), true).and_yield(report_mock)
-        Bugsnag.register_at_exit
-      end
-      after do
-        module Kernel
-          alias_method :at_exit, :old_at_exit
-        end
-      end
-    end
-  end
-  describe 'loading integrations' do
-    before do
-      module Kernel
-        REQUIRED = []
-        alias_method :old_require, :require
-        def require(path)
-          if path.include?("bugsnag/integrations/")
-            REQUIRED << path
-          else
-            old_require(path)
-          end
-        end
-      end
-    end
-    it 'attempts to load integrations' do
-      ENV["BUGSNAG_DISABLE_AUTOCONFIGURE"] = nil
-      load "./lib/bugsnag.rb"
-      Bugsnag::INTEGRATIONS.each do |integration|
-        expect(Kernel::REQUIRED).to include("bugsnag/integrations/#{integration}")
-      end
-    end
-    it 'does not load integrations when BUGSNAG_DISABLE_AUTOCONFIGURE is true' do
-      ENV["BUGSNAG_DISABLE_AUTOCONFIGURE"] = 'true'
-      load "./lib/bugsnag.rb"
-      expect(Kernel::REQUIRED).to eq(["bugsnag/integrations/rack"])
-    end
-    it 'loads all integrations if requested' do
-      Bugsnag.load_integrations
-      Bugsnag::INTEGRATIONS.each do |integration|
-        expect(Kernel::REQUIRED).to include("bugsnag/integrations/#{integration}")
-      end
-    end
-    Bugsnag::INTEGRATIONS.each do |integration|
-      it "loads #{integration}" do
-        Bugsnag.load_integration(integration)
-        expect(Kernel::REQUIRED).to include("bugsnag/integrations/#{integration}")
-      end
-    end
-    it 'loads railtie for rails' do
-      Bugsnag.load_integration(:rails)
-      expect(Kernel::REQUIRED).to include("bugsnag/integrations/railtie")
-    end
-    it 'loads railtie for railtie' do
-      Bugsnag.load_integration(:railtie)
-      expect(Kernel::REQUIRED).to include("bugsnag/integrations/railtie")
-    end
-    after do
-      module Kernel
-        alias_method :require, :old_require
-      end
-      Kernel.send(:remove_const, :REQUIRED)
-    end
-  end
-  describe ".leave_breadcrumb" do
-    it "requires only a name argument" do
-      Bugsnag.leave_breadcrumb("TestName")
-      expect(breadcrumbs.to_a.size).to eq(1)
-      expect(breadcrumbs.first.to_h).to match({
-        :name => "TestName",
-        :type => Bugsnag::Breadcrumbs::MANUAL_BREADCRUMB_TYPE,
-        :metaData => {},
-        :timestamp => match(timestamp_regex)
-      })
-    end
-    it "accepts meta_data" do
-      Bugsnag.leave_breadcrumb("TestName", { :a => 1, :b => "2" })
-      expect(breadcrumbs.to_a.size).to eq(1)
-      expect(breadcrumbs.first.to_h).to match({
-        :name => "TestName",
-        :type => Bugsnag::Breadcrumbs::MANUAL_BREADCRUMB_TYPE,
-        :metaData => { :a => 1, :b => "2" },
-        :timestamp => match(timestamp_regex)
-      })
-    end
-    it "allows different message types" do
-      Bugsnag.leave_breadcrumb("TestName", {}, Bugsnag::Breadcrumbs::ERROR_BREADCRUMB_TYPE)
-      expect(breadcrumbs.to_a.size).to eq(1)
-      expect(breadcrumbs.first.to_h).to match({
-        :name => "TestName",
-        :type => Bugsnag::Breadcrumbs::ERROR_BREADCRUMB_TYPE,
-        :metaData => {},
-        :timestamp => match(timestamp_regex)
-      })
-    end
-    it "validates before leaving" do
-      Bugsnag.leave_breadcrumb(
-        "123123123123123123123123123123456456456456456456456456456456",
-        {
-          :a => 1,
-          :b => [1, 2, 3, 4],
-          :c => {
-            :test => true,
-            :test2 => false
-          }
-        },
-        "Not a real type"
-      )
-      expect(breadcrumbs.to_a.size).to eq(1)
-      expect(breadcrumbs.first.to_h).to match({
-        :name => "123123123123123123123123123123456456456456456456456456456456",
-        :type => Bugsnag::Breadcrumbs::MANUAL_BREADCRUMB_TYPE,
-        :metaData => {
-          :a => 1
-        },
-        :timestamp => match(timestamp_regex)
-      })
-    end
-    it "runs callbacks before leaving" do
-      Bugsnag.configuration.before_breadcrumb_callbacks << Proc.new do |breadcrumb|
-        breadcrumb.meta_data = {
-          :callback => true
-        }
-      end
-      Bugsnag.leave_breadcrumb("TestName")
-      expect(breadcrumbs.to_a.size).to eq(1)
-      expect(breadcrumbs.first.to_h).to match({
-        :name => "TestName",
-        :type => Bugsnag::Breadcrumbs::MANUAL_BREADCRUMB_TYPE,
-        :metaData => {
-          :callback => true
-        },
-        :timestamp => match(timestamp_regex)
-      })
-    end
-    it "validates after callbacks" do
-      Bugsnag.configuration.before_breadcrumb_callbacks << Proc.new do |breadcrumb|
-        breadcrumb.meta_data = {
-          :int => 1,
-          :array => [1, 2, 3],
-          :hash => {
-            :a => 1,
-            :b => 2
-          }
-        }
-        breadcrumb.type = "Not a real type"
-        breadcrumb.name = "123123123123123123123123123123456456456456456"
-      end
-      Bugsnag.leave_breadcrumb("TestName")
-      expect(breadcrumbs.to_a.size).to eq(1)
-      expect(breadcrumbs.first.to_h).to match({
-        :name => "123123123123123123123123123123456456456456456",
-        :type => Bugsnag::Breadcrumbs::MANUAL_BREADCRUMB_TYPE,
-        :metaData => {
-          :int => 1
-        },
-        :timestamp => match(timestamp_regex)
-      })
-    end
-    it "doesn't add when ignored by the validator" do
-      Bugsnag.configuration.enabled_automatic_breadcrumb_types = []
-      Bugsnag.leave_breadcrumb("TestName", {}, Bugsnag::Breadcrumbs::ERROR_BREADCRUMB_TYPE, :auto)
-      expect(breadcrumbs.to_a.size).to eq(0)
-    end
-    it "doesn't add if ignored in a callback" do
-      Bugsnag.configuration.before_breadcrumb_callbacks << Proc.new do |breadcrumb|
-        breadcrumb.ignore!
-      end
-      Bugsnag.leave_breadcrumb("TestName")
-      expect(breadcrumbs.to_a.size).to eq(0)
-    end
-    it "doesn't add when ignored after the callbacks" do
-      Bugsnag.configuration.enabled_automatic_breadcrumb_types = [
-        Bugsnag::Breadcrumbs::MANUAL_BREADCRUMB_TYPE
-      ]
-      Bugsnag.configuration.before_breadcrumb_callbacks << Proc.new do |breadcrumb|
-        breadcrumb.type = Bugsnag::Breadcrumbs::ERROR_BREADCRUMB_TYPE
-      end
-      Bugsnag.leave_breadcrumb("TestName", {}, Bugsnag::Breadcrumbs::MANUAL_BREADCRUMB_TYPE, :auto)
-      expect(breadcrumbs.to_a.size).to eq(0)
-    end
-    it "doesn't call callbacks if ignored early" do
-      Bugsnag.configuration.enabled_automatic_breadcrumb_types = []
-      Bugsnag.configuration.before_breadcrumb_callbacks << Proc.new do |breadcrumb|
-        fail "This shouldn't be called"
-      end
-      Bugsnag.leave_breadcrumb("TestName", {}, Bugsnag::Breadcrumbs::ERROR_BREADCRUMB_TYPE, :auto)
-    end
-    it "doesn't continue to call callbacks if ignored in them" do
-      Bugsnag.configuration.before_breadcrumb_callbacks << Proc.new do |breadcrumb|
-        breadcrumb.ignore!
-      end
-      Bugsnag.configuration.before_breadcrumb_callbacks << Proc.new do |breadcrumb|
-        fail "This shouldn't be called"
-      end
-      Bugsnag.leave_breadcrumb("TestName")
-    end
-  end
-end