bugsnag 6.10.0 → 6.11.0

data/spec/bugsnag_spec.rb

@@ -2,6 +2,10 @@
 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')
@@ -11,10 +15,91 @@ describe Bugsnag 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
@@ -133,4 +218,149 @@ describe Bugsnag do
       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 => "123123123123123123123123123123",
+        :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 => "123123123123123123123123123123",
+        :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

data/spec/configuration_spec.rb

@@ -22,10 +22,93 @@ describe Bugsnag::Configuration do
       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
 
-    it "should have sensible defaults for session tracking" do
-      expect(subject.session_endpoint).to eq("https://sessions.bugsnag.com")
+  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
 
@@ -222,4 +305,95 @@ describe Bugsnag::Configuration do
     expect(subject.ignore_classes).to eq(Set.new([SystemExit, SignalException]))
   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
 end

data/spec/integrations/mongo_spec.rb

@@ -0,0 +1,262 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe 'Bugsnag::MongoBreadcrumbSubscriber', :order => :defined do
+  before do
+    unless defined?(::Mongo)
+      @mocked_mongo = true
+      module ::Mongo
+        module Monitoring
+          COMMAND = 'Command'
+          module Global
+          end
+        end
+      end
+      module Kernel
+        alias_method :old_require, :require
+        def require(path)
+          old_require(path) unless path == 'mongo'
+        end
+      end
+    end
+  end
+
+  it "should subscribe to the mongo monitoring service" do
+    expect(::Mongo::Monitoring::Global).to receive(:subscribe) do |command, subscriber|
+      expect(command).to eq(::Mongo::Monitoring::COMMAND)
+      expect(subscriber).to be_an_instance_of(::Bugsnag::MongoBreadcrumbSubscriber)
+    end
+    load './lib/bugsnag/integrations/mongo.rb'
+  end
+
+  context "with the module loaded" do
+    before do
+      allow(::Mongo::Monitoring::Global).to receive(:subscribe)
+      require './lib/bugsnag/integrations/mongo'
+    end
+
+    let(:subscriber) { Bugsnag::MongoBreadcrumbSubscriber.new }
+
+    describe "#started" do
+      it "calls #leave_command with the event" do
+        event = double
+        expect(subscriber).to receive(:leave_command).with(event)
+        subscriber.started(event)
+      end
+    end
+
+    describe "#succeeded" do
+      it "calls #leave_mongo_breadcrumb with the event_name and event" do
+        event = double
+        expect(subscriber).to receive(:leave_mongo_breadcrumb).with("succeeded", event)
+        subscriber.succeeded(event)
+      end
+    end
+
+    describe "#failed" do
+      it "calls #leave_mongo_breadcrumb with the event_name and event" do
+        event = double
+        expect(subscriber).to receive(:leave_mongo_breadcrumb).with("failed", event)
+        subscriber.failed(event)
+      end
+    end
+
+    describe "#leave_mongo_breadcrumb" do
+      let(:event) { double(
+        :command_name => "command",
+        :database_name => "database",
+        :operation_id => "1234567890",
+        :request_id => "123456",
+        :duration => "123.456"
+      ) }
+      let(:event_name) { "event_name" }
+      it "leaves a breadcrumb with relevant meta_data, message, type, and automatic notation" do
+        expect(Bugsnag).to receive(:leave_breadcrumb).with(
+          "Mongo query #{event_name}",
+          {
+            :event_name => "mongo.#{event_name}",
+            :command_name => "command",
+            :database_name => "database",
+            :operation_id => "1234567890",
+            :request_id => "123456",
+            :duration => "123.456"
+          },
+          "process",
+          :auto
+        )
+        subscriber.send(:leave_mongo_breadcrumb, event_name, event)
+      end
+
+      it "adds message data if present" do
+        allow(event).to receive(:message).and_return("This is a message")
+        expect(Bugsnag).to receive(:leave_breadcrumb).with(
+          "Mongo query #{event_name}",
+          {
+            :event_name => "mongo.#{event_name}",
+            :command_name => "command",
+            :database_name => "database",
+            :operation_id => "1234567890",
+            :request_id => "123456",
+            :duration => "123.456",
+            :message => "This is a message"
+          },
+          "process",
+          :auto
+        )
+        subscriber.send(:leave_mongo_breadcrumb, event_name, event)
+      end
+
+      context "command data is present" do
+        let(:command) {
+          {
+            "command" => "collection_name_command",
+            "collection" => "collection_name_getMore",
+            "filter" => nil
+          }
+        }
+
+        it "adds the collection name" do
+          expect(subscriber).to receive(:pop_command).with("123456").and_return(command)
+          expect(Bugsnag).to receive(:leave_breadcrumb).with(
+            "Mongo query #{event_name}",
+            {
+              :event_name => "mongo.#{event_name}",
+              :command_name => "command",
+              :database_name => "database",
+              :operation_id => "1234567890",
+              :request_id => "123456",
+              :duration => "123.456",
+              :collection => "collection_name_command"
+            },
+            "process",
+            :auto
+          )
+          subscriber.send(:leave_mongo_breadcrumb, event_name, event)
+        end
+
+        it "adds the correct collection name for 'getMore' commands" do
+          allow(event).to receive(:command_name).and_return("getMore")
+          expect(subscriber).to receive(:pop_command).with("123456").and_return(command)
+          expect(Bugsnag).to receive(:leave_breadcrumb).with(
+            "Mongo query #{event_name}",
+            {
+              :event_name => "mongo.#{event_name}",
+              :command_name => "getMore",
+              :database_name => "database",
+              :operation_id => "1234567890",
+              :request_id => "123456",
+              :duration => "123.456",
+              :collection => "collection_name_getMore"
+            },
+            "process",
+            :auto
+          )
+          subscriber.send(:leave_mongo_breadcrumb, event_name, event)
+        end
+
+        it "adds a JSON string of filter data" do
+          command["filter"] = {"a" => 1, "b" => 2, "$or" => [{"c" => 3}, {"d" => 4}]}
+          expect(subscriber).to receive(:pop_command).with("123456").and_return(command)
+          expect(Bugsnag).to receive(:leave_breadcrumb).with(
+            "Mongo query #{event_name}",
+            {
+              :event_name => "mongo.#{event_name}",
+              :command_name => "command",
+              :database_name => "database",
+              :operation_id => "1234567890",
+              :request_id => "123456",
+              :duration => "123.456",
+              :collection => "collection_name_command",
+              :filter => '{"a":"?","b":"?","$or":[{"c":"?"},{"d":"?"}]}'
+            },
+            "process",
+            :auto
+          )
+          subscriber.send(:leave_mongo_breadcrumb, event_name, event)
+        end
+      end
+    end
+
+    describe "#sanitize_filter_hash" do
+      it "calls into #sanitize_filter_value with the value from each {k,v} pair" do
+        expect(subscriber.send(:sanitize_filter_hash, {:a => 1, :b => 2})).to eq({:a => '?', :b => '?'})
+      end
+    end
+
+    describe "#sanitize_filter_value" do
+      it "returns '?' for strings, numbers, booleans, and nil" do
+        expect(subscriber.send(:sanitize_filter_value, 523, 0)).to eq('?')
+        expect(subscriber.send(:sanitize_filter_value, "string", 0)).to eq('?')
+        expect(subscriber.send(:sanitize_filter_value, true, 0)).to eq('?')
+        expect(subscriber.send(:sanitize_filter_value, nil, 0)).to eq('?')
+      end
+
+      it "is recursive and iterative for array values" do
+        expect(subscriber.send(:sanitize_filter_value, [1, [2, [3]]], 0)).to eq(['?', ['?', ['?']]])
+      end
+
+      it "calls #sanitize_filter_hash for hash values" do
+        expect(subscriber).to receive(:sanitize_filter_hash).with({:a => 1}, 1)
+        subscriber.send(:sanitize_filter_value, {:a => 1}, 0)
+      end
+
+      it "returns [MAX_FILTER_DEPTH_REACHED] if the filter depth is exceeded" do
+        expect(subscriber.send(:sanitize_filter_value, 1, 4)).to eq('[MAX_FILTER_DEPTH_REACHED]')
+      end
+    end
+
+    describe "#leave_command" do
+      it "extracts and stores the command by request_id" do
+        request_id = "123456"
+        command = "this is a command string"
+        event = double(:command => command, :request_id => request_id)
+
+        subscriber.send(:leave_command, event)
+        command_hash = Bugsnag.configuration.request_data[Bugsnag::MongoBreadcrumbSubscriber::MONGO_COMMAND_KEY]
+        expect(command_hash[request_id]).to eq(command)
+      end
+    end
+
+    describe "#pop_command" do
+      let(:request_id) { "123456" }
+      let(:command) { "this is a command string" }
+      before do
+        event = double(:command => command, :request_id => request_id)
+        subscriber.send(:leave_command, event)
+      end
+
+      it "returns the command given a request_id" do
+        expect(subscriber.send(:pop_command, request_id)).to eq(command)
+      end
+
+      it "removes the command from the request_data" do
+        subscriber.send(:pop_command, request_id)
+        command_hash = Bugsnag.configuration.request_data[Bugsnag::MongoBreadcrumbSubscriber::MONGO_COMMAND_KEY]
+        expect(command_hash).not_to have_key(request_id)
+      end
+
+      it "returns nil if the request_id is not found" do
+        expect(subscriber.send(:pop_command, "09876")).to be_nil
+      end
+    end
+
+    describe "#event_commands" do
+      it "returns a hash" do
+        expect(subscriber.send(:event_commands)).to be_a(Hash)
+      end
+
+      it "is stored in request data" do
+        subscriber.send(:event_commands)[:key] = "value"
+        command_hash = Bugsnag.configuration.request_data[Bugsnag::MongoBreadcrumbSubscriber::MONGO_COMMAND_KEY]
+        expect(command_hash[:key]).to eq("value")
+      end
+    end
+  end
+
+  after do
+    Object.send(:remove_const, :Mongo) if @mocked_mongo
+    module Kernel
+      alias_method :require, :old_require
+    end
+  end
+end