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

data/test/unit/exception_handling/honeybadger_callbacks_test.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require File.expand_path('../../test_helper',  __dir__)
+
+module ExceptionHandling
+  class HoneybadgerCallbacksTest < ActiveSupport::TestCase
+
+    class TestPoroWithAttribute
+      attr_reader :test_attribute
+
+      def initialize
+        @test_attribute = 'test'
+      end
+    end
+
+    class TestPoroWithFilteredAttribute
+      attr_reader :password
+
+      def initialize
+        @password = 'secret'
+      end
+    end
+
+    class TestPoroWithFilteredAttributeAndId < TestPoroWithFilteredAttribute
+      attr_reader :id
+
+      def initialize
+        super
+        @id = 1
+      end
+    end
+
+    class TestPoroWithFilteredAttributePkAndId < TestPoroWithFilteredAttributeAndId
+      def to_pk
+        'TestPoroWithFilteredAttributePkAndId_1'
+      end
+    end
+
+    class TestRaiseOnInspect < TestPoroWithAttribute
+      def inspect
+        raise "some error"
+      end
+    end
+
+    class TestRaiseOnInspectWithId < TestRaiseOnInspect
+      def id
+        123
+      end
+    end
+
+    class TestRaiseOnInspectWithToPk < TestRaiseOnInspect
+      def to_pk
+        "SomeRecord-123"
+      end
+    end
+
+    context "register_callbacks" do
+      should "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)
+      end
+    end
+
+    context "local_variable_filter" do
+      should "not inspect String, Hash, Array, Set, Numeric, TrueClass, FalseClass, NilClass" do
+        [
+          ['test', String],
+          [{ a: 1 }, Hash],
+          [[1, 2], Array],
+          [Set.new([1, 2]), Set],
+          [4.5, Numeric],
+          [true, TrueClass],
+          [false, FalseClass],
+          [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}"
+        end
+      end
+
+      should "inspect other classes" do
+        result = HoneybadgerCallbacks.send(:local_variable_filter, :variable_name, TestPoroWithAttribute.new, ['password'])
+        assert_match(/#<ExceptionHandling::HoneybadgerCallbacksTest::TestPoroWithAttribute:.* @test_attribute="test">/, result)
+      end
+
+      context "when inspect raises exceptions" do
+        should "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
+        end
+
+        should "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
+        end
+
+        should "handle exceptions for objects responding to to_pik" 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
+        end
+      end
+
+      context "not inspect objects that contain filter keys" do
+        should "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)
+        end
+
+        should "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)
+        end
+
+        should "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)
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -1,19 +1,19 @@
 # frozen_string_literal: true
 
-require File.expand_path('../../spec_helper',  __dir__)
-require 'rails-dom-testing'
+require File.expand_path('../../test_helper',  __dir__)
 
 module ExceptionHandling
-  describe Mailer do
+  class MailerTest < ActionMailer::TestCase
 
     include ::Rails::Dom::Testing::Assertions::SelectorAssertions
+    tests ExceptionHandling::Mailer
 
     def dont_stub_log_error
       true
     end
 
     context "ExceptionHandling::Mailer" do
-      before do
+      setup 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
-        it "send with string" do
+        should "send with string" do
           result = ExceptionHandling::Mailer.log_parser_exception_notification("This is my fake error", "My Fake Subj").deliver_now
-          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_equal "Test exception: My Fake Subj: This is my fake error", result.subject
+          assert_match(/This is my fake error/, result.body.to_s)
           assert_emails 1
         end
       end
 
       context "escalation_notification" do
-        before do
+        setup do
           def document_root_element
             @body_html.root
           end
         end
 
-        it "send all the information" do
+        should "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
-          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_equal ["Test Escalation Mailer <null_escalation@invoca.com>"], result[:from].formatted
+          assert_equal "Staging Full Escalation: Your Favorite <b>Feature<b> Failed", result.subject
           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
 
-        it "use defaults for missing fields" do
+        should "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
-          expect(result.from).to eq(["null_escalation@invoca.com"])
-          expect(result.subject).to eq('Test Escalation: Your Favorite Feature Failed')
+          assert_equal ["null_escalation@invoca.com"], result.from
+          assert_equal 'Test Escalation: Your Favorite Feature Failed', result.subject
           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
-          before do
+          setup do
             Time.now_override = Time.parse('1986-5-21 4:17 am UTC')
           end
 
-          it "notify production support" do
+          should "notify production support" do
             subject = "Runtime Error found!"
             exception = RuntimeError.new("Test")
             recipients = ["prodsupport@example.com"]
@@ -87,11 +87,12 @@ module ExceptionHandling
             ExceptionHandling.production_support_recipients = recipients
             ExceptionHandling.last_exception_timestamp = Time.now.to_i
 
-            expect(ExceptionHandling).to receive(:escalate).with(subject, exception, Time.now.to_i, recipients)
+            mock(ExceptionHandling).escalate(subject, exception, Time.now.to_i, recipients)
             ExceptionHandling.escalate_to_production_support(exception, subject)
           end
         end
       end
     end
+
   end
 end

data/test/unit/exception_handling/methods_test.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require File.expand_path('../../test_helper',  __dir__)
+
+require "exception_handling/testing"
+
+module ExceptionHandling
+  class MethodsTest < ActiveSupport::TestCase
+    include ExceptionHelpers
+
+    def dont_stub_log_error
+      true
+    end
+
+    context "ExceptionHandling.Methods" do
+      setup do
+        @controller = Testing::ControllerStub.new
+        ExceptionHandling.stub_handler = nil
+      end
+
+      should "set the around filter" do
+        assert_equal :set_current_controller, Testing::ControllerStub.around_filter_method
+        assert_nil ExceptionHandling.current_controller
+        @controller.simulate_around_filter do
+          assert_equal @controller, ExceptionHandling.current_controller
+        end
+        assert_nil ExceptionHandling.current_controller
+      end
+
+      should "use the current_controller when available" do
+        capture_notifications
+
+        mock(ExceptionHandling.logger).fatal(/blah/, anything)
+        @controller.simulate_around_filter do
+          ExceptionHandling.log_error(ArgumentError.new("blah"))
+          assert_equal 1, sent_notifications.size, sent_notifications.inspect
+          assert_match(@controller.request.request_uri, sent_notifications.last.enhanced_data['request'].to_s)
+        end
+      end
+
+      should "report long running controller action" do
+        assert_equal 2, @controller.send(:long_controller_action_timeout)
+        mock(ExceptionHandling).log_error(/Long controller action detected in #{@controller.class.name.split("::").last}::test_action/, anything, anything)
+        @controller.simulate_around_filter do
+          sleep(3)
+        end
+      end
+
+      should "not report long running controller actions if it is less than the timeout" do
+        assert_equal 2, @controller.send(:long_controller_action_timeout)
+        stub(ExceptionHandling).log_error { flunk "Should not timeout" }
+        @controller.simulate_around_filter do
+          sleep(1)
+        end
+      end
+
+      should "default long running controller action(300/30 for test/prod)" do
+        class DummyController
+          include ExceptionHandling::Methods
+        end
+
+        controller = DummyController.new
+
+        Rails.env = 'production'
+        assert_equal 30, controller.send(:long_controller_action_timeout)
+
+        Rails.env = 'test'
+        assert_equal 300, controller.send(:long_controller_action_timeout)
+      end
+
+      context "#log_warning" do
+        should "be available to the controller" do
+          assert_equal true, @controller.methods.include?(:log_warning)
+        end
+
+        should "call ExceptionHandling#log_warning" do
+          mock(ExceptionHandling).log_warning("Hi mom")
+          @controller.send(:log_warning, "Hi mom")
+        end
+      end
+    end
+
+  end
+end

data/test/unit/exception_handling/sensu_test.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require File.expand_path('../../test_helper',  __dir__)
+
+module ExceptionHandling
+  class SensuTest < ActiveSupport::TestCase
+    context "#generate_event" do
+      should "create an event" do
+        mock(ExceptionHandling::Sensu).send_event(name: "world_is_ending", output: "stick head between knees and kiss ass goodbye", status: 1)
+
+        ExceptionHandling::Sensu.generate_event("world_is_ending", "stick head between knees and kiss ass goodbye")
+      end
+
+      should "add the sensu prefix" do
+        ExceptionHandling.sensu_prefix = "cnn_"
+
+        mock(ExceptionHandling::Sensu).send_event(name: "cnn_world_is_ending", output: "stick head between knees and kiss ass goodbye", status: 1)
+
+        ExceptionHandling::Sensu.generate_event("world_is_ending", "stick head between knees and kiss ass goodbye")
+      end
+
+      should "allow the level to be set to critical" do
+        mock(ExceptionHandling::Sensu).send_event(name: "world_is_ending", output: "stick head between knees and kiss ass goodbye", status: 2)
+
+        ExceptionHandling::Sensu.generate_event("world_is_ending", "stick head between knees and kiss ass goodbye", :critical)
+      end
+
+      should "error if an invalid level is supplied" do
+        dont_allow(ExceptionHandling::Sensu).send_event
+
+        assert_raise(RuntimeError, "Invalid alert level") do
+          ExceptionHandling::Sensu.generate_event("world_is_ending", "stick head between knees and kiss ass goodbye", :hair_on_fire)
+        end
+      end
+    end
+
+    context "#send_event" do
+      setup do
+        @event = { name: "world_is_ending", output: "stick head between knees and kiss ass goodbye", status: 1 }
+        @socket = SocketStub.new
+      end
+
+      should "send event json to sensu client" do
+        mock.any_instance_of(Addrinfo).connect.with_any_args { @socket }
+
+        ExceptionHandling::Sensu.send_event(@event)
+
+        assert_equal @event.to_json, @socket.sent.first
+      end
+    end
+  end
+end