exception_handling 2.6.0 → 2.6.1

data/spec/unit/exception_handling/exception_catalog_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require File.expand_path('../../spec_helper',  __dir__)
+
+module ExceptionHandling
+  describe ExceptionCatalog do
+
+    context "With stubbed yaml content" do
+      before do
+        filter_list = { exception1: { error: "my error message" },
+                        exception2: { error: "some other message", session: "misc data" } }
+        allow(YAML).to receive(:load_file) { filter_list }
+
+        # bump modified time up to get the above filter loaded
+        allow(File).to receive(:mtime) { incrementing_mtime }
+      end
+
+      context "with loaded data" do
+        before do
+          allow(File).to receive(:mtime) { incrementing_mtime }
+          @exception_catalog = ExceptionCatalog.new(ExceptionHandling.filter_list_filename)
+          @exception_catalog.send :load_file
+        end
+
+        it "have loaded filters" do
+          expect(@exception_catalog.instance_eval("@filters").size).to eq(2)
+        end
+
+        it "find messages in the catalog" do
+          expect(!@exception_catalog.find(error: "Scott says unlikely to ever match")).to be_truthy
+        end
+
+        it "find matching data" do
+          exception_description = @exception_catalog.find(error: "this is my error message, which should match something")
+          expect(exception_description).to be_truthy
+          expect(exception_description.filter_name).to eq(:exception1)
+        end
+      end
+
+      it "write errors loading the yaml file directly to the log file" do
+        @exception_catalog = ExceptionCatalog.new(ExceptionHandling.filter_list_filename)
+
+        expect(ExceptionHandling).to receive(:log_error).never
+        expect(ExceptionHandling).to receive(:write_exception_to_log).with(anything, "ExceptionCatalog#refresh_filters: ./config/exception_filters.yml", anything)
+        expect(@exception_catalog).to receive(:load_file) { raise "noooooo" }
+
+        @exception_catalog.find({})
+      end
+    end
+
+    context "with live yaml content" do
+      before do
+        @filename = File.expand_path('../../../config/exception_filters.yml',  __dir__)
+        @exception_catalog = ExceptionCatalog.new(@filename)
+        expect do
+          @exception_catalog.send :load_file
+        end.not_to raise_error
+      end
+
+      it "load the filter data" do
+        expect(!@exception_catalog.find(error: "Scott says unlikely to ever match")).to be_truthy
+        expect(!@exception_catalog.find(error: "Scott says unlikely to ever match")).to be_truthy
+      end
+    end
+
+    context "with no yaml content" do
+      before do
+        @exception_catalog = ExceptionCatalog.new(nil)
+      end
+
+      it "not load filter data" do
+        expect(ExceptionHandling).to receive(:write_exception_to_log).with(any_args).never
+        @exception_catalog.find(error: "Scott says unlikely to ever match")
+      end
+    end
+
+    private
+
+    def incrementing_mtime
+      @mtime ||= Time.now
+      @mtime += 1.day
+    end
+
+  end
+end

data/spec/unit/exception_handling/exception_description_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require File.expand_path('../../spec_helper',  __dir__)
+
+module ExceptionHandling
+  describe ExceptionDescription do
+
+    context "Filter" do
+      it "allow direct matching of strings" do
+        @f = ExceptionDescription.new(:filter1, error: "my error message")
+        expect(@f.match?('error' => "my error message")).to be_truthy
+      end
+
+      it "allow direct matching of strings on with symbol keys" do
+        @f = ExceptionDescription.new(:filter1, error: "my error message")
+        expect(@f.match?(error: "my error message")).to be_truthy
+      end
+
+      it "allow wildcards to cross line boundries" do
+        @f = ExceptionDescription.new(:filter1, error: "my error message.*with multiple lines")
+        expect(@f.match?(error: "my error message\nwith more than one, with multiple lines")).to be_truthy
+      end
+
+      it "complain when no regexps have a value" do
+        expect { ExceptionDescription.new(:filter1, error: nil) }.to raise_exception(ArgumentError, /has all blank regexes/)
+      end
+
+      it "report when an invalid key is passed" do
+        expect { ExceptionDescription.new(:filter1, error: "my error message", not_a_parameter: false) }.to raise_exception(ArgumentError, "Unknown section: not_a_parameter")
+      end
+
+      it "allow send_to_honeybadger to be specified and have it disabled by default" do
+        expect(!ExceptionDescription.new(:filter1, error: "my error message", send_to_honeybadger: false).send_to_honeybadger).to be_truthy
+        expect(ExceptionDescription.new(:filter1, error: "my error message", send_to_honeybadger: true).send_to_honeybadger).to be_truthy
+        expect(!ExceptionDescription.new(:filter1, error: "my error message").send_to_honeybadger).to be_truthy
+      end
+
+      it "allow send_metric to be configured" do
+        expect(!ExceptionDescription.new(:filter1, error: "my error message", send_metric: false).send_metric).to be_truthy
+        expect(ExceptionDescription.new(:filter1, error: "my error message").send_metric).to be_truthy
+      end
+
+      it "provide metric name" do
+        expect(ExceptionDescription.new(:filter1, error: "my error message").metric_name).to eq("filter1")
+        expect(ExceptionDescription.new(:filter1, error: "my error message", metric_name: :some_other_metric_name).metric_name).to eq("some_other_metric_name")
+      end
+
+      it "replace spaces in metric name" do
+        @f = ExceptionDescription.new(:"filter has spaces", error: "my error message")
+        expect(@f.metric_name).to eq( "filter_has_spaces")
+      end
+
+      it "allow notes to be recorded" do
+        expect(ExceptionDescription.new(:filter1, error: "my error message").notes).to be_nil
+        expect(ExceptionDescription.new(:filter1, error: "my error message", notes: "a long string").notes).to eq("a long string")
+      end
+
+      it "not consider config options in the filter set" do
+        expect(ExceptionDescription.new(:filter1, error: "my error message", send_metric: false).match?(error: "my error message")).to be_truthy
+        expect(ExceptionDescription.new(:filter1, error: "my error message", metric_name: "false").match?(error: "my error message")).to be_truthy
+        expect(ExceptionDescription.new(:filter1, error: "my error message", notes: "hey").match?(error: "my error message")).to be_truthy
+      end
+
+      it "provide exception details" do
+        exception_description = ExceptionDescription.new(:filter1, error: "my error message", notes: "hey")
+
+        expected = { "send_metric" => true, "metric_name" => "filter1", "notes" => "hey" }
+
+        expect(exception_description.exception_data).to eq( expected)
+      end
+
+      it "match multiple email addresses" do
+        mobi = "ExceptionHandling::Warning: LoginAttempt::IPAddressLocked: failed login for 'mcc@mobistreak.com'"
+        credit = "ExceptionHandling::Warning: LoginAttempt::IPAddressLocked: failed login for 'damon@thecreditpros.com'"
+
+        exception_description = ExceptionDescription.new(:filter1, error: "ExceptionHandling::Warning: LoginAttempt::IPAddressLocked: failed login for '(mcc\@mobistreak|damon\@thecreditpros).com'")
+        expect(exception_description.match?(error: mobi)).to be_truthy
+        expect(exception_description.match?(error: credit)).to be_truthy
+      end
+    end
+  end
+end

data/{test/unit/exception_handling/exception_info_test.rb → spec/unit/exception_handling/exception_info_spec.rb}

@@ -1,58 +1,58 @@
 # frozen_string_literal: true
 
-require File.expand_path('../../test_helper',  __dir__)
+require File.expand_path('../../spec_helper',  __dir__)
 require_test_helper 'controller_helpers'
 require_test_helper 'exception_helpers'
 
 module ExceptionHandling
-  class ExceptionInfoTest < ActiveSupport::TestCase
+  describe ExceptionInfo do
     include ControllerHelpers
     include ExceptionHelpers
 
     context "initialize" do
-      setup do
+      before do
         @exception = StandardError.new("something went wrong")
         @timestamp = Time.now
         @controller = Object.new
       end
 
       context "controller_from_context" do
-        should "extract controller from context when not specified explicitly" do
+        it "extract controller from context when not specified explicitly" do
           exception_context = {
             "action_controller.instance" => @controller
           }
           exception_info = ExceptionInfo.new(@exception, exception_context, @timestamp)
-          assert_equal @controller, exception_info.controller
+          expect(exception_info.controller).to eq(@controller)
         end
 
-        should "prefer the explicit controller over the one from context" do
+        it "prefer the explicit controller over the one from context" do
           exception_context = {
             "action_controller.instance" => Object.new
           }
           exception_info = ExceptionInfo.new(@exception, exception_context, @timestamp, controller: @controller)
-          assert_equal @controller, exception_info.controller
-          assert_not_equal exception_context["action_controller.instance"], exception_info.controller
+          expect(exception_info.controller).to eq(@controller)
+          expect(exception_info.controller).not_to eq(exception_context["action_controller.instance"])
         end
 
-        should "leave controller unset when not included in the context hash" do
+        it "leave controller unset when not included in the context hash" do
           exception_info = ExceptionInfo.new(@exception, {}, @timestamp)
-          assert_nil exception_info.controller
+          expect(exception_info.controller).to be_nil
         end
 
-        should "leave controller unset when context is not in hash format" do
+        it "leave controller unset when context is not in hash format" do
           exception_info = ExceptionInfo.new(@exception, "string context", @timestamp)
-          assert_nil exception_info.controller
+          expect(exception_info.controller).to be_nil
         end
       end
     end
 
     context "data" do
-      setup do
+      before do
         @exception = StandardError.new("something went wrong")
         @timestamp = Time.now
       end
 
-      should "return a hash with exception specific data including context hash" do
+      it "return a hash with exception specific data including context hash" do
         exception_context = {
           "rack.session" => {
             user_id: 23,
@@ -73,17 +73,17 @@ module ExceptionHandling
           }
         }
 
-        assert_equal_with_diff expected_data, exception_info.data
+        expect(exception_info.data).to eq(expected_data)
       end
 
-      should "generate exception data appropriately if exception message is nil" do
+      it "generate exception data appropriately if exception message is nil" do
         exception_info = ExceptionInfo.new(exception_with_nil_message, "custom context data", @timestamp)
         exception_data = exception_info.data
-        assert_equal "RuntimeError: ", exception_data["error_string"]
-        assert_equal "RuntimeError: : custom context data", exception_data["error"]
+        expect(exception_data["error_string"]).to eq("RuntimeError: ")
+        expect(exception_data["error"]).to eq("RuntimeError: : custom context data")
       end
 
-      should "return a hash with exception specific data including context string" do
+      it "return a hash with exception specific data including context string" do
         exception_context = "custom context data"
         exception_info = ExceptionInfo.new(@exception, exception_context, @timestamp)
         expected_data = {
@@ -96,11 +96,10 @@ module ExceptionHandling
             "message" => "custom context data"
           }
         }
-
-        assert_equal_with_diff expected_data, exception_info.data
+        expect(exception_info.data).to eq(expected_data)
       end
 
-      should "not include enhanced data from controller or custom data callback" do
+      it "not include enhanced data from controller or custom data callback" do
         env = { server: "fe98" }
         parameters = { advertiser_id: 435 }
         session = { username: "jsmith" }
@@ -109,8 +108,8 @@ module ExceptionHandling
         data_callback = ->(data) { data[:custom_section] = "value" }
         exception_info = ExceptionInfo.new(@exception, "custom context data", @timestamp, controller: controller, data_callback: data_callback)
 
-        dont_allow(exception_info).extract_and_merge_controller_data
-        dont_allow(exception_info).customize_from_data_callback
+        expect(exception_info).to_not receive(:extract_and_merge_controller_data)
+        expect(exception_info).to_not receive(:customize_from_data_callback)
         expected_data = {
           "error_class" => "StandardError",
           "error_string" => "StandardError: something went wrong",
@@ -122,12 +121,12 @@ module ExceptionHandling
           }
         }
 
-        assert_equal_with_diff expected_data, exception_info.data
+        expect(exception_info.data).to eq(expected_data)
       end
     end
 
     context "enhanced_data" do
-      setup do
+      before do
         @exception = StandardError.new("something went wrong")
         @timestamp = Time.now
         @exception_context = {
@@ -145,13 +144,13 @@ module ExceptionHandling
         @data_callback = ->(data) { data[:custom_section] = "check this out" }
       end
 
-      should "not return a mutable object for the session" do
+      it "not return a mutable object for the session" do
         exception_info = ExceptionInfo.new(@exception, @exception_context, @timestamp)
         exception_info.enhanced_data["session"]["hello"] = "world"
-        assert_nil @controller.session["hello"]
+        expect(@controller.session["hello"]).to be_nil
       end
 
-      should "return a hash with generic exception attributes as well as context data" do
+      it "return a hash with generic exception attributes as well as context data" do
         exception_info = ExceptionInfo.new(@exception, @exception_context, @timestamp)
         expected_data = {
           "error_class" => "StandardError",
@@ -164,19 +163,19 @@ module ExceptionHandling
           "location" => { "file" => "<no backtrace>", "line" => nil }
         }
 
-        assert_equal_with_diff expected_data, prepare_data(exception_info.enhanced_data)
+        expect(prepare_data(exception_info.enhanced_data)).to eq(expected_data)
       end
 
-      should "generate exception data appropriately if exception message is nil" do
+      it "generate exception data appropriately if exception message is nil" do
         exception_with_nil_message = RuntimeError.new(nil)
-        stub(exception_with_nil_message).message { nil }
+        allow(exception_with_nil_message).to receive(:message).and_return(nil)
         exception_info = ExceptionInfo.new(exception_with_nil_message, @exception_context, @timestamp)
         exception_data = exception_info.enhanced_data
-        assert_equal "RuntimeError: ", exception_data["error_string"]
-        assert_equal "RuntimeError: ", exception_data["error"]
+        expect(exception_data["error_string"]).to eq("RuntimeError: ")
+        expect(exception_data["error"]).to eq("RuntimeError: ")
       end
 
-      should "include controller data when available" do
+      it "include controller data when available" do
         exception_info = ExceptionInfo.new(@exception, @exception_context, @timestamp, controller: @controller)
         expected_data = {
           "error_class" => "StandardError",
@@ -194,10 +193,10 @@ module ExceptionHandling
           "location" => { "controller" => "dummy", "action" => "fail", "file" => "<no backtrace>", "line" => nil }
         }
 
-        assert_equal_with_diff expected_data, prepare_data(exception_info.enhanced_data)
+        expect(prepare_data(exception_info.enhanced_data)).to eq(expected_data)
       end
 
-      should "extract controller from rack specific exception context when not provided explicitly" do
+      it "extract controller from rack specific exception context when not provided explicitly" do
         @exception_context["action_controller.instance"] = @controller
         exception_info = ExceptionInfo.new(@exception, @exception_context, @timestamp)
         expected_data = {
@@ -216,10 +215,10 @@ module ExceptionHandling
           "location" => { "controller" => "dummy", "action" => "fail", "file" => "<no backtrace>", "line" => nil }
         }
 
-        assert_equal_with_diff expected_data, prepare_data(exception_info.enhanced_data)
+        expect(prepare_data(exception_info.enhanced_data)).to eq(expected_data)
       end
 
-      should "add to_s attribute to specific sections that have their content in hash format" do
+      it "add to_s attribute to specific sections that have their content in hash format" do
         exception_info = ExceptionInfo.new(@exception, @exception_context, @timestamp, controller: @controller)
         expected_data = {
           "error_class" => "StandardError",
@@ -245,10 +244,10 @@ module ExceptionHandling
           "location" => { "controller" => "dummy", "action" => "fail", "file" => "<no backtrace>", "line" => nil }
         }
 
-        assert_equal_with_diff expected_data, exception_info.enhanced_data
+        expect(exception_info.enhanced_data).to eq(expected_data)
       end
 
-      should "filter out sensitive parameters like passwords" do
+      it "filter out sensitive parameters like passwords" do
         @controller.request.parameters[:password] = "super_secret"
         @controller.request.parameters[:user] = { "password" => "also super secret", "password_confirmation" => "also super secret" }
         exception_info = ExceptionInfo.new(@exception, @exception_context, @timestamp, controller: @controller)
@@ -261,10 +260,10 @@ module ExceptionHandling
             "password_confirmation" => "[FILTERED]"
           }
         }
-        assert_equal_with_diff expected_params, exception_info.enhanced_data["request"]["params"]
+        expect(exception_info.enhanced_data["request"]["params"]).to eq(expected_params)
       end
 
-      should "include the changes from the custom data callback" do
+      it "include the changes from the custom data callback" do
         exception_info = ExceptionInfo.new(@exception, @exception_context, @timestamp, controller: nil, data_callback: @data_callback)
         expected_data = {
           "error_class" => "StandardError",
@@ -278,11 +277,11 @@ module ExceptionHandling
           "location" => { "file" => "<no backtrace>", "line" => nil }
         }
 
-        assert_equal_with_diff expected_data, prepare_data(exception_info.enhanced_data)
+        expect(prepare_data(exception_info.enhanced_data)).to eq(expected_data)
       end
 
-      should "apply the custom_data_hook results" do
-        stub(ExceptionHandling).custom_data_hook { ->(data) { data[:custom_hook] = "changes from custom hook" } }
+      it "apply the custom_data_hook results" do
+        allow(ExceptionHandling).to receive(:custom_data_hook).and_return(->(data) { data[:custom_hook] = "changes from custom hook" })
         exception_info = ExceptionInfo.new(@exception, @exception_context, @timestamp)
         expected_data = {
           "error_class" => "StandardError",
@@ -296,35 +295,35 @@ module ExceptionHandling
           "location" => { "file" => "<no backtrace>", "line" => nil }
         }
 
-        assert_equal_with_diff expected_data, prepare_data(exception_info.enhanced_data)
+        expect(prepare_data(exception_info.enhanced_data)).to eq(expected_data)
       end
 
-      should "log info if the custom data hook results in a nil message exception" do
+      it "log info if the custom data hook results in a nil message exception" do
         ExceptionHandling.custom_data_hook = ->(_data) do
           raise_exception_with_nil_message
         end
         log_info_messages = []
-        stub(ExceptionHandling.logger).info.with_any_args do |message, _|
+        allow(ExceptionHandling.logger).to receive(:info).with(any_args) do |message, _|
           log_info_messages << message
         end
 
         exception_info = ExceptionInfo.new(@exception, @exception_context, @timestamp)
         exception_info.enhanced_data
-        assert log_info_messages.find { |message| message =~ /Unable to execute custom custom_data_hook callback/ }
+        expect(log_info_messages.find { |message| message =~ /Unable to execute custom custom_data_hook callback/ }).to be_truthy
         ExceptionHandling.custom_data_hook = nil
       end
     end
 
     context "exception_description" do
-      should "return the exception description from the global exception filter list" do
+      it "return the exception description from the global exception filter list" do
         exception = StandardError.new("No route matches")
         exception_info = ExceptionInfo.new(exception, {}, Time.now)
         description = exception_info.exception_description
-        assert_not_nil description
-        assert_equal :NoRoute, description.filter_name
+        expect(description).to_not be_nil
+        expect(description.filter_name).to eq(:NoRoute)
       end
 
-      should "find the description when filter criteria includes section in hash format" do
+      it "find the description when filter criteria includes section in hash format" do
         env = { server: "fe98" }
         parameters = { advertiser_id: 435, controller: "sessions", action: "fail" }
         session = { username: "jsmith", id: "session_key" }
@@ -332,25 +331,25 @@ module ExceptionHandling
         controller = create_dummy_controller(env, parameters, session, request_uri)
         exception = StandardError.new("Request to click domain rejected")
         exception_info = ExceptionInfo.new(exception, nil, Time.now, controller: controller)
-        assert_equal true, exception_info.enhanced_data[:request].is_a?(Hash)
+        expect(exception_info.enhanced_data[:request].is_a?(Hash)).to eq(true)
         description = exception_info.exception_description
-        assert_not_nil description
-        assert_equal :"Click Request Rejected", description.filter_name
+        expect(description).to_not be_nil
+        expect(description.filter_name).to eq(:"Click Request Rejected")
       end
 
-      should "return same description object for related errors (avoid reloading exception catalog from disk)" do
+      it "return same description object for related errors (avoid reloading exception catalog from disk)" do
         exception = StandardError.new("No route matches")
         exception_info = ExceptionInfo.new(exception, nil, Time.now)
         description = exception_info.exception_description
 
         repeat_ex = StandardError.new("No route matches 2")
         repeat_ex_info = ExceptionInfo.new(repeat_ex, nil, Time.now)
-        assert_equal description.object_id, repeat_ex_info.exception_description.object_id
+        expect(repeat_ex_info.exception_description.object_id).to eq(description.object_id)
       end
     end
 
     context "controller_name" do
-      setup do
+      before do
         @exception = StandardError.new('something went wrong')
         @timestamp = Time.now
         @exception_context = {
@@ -362,7 +361,7 @@ module ExceptionHandling
         }
       end
 
-      should "return controller_name when controller is present" do
+      it "return controller_name when controller is present" do
         env         = { server:     'fe98' }
         parameters  = { controller: 'some_controller' }
         session     = { username:   'smith' }
@@ -370,65 +369,85 @@ module ExceptionHandling
         controller  = create_dummy_controller(env, parameters, session, request_uri)
         exception_info = ExceptionInfo.new(@exception, @exception_context, @timestamp, controller: controller)
 
-        assert_equal 'some_controller', exception_info.controller_name
+        expect(exception_info.controller_name).to eq('some_controller')
       end
 
-      should "return an empty string when controller is not present" do
+      it "return an empty string when controller is not present" do
         exception_info = ExceptionInfo.new(@exception, @exception_context, @timestamp)
 
-        assert_equal '', exception_info.controller_name
+        expect(exception_info.controller_name).to eq('')
       end
     end
 
     context "send_to_honeybadger?" do
-      should "be enabled when Honeybadger is defined and exception is not in the filter list" do
-        stub(ExceptionHandling).honeybadger_defined? { true }
+      it "be enabled when Honeybadger is defined and exception is not in the filter list" do
+        allow(ExceptionHandling).to receive(:honeybadger_defined?).and_return(true)
         exception = StandardError.new("something went wrong")
         exception_info = ExceptionInfo.new(exception, nil, Time.now)
-        assert_nil exception_info.exception_description
-        assert_equal true, exception_info.send_to_honeybadger?
+        expect(exception_info.exception_description).to be_nil
+        expect(exception_info.send_to_honeybadger?).to eq(true)
       end
 
-      should "be enabled when Honeybadger is defined and exception is on the filter list with the flag turned on" do
-        stub(ExceptionHandling).honeybadger_defined? { true }
+      it "be enabled when Honeybadger is defined and exception is on the filter list with the flag turned on" do
+        allow(ExceptionHandling).to receive(:honeybadger_defined?).and_return(true)
         exception = StandardError.new("No route matches")
         exception_info = ExceptionInfo.new(exception, nil, Time.now)
-        assert_not_nil exception_info.exception_description
-        assert_equal true, exception_info.exception_description.send_to_honeybadger
-        assert_equal true, exception_info.send_to_honeybadger?
+        expect(exception_info.exception_description).to_not be_nil
+        expect(exception_info.exception_description.send_to_honeybadger).to eq(true)
+        expect(exception_info.send_to_honeybadger?).to eq(true)
       end
 
-      should "be disabled when Honeybadger is defined and exception is on the filter list with the flag turned off" do
-        stub(ExceptionHandling).honeybadger_defined? { true }
+      it "be disabled when Honeybadger is defined and exception is on the filter list with the flag turned off" do
+        allow(ExceptionHandling).to receive(:honeybadger_defined?).and_return(true)
         exception = StandardError.new("No route matches")
         exception_info = ExceptionInfo.new(exception, nil, Time.now)
-        assert_not_nil exception_info.exception_description
-        stub(exception_info.exception_description).send_to_honeybadger { false }
-        assert_equal false, exception_info.send_to_honeybadger?
+        expect(exception_info.exception_description).to_not be_nil
+        allow(exception_info.exception_description).to receive(:send_to_honeybadger).and_return(false)
+        expect(exception_info.send_to_honeybadger?).to eq(false)
       end
 
-      should "be disabled when Honeybadger is not defined" do
-        stub(ExceptionHandling).honeybadger_defined? { false }
+      it "be disabled when Honeybadger is not defined" do
+        allow(ExceptionHandling).to receive(:honeybadger_defined?).and_return(false)
         exception = StandardError.new("something went wrong")
         exception_info = ExceptionInfo.new(exception, nil, Time.now)
-        assert_nil exception_info.exception_description
-        assert_equal false, exception_info.send_to_honeybadger?
+        expect(exception_info.exception_description).to be_nil
+        expect(exception_info.send_to_honeybadger?).to eq(false)
       end
     end
 
     context "honeybadger_context_data" do
-      should "return the error details and relevant context data to be used as honeybadger notification context while filtering sensitive data" do
+      before do
+        allow(ExceptionHandling.logger).to receive(:current_context_for_thread).and_return({ cuid: 'ABCD' })
+      end
+
+      it "include thread_context when log_context: is nil" do
+        exception_with_nil_message = RuntimeError.new(nil)
+        allow(exception_with_nil_message).to receive(:message).and_return(nil)
+        exception_info = ExceptionInfo.new(exception_with_nil_message, @exception_context, @timestamp)
+        honeybadger_context_data = exception_info.honeybadger_context_data
+        expect(honeybadger_context_data[:log_context]).to eq({ "cuid" => 'ABCD' })
+      end
+
+      it "include thread context merged with log_context:" do
+        exception_with_nil_message = RuntimeError.new(nil)
+        allow(exception_with_nil_message).to receive(:message).and_return(nil)
+        exception_info = ExceptionInfo.new(exception_with_nil_message, @exception_context, @timestamp, log_context: { url: 'http://example.com' })
+        honeybadger_context_data = exception_info.honeybadger_context_data
+        expect(honeybadger_context_data[:log_context]).to eq({ "cuid" => 'ABCD', "url" => 'http://example.com' })
+      end
+
+      it "return the error details and relevant context data to be used as honeybadger notification context while filtering sensitive data" do
         env = { server: "fe98" }
         parameters = { advertiser_id: 435 }
         session = { username: "jsmith" }
         request_uri = "host/path"
         controller = create_dummy_controller(env, parameters, session, request_uri)
-        stub(ExceptionHandling).server_name { "invoca_fe98" }
+        allow(ExceptionHandling).to receive(:server_name).and_return("invoca_fe98")
 
         exception = StandardError.new("Some Exception")
         exception.set_backtrace([
-                                  "test/unit/exception_handling_test.rb:847:in `exception_1'",
-                                  "test/unit/exception_handling_test.rb:455:in `block (4 levels) in <class:ExceptionHandlingTest>'"
+                                  "spec/unit/exception_handling_test.rb:847:in `exception_1'",
+                                  "spec/unit/exception_handling_test.rb:455:in `block (4 levels) in <class:ExceptionHandlingTest>'"
                                 ])
         exception_context = { "SERVER_NAME" => "exceptional.com" }
         data_callback = ->(data) do
@@ -446,7 +465,6 @@ module ExceptionHandling
           exception_context: { "SERVER_NAME" => "exceptional.com" },
           server: "invoca_fe98",
           scm_revision: "5b24eac37aaa91f5784901e9aabcead36fd9df82",
-          notes: "this is used by a test",
           user_details: { "username" => "jsmith" },
           request: {
             "params" => { "advertiser_id" => 435 },
@@ -461,28 +479,30 @@ module ExceptionHandling
             "SERVER_NAME" => "exceptional.com"
           },
           backtrace: [
-            "test/unit/exception_handling_test.rb:847:in `exception_1'",
-            "test/unit/exception_handling_test.rb:455:in `block (4 levels) in <class:ExceptionHandlingTest>'"
+            "spec/unit/exception_handling_test.rb:847:in `exception_1'",
+            "spec/unit/exception_handling_test.rb:455:in `block (4 levels) in <class:ExceptionHandlingTest>'"
           ],
-          event_response: "Event successfully received"
+          event_response: "Event successfully received",
+          log_context: { "cuid" => "ABCD" },
+          notes: "this is used by a test"
         }
-        assert_equal_with_diff expected_data, exception_info.honeybadger_context_data
+        expect(exception_info.honeybadger_context_data).to eq(expected_data)
       end
 
       [['Hash',   { 'cookie' => 'cookie_context' }],
        ['String', 'Entering Error State'],
        ['Array',  ['Error1', 'Error2']]].each do |klass, value|
-        should "extract context from exception_context when it is a #{klass}" do
+        it "extract context from exception_context when it is a #{klass}" do
           exception = StandardError.new("Exception")
           exception_context = value
           exception_info = ExceptionInfo.new(exception, exception_context, Time.now)
 
-          assert_equal klass, value.class.name
-          assert_equal value, exception_info.honeybadger_context_data[:exception_context]
+          expect(value.class.name).to eq(klass)
+          expect(exception_info.honeybadger_context_data[:exception_context]).to eq(value)
         end
       end
 
-      should "filter out sensitive data from exception context such as [password, password_confirmation, oauth_token]" do
+      it "filter out sensitive data from exception context such as [password, password_confirmation, oauth_token]" do
         sensitive_data = {
           "password" => "super_secret",
           "password_confirmation" => "super_secret_confirmation",
@@ -517,15 +537,14 @@ module ExceptionHandling
           }
         }.merge(expected_sensitive_data)
 
-        assert_equal_with_diff expected_exception_context, exception_info.honeybadger_context_data[:exception_context]
+        expect(exception_info.honeybadger_context_data[:exception_context]).to eq(expected_exception_context)
       end
 
-      should "omit context if exception_context is empty" do
+      it "omit context if exception_context is empty" do
         exception = StandardError.new("Exception")
         exception_context = ""
         exception_info = ExceptionInfo.new(exception, exception_context, Time.now)
-
-        assert_nil exception_info.honeybadger_context_data[:exception_context]
+        expect(exception_info.honeybadger_context_data[:exception_context]).to be_nil
       end
     end