exception_handling 2.17.0.pre.tstarck.1 → 3.0.pre.1

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

@@ -1,75 +1,58 @@
 # frozen_string_literal: true
 
-require File.expand_path('../../spec_helper',  __dir__)
+require File.expand_path('../../test_helper',  __dir__)
 require_test_helper 'controller_helpers'
 require_test_helper 'exception_helpers'
 
 module ExceptionHandling
-  describe ExceptionInfo do
+  class ExceptionInfoTest < ActiveSupport::TestCase
     include ControllerHelpers
     include ExceptionHelpers
 
     context "initialize" do
-      before do
+      setup do
         @exception = StandardError.new("something went wrong")
         @timestamp = Time.now
         @controller = Object.new
       end
 
       context "controller_from_context" do
-        it "extract controller from context when not specified explicitly" do
+        should "extract controller from context when not specified explicitly" do
           exception_context = {
             "action_controller.instance" => @controller
           }
           exception_info = ExceptionInfo.new(@exception, exception_context, @timestamp)
-          expect(exception_info.controller).to eq(@controller)
+          assert_equal @controller, exception_info.controller
         end
 
-        it "prefer the explicit controller over the one from context" do
+        should "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)
-          expect(exception_info.controller).to eq(@controller)
-          expect(exception_info.controller).not_to eq(exception_context["action_controller.instance"])
+          exception_info = ExceptionInfo.new(@exception, exception_context, @timestamp, @controller)
+          assert_equal @controller, exception_info.controller
+          assert_not_equal exception_context["action_controller.instance"], exception_info.controller
         end
 
-        it "leave controller unset when not included in the context hash" do
+        should "leave controller unset when not included in the context hash" do
           exception_info = ExceptionInfo.new(@exception, {}, @timestamp)
-          expect(exception_info.controller).to be_nil
+          assert_nil exception_info.controller
         end
 
-        it "leave controller unset when context is not in hash format" do
+        should "leave controller unset when context is not in hash format" do
           exception_info = ExceptionInfo.new(@exception, "string context", @timestamp)
-          expect(exception_info.controller).to be_nil
-        end
-      end
-
-      context "honeybadger_tags" do
-        it "retrieved from log_context" do
-          exception_info = ExceptionInfo.new(@exception, "string context", @timestamp, log_context: { honeybadger_tags: ['Data-Services'] })
-          expect(exception_info.honeybadger_tags).to eq(['Data-Services'])
-        end
-
-        it "retrieved from log_context and normalized to array if a string" do
-          exception_info = ExceptionInfo.new(@exception, "string context", @timestamp, log_context: { honeybadger_tags: 'Data-Services' })
-          expect(exception_info.honeybadger_tags).to eq(['Data-Services'])
-        end
-
-        it "defaults to empty array if not given" do
-          exception_info = ExceptionInfo.new(@exception, "string context", @timestamp)
-          expect(exception_info.honeybadger_tags).to eq([])
+          assert_nil exception_info.controller
         end
       end
     end
 
     context "data" do
-      before do
+      setup do
         @exception = StandardError.new("something went wrong")
         @timestamp = Time.now
       end
 
-      it "return a hash with exception specific data including context hash" do
+      should "return a hash with exception specific data including context hash" do
         exception_context = {
           "rack.session" => {
             user_id: 23,
@@ -90,17 +73,17 @@ module ExceptionHandling
           }
         }
 
-        expect(exception_info.data).to eq(expected_data)
+        assert_equal_with_diff expected_data, exception_info.data
       end
 
-      it "generate exception data appropriately if exception message is nil" do
+      should "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
-        expect(exception_data["error_string"]).to eq("RuntimeError: ")
-        expect(exception_data["error"]).to eq("RuntimeError: : custom context data")
+        assert_equal "RuntimeError: ", exception_data["error_string"]
+        assert_equal "RuntimeError: : custom context data", exception_data["error"]
       end
 
-      it "return a hash with exception specific data including context string" do
+      should "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 = {
@@ -113,20 +96,21 @@ module ExceptionHandling
             "message" => "custom context data"
           }
         }
-        expect(exception_info.data).to eq(expected_data)
+
+        assert_equal_with_diff expected_data, exception_info.data
       end
 
-      it "not include enhanced data from controller or custom data callback" do
+      should "not include enhanced data from controller or custom data callback" do
         env = { server: "fe98" }
         parameters = { advertiser_id: 435 }
         session = { username: "jsmith" }
         request_uri = "host/path"
         controller = create_dummy_controller(env, parameters, session, request_uri)
         data_callback = ->(data) { data[:custom_section] = "value" }
-        exception_info = ExceptionInfo.new(@exception, "custom context data", @timestamp, controller: controller, data_callback: data_callback)
+        exception_info = ExceptionInfo.new(@exception, "custom context data", @timestamp, controller, data_callback)
 
-        expect(exception_info).to_not receive(:extract_and_merge_controller_data)
-        expect(exception_info).to_not receive(:customize_from_data_callback)
+        dont_allow(exception_info).extract_and_merge_controller_data
+        dont_allow(exception_info).customize_from_data_callback
         expected_data = {
           "error_class" => "StandardError",
           "error_string" => "StandardError: something went wrong",
@@ -138,12 +122,12 @@ module ExceptionHandling
           }
         }
 
-        expect(exception_info.data).to eq(expected_data)
+        assert_equal_with_diff expected_data, exception_info.data
       end
     end
 
     context "enhanced_data" do
-      before do
+      setup do
         @exception = StandardError.new("something went wrong")
         @timestamp = Time.now
         @exception_context = {
@@ -161,13 +145,13 @@ module ExceptionHandling
         @data_callback = ->(data) { data[:custom_section] = "check this out" }
       end
 
-      it "not return a mutable object for the session" do
+      should "not return a mutable object for the session" do
         exception_info = ExceptionInfo.new(@exception, @exception_context, @timestamp)
         exception_info.enhanced_data["session"]["hello"] = "world"
-        expect(@controller.session["hello"]).to be_nil
+        assert_nil @controller.session["hello"]
       end
 
-      it "return a hash with generic exception attributes as well as context data" do
+      should "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",
@@ -180,20 +164,20 @@ module ExceptionHandling
           "location" => { "file" => "<no backtrace>", "line" => nil }
         }
 
-        expect(prepare_data(exception_info.enhanced_data)).to eq(expected_data)
+        assert_equal_with_diff expected_data, prepare_data(exception_info.enhanced_data)
       end
 
-      it "generate exception data appropriately if exception message is nil" do
+      should "generate exception data appropriately if exception message is nil" do
         exception_with_nil_message = RuntimeError.new(nil)
-        allow(exception_with_nil_message).to receive(:message).and_return(nil)
+        stub(exception_with_nil_message).message { nil }
         exception_info = ExceptionInfo.new(exception_with_nil_message, @exception_context, @timestamp)
         exception_data = exception_info.enhanced_data
-        expect(exception_data["error_string"]).to eq("RuntimeError: ")
-        expect(exception_data["error"]).to eq("RuntimeError: ")
+        assert_equal "RuntimeError: ", exception_data["error_string"]
+        assert_equal "RuntimeError: ", exception_data["error"]
       end
 
-      it "include controller data when available" do
-        exception_info = ExceptionInfo.new(@exception, @exception_context, @timestamp, controller: @controller)
+      should "include controller data when available" do
+        exception_info = ExceptionInfo.new(@exception, @exception_context, @timestamp, @controller)
         expected_data = {
           "error_class" => "StandardError",
           "error_string" => "StandardError: something went wrong",
@@ -210,10 +194,10 @@ module ExceptionHandling
           "location" => { "controller" => "dummy", "action" => "fail", "file" => "<no backtrace>", "line" => nil }
         }
 
-        expect(prepare_data(exception_info.enhanced_data)).to eq(expected_data)
+        assert_equal_with_diff expected_data, prepare_data(exception_info.enhanced_data)
       end
 
-      it "extract controller from rack specific exception context when not provided explicitly" do
+      should "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 = {
@@ -232,11 +216,11 @@ module ExceptionHandling
           "location" => { "controller" => "dummy", "action" => "fail", "file" => "<no backtrace>", "line" => nil }
         }
 
-        expect(prepare_data(exception_info.enhanced_data)).to eq(expected_data)
+        assert_equal_with_diff expected_data, prepare_data(exception_info.enhanced_data)
       end
 
-      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)
+      should "add to_s attribute to specific sections that have their content in hash format" do
+        exception_info = ExceptionInfo.new(@exception, @exception_context, @timestamp, @controller)
         expected_data = {
           "error_class" => "StandardError",
           "error_string" => "StandardError: something went wrong",
@@ -261,13 +245,13 @@ module ExceptionHandling
           "location" => { "controller" => "dummy", "action" => "fail", "file" => "<no backtrace>", "line" => nil }
         }
 
-        expect(exception_info.enhanced_data).to eq(expected_data)
+        assert_equal_with_diff expected_data, exception_info.enhanced_data
       end
 
-      it "filter out sensitive parameters like passwords" do
+      should "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)
+        exception_info = ExceptionInfo.new(@exception, @exception_context, @timestamp, @controller)
         expected_params = {
           "password" => "[FILTERED]",
           "advertiser_id" => 435, "controller" => "dummy",
@@ -277,11 +261,11 @@ module ExceptionHandling
             "password_confirmation" => "[FILTERED]"
           }
         }
-        expect(exception_info.enhanced_data["request"]["params"]).to eq(expected_params)
+        assert_equal_with_diff expected_params, exception_info.enhanced_data["request"]["params"]
       end
 
-      it "include the changes from the custom data callback" do
-        exception_info = ExceptionInfo.new(@exception, @exception_context, @timestamp, controller: nil, data_callback: @data_callback)
+      should "include the changes from the custom data callback" do
+        exception_info = ExceptionInfo.new(@exception, @exception_context, @timestamp, nil, @data_callback)
         expected_data = {
           "error_class" => "StandardError",
           "error_string" => "StandardError: something went wrong",
@@ -294,11 +278,11 @@ module ExceptionHandling
           "location" => { "file" => "<no backtrace>", "line" => nil }
         }
 
-        expect(prepare_data(exception_info.enhanced_data)).to eq(expected_data)
+        assert_equal_with_diff expected_data, prepare_data(exception_info.enhanced_data)
       end
 
-      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" })
+      should "apply the custom_data_hook results" do
+        stub(ExceptionHandling).custom_data_hook { ->(data) { data[:custom_hook] = "changes from custom hook" } }
         exception_info = ExceptionInfo.new(@exception, @exception_context, @timestamp)
         expected_data = {
           "error_class" => "StandardError",
@@ -312,61 +296,61 @@ module ExceptionHandling
           "location" => { "file" => "<no backtrace>", "line" => nil }
         }
 
-        expect(prepare_data(exception_info.enhanced_data)).to eq(expected_data)
+        assert_equal_with_diff expected_data, prepare_data(exception_info.enhanced_data)
       end
 
-      it "log info if the custom data hook results in a nil message exception" do
+      should "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 = []
-        allow(ExceptionHandling.logger).to receive(:info).with(any_args) do |message, _|
+        stub(ExceptionHandling.logger).info.with_any_args do |message, _|
           log_info_messages << message
         end
 
         exception_info = ExceptionInfo.new(@exception, @exception_context, @timestamp)
         exception_info.enhanced_data
-        expect(log_info_messages.find { |message| message =~ /Unable to execute custom custom_data_hook callback/ }).to be_truthy
+        assert log_info_messages.find { |message| message =~ /Unable to execute custom custom_data_hook callback/ }
         ExceptionHandling.custom_data_hook = nil
       end
     end
 
     context "exception_description" do
-      it "return the exception description from the global exception filter list" do
+      should "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
-        expect(description).to_not be_nil
-        expect(description.filter_name).to eq(:NoRoute)
+        assert_not_nil description
+        assert_equal :NoRoute, description.filter_name
       end
 
-      it "find the description when filter criteria includes section in hash format" do
+      should "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" }
         request_uri = "host/path"
         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)
-        expect(exception_info.enhanced_data[:request].is_a?(Hash)).to eq(true)
+        exception_info = ExceptionInfo.new(exception, {}, Time.now, controller)
+        assert_equal true, exception_info.enhanced_data[:request].is_a?(Hash)
         description = exception_info.exception_description
-        expect(description).to_not be_nil
-        expect(description.filter_name).to eq(:"Click Request Rejected")
+        assert_not_nil description
+        assert_equal :"Click Request Rejected", description.filter_name
       end
 
-      it "return same description object for related errors (avoid reloading exception catalog from disk)" do
+      should "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)
+        exception_info = ExceptionInfo.new(exception, {}, 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)
-        expect(repeat_ex_info.exception_description.object_id).to eq(description.object_id)
+        repeat_ex_info = ExceptionInfo.new(repeat_ex, {}, Time.now)
+        assert_equal description.object_id, repeat_ex_info.exception_description.object_id
       end
     end
 
     context "controller_name" do
-      before do
+      setup do
         @exception = StandardError.new('something went wrong')
         @timestamp = Time.now
         @exception_context = {
@@ -378,113 +362,73 @@ module ExceptionHandling
         }
       end
 
-      it "returns honeybadger_grouping from the log context" do
-        allow(ExceptionHandling.logger).to receive(:current_context_for_thread).and_return({ honeybadger_grouping: 'Group 1' })
-        exception_info = ExceptionInfo.new(@exception, @exception_context, @timestamp)
-
-        expect(exception_info.controller_name).to eq('Group 1')
-      end
-
-      it "returns honeybadger_grouping from log context even if controller is defined" do
-        allow(ExceptionHandling.logger).to receive(:current_context_for_thread).and_return({ honeybadger_grouping: 'Group 1' })
-
+      should "return controller_name when controller is present" do
         env         = { server:     'fe98' }
         parameters  = { controller: 'some_controller' }
         session     = { username:   'smith' }
         request_uri = "host/path"
         controller  = create_dummy_controller(env, parameters, session, request_uri)
-        exception_info = ExceptionInfo.new(@exception, @exception_context, @timestamp, controller: controller)
+        exception_info = ExceptionInfo.new(@exception, @exception_context, @timestamp, controller)
 
-        expect(exception_info.controller_name).to eq('Group 1')
+        assert_equal 'some_controller', exception_info.controller_name
       end
 
-      it "return controller_name when controller is present" do
-        env         = { server:     'fe98' }
-        parameters  = { controller: 'some_controller' }
-        session     = { username:   'smith' }
-        request_uri = "host/path"
-        controller  = create_dummy_controller(env, parameters, session, request_uri)
-        exception_info = ExceptionInfo.new(@exception, @exception_context, @timestamp, controller: controller)
-
-        expect(exception_info.controller_name).to eq('some_controller')
-      end
-
-      it "return an empty string when controller is not present" do
+      should "return an empty string when controller is not present" do
         exception_info = ExceptionInfo.new(@exception, @exception_context, @timestamp)
 
-        expect(exception_info.controller_name).to eq('')
+        assert_equal '', exception_info.controller_name
       end
     end
 
     context "send_to_honeybadger?" do
-      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)
+      should "be enabled when Honeybadger is defined and exception is not in the filter list" do
+        stub(ExceptionHandling).honeybadger_defined? { true }
         exception = StandardError.new("something went wrong")
-        exception_info = ExceptionInfo.new(exception, nil, Time.now)
-        expect(exception_info.exception_description).to be_nil
-        expect(exception_info.send_to_honeybadger?).to eq(true)
+        exception_info = ExceptionInfo.new(exception, {}, Time.now)
+        assert_nil exception_info.exception_description
+        assert_equal true, exception_info.send_to_honeybadger?
       end
 
-      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)
+      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 }
         exception = StandardError.new("No route matches")
-        exception_info = ExceptionInfo.new(exception, nil, Time.now)
-        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)
+        exception_info = ExceptionInfo.new(exception, {}, 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?
       end
 
-      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)
+      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 }
         exception = StandardError.new("No route matches")
-        exception_info = ExceptionInfo.new(exception, nil, Time.now)
-        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)
+        exception_info = ExceptionInfo.new(exception, {}, 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?
       end
 
-      it "be disabled when Honeybadger is not defined" do
-        allow(ExceptionHandling).to receive(:honeybadger_defined?).and_return(false)
+      should "be disabled when Honeybadger is not defined" do
+        stub(ExceptionHandling).honeybadger_defined? { false }
         exception = StandardError.new("something went wrong")
-        exception_info = ExceptionInfo.new(exception, nil, Time.now)
-        expect(exception_info.exception_description).to be_nil
-        expect(exception_info.send_to_honeybadger?).to eq(false)
+        exception_info = ExceptionInfo.new(exception, {}, Time.now)
+        assert_nil exception_info.exception_description
+        assert_equal false, exception_info.send_to_honeybadger?
       end
     end
 
     context "honeybadger_context_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
+      should "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)
-        allow(ExceptionHandling).to receive(:server_name).and_return("invoca_fe98")
+        stub(ExceptionHandling).server_name { "invoca_fe98" }
 
         exception = StandardError.new("Some Exception")
         exception.set_backtrace([
-                                  "spec/unit/exception_handling_test.rb:847:in `exception_1'",
-                                  "spec/unit/exception_handling_test.rb:455:in `block (4 levels) in <class:ExceptionHandlingTest>'"
+                                  "test/unit/exception_handling_test.rb:847:in `exception_1'",
+                                  "test/unit/exception_handling_test.rb:455:in `block (4 levels) in <class:ExceptionHandlingTest>'"
                                 ])
         exception_context = { "SERVER_NAME" => "exceptional.com" }
         data_callback = ->(data) do
@@ -494,7 +438,7 @@ module ExceptionHandling
           data[:other_section] = "This should not be included in the response"
         end
         timestamp = Time.now
-        exception_info = ExceptionInfo.new(exception, exception_context, timestamp, controller: controller, data_callback: data_callback)
+        exception_info = ExceptionInfo.new(exception, exception_context, timestamp, controller, data_callback)
 
         expected_data = {
           timestamp: timestamp,
@@ -502,6 +446,7 @@ 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 },
@@ -516,30 +461,28 @@ module ExceptionHandling
             "SERVER_NAME" => "exceptional.com"
           },
           backtrace: [
-            "spec/unit/exception_handling_test.rb:847:in `exception_1'",
-            "spec/unit/exception_handling_test.rb:455:in `block (4 levels) in <class:ExceptionHandlingTest>'"
+            "test/unit/exception_handling_test.rb:847:in `exception_1'",
+            "test/unit/exception_handling_test.rb:455:in `block (4 levels) in <class:ExceptionHandlingTest>'"
           ],
-          event_response: "Event successfully received",
-          log_context: { "cuid" => "ABCD" },
-          notes: "this is used by a test"
+          event_response: "Event successfully received"
         }
-        expect(exception_info.honeybadger_context_data).to eq(expected_data)
+        assert_equal_with_diff expected_data, exception_info.honeybadger_context_data
       end
 
       [['Hash',   { 'cookie' => 'cookie_context' }],
        ['String', 'Entering Error State'],
        ['Array',  ['Error1', 'Error2']]].each do |klass, value|
-        it "extract context from exception_context when it is a #{klass}" do
+        should "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)
 
-          expect(value.class.name).to eq(klass)
-          expect(exception_info.honeybadger_context_data[:exception_context]).to eq(value)
+          assert_equal klass, value.class.name
+          assert_equal value, exception_info.honeybadger_context_data[:exception_context]
         end
       end
 
-      it "filter out sensitive data from exception context such as [password, password_confirmation, oauth_token]" do
+      should "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",
@@ -574,14 +517,15 @@ module ExceptionHandling
           }
         }.merge(expected_sensitive_data)
 
-        expect(exception_info.honeybadger_context_data[:exception_context]).to eq(expected_exception_context)
+        assert_equal_with_diff expected_exception_context, exception_info.honeybadger_context_data[:exception_context]
       end
 
-      it "omit context if exception_context is empty" do
+      should "omit context if exception_context is empty" do
         exception = StandardError.new("Exception")
         exception_context = ""
         exception_info = ExceptionInfo.new(exception, exception_context, Time.now)
-        expect(exception_info.honeybadger_context_data[:exception_context]).to be_nil
+
+        assert_nil exception_info.honeybadger_context_data[:exception_context]
       end
     end