exception_handling 2.7.0.pre.1 → 2.8.1.pre.1

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

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

data/{test/unit/exception_handling/log_error_stub_test.rb → spec/unit/exception_handling/log_error_stub_spec.rb}

@@ -1,27 +1,27 @@
 # frozen_string_literal: true
 
-require File.expand_path('../../test_helper',  __dir__)
+require File.expand_path('../../spec_helper',  __dir__)
 
 module ExceptionHandling
-  class LogErrorStubTest < ActiveSupport::TestCase
+  describe LogErrorStub do
 
     include LogErrorStub
 
     context "while running tests" do
-      setup do
+      before do
         setup_log_error_stub
       end
 
-      teardown do
+      after do
         teardown_log_error_stub
       end
 
-      should "raise an error when log_error and log_warning are called" do
+      it "raise an error when log_error and log_warning are called" do
         begin
           ExceptionHandling.log_error("Something happened")
           flunk
         rescue Exception => ex # LogErrorStub::UnexpectedExceptionLogged => ex
-          assert ex.to_s.starts_with?("StandardError: Something happened"), ex.to_s
+          expect(ex.to_s.starts_with?("StandardError: Something happened")).to be_truthy
         end
 
         begin
@@ -31,16 +31,16 @@ module ExceptionHandling
           begin
             ExceptionHandling.log_error(ex)
           rescue LogErrorStub::UnexpectedExceptionLogged => ex
-            assert ex.to_s.starts_with?("RaisedError: This should raise"), ex.to_s
+            expect(ex.to_s.starts_with?("RaisedError: This should raise")).to be_truthy
           end
         end
       end
 
-      should "allow for the regex specification of an expected exception to be ignored" do
+      it "allow for the regex specification of an expected exception to be ignored" do
         exception_pattern = /StandardError: This is a test error/
-        assert_nil exception_whitelist # test that exception expectations are cleared
+        expect(exception_whitelist).to be_nil  # test that exception expectations are cleared
         expects_exception(exception_pattern)
-        assert_equal exception_pattern, exception_whitelist[0][0]
+        expect(exception_whitelist[0][0]).to eq(exception_pattern)
         begin
           ExceptionHandling.log_error("This is a test error")
         rescue StandardError
@@ -48,11 +48,11 @@ module ExceptionHandling
         end
       end
 
-      should "allow for the string specification of an expected exception to be ignored" do
+      it "allow for the string specification of an expected exception to be ignored" do
         exception_pattern = "StandardError: This is a test error"
-        assert_nil exception_whitelist # test that exception expectations are cleared
+        expect(exception_whitelist).to be_nil # test that exception expectations are cleared
         expects_exception(exception_pattern)
-        assert_equal exception_pattern, exception_whitelist[0][0]
+        expect(exception_whitelist[0][0]).to eq(exception_pattern)
         begin
           ExceptionHandling.log_error("This is a test error")
         rescue StandardError
@@ -60,9 +60,9 @@ module ExceptionHandling
         end
       end
 
-      should "allow multiple errors to be ignored" do
+      it "allow multiple errors to be ignored" do
         class IgnoredError < StandardError; end
-        assert_nil exception_whitelist # test that exception expectations are cleared
+        expect(exception_whitelist).to be_nil # test that exception expectations are cleared
         expects_exception(/StandardError: This is a test error/)
         expects_exception(/IgnoredError: This should be ignored/)
         ExceptionHandling.log_error("This is a test error")
@@ -73,7 +73,7 @@ module ExceptionHandling
         end
       end
 
-      should "expect exception twice if declared twice" do
+      it "expect exception twice if declared twice" do
         expects_exception(/StandardError: ERROR: I love lamp/)
         expects_exception(/StandardError: ERROR: I love lamp/)
         ExceptionHandling.log_error("ERROR: I love lamp")
@@ -82,23 +82,39 @@ module ExceptionHandling
     end
 
     context "teardown_log_error_stub" do
-      should "support MiniTest framework for adding a failure" do
+      before do
+        RSpec.configure do |config|
+          config.mock_with :rspec do |mocks|
+            mocks.verify_partial_doubles = false
+          end
+        end
+      end
+
+      after do
+        RSpec.configure do |config|
+          config.mock_with :rspec do |mocks|
+            mocks.verify_partial_doubles = true
+          end
+        end
+      end
+
+      it "support MiniTest framework for adding a failure" do
         expects_exception(/foo/)
 
-        mock(self).is_mini_test?.returns { true }
+        expect(self).to receive(:is_mini_test?) { true }
 
-        mock(self).flunk("log_error expected 1 times with pattern: 'foo' found 0")
+        expect(self).to receive(:flunk).with("log_error expected 1 times with pattern: 'foo' found 0")
         teardown_log_error_stub
 
         self.exception_whitelist = nil
       end
 
-      should "support Test::Unit framework for adding a failure" do
+      it "support Test::Unit framework for adding a failure" do
         expects_exception(/foo/)
 
-        mock(self).is_mini_test?.returns { false }
+        expect(self).to receive(:is_mini_test?) { false }
 
-        mock(self).add_failure("log_error expected 1 times with pattern: 'foo' found 0")
+        expect(self).to receive(:add_failure).with("log_error expected 1 times with pattern: 'foo' found 0")
         teardown_log_error_stub
 
         self.exception_whitelist = nil

data/{test/unit/exception_handling/logging_methods_test.rb → spec/unit/exception_handling/logging_methods_spec.rb}

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
-require_relative '../../test_helper'
+require File.expand_path('../../spec_helper',  __dir__)
+
 require_relative '../../helpers/exception_helpers'
 
 require "exception_handling/testing"
 
 module ExceptionHandling
-  class LoggingMethodsTest < ActiveSupport::TestCase
+  describe LoggingMethods do
     include ExceptionHelpers
 
     def dont_stub_log_error
@@ -14,21 +15,21 @@ module ExceptionHandling
     end
 
     context "ExceptionHandling::LoggingMethods" do
-      setup do
+      before do
         @controller = Testing::LoggingMethodsControllerStub.new
         ExceptionHandling.stub_handler = nil
       end
 
       context "#log_warning" do
-        should "be available to the controller" do
+        it "be available to the controller" do
           klass = Class.new
           klass.include ExceptionHandling::LoggingMethods
           instance = klass.new
-          assert instance.methods.include?(:log_warning)
+          expect(instance.methods.include?(:log_warning)).to eq(true)
         end
 
-        should "call ExceptionHandling#log_warning" do
-          mock(ExceptionHandling).log_warning("Hi mom")
+        it "call ExceptionHandling#log_warning" do
+          expect(ExceptionHandling).to receive(:log_warning).with("Hi mom")
           @controller.send(:log_warning, "Hi mom")
         end
       end

data/{test/unit/exception_handling/mailer_test.rb → spec/unit/exception_handling/mailer_spec.rb}

@@ -1,19 +1,19 @@
 # frozen_string_literal: true
 
-require File.expand_path('../../test_helper',  __dir__)
+require File.expand_path('../../spec_helper',  __dir__)
+require 'rails-dom-testing'
 
 module ExceptionHandling
-  class MailerTest < ActionMailer::TestCase
+  describe Mailer do
 
     include ::Rails::Dom::Testing::Assertions::SelectorAssertions
-    tests ExceptionHandling::Mailer
 
     def dont_stub_log_error
       true
     end
 
     context "ExceptionHandling::Mailer" do
-      setup do
+      before do
         ExceptionHandling.email_environment = 'Test'
         ExceptionHandling.sender_address = %("Test Exception Mailer" <null_exception@invoca.com>)
         ExceptionHandling.exception_recipients = ['test_exception@invoca.com']
@@ -21,22 +21,22 @@ module ExceptionHandling
       end
 
       context "log_parser_exception_notification" do
-        should "send with string" do
+        it "send with string" do
           result = ExceptionHandling::Mailer.log_parser_exception_notification("This is my fake error", "My Fake Subj").deliver_now
-          assert_equal "Test exception: My Fake Subj: This is my fake error", result.subject
-          assert_match(/This is my fake error/, result.body.to_s)
+          expect(result.subject).to eq("Test exception: My Fake Subj: This is my fake error")
+          expect(result.body.to_s).to match(/This is my fake error/)
           assert_emails 1
         end
       end
 
       context "escalation_notification" do
-        setup do
+        before do
           def document_root_element
             @body_html.root
           end
         end
 
-        should "send all the information" do
+        it "send all the information" do
           ExceptionHandling.email_environment = 'Staging Full'
           ExceptionHandling.server_name = 'test-fe3'
 
@@ -46,8 +46,8 @@ module ExceptionHandling
           result = ActionMailer::Base.deliveries.last
           @body_html = Nokogiri::HTML(result.body.to_s)
           assert_equal_with_diff ['test_escalation@invoca.com'], result.to
-          assert_equal ["Test Escalation Mailer <null_escalation@invoca.com>"], result[:from].formatted
-          assert_equal "Staging Full Escalation: Your Favorite <b>Feature<b> Failed", result.subject
+          expect(result[:from].formatted).to eq(["Test Escalation Mailer <null_escalation@invoca.com>"])
+          expect(result.subject).to eq("Staging Full Escalation: Your Favorite <b>Feature<b> Failed")
           assert_select "title", "Exception Escalation"
           assert_select "html" do
             assert_select "body br", { count: 4 }, result.body.to_s # plus 1 for the multiline summary
@@ -60,13 +60,13 @@ module ExceptionHandling
           end
         end
 
-        should "use defaults for missing fields" do
+        it "use defaults for missing fields" do
           result = ExceptionHandling::Mailer.escalation_notification("Your Favorite Feature Failed", error_string: "It failed because of an error\n More Info")
           @body_html = Nokogiri::HTML(result.body.to_s)
 
           assert_equal_with_diff ['test_escalation@invoca.com'], result.to
-          assert_equal ["null_escalation@invoca.com"], result.from
-          assert_equal 'Test Escalation: Your Favorite Feature Failed', result.subject
+          expect(result.from).to eq(["null_escalation@invoca.com"])
+          expect(result.subject).to eq('Test Escalation: Your Favorite Feature Failed')
           assert_select "html" do
             assert_select "body i", true, result.body.to_s do |is|
               assert_select is, "i", 'no error #'
@@ -75,11 +75,11 @@ module ExceptionHandling
         end
 
         context "ExceptionHandling.escalate_to_production_support" do
-          setup do
+          before do
             Time.now_override = Time.parse('1986-5-21 4:17 am UTC')
           end
 
-          should "notify production support" do
+          it "notify production support" do
             subject = "Runtime Error found!"
             exception = RuntimeError.new("Test")
             recipients = ["prodsupport@example.com"]
@@ -87,7 +87,7 @@ module ExceptionHandling
             ExceptionHandling.production_support_recipients = recipients
             ExceptionHandling.last_exception_timestamp = Time.now.to_i
 
-            mock(ExceptionHandling).escalate(subject, exception, Time.now.to_i, recipients)
+            expect(ExceptionHandling).to receive(:escalate).with(subject, exception, Time.now.to_i, recipients)
             ExceptionHandling.escalate_to_production_support(exception, subject)
           end
         end

data/spec/unit/exception_handling/methods_spec.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require File.expand_path('../../spec_helper',  __dir__)
+
+require "exception_handling/testing"
+require_relative '../../helpers/exception_helpers.rb'
+
+module ExceptionHandling
+  describe Methods do
+    include ExceptionHelpers
+
+    def dont_stub_log_error
+      true
+    end
+
+    context "ExceptionHandling::Methods" do
+      before do
+        @controller = Testing::MethodsControllerStub.new
+        ExceptionHandling.stub_handler = nil
+      end
+
+      it "set the around filter" do
+        expect(Testing::MethodsControllerStub.around_filter_method).to eq(:set_current_controller)
+        expect(ExceptionHandling.current_controller).to be_nil
+        @controller.simulate_around_filter do
+          expect(ExceptionHandling.current_controller).to eq(@controller)
+        end
+        expect(ExceptionHandling.current_controller).to be_nil
+      end
+
+      it "use the current_controller when available" do
+        capture_notifications
+
+        expect(ExceptionHandling.logger).to receive(:fatal).with(/blah/, anything).at_least(:once)
+        @controller.simulate_around_filter do
+          ExceptionHandling.log_error(ArgumentError.new("blah"))
+          expect(sent_notifications.size).to eq(1)
+          expect(/#{Regexp.new(Regexp.escape(@controller.request.request_uri))}/).to match(sent_notifications.last.enhanced_data['request'].to_s)
+        end
+      end
+
+      it "report long running controller action" do
+        expect(@controller.send(:long_controller_action_timeout)).to eq(2)
+        expect(ExceptionHandling).to receive(:log_error).with(/Long controller action detected in #{@controller.class.name.split("::").last}::test_action/)
+        @controller.simulate_around_filter do
+          sleep(3)
+        end
+      end
+
+      it "not report long running controller actions if it is less than the timeout" do
+        expect(@controller.send(:long_controller_action_timeout)).to eq(2)
+        allow(ExceptionHandling).to receive(:log_error).and_return("Should not timeout")
+        @controller.simulate_around_filter do
+          sleep(1)
+        end
+      end
+
+      it "default long running controller action(300/30 for test/prod)" do
+        class DummyController
+          include ExceptionHandling::Methods
+        end
+
+        controller = DummyController.new
+
+        Rails.env = 'production'
+        expect(controller.send(:long_controller_action_timeout)).to eq(30)
+
+        Rails.env = 'test'
+        expect(controller.send(:long_controller_action_timeout)).to eq(300)
+      end
+
+      context "#log_warning" do
+        it "be available to the controller" do
+          expect(@controller.methods.include?(:log_warning)).to eq(true)
+        end
+      end
+
+      context  "included deprecation" do
+        before do
+          mock_deprecation_3_0
+        end
+
+        it "deprecate when no around_filter in included hook" do
+          k = Class.new
+          k.include ExceptionHandling::Methods
+        end
+
+        it "deprecate controller around_filter in included hook" do
+          controller = Class.new
+          class << controller
+            def around_filter(*)
+            end
+          end
+          controller.include ExceptionHandling::Methods
+        end
+      end
+
+      private
+
+      def mock_deprecation_3_0
+        expect(STDERR).to receive(:puts).with(/DEPRECATION WARNING: ExceptionHandling::Methods is deprecated and will be removed from exception_handling 3\.0/)
+      end
+    end
+  end
+end