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

data/spec/unit/exception_handling/escalate_callback_spec.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-require 'exception_handling/escalate_callback'
-require File.expand_path('../../spec_helper',  __dir__)
-
-module ExceptionHandling
-  describe EscalateCallback do
-    before do
-      class TestGem
-        class << self
-          attr_accessor :logger
-        end
-        include Escalate.mixin
-      end
-      TestGem.logger = logger
-      Escalate.clear_on_escalate_callbacks
-    end
-
-    after do
-      Escalate.clear_on_escalate_callbacks
-    end
-
-    let(:exception) do
-      raise "boom!"
-    rescue => ex
-      ex
-    end
-    let(:location_message) { "happened in TestGem" }
-    let(:context_hash) { { cuid: 'AABBCD' } }
-    let(:logger) { double("logger") }
-
-    describe '.register_if_configured!' do
-      context 'when already configured' do
-        before do
-          @original_logger = ExceptionHandling.logger
-          ExceptionHandling.logger = ::Logger.new('/dev/null')
-        end
-
-        after do
-          ExceptionHandling.logger = @original_logger
-        end
-
-        it 'registers a callback' do
-          EscalateCallback.register_if_configured!
-
-          expect(logger).to_not receive(:error)
-          expect(logger).to_not receive(:fatal)
-          expect(ExceptionHandling).to receive(:log_error).with(exception, location_message, context_hash)
-
-          TestGem.escalate(exception, location_message, context: context_hash)
-        end
-      end
-
-      context 'when not yet configured' do
-        before do
-          @original_logger = ExceptionHandling.logger
-          ExceptionHandling.logger = nil
-        end
-
-        after do
-          ExceptionHandling.logger = @original_logger
-        end
-
-        it 'registers a callback once the logger is set' do
-          EscalateCallback.register_if_configured!
-
-          expect(Escalate.on_escalate_callbacks).to be_empty
-
-          ExceptionHandling.logger = ::Logger.new('/dev/null')
-          expect(Escalate.on_escalate_callbacks).to_not be_empty
-
-          expect(logger).to_not receive(:error)
-          expect(logger).to_not receive(:fatal)
-          expect(ExceptionHandling).to receive(:log_error).with(exception, location_message, context_hash)
-
-          TestGem.escalate(exception, location_message, context: context_hash)
-        end
-      end
-    end
-  end
-end

data/spec/unit/exception_handling/exception_catalog_spec.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-require File.expand_path('../../spec_helper',  __dir__)
-
-module ExceptionHandling
-  describe ExceptionCatalog do
-
-    context "With stubbed yaml content" do
-      before do
-        filter_list = { exception1: { error: "my error message" },
-                        exception2: { error: "some other message", session: "misc data" } }
-        allow(YAML).to receive(:load_file) { filter_list }
-
-        # bump modified time up to get the above filter loaded
-        allow(File).to receive(:mtime) { incrementing_mtime }
-      end
-
-      context "with loaded data" do
-        before do
-          allow(File).to receive(:mtime) { incrementing_mtime }
-          @exception_catalog = ExceptionCatalog.new(ExceptionHandling.filter_list_filename)
-          @exception_catalog.send :load_file
-        end
-
-        it "have loaded filters" do
-          expect(@exception_catalog.instance_eval("@filters").size).to eq(2)
-        end
-
-        it "find messages in the catalog" do
-          expect(!@exception_catalog.find(error: "Scott says unlikely to ever match")).to be_truthy
-        end
-
-        it "find matching data" do
-          exception_description = @exception_catalog.find(error: "this is my error message, which should match something")
-          expect(exception_description).to be_truthy
-          expect(exception_description.filter_name).to eq(:exception1)
-        end
-      end
-
-      it "write errors loading the yaml file directly to the log file" do
-        @exception_catalog = ExceptionCatalog.new(ExceptionHandling.filter_list_filename)
-
-        expect(ExceptionHandling).to receive(:log_error).never
-        expect(ExceptionHandling).to receive(:write_exception_to_log).with(anything, "ExceptionCatalog#refresh_filters: ./config/exception_filters.yml", any_args)
-        expect(@exception_catalog).to receive(:load_file) { raise "noooooo" }
-
-        @exception_catalog.find({})
-      end
-    end
-
-    context "with live yaml content" do
-      before do
-        @filename = File.expand_path('../../../config/exception_filters.yml',  __dir__)
-        @exception_catalog = ExceptionCatalog.new(@filename)
-        expect do
-          @exception_catalog.send :load_file
-        end.not_to raise_error
-      end
-
-      it "load the filter data" do
-        expect(!@exception_catalog.find(error: "Scott says unlikely to ever match")).to be_truthy
-        expect(!@exception_catalog.find(error: "Scott says unlikely to ever match")).to be_truthy
-      end
-    end
-
-    context "with no yaml content" do
-      before do
-        @exception_catalog = ExceptionCatalog.new(nil)
-      end
-
-      it "not load filter data" do
-        expect(ExceptionHandling).to receive(:write_exception_to_log).with(any_args).never
-        @exception_catalog.find(error: "Scott says unlikely to ever match")
-      end
-    end
-
-    private
-
-    def incrementing_mtime
-      @mtime ||= Time.now
-      @mtime += 1.day
-    end
-
-  end
-end

data/spec/unit/exception_handling/exception_description_spec.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-require File.expand_path('../../spec_helper',  __dir__)
-
-module ExceptionHandling
-  describe ExceptionDescription do
-
-    context "Filter" do
-      it "allow direct matching of strings" do
-        @f = ExceptionDescription.new(:filter1, error: "my error message")
-        expect(@f.match?('error' => "my error message")).to be_truthy
-      end
-
-      it "allow direct matching of strings on with symbol keys" do
-        @f = ExceptionDescription.new(:filter1, error: "my error message")
-        expect(@f.match?(error: "my error message")).to be_truthy
-      end
-
-      it "allow wildcards to cross line boundries" do
-        @f = ExceptionDescription.new(:filter1, error: "my error message.*with multiple lines")
-        expect(@f.match?(error: "my error message\nwith more than one, with multiple lines")).to be_truthy
-      end
-
-      it "complain when no regexps have a value" do
-        expect { ExceptionDescription.new(:filter1, error: nil) }.to raise_exception(ArgumentError, /has all blank regexes/)
-      end
-
-      it "report when an invalid key is passed" do
-        expect { ExceptionDescription.new(:filter1, error: "my error message", not_a_parameter: false) }.to raise_exception(ArgumentError, "Unknown section: not_a_parameter")
-      end
-
-      it "allow send_to_honeybadger to be specified and have it disabled by default" do
-        expect(!ExceptionDescription.new(:filter1, error: "my error message", send_to_honeybadger: false).send_to_honeybadger).to be_truthy
-        expect(ExceptionDescription.new(:filter1, error: "my error message", send_to_honeybadger: true).send_to_honeybadger).to be_truthy
-        expect(!ExceptionDescription.new(:filter1, error: "my error message").send_to_honeybadger).to be_truthy
-      end
-
-      it "allow send_metric to be configured" do
-        expect(!ExceptionDescription.new(:filter1, error: "my error message", send_metric: false).send_metric).to be_truthy
-        expect(ExceptionDescription.new(:filter1, error: "my error message").send_metric).to be_truthy
-      end
-
-      it "provide metric name" do
-        expect(ExceptionDescription.new(:filter1, error: "my error message").metric_name).to eq("filter1")
-        expect(ExceptionDescription.new(:filter1, error: "my error message", metric_name: :some_other_metric_name).metric_name).to eq("some_other_metric_name")
-      end
-
-      it "replace spaces in metric name" do
-        @f = ExceptionDescription.new(:"filter has spaces", error: "my error message")
-        expect(@f.metric_name).to eq( "filter_has_spaces")
-      end
-
-      it "allow notes to be recorded" do
-        expect(ExceptionDescription.new(:filter1, error: "my error message").notes).to be_nil
-        expect(ExceptionDescription.new(:filter1, error: "my error message", notes: "a long string").notes).to eq("a long string")
-      end
-
-      it "not consider config options in the filter set" do
-        expect(ExceptionDescription.new(:filter1, error: "my error message", send_metric: false).match?(error: "my error message")).to be_truthy
-        expect(ExceptionDescription.new(:filter1, error: "my error message", metric_name: "false").match?(error: "my error message")).to be_truthy
-        expect(ExceptionDescription.new(:filter1, error: "my error message", notes: "hey").match?(error: "my error message")).to be_truthy
-      end
-
-      it "provide exception details" do
-        exception_description = ExceptionDescription.new(:filter1, error: "my error message", notes: "hey")
-
-        expected = { "send_metric" => true, "metric_name" => "filter1", "notes" => "hey" }
-
-        expect(exception_description.exception_data).to eq( expected)
-      end
-
-      it "match multiple email addresses" do
-        mobi = "ExceptionHandling::Warning: LoginAttempt::IPAddressLocked: failed login for 'mcc@mobistreak.com'"
-        credit = "ExceptionHandling::Warning: LoginAttempt::IPAddressLocked: failed login for 'damon@thecreditpros.com'"
-
-        exception_description = ExceptionDescription.new(:filter1, error: "ExceptionHandling::Warning: LoginAttempt::IPAddressLocked: failed login for '(mcc\@mobistreak|damon\@thecreditpros).com'")
-        expect(exception_description.match?(error: mobi)).to be_truthy
-        expect(exception_description.match?(error: credit)).to be_truthy
-      end
-    end
-  end
-end

data/spec/unit/exception_handling/logging_methods_spec.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require File.expand_path('../../spec_helper',  __dir__)
-
-require_relative '../../helpers/exception_helpers'
-
-require "exception_handling/testing"
-
-module ExceptionHandling
-  describe LoggingMethods do
-    include ExceptionHelpers
-
-    def dont_stub_log_error
-      true
-    end
-
-    context "ExceptionHandling::LoggingMethods" do
-      before do
-        @controller = Testing::LoggingMethodsControllerStub.new
-        ExceptionHandling.stub_handler = nil
-      end
-
-      context "#log_warning" do
-        it "be available to the controller" do
-          klass = Class.new
-          klass.include ExceptionHandling::LoggingMethods
-          instance = klass.new
-          expect(instance.methods.include?(:log_warning)).to eq(true)
-        end
-
-        it "call ExceptionHandling#log_warning" do
-          expect(ExceptionHandling).to receive(:log_warning).with("Hi mom")
-          @controller.send(:log_warning, "Hi mom")
-        end
-      end
-    end
-  end
-end

data/spec/unit/exception_handling/methods_spec.rb

@@ -1,105 +0,0 @@
-# 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/, any_args).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

data/spec/unit/exception_handling/sensu_spec.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require File.expand_path('../../spec_helper',  __dir__)
-
-module ExceptionHandling
-  describe Sensu do
-    context "#generate_event" do
-      it "create an event" do
-        expect(ExceptionHandling::Sensu).to receive(:send_event).with({ 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
-
-      it "add the sensu prefix" do
-        ExceptionHandling.sensu_prefix = "cnn_"
-
-        expect(ExceptionHandling::Sensu).to receive(:send_event).with({ 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
-
-      it "allow the level to be set to critical" do
-        expect(ExceptionHandling::Sensu).to receive(:send_event).with({ 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
-
-      it "error if an invalid level is supplied" do
-        expect(ExceptionHandling::Sensu).to_not receive(:send_event)
-
-        expect do
-          ExceptionHandling::Sensu.generate_event("world_is_ending", "stick head between knees and kiss ass goodbye", :hair_on_fire)
-        end.to raise_exception(RuntimeError, /Invalid alert level/)
-      end
-    end
-
-    context "#send_event" do
-      before do
-        @event = { name: "world_is_ending", output: "stick head between knees and kiss ass goodbye", status: 1 }
-        @socket = SocketStub.new
-      end
-
-      it "send event json to sensu client" do
-        expect_any_instance_of(Addrinfo).to receive(:connect).with(any_args) { @socket }
-        ExceptionHandling::Sensu.send_event(@event)
-
-        expect(@socket.sent.first).to eq(@event.to_json)
-      end
-    end
-  end
-end