bugsnag 6.15.0 → 6.20.0

data/spec/middleware_spec.rb

@@ -1,254 +0,0 @@
-require 'spec_helper'
-require 'fixtures/middleware/public_info_setter'
-require 'fixtures/middleware/internal_info_setter'
-
-describe Bugsnag::MiddlewareStack do
-  it "runs before_bugsnag_notify callbacks, adding a tab" do
-    callback_run_count = 0
-    Bugsnag.before_notify_callbacks << lambda {|notif|
-      notif.add_tab(:some_tab, {
-        :info => "here",
-        :data => "also here"
-      })
-      callback_run_count += 1
-    }
-
-    Bugsnag.notify(BugsnagTestException.new("It crashed"))
-    expect(callback_run_count).to eq(1)
-
-    expect(Bugsnag).to have_sent_notification{ |payload, headers|
-      event = get_event_from_payload(payload)
-      expect(event["metaData"]["some_tab"]).not_to be_nil
-      expect(event["metaData"]["some_tab"]["info"]).to eq("here")
-      expect(event["metaData"]["some_tab"]["data"]).to eq("also here")
-    }
-
-  end
-
-  it "runs before_bugsnag_notify callbacks, adding custom data" do
-    callback_run_count = 0
-    Bugsnag.before_notify_callbacks << lambda {|notif|
-      notif.add_tab(:custom, {info: "here"})
-      notif.add_tab(:custom, {data: "also here"})
-
-      callback_run_count += 1
-    }
-
-    Bugsnag.notify(BugsnagTestException.new("It crashed"))
-    expect(callback_run_count).to eq(1)
-
-    expect(Bugsnag).to have_sent_notification{ |payload, headers|
-      event = get_event_from_payload(payload)
-      expect(event["metaData"]["custom"]).not_to be_nil
-      expect(event["metaData"]["custom"]["info"]).to eq("here")
-      expect(event["metaData"]["custom"]["data"]).to eq("also here")
-    }
-
-  end
-
-  it "runs before_bugsnag_notify callbacks, setting the user" do
-    callback_run_count = 0
-    Bugsnag.before_notify_callbacks << lambda {|notif|
-      notif.user = {:id => "here", :email => "also here", :name => "also here too", :random_key => "also here too too"}
-      callback_run_count += 1
-    }
-
-    Bugsnag.notify(BugsnagTestException.new("It crashed"))
-    expect(callback_run_count).to eq(1)
-
-    expect(Bugsnag).to have_sent_notification{ |payload, headers|
-      event = get_event_from_payload(payload)
-      expect(event["user"]).not_to be_nil
-      expect(event["user"]["id"]).to eq("here")
-      expect(event["user"]["email"]).to eq("also here")
-      expect(event["user"]["name"]).to eq("also here too")
-      expect(event["user"]["random_key"]).to eq("also here too too")
-    }
-
-  end
-
-  it "allows block to override values set by internal middleware" do
-    Bugsnag.configuration.internal_middleware.use(InternalInfoSetter)
-    Bugsnag.notify(BugsnagTestException.new("It crashed")) do |report|
-      report.meta_data.merge!({custom: {info: 'overridden'}})
-    end
-
-    expect(Bugsnag).to have_sent_notification{ |payload, headers|
-      event = get_event_from_payload(payload)
-      expect(event["metaData"]["custom"]).not_to be_nil
-      expect(event["metaData"]["custom"]["info"]).to eq("overridden")
-    }
-  end
-
-  it "allows block to override public middleware" do
-    Bugsnag.configuration.middleware.use(PublicInfoSetter)
-
-    Bugsnag.notify(BugsnagTestException.new("It crashed")) do |report|
-      report.meta_data.merge!({custom: {info: 'overridden'}})
-    end
-
-    expect(Bugsnag).to have_sent_notification{ |payload, headers|
-      event = get_event_from_payload(payload)
-      expect(event["metaData"]["custom"]).not_to be_nil
-      expect(event["metaData"]["custom"]["info"]).to eq("overridden")
-    }
-  end
-
-  it "does not have have before callbacks by default" do
-    expect(Bugsnag.before_notify_callbacks.size).to eq(0)
-    Bugsnag.notify(BugsnagTestException.new("It crashed"))
-    expect(Bugsnag).to have_sent_notification{ |payload, headers|
-      event = get_event_from_payload(payload)
-      expect(event["metaData"].size).to eq(0)
-    }
-  end
-
-  it "does not execute disabled bugsnag middleware" do
-    callback_run_count = 0
-    Bugsnag.configure do |config|
-      config.middleware.disable(Bugsnag::Middleware::Callbacks)
-    end
-
-    Bugsnag.before_notify_callbacks << lambda {|notif|
-      callback_run_count += 1
-    }
-
-    Bugsnag.notify(BugsnagTestException.new("It crashed"))
-    expect(callback_run_count).to eq(0)
-  end
-
-  it "does not notify if a callback told so" do
-    Bugsnag.before_notify_callbacks << lambda do |notif|
-      notif.ignore!
-    end
-    Bugsnag.notify(BugsnagTestException.new("It crashed"))
-    expect(Bugsnag).not_to have_sent_notification
-  end
-
-  it "allows inspection of meta_data before ignoring exception" do
-    # Use before notify callbacks as only the callback based metadata is
-    # available to before_notify_callbacks
-    Bugsnag.before_notify_callbacks << lambda do |notif|
-      notif.add_tab(:sidekiq, {:retry_count => 4})
-    end
-
-    Bugsnag.before_notify_callbacks << lambda do |notif|
-      notif.ignore! if notif.meta_data[:sidekiq][:retry_count] > 3
-    end
-
-    Bugsnag.notify(BugsnagTestException.new("It crashed"))
-    expect(Bugsnag).not_to have_sent_notification
-
-  end
-
-  it "allows meta_data to be modified in a middleware" do
-    MetaDataAdder = Class.new do
-      def initialize(bugsnag)
-        @bugsnag = bugsnag
-      end
-
-      def call(report)
-        report.meta_data = {test: {value: "abcdef123456abcdef123456abcdef123456"}}
-        @bugsnag.call(report)
-      end
-    end
-
-    MetaDataMunger = Class.new do
-      def initialize(bugsnag)
-        @bugsnag = bugsnag
-      end
-
-      def call(report)
-        token = report.meta_data[:test][:value]
-        report.meta_data[:test][:value] = "#{token[0...6]}*****#{token[-4..-1]}"
-        @bugsnag.call(report)
-      end
-    end
-
-    Bugsnag.configure do |c|
-      c.middleware.use MetaDataAdder
-      c.middleware.use MetaDataMunger
-    end
-
-    Bugsnag.notify(BugsnagTestException.new("It crashed"))
-
-    expect(Bugsnag).to have_sent_notification{ |payload, headers|
-      event = get_event_from_payload(payload)
-      expect(event["metaData"]['test']['value']).to eq("abcdef*****3456")
-    }
-  end
-
-  if ruby_version_greater_equal?("2.3.0")
-    context "with a ruby version >= 2.3.0" do
-      it "attaches did you mean metadata when necessary" do
-        begin
-          "Test".prepnd "T"
-        rescue Exception => e
-          Bugsnag.notify(e)
-        end
-
-        expect(Bugsnag).to have_sent_notification{ |payload, headers|
-          event = get_event_from_payload(payload)
-          expect(event["metaData"]["error"]).to_not be_nil
-          expect(event["metaData"]["error"]).to eq({"suggestion" => "prepend"})
-        }
-      end
-    end
-  end
-
-  context "with a ruby version < 2.3.0" do
-    if !ruby_version_greater_equal?("2.3.0")
-      it "doesn't attach did you mean metadata" do
-        begin
-          "Test".prepnd "T"
-        rescue Exception => e
-          Bugsnag.notify(e)
-        end
-
-        expect(Bugsnag).to have_sent_notification{ |payload, headers|
-          event = get_event_from_payload(payload)
-          expect(event["metaData"]["error"]).to be_nil
-        }
-      end
-    end
-  end
-
-  it "doesn't allow handledState properties to be changed in middleware" do
-    HandledStateChanger = Class.new do
-      def initialize(bugsnag)
-        @bugsnag = bugsnag
-      end
-
-      def call(report)
-        report.severity_reason = {
-          :test => "test"
-        }
-        @bugsnag.call(report)
-      end
-    end
-
-    Bugsnag.configure do |c|
-      c.middleware.use HandledStateChanger
-    end
-
-    Bugsnag.notify(BugsnagTestException.new("It crashed"), true) do |report|
-      report.severity_reason = {
-        :type => "middleware_handler",
-        :attributes => {
-          :name => "middleware_test"
-        }
-      }
-    end
-
-    expect(Bugsnag).to have_sent_notification{ |payload, headers|
-      event = get_event_from_payload(payload)
-      expect(event["unhandled"]).to be true
-      expect(event["severityReason"]).to eq({
-        "type" => "middleware_handler",
-        "attributes" => {
-          "name" => "middleware_test"
-        }
-      })
-    }
-  end
-end

data/spec/middleware_stack_spec.rb

@@ -1,151 +0,0 @@
-require 'spec_helper'
-
-class TestMiddleware
-  def initialize(bugsnag)
-    @bugsnag = bugsnag
-  end
-
-  def call(report)
-    @bugsnag.call(report)
-  end
-end
-
-module Bugsnag
-  class MiddlewareStack
-    attr_reader :middlewares
-    attr_reader :disabled_middleware
-  end
-end
-
-describe Bugsnag::MiddlewareStack do
-  describe "defaults" do
-    it "to empty middleware lists" do
-      expect(subject.middlewares.size).to eq(0)
-      expect(subject.disabled_middleware.size).to eq(0)
-    end
-  end
-
-  describe "use" do
-    it "allows middleware to be added to the stack" do
-      middleware = TestMiddleware.new(nil)
-      subject.use(middleware)
-      expect(subject.middlewares.size).to eq(1)
-      expect(subject.middlewares.last).to eq(middleware)
-    end
-
-    it "doesn't add middleware more than once" do
-      middleware = TestMiddleware.new(nil)
-      subject.use(middleware)
-      expect(subject.middlewares.size).to eq(1)
-      subject.use(middleware)
-      expect(subject.middlewares.size).to eq(1)
-    end
-  end
-
-  describe "disable" do
-    it "adds middleware to a disabled list" do
-      middleware = TestMiddleware.new(nil)
-      subject.disable(middleware)
-      expect(subject.disabled_middleware.size).to eq(1)
-      expect(subject.disabled_middleware.last).to eq(middleware)
-    end
-
-    it "prevents middleware from being added" do
-      middleware = TestMiddleware.new(nil)
-      subject.disable(middleware)
-      subject.use(middleware)
-      expect(subject.middlewares.size).to eq(0)
-    end
-
-    it "removes already added middleware" do
-      middleware = TestMiddleware.new(nil)
-      subject.use(middleware)
-      expect(subject.middlewares.size).to eq(1)
-      subject.disable(middleware)
-      expect(subject.middlewares.size).to eq(0)
-    end
-  end
-
-  describe "insert_before" do
-    it "inserts middleware before specified middleware" do
-      middleware_one = TestMiddleware.new(nil)
-      middleware_two = TestMiddleware.new(nil)
-      subject.use(middleware_one)
-      expect(subject.middlewares.size).to eq(1)
-      expect(subject.middlewares.first).to eq(middleware_one)
-      subject.insert_before(middleware_one, middleware_two)
-      expect(subject.middlewares.size).to eq(2)
-      expect(subject.middlewares.first).to eq(middleware_two)
-    end
-
-    it "appends middleware otherwise" do
-      middleware_one = TestMiddleware.new(nil)
-      middleware_two = TestMiddleware.new(nil)
-      subject.use(middleware_one)
-      expect(subject.middlewares.size).to eq(1)
-      expect(subject.middlewares.first).to eq(middleware_one)
-      subject.insert_before(nil, middleware_two)
-      expect(subject.middlewares.size).to eq(2)
-      expect(subject.middlewares.first).to eq(middleware_one)
-    end
-
-    it "accepts an array of middleware to insert before" do
-      middleware_one = TestMiddleware.new(nil)
-      middleware_two = TestMiddleware.new(nil)
-      middleware_three = TestMiddleware.new(nil)
-      subject.use(middleware_one)
-      subject.use(middleware_two)
-      expect(subject.middlewares.size).to eq(2)
-      expect(subject.middlewares.first).to eq(middleware_one)
-      subject.insert_before([middleware_one, middleware_two], middleware_three)
-      expect(subject.middlewares.size).to eq(3)
-      expect(subject.middlewares.first).to eq(middleware_three)
-    end
-  end
-
-  describe "insert_after" do
-    it "inserts middleware after specified middleware" do
-      middleware_one = TestMiddleware.new(nil)
-      middleware_two = TestMiddleware.new(nil)
-      subject.use(middleware_one)
-      expect(subject.middlewares.size).to eq(1)
-      expect(subject.middlewares.first).to eq(middleware_one)
-      subject.insert_after(middleware_one, middleware_two)
-      expect(subject.middlewares.size).to eq(2)
-      expect(subject.middlewares.last).to eq(middleware_two)
-    end
-
-    it "appends middleware otherwise" do
-      middleware_one = TestMiddleware.new(nil)
-      middleware_two = TestMiddleware.new(nil)
-      subject.use(middleware_one)
-      expect(subject.middlewares.size).to eq(1)
-      expect(subject.middlewares.first).to eq(middleware_one)
-      subject.insert_after(nil, middleware_two)
-      expect(subject.middlewares.size).to eq(2)
-      expect(subject.middlewares.first).to eq(middleware_one)
-    end
-
-    it "accepts an array of middleware to insert after" do
-      middleware_one = TestMiddleware.new(nil)
-      middleware_two = TestMiddleware.new(nil)
-      middleware_three = TestMiddleware.new(nil)
-      subject.use(middleware_one)
-      subject.use(middleware_two)
-      expect(subject.middlewares.size).to eq(2)
-      expect(subject.middlewares.last).to eq(middleware_two)
-      subject.insert_after([middleware_one, middleware_two], middleware_three)
-      expect(subject.middlewares.size).to eq(3)
-      expect(subject.middlewares.last).to eq(middleware_three)
-    end
-  end
-
-  describe "method_missing" do
-    it "calls send and proxies the method into the array" do
-      middleware = TestMiddleware.new(nil)
-      subject.method_missing(:<<, middleware)
-      expect(subject.middlewares.size).to eq(1)
-      expect(subject.middlewares.last).to eq(middleware)
-    end
-  end
-end

data/spec/on_error_spec.rb

@@ -1,332 +0,0 @@
-require "spec_helper"
-
-describe "on_error callbacks" do
-  it "runs callbacks on notify" do
-    callback1 = proc {|report| report.add_tab(:important, { hello: "world" }) }
-    callback2 = proc {|report| report.add_tab(:significant, { hey: "earth" }) }
-
-    Bugsnag.add_on_error(callback1)
-    Bugsnag.add_on_error(callback2)
-
-    Bugsnag.notify(RuntimeError.new("Oh no!"))
-
-    expect(Bugsnag).to(have_sent_notification do |payload, _headers|
-      event = get_event_from_payload(payload)
-
-      expect(event["metaData"]["important"]).to eq({ "hello" => "world" })
-      expect(event["metaData"]["significant"]).to eq({ "hey" => "earth" })
-    end)
-  end
-
-  it "can add callbacks in a configure block" do
-    callback1 = proc {|report| report.add_tab(:important, { hello: "world" }) }
-    callback2 = proc {|report| report.add_tab(:significant, { hey: "earth" }) }
-
-    Bugsnag.configure do |config|
-      config.add_on_error(callback1)
-      config.add_on_error(callback2)
-    end
-
-    Bugsnag.notify(RuntimeError.new("Oh no!"))
-
-    expect(Bugsnag).to(have_sent_notification do |payload, _headers|
-      event = get_event_from_payload(payload)
-
-      expect(event["metaData"]["important"]).to eq({ "hello" => "world" })
-      expect(event["metaData"]["significant"]).to eq({ "hey" => "earth" })
-    end)
-  end
-
-  it "can remove an already registered callback" do
-    callback1 = proc {|report| report.add_tab(:important, { hello: "world" }) }
-    callback2 = proc {|report| report.add_tab(:significant, { hey: "earth" }) }
-
-    Bugsnag.add_on_error(callback1)
-    Bugsnag.add_on_error(callback2)
-
-    Bugsnag.remove_on_error(callback1)
-
-    Bugsnag.notify(RuntimeError.new("Oh no!"))
-
-    expect(Bugsnag).to(have_sent_notification do |payload, _headers|
-      event = get_event_from_payload(payload)
-
-      expect(event["metaData"]["important"]).to be_nil
-      expect(event["metaData"]["significant"]).to eq({ "hey" => "earth" })
-    end)
-  end
-
-  it "can remove all registered callbacks" do
-    callback1 = proc {|report| report.add_tab(:important, { hello: "world" }) }
-    callback2 = proc {|report| report.add_tab(:significant, { hey: "earth" }) }
-
-    Bugsnag.add_on_error(callback1)
-    Bugsnag.add_on_error(callback2)
-
-    Bugsnag.remove_on_error(callback2)
-    Bugsnag.remove_on_error(callback1)
-
-    Bugsnag.notify(RuntimeError.new("Oh no!"))
-
-    expect(Bugsnag).to(have_sent_notification do |payload, _headers|
-      event = get_event_from_payload(payload)
-
-      expect(event["metaData"]["important"]).to be_nil
-      expect(event["metaData"]["significant"]).to be_nil
-    end)
-  end
-
-  it "does not remove an identical callback if it is not the same Proc" do
-    callback1 = proc {|report| report.add_tab(:important, { hello: "world" }) }
-    callback1_duplicate = proc {|report| report.add_tab(:important, { hello: "world" }) }
-
-    Bugsnag.add_on_error(callback1)
-    Bugsnag.remove_on_error(callback1_duplicate)
-
-    Bugsnag.notify(RuntimeError.new("Oh no!"))
-
-    expect(Bugsnag).to(have_sent_notification do |payload, _headers|
-      event = get_event_from_payload(payload)
-
-      expect(event["metaData"]["important"]).to eq({ "hello" => "world" })
-    end)
-  end
-
-  it "can re-add callbacks that have previously been removed" do
-    callback1 = proc {|report| report.add_tab(:important, { hello: "world" }) }
-    callback2 = proc {|report| report.add_tab(:significant, { hey: "earth" }) }
-
-    Bugsnag.add_on_error(callback1)
-    Bugsnag.add_on_error(callback2)
-
-    Bugsnag.remove_on_error(callback1)
-
-    Bugsnag.add_on_error(callback1)
-
-    Bugsnag.notify(RuntimeError.new("Oh no!"))
-
-    expect(Bugsnag).to(have_sent_notification do |payload, _headers|
-      event = get_event_from_payload(payload)
-
-      expect(event["metaData"]["important"]).to eq({ "hello" => "world" })
-      expect(event["metaData"]["significant"]).to eq({ "hey" => "earth" })
-    end)
-  end
-
-  it "will only add a callback once" do
-    called_count = 0
-
-    callback = proc do |report|
-      called_count += 1
-
-      report.add_tab(:important, { called: called_count })
-    end
-
-    1.upto(10) do |i|
-      Bugsnag.add_on_error(callback)
-    end
-
-    Bugsnag.notify(RuntimeError.new("Oh no!"))
-
-    expect(Bugsnag).to(have_sent_notification do |payload, _headers|
-      event = get_event_from_payload(payload)
-
-      expect(called_count).to be(1)
-      expect(event["metaData"]["important"]).to eq({ "called" => 1 })
-    end)
-  end
-
-  it "will ignore the report and stop calling callbacks if one returns false" do
-    logger = spy('logger')
-    Bugsnag.configuration.logger = logger
-
-    called_count = 0
-
-    callback1 = proc { called_count += 1 }
-    callback2 = proc { called_count += 1 }
-    callback3 = proc { false }
-    callback4 = proc { called_count += 1 }
-    callback5 = proc { called_count += 1 }
-
-    Bugsnag.add_on_error(callback1)
-    Bugsnag.add_on_error(callback2)
-    Bugsnag.add_on_error(callback3)
-    Bugsnag.add_on_error(callback4)
-    Bugsnag.add_on_error(callback5)
-
-    Bugsnag.notify(RuntimeError.new("Oh no!"))
-
-    expect(Bugsnag).not_to have_sent_notification
-    expect(called_count).to be(2)
-
-    expect(logger).to have_received(:debug).with("[Bugsnag]") do |&block|
-      expect(block.call).to eq("Not notifying RuntimeError due to ignore being signified in user provided middleware")
-    end
-  end
-
-  it "callbacks are called in the same order they are added (FIFO)" do
-    callback1 = proc do |report|
-      expect(report.meta_data[:important]).to be_nil
-
-      report.add_tab(:important, { magic_number: 9 })
-    end
-
-    callback2 = proc do |report|
-      expect(report.meta_data[:important]).to eq({ magic_number: 9 })
-
-      report.add_tab(:important, { magic_number: 99 })
-    end
-
-    callback3 = proc do |report|
-      expect(report.meta_data[:important]).to eq({ magic_number: 99 })
-
-      report.add_tab(:important, { magic_number: 999 })
-    end
-
-    Bugsnag.add_on_error(callback1)
-    Bugsnag.add_on_error(callback2)
-    Bugsnag.add_on_error(callback3)
-
-    Bugsnag.notify(RuntimeError.new("Oh no!"))
-
-    expect(Bugsnag).to(have_sent_notification do |payload, _headers|
-      event = get_event_from_payload(payload)
-
-      expect(event["metaData"]["important"]).to eq({ "magic_number" => 999 })
-    end)
-  end
-
-  it "callbacks continue being called after a callback raises" do
-    logger = spy('logger')
-    Bugsnag.configuration.logger = logger
-
-    callback1 = proc {|report| report.add_tab(:important, { a: "b" }) }
-    callback2 = proc {|_report| raise "bad things" }
-    callback3 = proc {|report| report.add_tab(:important, { c: "d" }) }
-
-    Bugsnag.add_on_error(callback1)
-    Bugsnag.add_on_error(callback2)
-    Bugsnag.add_on_error(callback3)
-
-    Bugsnag.notify(RuntimeError.new("Oh no!"))
-
-    expect(Bugsnag).to(have_sent_notification do |payload, _headers|
-      event = get_event_from_payload(payload)
-
-      expect(event["metaData"]["important"]).to eq({ "a" => "b", "c" => "d" })
-    end)
-
-    message_index = 0
-    expected_messages = [
-      /^Error occurred in on_error callback: 'bad things'$/,
-      /^on_error callback stacktrace:/
-    ]
-
-    expect(logger).to have_received(:warn).with("[Bugsnag]").twice do |&block|
-      expect(block.call).to match(expected_messages[message_index])
-      message_index += 1
-    end
-  end
-
-  it "runs callbacks even if no other middleware is registered" do
-    # Reset the middleware stack so any default middleware are removed
-    Bugsnag.configuration.middleware = Bugsnag::MiddlewareStack.new
-
-    callback1 = proc {|report| report.add_tab(:important, { hello: "world" }) }
-    callback2 = proc {|report| report.add_tab(:significant, { hey: "earth" }) }
-
-    Bugsnag.add_on_error(callback1)
-    Bugsnag.add_on_error(callback2)
-
-    Bugsnag.notify(RuntimeError.new("Oh no!"))
-
-    expect(Bugsnag).to(have_sent_notification do |payload, _headers|
-      event = get_event_from_payload(payload)
-
-      expect(event["metaData"]["important"]).to eq({ "hello" => "world" })
-      expect(event["metaData"]["significant"]).to eq({ "hey" => "earth" })
-    end)
-  end
-
-  describe "using callbacks across threads" do
-    it "runs callbacks that are added in different threads" do
-      callback1 = proc {|report| report.add_tab(:important, { hello: "world" }) }
-      callback2 = proc {|report| report.add_tab(:significant, { hey: "earth" }) }
-      callback3 = proc {|report| report.add_tab(:crucial, { magic_number: 999 }) }
-
-      Bugsnag.add_on_error(callback1)
-
-      threads = [
-        Thread.new { Bugsnag.add_on_error(callback2) },
-        Thread.new { Bugsnag.add_on_error(callback3) }
-      ]
-
-      threads.each(&:join)
-
-      Bugsnag.notify(RuntimeError.new("Oh no!"))
-
-      expect(Bugsnag).to(have_sent_notification do |payload, _headers|
-        event = get_event_from_payload(payload)
-
-        expect(event["metaData"]["important"]).to eq({ "hello" => "world" })
-        expect(event["metaData"]["significant"]).to eq({ "hey" => "earth" })
-        expect(event["metaData"]["crucial"]).to eq({ "magic_number" => 999 })
-      end)
-    end
-
-    it "can remove callbacks that are added in different threads" do
-      callback1 = proc {|report| report.add_tab(:important, { hello: "world" }) }
-      callback2 = proc {|report| report.add_tab(:significant, { hey: "earth" }) }
-
-      # We need to create & join these one at a time so that callback1 has
-      # definitely been added before it is removed, otherwise this test will fail
-      # at random
-      Thread.new { Bugsnag.add_on_error(callback1) }.join
-      Thread.new { Bugsnag.remove_on_error(callback1) }.join
-      Thread.new { Bugsnag.add_on_error(callback2) }.join
-
-      Bugsnag.notify(RuntimeError.new("Oh no!"))
-
-      expect(Bugsnag).to(have_sent_notification do |payload, _headers|
-        event = get_event_from_payload(payload)
-
-        expect(event["metaData"]["important"]).to be_nil
-        expect(event["metaData"]["significant"]).to eq({ "hey" => "earth" })
-      end)
-    end
-
-    it "callbacks are called in FIFO order when added in separate threads" do
-      callback1 = proc do |report|
-        expect(report.meta_data[:important]).to be_nil
-
-        report.add_tab(:important, { magic_number: 9 })
-      end
-
-      callback2 = proc do |report|
-        expect(report.meta_data[:important]).to eq({ magic_number: 9 })
-
-        report.add_tab(:important, { magic_number: 99 })
-      end
-
-      callback3 = proc do |report|
-        expect(report.meta_data[:important]).to eq({ magic_number: 99 })
-
-        report.add_tab(:important, { magic_number: 999 })
-      end
-
-      # As above, we need to create & join these one at a time so that each
-      # callback is added in sequence
-      Thread.new { Bugsnag.add_on_error(callback1) }.join
-      Thread.new { Bugsnag.add_on_error(callback2) }.join
-      Thread.new { Bugsnag.add_on_error(callback3) }.join
-
-      Bugsnag.notify(RuntimeError.new("Oh no!"))
-
-      expect(Bugsnag).to(have_sent_notification do |payload, _headers|
-        event = get_event_from_payload(payload)
-
-        expect(event["metaData"]["important"]).to eq({ "magic_number" => 999 })
-      end)
-    end
-  end
-end