exception_handling 2.6.1 → 2.7.0.pre.1

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

@@ -1,58 +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"])
+          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
+          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,
@@ -73,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 = {
@@ -96,10 +96,11 @@ 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" }
@@ -108,8 +109,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)
 
-        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",
@@ -121,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 = {
@@ -144,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",
@@ -163,19 +164,19 @@ 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
+      should "include controller data when available" do
         exception_info = ExceptionInfo.new(@exception, @exception_context, @timestamp, controller: @controller)
         expected_data = {
           "error_class" => "StandardError",
@@ -193,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 = {
@@ -215,10 +216,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 "add to_s attribute to specific sections that have their content in hash format" do
+      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: @controller)
         expected_data = {
           "error_class" => "StandardError",
@@ -244,10 +245,10 @@ 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)
@@ -260,10 +261,10 @@ 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
+      should "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",
@@ -277,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",
@@ -295,35 +296,35 @@ 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" }
@@ -331,25 +332,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)
-        expect(exception_info.enhanced_data[:request].is_a?(Hash)).to eq(true)
+        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)
         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)
+        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 = {
@@ -361,7 +362,7 @@ module ExceptionHandling
         }
       end
 
-      it "return controller_name when controller is present" do
+      should "return controller_name when controller is present" do
         env         = { server:     'fe98' }
         parameters  = { controller: 'some_controller' }
         session     = { username:   'smith' }
@@ -369,85 +370,85 @@ module ExceptionHandling
         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')
+        assert_equal 'some_controller', exception_info.controller_name
       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)
+        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)
+        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)
+        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)
+        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' })
+      setup do
+        stub(ExceptionHandling.logger).current_context_for_thread { { cuid: 'ABCD' } }
       end
 
-      it "include thread_context when log_context: is nil" do
+      should "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)
+        stub(exception_with_nil_message).message { 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' })
+        assert_equal({ "cuid" => 'ABCD' }, honeybadger_context_data[:log_context])
       end
 
-      it "include thread context merged with log_context:" do
+      should "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)
+        stub(exception_with_nil_message).message { 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' })
+        assert_equal({ "cuid" => 'ABCD', "url" => 'http://example.com' }, honeybadger_context_data[:log_context])
       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
@@ -465,6 +466,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 },
@@ -479,30 +481,29 @@ 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"
+          log_context: { "cuid" => "ABCD" }
         }
-        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",
@@ -537,14 +538,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
 

data/{spec/unit/exception_handling/honeybadger_callbacks_spec.rb → test/unit/exception_handling/honeybadger_callbacks_test.rb}

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require File.expand_path('../../spec_helper',  __dir__)
+require File.expand_path('../../test_helper',  __dir__)
 
 module ExceptionHandling
-  describe HoneybadgerCallbacks do
+  class HoneybadgerCallbacksTest < ActiveSupport::TestCase
 
     class TestPoroWithAttribute
       attr_reader :test_attribute
@@ -55,15 +55,15 @@ module ExceptionHandling
     end
 
     context "register_callbacks" do
-      it "store the callbacks in the honeybadger object" do
+      should "store the callbacks in the honeybadger object" do
         HoneybadgerCallbacks.register_callbacks
         result = Honeybadger.config.local_variable_filter.call(:variable_name, 'test', [])
-        expect(result).to eq('test')
+        assert_equal('test', result)
       end
     end
 
     context "local_variable_filter" do
-      it "not inspect String, Hash, Array, Set, Numeric, TrueClass, FalseClass, NilClass" do
+      should "not inspect String, Hash, Array, Set, Numeric, TrueClass, FalseClass, NilClass" do
         [
           ['test', String],
           [{ a: 1 }, Hash],
@@ -75,46 +75,46 @@ module ExceptionHandling
           [nil, NilClass]
         ].each do |object, expected_class|
           result = HoneybadgerCallbacks.send(:local_variable_filter, :variable_name, object, [])
-          expect(result.is_a?(expected_class)).to be_truthy
+          assert result.is_a?(expected_class), "Expected #{expected_class.name} but got #{result.class.name}"
         end
       end
 
-      it "inspect other classes" do
+      should "inspect other classes" do
         result = HoneybadgerCallbacks.send(:local_variable_filter, :variable_name, TestPoroWithAttribute.new, ['password'])
-        expect(result).to match(/#<ExceptionHandling::TestPoroWithAttribute:.* @test_attribute="test">/)
+        assert_match(/#<ExceptionHandling::HoneybadgerCallbacksTest::TestPoroWithAttribute:.* @test_attribute="test">/, result)
       end
 
       context "when inspect raises exceptions" do
-        it "handle exceptions for objects" do
+        should "handle exceptions for objects" do
           result = HoneybadgerCallbacks.send(:local_variable_filter, :variable_name, TestRaiseOnInspect.new, ['password'])
-          expect(result).to eq("#<ExceptionHandling::TestRaiseOnInspect [error 'RuntimeError: some error' while calling #inspect]>")
+          assert_equal "#<ExceptionHandling::HoneybadgerCallbacksTest::TestRaiseOnInspect [error 'RuntimeError: some error' while calling #inspect]>", result
         end
 
-        it "handle exceptions for objects responding to id" do
+        should "handle exceptions for objects responding to id" do
           result = HoneybadgerCallbacks.send(:local_variable_filter, :variable_name, TestRaiseOnInspectWithId.new, ['password'])
-          expect(result).to eq("#<ExceptionHandling::TestRaiseOnInspectWithId @id=123 [error 'RuntimeError: some error' while calling #inspect]>")
+          assert_equal "#<ExceptionHandling::HoneybadgerCallbacksTest::TestRaiseOnInspectWithId @id=123 [error 'RuntimeError: some error' while calling #inspect]>", result
         end
 
-        it "handle exceptions for objects responding to to_pk" do
+        should "handle exceptions for objects responding to to_pk" do
           result = HoneybadgerCallbacks.send(:local_variable_filter, :variable_name, TestRaiseOnInspectWithToPk.new, ['password'])
-          expect(result).to eq("#<ExceptionHandling::TestRaiseOnInspectWithToPk @pk=SomeRecord-123 [error 'RuntimeError: some error' while calling #inspect]>")
+          assert_equal "#<ExceptionHandling::HoneybadgerCallbacksTest::TestRaiseOnInspectWithToPk @pk=SomeRecord-123 [error 'RuntimeError: some error' while calling #inspect]>", result
         end
       end
 
       context "not inspect objects that contain filter keys" do
-        it "use to_pk if available, even if id is available" do
+        should "use to_pk if available, even if id is available" do
           result = HoneybadgerCallbacks.send(:local_variable_filter, :variable_name, TestPoroWithFilteredAttributePkAndId.new, ['password'])
-          expect(result).to match(/#<ExceptionHandling::TestPoroWithFilteredAttributePkAndId @pk=TestPoroWithFilteredAttributePkAndId_1, \[FILTERED\]>/)
+          assert_match(/#<ExceptionHandling::HoneybadgerCallbacksTest::TestPoroWithFilteredAttributePkAndId @pk=TestPoroWithFilteredAttributePkAndId_1, \[FILTERED\]>/, result)
         end
 
-        it "use id if to_pk is not available" do
+        should "use id if to_pk is not available" do
           result = HoneybadgerCallbacks.send(:local_variable_filter, :variable_name, TestPoroWithFilteredAttributeAndId.new, ['password'])
-          expect(result).to match(/#<ExceptionHandling::TestPoroWithFilteredAttributeAndId @id=1, \[FILTERED\]>/)
+          assert_match(/#<ExceptionHandling::HoneybadgerCallbacksTest::TestPoroWithFilteredAttributeAndId @id=1, \[FILTERED\]>/, result)
         end
 
-        it "print the object name if no id or to_pk" do
+        should "print the object name if no id or to_pk" do
           result = HoneybadgerCallbacks.send(:local_variable_filter, :variable_name, TestPoroWithFilteredAttribute.new, ['password'])
-          expect(result).to match(/#<ExceptionHandling::TestPoroWithFilteredAttribute \[FILTERED\]>/)
+          assert_match(/#<ExceptionHandling::HoneybadgerCallbacksTest::TestPoroWithFilteredAttribute \[FILTERED\]>/, result)
         end
       end
     end