exception_handling 2.6.1 → 2.7.0.pre.1

data/{spec/unit/exception_handling_spec.rb → test/unit/exception_handling_test.rb}

@@ -1,14 +1,14 @@
 # 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'
 
-describe ExceptionHandling do
+class ExceptionHandlingTest < ActiveSupport::TestCase
   include ControllerHelpers
   include ExceptionHelpers
 
-  before do
+  setup do
     @fail_count = 0
   end
 
@@ -108,228 +108,228 @@ describe ExceptionHandling do
   end
 
   context "with warn and honeybadger notify stubbed" do
-    before do
-      allow(ExceptionHandling).to receive(:warn).with(anything)
-      allow(Honeybadger).to receive(:notify).with(anything)
+    setup do
+      stub(ExceptionHandling).warn(anything)
+      stub(Honeybadger).notify(anything)
     end
 
     context "with logger stashed" do
-      before { @original_logger = ExceptionHandling.logger }
-      after { ExceptionHandling.logger = @original_logger }
+      setup { @original_logger = ExceptionHandling.logger }
+      teardown { ExceptionHandling.logger = @original_logger }
 
-      it "store logger as-is if it has ContextualLogger::Mixin" do
+      should "store logger as-is if it has ContextualLogger::Mixin" do
         logger = Logger.new('/dev/null')
         logger.extend(ContextualLogger::LoggerMixin)
         ancestors = logger.singleton_class.ancestors.*.name
 
         ExceptionHandling.logger = logger
-        expect(ExceptionHandling.logger.singleton_class.ancestors.*.name).to eq(ancestors)
+        assert_equal ancestors, ExceptionHandling.logger.singleton_class.ancestors.*.name
       end
 
-      it "allow logger = nil (no deprecation warning)" do
-        expect(STDERR).to receive(:puts).with(/DEPRECATION WARNING/).never
+      should "allow logger = nil (no deprecation warning)" do
+        mock(STDERR).puts(/DEPRECATION WARNING/).never
         ExceptionHandling.logger = nil
       end
 
-      it "[deprecated] mix in ContextualLogger::Mixin if not there" do
-        expect(STDERR).to receive(:puts).with(/DEPRECATION WARNING: implicit extend with ContextualLogger::LoggerMixin is deprecated and will be removed from exception_handling 3\.0/)
+      should "[deprecated] mix in ContextualLogger::Mixin if not there" do
+        mock(STDERR).puts(/DEPRECATION WARNING: implicit extend with ContextualLogger::LoggerMixin is deprecated and will be removed from exception_handling 3\.0/)
         logger = Logger.new('/dev/null')
         ancestors = logger.singleton_class.ancestors.*.name
 
         ExceptionHandling.logger = logger
-        expect(ExceptionHandling.logger.singleton_class.ancestors.*.name).to_not eq(ancestors)
-        expect(ExceptionHandling.logger).to be_kind_of(ContextualLogger::LoggerMixin)
+        assert_not_equal ancestors, ExceptionHandling.logger.singleton_class.ancestors.*.name
+        assert_kind_of ContextualLogger::LoggerMixin, ExceptionHandling.logger
       end
     end
 
     context "#log_error" do
-      it "take in additional logging context hash and pass it to the logger" do
+      should "take in additional logging context hash and pass it to the logger" do
         ExceptionHandling.log_error('This is an Error', 'This is the prefix context', service_name: 'exception_handling')
-        expect(logged_excluding_reload_filter.last[:message]).to match(/This is an Error/)
-        expect(logged_excluding_reload_filter.last[:context]).to_not be_empty
-        expect(service_name: 'exception_handling').to eq(logged_excluding_reload_filter.last[:context])
+        assert_match(/This is an Error/, logged_excluding_reload_filter.last[:message])
+        assert_not_empty logged_excluding_reload_filter.last[:context]
+        assert_equal logged_excluding_reload_filter.last[:context], service_name: 'exception_handling'
       end
 
-      it "log with Severity::FATAL" do
+      should "log with Severity::FATAL" do
         ExceptionHandling.log_error('This is a Warning', service_name: 'exception_handling')
-        expect('FATAL').to eq(logged_excluding_reload_filter.last[:severity])
+        assert_equal logged_excluding_reload_filter.last[:severity], 'FATAL'
       end
     end
 
     context "#log_warning" do
-      it "have empty array as a backtrace" do
-        expect(ExceptionHandling).to receive(:log_error).with((ExceptionHandling::Warning), anything) do |error|
-          expect(error.backtrace).to eq([])
+      should "have empty array as a backtrace" do
+        mock(ExceptionHandling).log_error(is_a(ExceptionHandling::Warning), anything) do |error|
+          assert_equal [], error.backtrace
         end
         ExceptionHandling.log_warning('Now with empty array as a backtrace!')
       end
 
-      it "take in additional key word args as logging context and pass them to the logger" do
+      should "take in additional key word args as logging context and pass them to the logger" do
         ExceptionHandling.log_warning('This is a Warning', service_name: 'exception_handling')
-        expect(logged_excluding_reload_filter.last[:message]).to match(/This is a Warning/)
-        expect(logged_excluding_reload_filter.last[:context]).to_not be_empty
-        expect(service_name: 'exception_handling').to eq(logged_excluding_reload_filter.last[:context])
+        assert_match(/This is a Warning/, logged_excluding_reload_filter.last[:message])
+        assert_not_empty logged_excluding_reload_filter.last[:context]
+        assert_equal logged_excluding_reload_filter.last[:context], service_name: 'exception_handling'
       end
 
-      it "log with Severity::WARN" do
+      should "log with Severity::WARN" do
         ExceptionHandling.log_warning('This is a Warning', service_name: 'exception_handling')
-        expect('WARN').to eq(logged_excluding_reload_filter.last[:severity])
+        assert_equal logged_excluding_reload_filter.last[:severity], 'WARN'
       end
     end
 
     context "#log_info" do
-      it "take in additional key word args as logging context and pass them to the logger" do
+      should "take in additional key word args as logging context and pass them to the logger" do
         ExceptionHandling.log_info('This is an Info', service_name: 'exception_handling')
-        expect(logged_excluding_reload_filter.last[:message]).to match(/This is an Info/)
-        expect(logged_excluding_reload_filter.last[:context]).to_not be_empty
-        expect(service_name: 'exception_handling').to eq(logged_excluding_reload_filter.last[:context])
+        assert_match(/This is an Info/, logged_excluding_reload_filter.last[:message])
+        assert_not_empty logged_excluding_reload_filter.last[:context]
+        assert_equal logged_excluding_reload_filter.last[:context], service_name: 'exception_handling'
       end
 
-      it "log with Severity::INFO" do
+      should "log with Severity::INFO" do
         ExceptionHandling.log_info('This is a Warning', service_name: 'exception_handling')
-        expect('INFO').to eq(logged_excluding_reload_filter.last[:severity])
+        assert_equal logged_excluding_reload_filter.last[:severity], 'INFO'
       end
     end
 
     context "#log_debug" do
-      it "take in additional key word args as logging context and pass them to the logger" do
+      should "take in additional key word args as logging context and pass them to the logger" do
         ExceptionHandling.log_debug('This is a Debug', service_name: 'exception_handling')
-        expect(logged_excluding_reload_filter.last[:message]).to match(/This is a Debug/)
-        expect(logged_excluding_reload_filter.last[:context]).to_not be_empty
-        expect(service_name: 'exception_handling').to eq(logged_excluding_reload_filter.last[:context])
+        assert_match(/This is a Debug/, logged_excluding_reload_filter.last[:message])
+        assert_not_empty logged_excluding_reload_filter.last[:context]
+        assert_equal logged_excluding_reload_filter.last[:context], service_name: 'exception_handling'
       end
 
-      it "log with Severity::DEBUG" do
+      should "log with Severity::DEBUG" do
         ExceptionHandling.log_debug('This is a Warning', service_name: 'exception_handling')
-        expect('DEBUG').to eq(logged_excluding_reload_filter.last[:severity])
+        assert_equal logged_excluding_reload_filter.last[:severity], 'DEBUG'
       end
     end
 
     context "#write_exception_to_log" do
-      it "log warnings with Severity::WARN" do
+      should "log warnings with Severity::WARN" do
         warning = ExceptionHandling::Warning.new('This is a Warning')
         ExceptionHandling.write_exception_to_log(warning, '', Time.now.to_i, service_name: 'exception_handling')
-        expect('WARN').to eq(logged_excluding_reload_filter.last[:severity])
+        assert_equal logged_excluding_reload_filter.last[:severity], 'WARN'
       end
 
-      it "log everything else with Severity::FATAL" do
+      should "log everything else with Severity::FATAL" do
         error = RuntimeError.new('This is a runtime error')
         ExceptionHandling.write_exception_to_log(error, '', Time.now.to_i, service_name: 'exception_handling')
-        expect('FATAL').to eq(logged_excluding_reload_filter.last[:severity])
+        assert_equal logged_excluding_reload_filter.last[:severity], 'FATAL'
       end
     end
 
     context "configuration with custom_data_hook or post_log_error_hook" do
-      after do
+      teardown do
         ExceptionHandling.custom_data_hook = nil
         ExceptionHandling.post_log_error_hook = nil
       end
 
-      it "support a custom_data_hook" do
+      should "support a custom_data_hook" do
         capture_notifications
 
         ExceptionHandling.custom_data_hook = method(:append_organization_info_config)
         ExceptionHandling.ensure_safe("context") { raise "Some Exception" }
 
-        expect(sent_notifications.last.enhanced_data['user_details'].to_s).to match(/Invoca Engineering Dept./)
+        assert_match(/Invoca Engineering Dept./, sent_notifications.last.enhanced_data['user_details'].to_s)
       end
 
-      it "support a log_error hook, and pass exception_data, treat_like_warning, and logged_to_honeybadger to it" do
+      should "support a log_error hook, and pass exception_data, treat_like_warning, and logged_to_honeybadger to it" do
         @honeybadger_status = nil
         ExceptionHandling.post_log_error_hook = method(:log_error_callback_config)
 
         notify_args = []
-        expect(Honeybadger).to receive(:notify).with(any_args) { |info| notify_args << info; '06220c5a-b471-41e5-baeb-de247da45a56' }
+        mock(Honeybadger).notify.with_any_args { |info| notify_args << info; '06220c5a-b471-41e5-baeb-de247da45a56' }
         ExceptionHandling.ensure_safe("context") { raise "Some Exception" }
-        expect(@fail_count).to eq(1)
-        expect(@treat_like_warning).to eq(false)
-        expect(@honeybadger_status).to eq(:success)
+        assert_equal 1, @fail_count
+        assert_equal false, @treat_like_warning
+        assert_equal :success, @honeybadger_status
 
-        expect(@callback_data["notes"]).to eq("this is used by a test")
-        expect(notify_args.size).to eq(1), notify_args.inspect
-        expect(notify_args.last[:context].to_s).to match(/this is used by a test/)
+        assert_equal "this is used by a test", @callback_data["notes"]
+        assert_equal 1, notify_args.size, notify_args.inspect
+        assert_match(/this is used by a test/, notify_args.last[:context].to_s)
       end
 
-      it "plumb treat_like_warning and logged_to_honeybadger to log error hook" do
+      should "plumb treat_like_warning and logged_to_honeybadger to log error hook" do
         @honeybadger_status = nil
         ExceptionHandling.post_log_error_hook = method(:log_error_callback_config)
         ExceptionHandling.log_error(StandardError.new("Some Exception"), "mooo", treat_like_warning: true)
-        expect(@fail_count).to eq(1)
-        expect(@treat_like_warning).to eq(true)
-        expect(@honeybadger_status).to eq(:skipped)
+        assert_equal 1, @fail_count
+        assert_equal true, @treat_like_warning
+        assert_equal :skipped, @honeybadger_status
       end
 
-      it "include logging context in the exception data" do
+      should "include logging context in the exception data" do
         ExceptionHandling.post_log_error_hook = method(:log_error_callback_config)
         ExceptionHandling.log_error(StandardError.new("Some Exception"), "mooo", treat_like_warning: true, log_context_test: "contextual_logging")
 
         expected_log_context = {
           "log_context_test" => "contextual_logging"
         }
-        expect(@callback_data[:log_context]).to eq(expected_log_context)
+        assert_equal expected_log_context, @callback_data[:log_context]
       end
 
-      it "support rescue exceptions from a log_error hook" do
+      should "support rescue exceptions from a log_error hook" do
         ExceptionHandling.post_log_error_hook = method(:log_error_callback_with_failure)
         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
-        expect { ExceptionHandling.ensure_safe("mooo") { raise "Some Exception" } }.to_not raise_error
-        expect(log_info_messages.find { |message| message =~ /Unable to execute custom log_error callback/ }).to be_truthy
+        assert_nothing_raised { ExceptionHandling.ensure_safe("mooo") { raise "Some Exception" } }
+        assert log_info_messages.find { |message| message =~ /Unable to execute custom log_error callback/ }
       end
 
-      it "handle nil message exceptions resulting from the log_error hook" do
+      should "handle nil message exceptions resulting from the log_error hook" do
         ExceptionHandling.post_log_error_hook = method(:log_error_callback_returns_nil_message_exception)
         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
-        expect { ExceptionHandling.ensure_safe("mooo") { raise "Some Exception" } }.to_not raise_error
-        expect(log_info_messages.find { |message| message =~ /Unable to execute custom log_error callback/ }).to be_truthy
+        assert_nothing_raised { ExceptionHandling.ensure_safe("mooo") { raise "Some Exception" } }
+        assert log_info_messages.find { |message| message =~ /Unable to execute custom log_error callback/ }
       end
 
-      it "handle nil message exceptions resulting from the custom data hook" do
+      should "handle nil message exceptions resulting from the custom data hook" do
         ExceptionHandling.custom_data_hook = method(:custom_data_callback_returns_nil_message_exception)
         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
-        expect { ExceptionHandling.ensure_safe("mooo") { raise "Some Exception" } }.not_to raise_error
-        expect(log_info_messages.find { |message| message =~ /Unable to execute custom custom_data_hook callback/ }).to be_truthy
+        assert_nothing_raised { ExceptionHandling.ensure_safe("mooo") { raise "Some Exception" } }
+        assert log_info_messages.find { |message| message =~ /Unable to execute custom custom_data_hook callback/ }
       end
     end
 
     context "Exception Handling" do
       context "default_metric_name" do
         context "when metric_name is present in exception_data" do
-          it "include metric_name in resulting metric name" do
+          should "include metric_name in resulting metric name" do
             exception = StandardError.new('this is an exception')
             metric    = ExceptionHandling.default_metric_name({ 'metric_name' => 'special_metric' }, exception, true)
-            expect(metric).to eq('exception_handling.special_metric')
+            assert_equal 'exception_handling.special_metric', metric
           end
         end
 
         context "when metric_name is not present in exception_data" do
-          it "return exception_handling.warning when using log warning" do
+          should "return exception_handling.warning when using log warning" do
             warning = ExceptionHandling::Warning.new('this is a warning')
             metric  = ExceptionHandling.default_metric_name({}, warning, false)
-            expect(metric).to eq('exception_handling.warning')
+            assert_equal 'exception_handling.warning', metric
           end
 
-          it "return exception_handling.exception when using log error" do
+          should "return exception_handling.exception when using log error" do
             exception = StandardError.new('this is an exception')
             metric    = ExceptionHandling.default_metric_name({}, exception, false)
-            expect(metric).to eq('exception_handling.exception')
+            assert_equal 'exception_handling.exception', metric
           end
 
           context "when using log error with treat_like_warning" do
-            it "return exception_handling.unforwarded_exception when exception not present" do
+            should "return exception_handling.unforwarded_exception when exception not present" do
               metric = ExceptionHandling.default_metric_name({}, nil, true)
-              expect(metric).to eq('exception_handling.unforwarded_exception')
+              assert_equal 'exception_handling.unforwarded_exception', metric
             end
 
-            it "return exception_handling.unforwarded_exception with exception classname when exception is present" do
+            should "return exception_handling.unforwarded_exception with exception classname when exception is present" do
               module SomeModule
                 class SomeException < StandardError
                 end
@@ -337,43 +337,43 @@ describe ExceptionHandling do
 
               exception = SomeModule::SomeException.new('this is an exception')
               metric    = ExceptionHandling.default_metric_name({}, exception, true)
-              expect(metric).to eq('exception_handling.unforwarded_exception_SomeException')
+              assert_equal 'exception_handling.unforwarded_exception_SomeException', metric
             end
           end
         end
       end
 
       context "default_honeybadger_metric_name" do
-        it "return exception_handling.honeybadger.success when status is :success" do
+        should "return exception_handling.honeybadger.success when status is :success" do
           metric = ExceptionHandling.default_honeybadger_metric_name(:success)
-          expect(metric).to eq('exception_handling.honeybadger.success')
+          assert_equal 'exception_handling.honeybadger.success', metric
         end
 
-        it "return exception_handling.honeybadger.failure when status is :failure" do
+        should "return exception_handling.honeybadger.failure when status is :failure" do
           metric = ExceptionHandling.default_honeybadger_metric_name(:failure)
-          expect(metric).to eq('exception_handling.honeybadger.failure')
+          assert_equal 'exception_handling.honeybadger.failure', metric
         end
 
-        it "return exception_handling.honeybadger.skipped when status is :skipped" do
+        should "return exception_handling.honeybadger.skipped when status is :skipped" do
           metric = ExceptionHandling.default_honeybadger_metric_name(:skipped)
-          expect(metric).to eq('exception_handling.honeybadger.skipped')
+          assert_equal 'exception_handling.honeybadger.skipped', metric
         end
 
-        it "return exception_handling.honeybadger.unknown_status when status is not recognized" do
+        should "return exception_handling.honeybadger.unknown_status when status is not recognized" do
           metric = ExceptionHandling.default_honeybadger_metric_name(nil)
-          expect(metric).to eq('exception_handling.honeybadger.unknown_status')
+          assert_equal 'exception_handling.honeybadger.unknown_status', metric
         end
       end
 
       context "ExceptionHandling.ensure_safe" do
-        it "log an exception with call stack if an exception is raised." do
-          expect(ExceptionHandling.logger).to receive(:fatal).with(/\(blah\):\n.*exception_handling_spec\.rb/, anything)
+        should "log an exception with call stack if an exception is raised." do
+          mock(ExceptionHandling.logger).fatal(/\(blah\):\n.*exception_handling_test\.rb/, anything)
           ExceptionHandling.ensure_safe { raise ArgumentError, "blah" }
         end
 
         if ActionView::VERSION::MAJOR >= 5
-          it "log an exception with call stack if an ActionView template exception is raised." do
-            expect(ExceptionHandling.logger).to receive(:fatal).with(/\(Error:\d+\) \nActionView::Template::Error: \(blah\):\n /, anything)
+          should "log an exception with call stack if an ActionView template exception is raised." do
+            mock(ExceptionHandling.logger).fatal(/\(Error:\d+\) \nActionView::Template::Error: \(blah\):\n /, anything)
             ExceptionHandling.ensure_safe do
               begin
                 # Rails 5 made the switch from ActionView::TemplateError taking in the original exception
@@ -385,292 +385,297 @@ describe ExceptionHandling do
             end
           end
         else
-          it "log an exception with call stack if an ActionView template exception is raised." do
-            expect(ExceptionHandling.logger).to receive(:fatal).with(/\(Error:\d+\) \nActionView::Template::Error: \(blah\):\n /, anything)
+          should "log an exception with call stack if an ActionView template exception is raised." do
+            mock(ExceptionHandling.logger).fatal(/\(Error:\d+\) \nActionView::Template::Error: \(blah\):\n /, anything)
             ExceptionHandling.ensure_safe { raise ActionView::TemplateError.new({}, ArgumentError.new("blah")) }
           end
         end
 
-        it "should not log an exception if an exception is not raised." do
-          expect(ExceptionHandling.logger).to_not receive(:fatal)
+        should "should not log an exception if an exception is not raised." do
+          dont_allow(ExceptionHandling.logger).fatal
           ExceptionHandling.ensure_safe { ; }
         end
 
-        it "return its value if used during an assignment" do
-          expect(ExceptionHandling.logger).to_not receive(:fatal)
+        should "return its value if used during an assignment" do
+          dont_allow(ExceptionHandling.logger).fatal
           b = ExceptionHandling.ensure_safe { 5 }
-          expect(b).to eq(5)
+          assert_equal 5, b
         end
 
-        it "return nil if an exception is raised during an assignment" do
-          expect(ExceptionHandling.logger).to receive(:fatal).with(/\(blah\):\n.*exception_handling_spec\.rb/, anything)
+        should "return nil if an exception is raised during an assignment" do
+          mock(ExceptionHandling.logger).fatal(/\(blah\):\n.*exception_handling_test\.rb/, anything)
           b = ExceptionHandling.ensure_safe { raise ArgumentError, "blah" }
-          expect(b).to be_nil
+          assert_nil b
         end
 
-        it "allow a message to be appended to the error when logged." do
-          expect(ExceptionHandling.logger).to receive(:fatal).with(/mooo\nArgumentError: \(blah\):\n.*exception_handling_spec\.rb/, anything)
+        should "allow a message to be appended to the error when logged." do
+          mock(ExceptionHandling.logger).fatal(/mooo\nArgumentError: \(blah\):\n.*exception_handling_test\.rb/, anything)
           b = ExceptionHandling.ensure_safe("mooo") { raise ArgumentError, "blah" }
-          expect(b).to be_nil
+          assert_nil b
         end
 
-        it "only rescue StandardError and descendents" do
-          expect { ExceptionHandling.ensure_safe("mooo") { raise Exception } }.to raise_exception(Exception)
+        should "only rescue StandardError and descendents" do
+          assert_raise(Exception) { ExceptionHandling.ensure_safe("mooo") { raise Exception } }
 
-          expect(ExceptionHandling.logger).to receive(:fatal).with(/mooo\nStandardError: \(blah\):\n.*exception_handling_spec\.rb/, anything)
+          mock(ExceptionHandling.logger).fatal(/mooo\nStandardError: \(blah\):\n.*exception_handling_test\.rb/, anything)
 
           b = ExceptionHandling.ensure_safe("mooo") { raise StandardError, "blah" }
-          expect(b).to be_nil
+          assert_nil b
         end
       end
 
       context "ExceptionHandling.ensure_completely_safe" do
-        it "log an exception if an exception is raised." do
-          expect(ExceptionHandling.logger).to receive(:fatal).with(/\(blah\):\n.*exception_handling_spec\.rb/, anything)
+        should "log an exception if an exception is raised." do
+          mock(ExceptionHandling.logger).fatal(/\(blah\):\n.*exception_handling_test\.rb/, anything)
           ExceptionHandling.ensure_completely_safe { raise ArgumentError, "blah" }
         end
 
-        it "should not log an exception if an exception is not raised." do
-          expect(ExceptionHandling.logger).to receive(:fatal).exactly(0)
+        should "should not log an exception if an exception is not raised." do
+          mock(ExceptionHandling.logger).fatal.times(0)
           ExceptionHandling.ensure_completely_safe { ; }
         end
 
-        it "return its value if used during an assignment" do
-          expect(ExceptionHandling.logger).to receive(:fatal).exactly(0)
+        should "return its value if used during an assignment" do
+          mock(ExceptionHandling.logger).fatal.times(0)
           b = ExceptionHandling.ensure_completely_safe { 5 }
-          expect(b).to eq(5)
+          assert_equal 5, b
         end
 
-        it "return nil if an exception is raised during an assignment" do
-          expect(ExceptionHandling.logger).to receive(:fatal).with(/\(blah\):\n.*exception_handling_spec\.rb/, anything) { nil }
+        should "return nil if an exception is raised during an assignment" do
+          mock(ExceptionHandling.logger).fatal(/\(blah\):\n.*exception_handling_test\.rb/, anything) { nil }
           b = ExceptionHandling.ensure_completely_safe { raise ArgumentError, "blah" }
-          expect(b).to be_nil
+          assert_nil b
         end
 
-        it "allow a message to be appended to the error when logged." do
-          expect(ExceptionHandling.logger).to receive(:fatal).with(/mooo\nArgumentError: \(blah\):\n.*exception_handling_spec\.rb/, anything)
+        should "allow a message to be appended to the error when logged." do
+          mock(ExceptionHandling.logger).fatal(/mooo\nArgumentError: \(blah\):\n.*exception_handling_test\.rb/, anything)
           b = ExceptionHandling.ensure_completely_safe("mooo") { raise ArgumentError, "blah" }
-          expect(b).to be_nil
+          assert_nil b
         end
 
-        it "rescue any instance or child of Exception" do
-          expect(ExceptionHandling.logger).to receive(:fatal).with(/\(blah\):\n.*exception_handling_spec\.rb/, anything)
+        should "rescue any instance or child of Exception" do
+          mock(ExceptionHandling.logger).fatal(/\(blah\):\n.*exception_handling_test\.rb/, anything)
           ExceptionHandling.ensure_completely_safe { raise Exception, "blah" }
         end
 
-        it "not rescue the special exceptions that Ruby uses" do
+        should "not rescue the special exceptions that Ruby uses" do
           [SystemExit, SystemStackError, NoMemoryError, SecurityError].each do |exception|
-            expect do
+            assert_raise exception do
               ExceptionHandling.ensure_completely_safe do
                 raise exception
               end
-            end.to raise_exception(exception)
+            end
           end
         end
       end
 
       context "ExceptionHandling.ensure_escalation" do
-        before do
+        setup do
           capture_notifications
           ActionMailer::Base.deliveries.clear
         end
 
-        it "log the exception as usual and send the proper email" do
-          expect(ExceptionHandling.logger).to receive(:fatal).with(/\(blah\):\n.*exception_handling_spec\.rb/, anything)
+        should "log the exception as usual and send the proper email" do
+          mock(ExceptionHandling.logger).fatal(/\(blah\):\n.*exception_handling_test\.rb/, anything)
           ExceptionHandling.ensure_escalation("Favorite Feature") { raise ArgumentError, "blah" }
-          expect(ActionMailer::Base.deliveries.count).to eq(1)
-          expect(sent_notifications.size).to eq(1), sent_notifications.inspect
+          assert_equal 1, ActionMailer::Base.deliveries.count
+          assert_equal 1, sent_notifications.size, sent_notifications.inspect
 
           email = ActionMailer::Base.deliveries.last
-          expect(email.subject).to eq("#{ExceptionHandling.email_environment} Escalation: Favorite Feature")
-          expect(email.body.to_s).to match('ArgumentError: blah')
-          expect(email.body.to_s).to match(ExceptionHandling.last_exception_timestamp.to_s)
+          assert_equal "#{ExceptionHandling.email_environment} Escalation: Favorite Feature", email.subject
+          assert_match 'ArgumentError: blah', email.body.to_s
+          assert_match ExceptionHandling.last_exception_timestamp.to_s, email.body.to_s
         end
 
-        it "should not escalate if an exception is not raised." do
-          expect(ExceptionHandling.logger).to_not receive(:fatal)
+        should "should not escalate if an exception is not raised." do
+          dont_allow(ExceptionHandling.logger).fatal
           ExceptionHandling.ensure_escalation('Ignored') { ; }
-          expect(ActionMailer::Base.deliveries.count).to eq(0)
+          assert_equal 0, ActionMailer::Base.deliveries.count
         end
 
-        it "log if the escalation email cannot be sent" do
-          expect_any_instance_of(Mail::Message).to receive(:deliver).and_raise(RuntimeError.new, "Delivery Error")
+        should "log if the escalation email cannot be sent" do
+          any_instance_of(Mail::Message) do |message|
+            mock(message).deliver { raise RuntimeError.new, "Delivery Error" }
+          end
           log_fatals = []
-          expect(ExceptionHandling.logger).to receive(:fatal).with(any_args).at_least(:once) do |*args|
-            log_fatals << args
+          stub(ExceptionHandling.logger) do |logger|
+            logger.fatal.with_any_args { |*args| log_fatals << args }
           end
 
           ExceptionHandling.ensure_escalation("ensure context") { raise ArgumentError, "first_test_exception" }
-          expect(log_fatals[0].first).to match(/ArgumentError.*first_test_exception/)
-          expect(log_fatals[1].first).to match(/safe_email_deliver.*Delivery Error/m)
 
-          expect(log_fatals.size).to eq(2), log_fatals.inspect
+          assert_match(/ArgumentError.*first_test_exception/, log_fatals[0].first)
+          assert_match(/safe_email_deliver.*Delivery Error/m, log_fatals[1].first)
+
+          assert_equal 2, log_fatals.size, log_fatals.inspect
 
-          expect(sent_notifications.size).to eq(1), sent_notifications.inspect # still sent to honeybadger
+          assert_equal 1, sent_notifications.size, sent_notifications.inspect # still sent to honeybadger
         end
 
-        it "allow the caller to specify custom recipients" do
+        should "allow the caller to specify custom recipients" do
           custom_recipients = ['something@invoca.com']
-          expect(ExceptionHandling.logger).to receive(:fatal).with(/\(blah\):\n.*exception_handling_spec\.rb/, anything)
+          mock(ExceptionHandling.logger).fatal(/\(blah\):\n.*exception_handling_test\.rb/, anything)
           ExceptionHandling.ensure_escalation("Favorite Feature", custom_recipients) { raise ArgumentError, "blah" }
-          expect(ActionMailer::Base.deliveries.count).to eq(1)
-          expect(sent_notifications.size).to eq(1), sent_notifications.inspect
+          assert_equal 1, ActionMailer::Base.deliveries.count
+          assert_equal 1, sent_notifications.size, sent_notifications.inspect
 
           email = ActionMailer::Base.deliveries.last
-          expect(email.subject).to eq("#{ExceptionHandling.email_environment} Escalation: Favorite Feature")
-          expect(email.body.to_s).to match('ArgumentError: blah')
-          expect(email.body.to_s).to match(ExceptionHandling.last_exception_timestamp.to_s)
-          expect(email.to).to eq(custom_recipients)
+          assert_equal "#{ExceptionHandling.email_environment} Escalation: Favorite Feature", email.subject
+          assert_match 'ArgumentError: blah', email.body.to_s
+          assert_match ExceptionHandling.last_exception_timestamp.to_s, email.body.to_s
+          assert_equal custom_recipients, email.to
         end
       end
 
       context "ExceptionHandling.ensure_alert" do
-        it "log the exception as usual and fire a sensu event" do
-          expect(ExceptionHandling::Sensu).to receive(:generate_event).with("Favorite Feature", "test context\nblah")
-          expect(ExceptionHandling.logger).to receive(:fatal).with(/\(blah\):\n.*exception_handling_spec\.rb/, anything)
+        should "log the exception as usual and fire a sensu event" do
+          mock(ExceptionHandling::Sensu).generate_event("Favorite Feature", "test context\nblah")
+          mock(ExceptionHandling.logger).fatal(/\(blah\):\n.*exception_handling_test\.rb/, anything)
           ExceptionHandling.ensure_alert('Favorite Feature', 'test context') { raise ArgumentError, "blah" }
         end
 
-        it "should not send sensu event if an exception is not raised." do
-          expect(ExceptionHandling.logger).to_not receive(:fatal)
-          expect(ExceptionHandling::Sensu).to_not receive(:generate_event)
+        should "should not send sensu event if an exception is not raised." do
+          dont_allow(ExceptionHandling.logger).fatal
+          dont_allow(ExceptionHandling::Sensu).generate_event
           ExceptionHandling.ensure_alert('Ignored', 'test context') { ; }
         end
 
-        it "log if the sensu event could not be sent" do
-          expect(ExceptionHandling::Sensu).to receive(:send_event).with(anything) { raise "Failed to send" }
-          expect(ExceptionHandling.logger).to receive(:fatal).with(/first_test_exception/, anything)
-          expect(ExceptionHandling.logger).to receive(:fatal).with(/Failed to send/, anything)
+        should "log if the sensu event could not be sent" do
+          mock(ExceptionHandling::Sensu).send_event(anything) { raise "Failed to send" }
+          mock(ExceptionHandling.logger) do |logger|
+            logger.fatal(/first_test_exception/, anything)
+            logger.fatal(/Failed to send/, anything)
+          end
           ExceptionHandling.ensure_alert("Not Used", 'test context') { raise ArgumentError, "first_test_exception" }
         end
 
-        it "log if the exception message is nil" do
-          expect(ExceptionHandling::Sensu).to receive(:generate_event).with("some alert", "test context\n")
+        should "log if the exception message is nil" do
+          mock(ExceptionHandling::Sensu).generate_event("some alert", "test context\n")
           ExceptionHandling.ensure_alert('some alert', 'test context') { raise_exception_with_nil_message }
         end
       end
 
       context "ExceptionHandling.escalate_to_production_support" do
-        it "notify production support" do
+        should "notify production support" do
           subject = "Runtime Error found!"
           exception = RuntimeError.new("Test")
           recipients = ["prodsupport@example.com"]
 
-          expect(ExceptionHandling).to receive(:production_support_recipients).and_return(recipients).exactly(2)
-          expect(ExceptionHandling).to receive(:escalate).with(subject, exception, ExceptionHandling.last_exception_timestamp, recipients)
+          mock(ExceptionHandling).production_support_recipients { recipients }.times(2)
+          mock(ExceptionHandling).escalate(subject, exception, ExceptionHandling.last_exception_timestamp, recipients)
           ExceptionHandling.escalate_to_production_support(exception, subject)
         end
       end
 
       context "exception timestamp" do
-        before do
+        setup do
           Time.now_override = Time.parse('1986-5-21 4:17 am UTC')
         end
 
-        it "include the timestamp when the exception is logged" do
+        should "include the timestamp when the exception is logged" do
           capture_notifications
 
-          expect(ExceptionHandling.logger).to receive(:fatal).with(/\(Error:517033020\) context\nArgumentError: \(blah\):\n.*exception_handling_spec\.rb/, anything)
+          mock(ExceptionHandling.logger).fatal(/\(Error:517033020\) context\nArgumentError: \(blah\):\n.*exception_handling_test\.rb/, anything)
           b = ExceptionHandling.ensure_safe("context") { raise ArgumentError, "blah" }
-          expect(b).to be_nil
+          assert_nil b
 
-          expect(ExceptionHandling.last_exception_timestamp).to eq(517_033_020)
+          assert_equal 517_033_020, ExceptionHandling.last_exception_timestamp
 
-          expect(sent_notifications.size).to eq(1), sent_notifications.inspect
+          assert_equal 1, sent_notifications.size, sent_notifications.inspect
 
-          expect(sent_notifications.last.enhanced_data['timestamp']).to eq(517_033_020)
+          assert_equal 517_033_020, sent_notifications.last.enhanced_data['timestamp']
         end
       end
 
-      it "log the error if the exception message is nil" do
+      should "log the error if the exception message is nil" do
         capture_notifications
 
         ExceptionHandling.log_error(exception_with_nil_message)
 
-        expect(sent_notifications.size).to eq(1), sent_notifications.inspect
-        expect(sent_notifications.last.enhanced_data['error_string']).to eq('RuntimeError: ')
+        assert_equal 1, sent_notifications.size, sent_notifications.inspect
+        assert_equal 'RuntimeError: ', sent_notifications.last.enhanced_data['error_string']
       end
 
-      it "log the error if the exception message is nil and the exception context is a hash" do
+      should "log the error if the exception message is nil and the exception context is a hash" do
         capture_notifications
 
         ExceptionHandling.log_error(exception_with_nil_message, "SERVER_NAME" => "exceptional.com")
 
-        expect(sent_notifications.size).to eq(1), sent_notifications.inspect
-        expect(sent_notifications.last.enhanced_data['error_string']).to eq('RuntimeError: ')
+        assert_equal 1, sent_notifications.size, sent_notifications.inspect
+        assert_equal 'RuntimeError: ', sent_notifications.last.enhanced_data['error_string']
       end
 
       context "Honeybadger integration" do
         context "with Honeybadger not defined" do
-          before do
-            allow(ExceptionHandling).to receive(:honeybadger_defined?) { false }
+          setup do
+            stub(ExceptionHandling).honeybadger_defined? { false }
           end
 
-          it "not invoke send_exception_to_honeybadger when log_error is executed" do
-            expect(ExceptionHandling).to_not receive(:send_exception_to_honeybadger)
+          should "not invoke send_exception_to_honeybadger when log_error is executed" do
+            dont_allow(ExceptionHandling).send_exception_to_honeybadger
             ExceptionHandling.log_error(exception_1)
           end
 
-          it "not invoke send_exception_to_honeybadger when ensure_safe is executed" do
-            expect(ExceptionHandling).to_not receive(:send_exception_to_honeybadger)
+          should "not invoke send_exception_to_honeybadger when ensure_safe is executed" do
+            dont_allow(ExceptionHandling).send_exception_to_honeybadger
             ExceptionHandling.ensure_safe { raise exception_1 }
           end
         end
 
         context "with Honeybadger defined" do
-          it "not send_exception_to_honeybadger when log_warning is executed" do
-            expect(ExceptionHandling).to_not receive(:send_exception_to_honeybadger)
+          should "not send_exception_to_honeybadger when log_warning is executed" do
+            dont_allow(ExceptionHandling).send_exception_to_honeybadger
             ExceptionHandling.log_warning("This should not go to honeybadger")
           end
 
-          it "not send_exception_to_honeybadger when log_error is called with a Warning" do
-            expect(ExceptionHandling).to_not receive(:send_exception_to_honeybadger)
+          should "not send_exception_to_honeybadger when log_error is called with a Warning" do
+            dont_allow(ExceptionHandling).send_exception_to_honeybadger
             ExceptionHandling.log_error(ExceptionHandling::Warning.new("This should not go to honeybadger"))
           end
 
-          it "invoke send_exception_to_honeybadger when log_error is executed" do
-            expect(ExceptionHandling).to receive(:send_exception_to_honeybadger).with(any_args).and_call_original
+          should "invoke send_exception_to_honeybadger when log_error is executed" do
+            mock.proxy(ExceptionHandling).send_exception_to_honeybadger.with_any_args
             ExceptionHandling.log_error(exception_1)
           end
 
-          it "invoke send_exception_to_honeybadger when log_error_rack is executed" do
-            expect(ExceptionHandling).to receive(:send_exception_to_honeybadger).with(any_args).and_call_original
+          should "invoke send_exception_to_honeybadger when log_error_rack is executed" do
+            mock.proxy(ExceptionHandling).send_exception_to_honeybadger.with_any_args
             ExceptionHandling.log_error_rack(exception_1, {}, nil)
           end
 
-          it "invoke send_exception_to_honeybadger when ensure_safe is executed" do
-            expect(ExceptionHandling).to receive(:send_exception_to_honeybadger).with(any_args).and_call_original
+          should "invoke send_exception_to_honeybadger when ensure_safe is executed" do
+            mock.proxy(ExceptionHandling).send_exception_to_honeybadger.with_any_args
             ExceptionHandling.ensure_safe { raise exception_1 }
           end
 
-          it "specify error message as an empty string when notifying honeybadger if exception message is nil" do
-            expect(Honeybadger).to receive(:notify).with(any_args) do |args|
-              expect(args[:error_message]).to eq("")
+          should "specify error message as an empty string when notifying honeybadger if exception message is nil" do
+            mock(Honeybadger).notify.with_any_args do |args|
+              assert_equal "", args[:error_message]
             end
             ExceptionHandling.log_error(exception_with_nil_message)
           end
 
           context "with stubbed values" do
-            before do
+            setup do
               Time.now_override = Time.now
               @env = { server: "fe98" }
               @parameters = { advertiser_id: 435, controller: "some_controller" }
               @session = { username: "jsmith" }
               @request_uri = "host/path"
               @controller = create_dummy_controller(@env, @parameters, @session, @request_uri)
-              allow(ExceptionHandling).to receive(:server_name) { "invoca_fe98" }
+              stub(ExceptionHandling).server_name { "invoca_fe98" }
 
               @exception = StandardError.new("Some Exception")
               @exception.set_backtrace([
-                                         "spec/unit/exception_handling_spec.rb:847:in `exception_1'",
-                                         "spec/unit/exception_handling_spec.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" }
             end
 
-            it "send error details and relevant context data to Honeybadger with log_context" do
+            should "send error details and relevant context data to Honeybadger with log_context" do
               honeybadger_data = nil
-              expect(Honeybadger).to receive(:notify).with(any_args) do |data|
+              mock(Honeybadger).notify.with_any_args do |data|
                 honeybadger_data = data
               end
               ExceptionHandling.logger.global_context = { service_name: "rails", region: "AWS-us-east-1" }
@@ -708,19 +713,19 @@ describe ExceptionHandling do
                     "SERVER_NAME" => "exceptional.com"
                   },
                   backtrace: [
-                    "spec/unit/exception_handling_spec.rb:847:in `exception_1'",
-                    "spec/unit/exception_handling_spec.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: { "service_name" => "bin/console", "region" => "AWS-us-east-1", "log_source" => "gem/listen" }
                 }
               }
-              expect(honeybadger_data).to eq(expected_data)
+              assert_equal_with_diff expected_data, honeybadger_data
             end
 
-            it "send error details and relevant context data to Honeybadger with empty log_context" do
+            should "send error details and relevant context data to Honeybadger with empty log_context" do
               honeybadger_data = nil
-              expect(Honeybadger).to receive(:notify).with(any_args) do |data|
+              mock(Honeybadger).notify.with_any_args do |data|
                 honeybadger_data = data
               end
               ExceptionHandling.logger.global_context = {}
@@ -758,22 +763,22 @@ describe ExceptionHandling do
                     "SERVER_NAME" => "exceptional.com"
                   },
                   backtrace: [
-                               "spec/unit/exception_handling_spec.rb:847:in `exception_1'",
-                               "spec/unit/exception_handling_spec.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"
                 }
               }
-              expect(honeybadger_data).to eq(expected_data)
+              assert_equal_with_diff expected_data, honeybadger_data
             end
           end
 
           context "with post_log_error_hook set" do
-            after do
+            teardown do
               ExceptionHandling.post_log_error_hook = nil
             end
 
-            it "not send notification to honeybadger when exception description has the flag turned off and call log error callback with logged_to_honeybadger set to nil" do
+            should "not send notification to honeybadger when exception description has the flag turned off and call log error callback with logged_to_honeybadger set to nil" do
               @honeybadger_status = nil
               ExceptionHandling.post_log_error_hook = method(:log_error_callback_config)
               filter_list = {
@@ -782,37 +787,37 @@ describe ExceptionHandling do
                   send_to_honeybadger: false
                 }
               }
-              allow(File).to receive(:mtime) { incrementing_mtime }
-              expect(YAML).to receive(:load_file).with(any_args) { ActiveSupport::HashWithIndifferentAccess.new(filter_list) }.at_least(1)
+              stub(File).mtime { incrementing_mtime }
+              mock(YAML).load_file.with_any_args { ActiveSupport::HashWithIndifferentAccess.new(filter_list) }.at_least(1)
 
-              expect(ExceptionHandling).to receive(:send_exception_to_honeybadger_unless_filtered).with(any_args).exactly(1).and_call_original
-              expect(Honeybadger).to_not receive(:notify)
+              mock.proxy(ExceptionHandling).send_exception_to_honeybadger_unless_filtered.with_any_args.once
+              dont_allow(Honeybadger).notify
               ExceptionHandling.log_error(StandardError.new("suppress Honeybadger notification"))
-              expect(@honeybadger_status).to eq(:skipped)
+              assert_equal :skipped, @honeybadger_status
             end
 
-            it "call log error callback with logged_to_honeybadger set to false if an error occurs while attempting to notify honeybadger" do
+            should "call log error callback with logged_to_honeybadger set to false if an error occurs while attempting to notify honeybadger" do
               @honeybadger_status = nil
               ExceptionHandling.post_log_error_hook = method(:log_error_callback_config)
-              expect(Honeybadger).to receive(:notify).with(any_args) { raise "Honeybadger Notification Failure" }
+              mock(Honeybadger).notify.with_any_args { raise "Honeybadger Notification Failure" }
               ExceptionHandling.log_error(exception_1)
-              expect(@honeybadger_status).to eq(:failure)
+              assert_equal :failure, @honeybadger_status
             end
 
-            it "call log error callback with logged_to_honeybadger set to false on unsuccessful honeybadger notification" do
+            should "call log error callback with logged_to_honeybadger set to false on unsuccessful honeybadger notification" do
               @honeybadger_status = nil
               ExceptionHandling.post_log_error_hook = method(:log_error_callback_config)
-              expect(Honeybadger).to receive(:notify).with(any_args) { false }
+              mock(Honeybadger).notify.with_any_args { false }
               ExceptionHandling.log_error(exception_1)
-              expect(@honeybadger_status).to eq(:failure)
+              assert_equal :failure, @honeybadger_status
             end
 
-            it "call log error callback with logged_to_honeybadger set to true on successful honeybadger notification" do
+            should "call log error callback with logged_to_honeybadger set to true on successful honeybadger notification" do
               @honeybadger_status = nil
               ExceptionHandling.post_log_error_hook = method(:log_error_callback_config)
-              expect(Honeybadger).to receive(:notify).with(any_args) { '06220c5a-b471-41e5-baeb-de247da45a56' }
+              mock(Honeybadger).notify.with_any_args { '06220c5a-b471-41e5-baeb-de247da45a56' }
               ExceptionHandling.log_error(exception_1)
-              expect(@honeybadger_status).to eq(:success)
+              assert_equal :success, @honeybadger_status
             end
           end
         end
@@ -824,33 +829,33 @@ describe ExceptionHandling do
         end
       end
 
-      it "allow sections to have data with just a to_s method" do
+      should "allow sections to have data with just a to_s method" do
         capture_notifications
 
         ExceptionHandling.log_error("This is my RingSwitch example.") do |data|
           data.merge!(event_response: EventResponse.new)
         end
 
-        expect(sent_notifications.size).to eq(1), sent_notifications.inspect
-        expect(sent_notifications.last.enhanced_data['event_response'].to_s).to match(/message from to_s!/)
+        assert_equal 1, sent_notifications.size, sent_notifications.inspect
+        assert_match(/message from to_s!/, sent_notifications.last.enhanced_data['event_response'].to_s)
       end
     end
 
-    it "return the error ID (timestamp)" do
+    should "return the error ID (timestamp)" do
       result = ExceptionHandling.log_error(RuntimeError.new("A runtime error"), "Runtime message")
-      expect(result).to eq(ExceptionHandling.last_exception_timestamp)
+      assert_equal ExceptionHandling.last_exception_timestamp, result
     end
 
-    it "rescue exceptions that happen in log_error" do
-      allow(ExceptionHandling).to receive(:make_exception) { raise ArgumentError, "Bad argument" }
-      expect(ExceptionHandling).to receive(:write_exception_to_log).with(satisfy { |ex| ex.to_s['Bad argument'] },
+    should "rescue exceptions that happen in log_error" do
+      stub(ExceptionHandling).make_exception { raise ArgumentError, "Bad argument" }
+      mock(ExceptionHandling).write_exception_to_log(satisfy { |ex| ex.to_s['Bad argument'] },
                                                      satisfy { |context| context['ExceptionHandlingError: log_error rescued exception while logging Runtime message'] },
                                                      anything)
       ExceptionHandling.log_error(RuntimeError.new("A runtime error"), "Runtime message")
     end
 
-    it "rescue exceptions that happen when log_error yields" do
-      expect(ExceptionHandling).to receive(:write_exception_to_log).with(satisfy { |ex| ex.to_s['Bad argument'] },
+    should "rescue exceptions that happen when log_error yields" do
+      mock(ExceptionHandling).write_exception_to_log(satisfy { |ex| ex.to_s['Bad argument'] },
                                                      satisfy { |context| context['Context message'] },
                                                      anything,
                                                      anything)
@@ -858,38 +863,38 @@ describe ExceptionHandling do
     end
 
     context "Exception Filtering" do
-      before do
+      setup do
         filter_list = { exception1: { 'error' => "my error message" },
                         exception2: { 'error' => "some other message", :session => "misc data" } }
-        allow(YAML).to receive(:load_file) { ActiveSupport::HashWithIndifferentAccess.new(filter_list) }
+        stub(YAML).load_file { ActiveSupport::HashWithIndifferentAccess.new(filter_list) }
 
         # bump modified time up to get the above filter loaded
-        allow(File).to receive(:mtime) { incrementing_mtime }
+        stub(File).mtime { incrementing_mtime }
       end
 
-      it "handle case where filter list is not found" do
-        allow(YAML).to receive(:load_file) { raise Errno::ENOENT, "File not found" }
+      should "handle case where filter list is not found" do
+        stub(YAML).load_file { raise Errno::ENOENT, "File not found" }
 
         capture_notifications
 
         ExceptionHandling.log_error("My error message is in list")
-        expect(sent_notifications.size).to eq(1), sent_notifications.inspect
+        assert_equal 1, sent_notifications.size, sent_notifications.inspect
       end
 
-      it "log exception and suppress email when exception is on filter list" do
+      should "log exception and suppress email when exception is on filter list" do
         capture_notifications
 
         ExceptionHandling.log_error("Error message is not in list")
-        expect(sent_notifications.size).to eq(1), sent_notifications.inspect
+        assert_equal 1, sent_notifications.size, sent_notifications.inspect
 
         sent_notifications.clear
         ExceptionHandling.log_error("My error message is in list")
-        expect(sent_notifications.size).to eq(0), sent_notifications.inspect
+        assert_equal 0, sent_notifications.size, sent_notifications.inspect
       end
 
-      it "allow filtering exception on any text in exception data" do
+      should "allow filtering exception on any text in exception data" do
         filters = { exception1: { session: "data: my extra session data" } }
-        allow(YAML).to receive(:load_file) { ActiveSupport::HashWithIndifferentAccess.new(filters) }
+        stub(YAML).load_file { ActiveSupport::HashWithIndifferentAccess.new(filters) }
 
         capture_notifications
 
@@ -899,7 +904,7 @@ describe ExceptionHandling do
             data: "my extra session data"
           }
         end
-        expect(sent_notifications.size).to eq(0), sent_notifications.inspect
+        assert_equal 0, sent_notifications.size, sent_notifications.inspect
 
         ExceptionHandling.log_error("No match here") do |data|
           data[:session] = {
@@ -907,86 +912,86 @@ describe ExceptionHandling do
             data: "my extra session <no match!> data"
           }
         end
-        expect(sent_notifications.size).to eq(1), sent_notifications.inspect
+        assert_equal 1, sent_notifications.size, sent_notifications.inspect
       end
 
-      it "reload filter list on the next exception if file was modified" do
+      should "reload filter list on the next exception if file was modified" do
         capture_notifications
 
         ExceptionHandling.log_error("Error message is not in list")
-        expect(sent_notifications.size).to eq(1), sent_notifications.inspect
+        assert_equal 1, sent_notifications.size, sent_notifications.inspect
 
         filter_list = { exception1: { 'error' => "Error message is not in list" } }
-        allow(YAML).to receive(:load_file) { ActiveSupport::HashWithIndifferentAccess.new(filter_list) }
-        allow(File).to receive(:mtime) { incrementing_mtime }
+        stub(YAML).load_file { ActiveSupport::HashWithIndifferentAccess.new(filter_list) }
+        stub(File).mtime { incrementing_mtime }
 
         sent_notifications.clear
         ExceptionHandling.log_error("Error message is not in list")
-        expect(sent_notifications.size).to eq(0), sent_notifications.inspect
+        assert_equal 0, sent_notifications.size, sent_notifications.inspect
       end
 
-      it "not consider filter if both error message and body do not match" do
+      should "not consider filter if both error message and body do not match" do
         capture_notifications
 
         # error message matches, but not full text
         ExceptionHandling.log_error("some other message")
-        expect(sent_notifications.size).to eq(1), sent_notifications.inspect
+        assert_equal 1, sent_notifications.size, sent_notifications.inspect
 
         # now both match
         sent_notifications.clear
         ExceptionHandling.log_error("some other message") do |data|
           data[:session] = { some_random_key: "misc data" }
         end
-        expect(sent_notifications.size).to eq(0), sent_notifications.inspect
+        assert_equal 0, sent_notifications.size, sent_notifications.inspect
       end
 
-      it "skip environment keys not on whitelist" do
+      should "skip environment keys not on whitelist" do
         capture_notifications
 
         ExceptionHandling.log_error("some message") do |data|
           data[:environment] = { SERVER_PROTOCOL: "HTTP/1.0", RAILS_SECRETS_YML_CONTENTS: 'password: VERY_SECRET_PASSWORD' }
         end
-        expect(sent_notifications.size).to eq(1), sent_notifications.inspect
+        assert_equal 1, sent_notifications.size, sent_notifications.inspect
 
         mail = sent_notifications.last
         environment = mail.enhanced_data['environment']
 
-        expect(environment["RAILS_SECRETS_YML_CONTENTS"]).to be_nil, environment.inspect # this is not on whitelist).to be_nil
-        expect(environment["SERVER_PROTOCOL"]).to be_truthy, environment.inspect # this is
+        assert_nil environment["RAILS_SECRETS_YML_CONTENTS"], environment.inspect # this is not on whitelist
+        assert     environment["SERVER_PROTOCOL"], environment.inspect # this is
       end
 
-      it "omit environment defaults" do
+      should "omit environment defaults" do
         capture_notifications
 
-        allow(ExceptionHandling).to receive(:send_exception_to_honeybadger).with(anything) { |exception_info| sent_notifications << exception_info }
+        stub(ExceptionHandling).send_exception_to_honeybadger(anything) { |exception_info| sent_notifications << exception_info }
 
         ExceptionHandling.log_error("some message") do |data|
           data[:environment] = { SERVER_PORT: '80', SERVER_PROTOCOL: "HTTP/1.0" }
         end
-        expect(sent_notifications.size).to eq(1), sent_notifications.inspect
+        assert_equal 1, sent_notifications.size, sent_notifications.inspect
         mail = sent_notifications.last
         environment = mail.enhanced_data['environment']
 
-        expect(environment["SERVER_PORT"]).to be_nil, environment.inspect # this was default).to be_nil
-        expect(environment["SERVER_PROTOCOL"]).to be_truthy, environment.inspect # this was not
+        assert_nil environment["SERVER_PORT"], environment.inspect # this was default
+        assert     environment["SERVER_PROTOCOL"], environment # this was not
       end
 
-      it "reject the filter file if any contain all empty regexes" do
+      should "reject the filter file if any contain all empty regexes" do
         filter_list = { exception1: { 'error' => "", :session => "" },
                         exception2: { 'error' => "is not in list", :session => "" } }
-        allow(YAML).to receive(:load_file) { ActiveSupport::HashWithIndifferentAccess.new(filter_list) }
-        allow(File).to receive(:mtime) { incrementing_mtime }
+        stub(YAML).load_file { ActiveSupport::HashWithIndifferentAccess.new(filter_list) }
+        stub(File).mtime { incrementing_mtime }
 
         capture_notifications
 
         ExceptionHandling.log_error("Error message is not in list")
-        expect(sent_notifications.size).to eq(1), sent_notifications.inspect
+        assert_equal 1, sent_notifications.size, sent_notifications.inspect
       end
 
-      it "reload filter file if filename changes" do
+      should "reload filter file if filename changes" do
         catalog = ExceptionHandling.exception_catalog
         ExceptionHandling.filter_list_filename = "./config/other_exception_filters.yml"
-        expect(ExceptionHandling.exception_catalog).to_not eq(catalog)
+        assert_not_equal catalog, ExceptionHandling.exception_catalog
       end
 
       context "Exception Handling Mailer" do
@@ -1000,7 +1005,7 @@ describe ExceptionHandling do
 
         [[true, false], [true, true]].each do |em_flag, synchrony_flag|
           context "eventmachine_safe = #{em_flag} && eventmachine_synchrony = #{synchrony_flag}" do
-            before do
+            setup do
               ExceptionHandling.eventmachine_safe       = em_flag
               ExceptionHandling.eventmachine_synchrony  = synchrony_flag
               EventMachineStub.block = nil
@@ -1010,60 +1015,61 @@ describe ExceptionHandling do
               set_test_const('EventMachine::DNS::Resolver', DNSResolvStub)
             end
 
-            after do
+            teardown do
               ExceptionHandling.eventmachine_safe       = false
               ExceptionHandling.eventmachine_synchrony  = false
             end
 
-            it "schedule EventMachine STMP when EventMachine defined" do
+            should "schedule EventMachine STMP when EventMachine defined" do
               ActionMailer::Base.deliveries.clear
 
               set_test_const('EventMachine::Protocols::SmtpClient', SmtpClientStub)
 
               ExceptionHandling.ensure_escalation("ensure message") { raise 'Exception to escalate!' }
-              expect(EventMachineStub.block).to be_truthy
+              assert EventMachineStub.block
               EventMachineStub.block.call
-              expect(DNSResolvStub.callback_block).to be_truthy
+              assert DNSResolvStub.callback_block
               DNSResolvStub.callback_block.call ['127.0.0.1']
-              expect((SmtpClientStub.send_hash & EXPECTED_SMTP_HASH.keys).map_hash { |_k, v| v.to_s }) .to eq(EXPECTED_SMTP_HASH), SmtpClientStub.send_hash.inspect
-              expect(SmtpClientStub.last_method).to eq((synchrony_flag ? :asend : :send))
-              expect(SmtpClientStub.send_hash[:content]).to match(/Exception to escalate/)
+              assert_equal_with_diff EXPECTED_SMTP_HASH, (SmtpClientStub.send_hash & EXPECTED_SMTP_HASH.keys).map_hash { |_k, v| v.to_s }, SmtpClientStub.send_hash.inspect
+              assert_equal((synchrony_flag ? :asend : :send), SmtpClientStub.last_method)
+              assert_match(/Exception to escalate/, SmtpClientStub.send_hash[:content])
               assert_emails 0, ActionMailer::Base.deliveries.*.to_s
             end
 
-            it "pass the content as a proper rfc 2822 message" do
+            should "pass the content as a proper rfc 2822 message" do
               set_test_const('EventMachine::Protocols::SmtpClient', SmtpClientStub)
               ExceptionHandling.ensure_escalation("ensure message") { raise 'Exception to escalate!' }
-              expect(EventMachineStub.block).to be_truthy
+              assert EventMachineStub.block
               EventMachineStub.block.call
-              expect(DNSResolvStub.callback_block).to be_truthy
+              assert DNSResolvStub.callback_block
               DNSResolvStub.callback_block.call ['127.0.0.1']
-              expect(content = SmtpClientStub.send_hash[:content]).to be_truthy
-              expect(content).to match(/Content-Transfer-Encoding: 7bit/)
-              expect(content).to match(/\r\n\.\r\n\z/)
+              assert content = SmtpClientStub.send_hash[:content]
+              assert_match(/Content-Transfer-Encoding: 7bit/, content)
+              assert_match(/\r\n\.\r\n\z/, content)
             end
 
-            it "log fatal on EventMachine STMP errback" do
+            should "log fatal on EventMachine STMP errback" do
               ActionMailer::Base.deliveries.clear
 
               set_test_const('EventMachine::Protocols::SmtpClient', SmtpClientErrbackStub)
-              expect(ExceptionHandling.logger).to receive(:fatal).with(/Exception to escalate/, anything)
-              expect(ExceptionHandling.logger).to receive(:fatal).with(/Failed to email by SMTP: "credential mismatch"/)
+              mock(ExceptionHandling.logger).fatal(/Exception to escalate/, anything)
+              mock(ExceptionHandling.logger).fatal(/Failed to email by SMTP: "credential mismatch"/)
 
               ExceptionHandling.ensure_escalation("ensure message") { raise 'Exception to escalate!' }
-              expect(EventMachineStub.block).to be_truthy
+              assert EventMachineStub.block
               EventMachineStub.block.call
-              expect(DNSResolvStub.callback_block).to be_truthy
+              assert DNSResolvStub.callback_block
               DNSResolvStub.callback_block.call(['127.0.0.1'])
               SmtpClientErrbackStub.block.call("credential mismatch")
-              expect((SmtpClientErrbackStub.send_hash & EXPECTED_SMTP_HASH.keys).map_hash { |_k, v| v.to_s }).to eq(EXPECTED_SMTP_HASH), SmtpClientErrbackStub.send_hash.inspect            end
+              assert_equal_with_diff EXPECTED_SMTP_HASH, (SmtpClientErrbackStub.send_hash & EXPECTED_SMTP_HASH.keys).map_hash { |_k, v| v.to_s }, SmtpClientErrbackStub.send_hash.inspect
+            end
 
-            it "log fatal on EventMachine dns resolver errback" do
-              expect(ExceptionHandling.logger).to receive(:fatal).with(/Exception to escalate/, anything)
-              expect(ExceptionHandling.logger).to receive(:fatal).with(/Failed to resolv DNS for localhost: "softlayer sucks"/)
+            should "log fatal on EventMachine dns resolver errback" do
+              mock(ExceptionHandling.logger).fatal(/Exception to escalate/, anything)
+              mock(ExceptionHandling.logger).fatal(/Failed to resolv DNS for localhost: "softlayer sucks"/)
 
               ExceptionHandling.ensure_escalation("ensure message") { raise 'Exception to escalate!' }
-              expect(EventMachineStub.block).to be_truthy
+              assert EventMachineStub.block
               EventMachineStub.block.call
               DNSResolvStub.errback_block.call("softlayer sucks")
             end
@@ -1073,7 +1079,7 @@ describe ExceptionHandling do
     end
 
     context "Exception mapping" do
-      before do
+      setup do
         @data = {
           environment: {
             'HTTP_HOST' => "localhost",
@@ -1098,17 +1104,17 @@ describe ExceptionHandling do
         }
       end
 
-      it "clean backtraces" do
+      should "clean backtraces" do
         begin
           raise "test exception"
         rescue => ex
           backtrace = ex.backtrace
         end
         result = ExceptionHandling.send(:clean_backtrace, ex).to_s
-        expect(backtrace).to_not eq(result)
+        assert_not_equal result, backtrace
       end
 
-      it "return entire backtrace if cleaned is emtpy" do
+      should "return entire backtrace if cleaned is emtpy" do
         begin
           backtrace = ["/Users/peter/ringrevenue/web/vendor/rails-3.2.12/activerecord/lib/active_record/relation/finder_methods.rb:312:in `find_with_ids'",
                        "/Users/peter/ringrevenue/web/vendor/rails-3.2.12/activerecord/lib/active_record/relation/finder_methods.rb:107:in `find'",
@@ -1146,14 +1152,12 @@ describe ExceptionHandling do
             end
           end
 
-          rails = double(Rails)
-          expect(rails).to receive(:backtrace_cleaner) { Rails::BacktraceCleaner.new }
-          rails.backtrace_cleaner
+          mock(Rails).backtrace_cleaner { Rails::BacktraceCleaner.new }
 
           ex = Exception.new
           ex.set_backtrace(backtrace)
           result = ExceptionHandling.send(:clean_backtrace, ex)
-          expect(result).to eq(backtrace)
+          assert_equal backtrace, result
         ensure
           Object.send(:remove_const, :Rails)
         end
@@ -1161,36 +1165,36 @@ describe ExceptionHandling do
     end
 
     context "log_perodically" do
-      before do
+      setup do
         Time.now_override = Time.now # Freeze time
         ExceptionHandling.logger.clear
       end
 
-      after do
+      teardown do
         Time.now_override = nil
       end
 
-      it "take in additional logging context and pass them to the logger" do
+      should "take in additional logging context and pass them to the logger" do
         ExceptionHandling.log_periodically(:test_context_with_periodic, 30.minutes, "this will be written", service_name: 'exception_handling')
-        expect(logged_excluding_reload_filter.last[:context]).to_not be_empty
-        expect(logged_excluding_reload_filter.last[:context]).to eq({ service_name: 'exception_handling' })
+        assert_not_empty logged_excluding_reload_filter.last[:context]
+        assert_equal({ service_name: 'exception_handling' }, logged_excluding_reload_filter.last[:context])
       end
 
-      it "log immediately when we are expected to log" do
+      should "log immediately when we are expected to log" do
         ExceptionHandling.log_periodically(:test_periodic_exception, 30.minutes, "this will be written")
-        expect(logged_excluding_reload_filter.size).to eq(1)
+        assert_equal 1, logged_excluding_reload_filter.size
 
         Time.now_override = Time.now + 5.minutes
         ExceptionHandling.log_periodically(:test_periodic_exception, 30.minutes, "this will not be written")
-        expect(logged_excluding_reload_filter.size).to eq(1)
+        assert_equal 1, logged_excluding_reload_filter.size
 
         ExceptionHandling.log_periodically(:test_another_periodic_exception, 30.minutes, "this will be written")
-        expect(logged_excluding_reload_filter.size).to eq(2)
+        assert_equal 2, logged_excluding_reload_filter.size
 
         Time.now_override = Time.now + 26.minutes
 
         ExceptionHandling.log_periodically(:test_periodic_exception, 30.minutes, "this will be written")
-        expect(logged_excluding_reload_filter.size).to eq(3)
+        assert_equal 3, logged_excluding_reload_filter.size
       end
     end
   end