exception_handling 2.2.1 → 2.3.0.pre.1

data/lib/exception_handling.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'timeout'
 require 'active_support'
 require 'active_support/core_ext/hash'
@@ -17,13 +19,12 @@ require "exception_handling/honeybadger_callbacks.rb"
 _ = ActiveSupport::HashWithIndifferentAccess
 
 module ExceptionHandling # never included
-
   class Warning < StandardError; end
   class MailerTimeout < Timeout::Error; end
   class ClientLoggingError < StandardError; end
 
   SUMMARY_THRESHOLD = 5
-  SUMMARY_PERIOD = 60*60 # 1.hour
+  SUMMARY_PERIOD = 60 * 60 # 1.hour
 
   AUTHENTICATION_HEADERS = ['HTTP_AUTHORIZATION', 'X-HTTP_AUTHORIZATION', 'X_HTTP_AUTHORIZATION', 'REDIRECT_X_HTTP_AUTHORIZATION'].freeze
   HONEYBADGER_STATUSES   = [:success, :failure, :skipped].freeze
@@ -38,19 +39,19 @@ module ExceptionHandling # never included
     attr_writer :exception_recipients
 
     def server_name
-      @server_name or raise ArgumentError, "You must assign a value to #{self.name}.server_name"
+      @server_name or raise ArgumentError, "You must assign a value to #{name}.server_name"
     end
 
     def sender_address
-      @sender_address or raise ArgumentError, "You must assign a value to #{self.name}.sender_address"
+      @sender_address or raise ArgumentError, "You must assign a value to #{name}.sender_address"
     end
 
     def exception_recipients
-      @exception_recipients or raise ArgumentError, "You must assign a value to #{self.name}.exception_recipients"
+      @exception_recipients or raise ArgumentError, "You must assign a value to #{name}.exception_recipients"
     end
 
     def logger
-      @logger or raise ArgumentError, "You must assign a value to #{self.name}.logger"
+      @logger or raise ArgumentError, "You must assign a value to #{name}.logger"
     end
 
     def logger=(logger)
@@ -87,7 +88,6 @@ module ExceptionHandling # never included
     attr_accessor :production_support_recipients
     attr_accessor :escalation_recipients
     attr_accessor :email_environment
-    attr_accessor :mailer_send_enabled
     attr_accessor :custom_data_hook
     attr_accessor :post_log_error_hook
     attr_accessor :stub_handler
@@ -100,7 +100,6 @@ module ExceptionHandling # never included
     attr_reader :eventmachine_synchrony
 
     @filter_list_filename = "./config/exception_filters.yml"
-    @mailer_send_enabled  = true
     @email_environment = ""
     @eventmachine_safe = false
     @eventmachine_synchrony = false
@@ -111,8 +110,9 @@ module ExceptionHandling # never included
     # set this for operation within an eventmachine reactor
     def eventmachine_safe=(bool)
       if bool != true && bool != false
-        raise ArgumentError, "#{self.name}.eventmachine_safe must be a boolean."
+        raise ArgumentError, "#{name}.eventmachine_safe must be a boolean."
       end
+
       if bool
         require 'eventmachine'
         require 'em/protocols/smtpclient'
@@ -123,8 +123,9 @@ module ExceptionHandling # never included
     # set this for EM::Synchrony async operation
     def eventmachine_synchrony=(bool)
       if bool != true && bool != false
-        raise ArgumentError, "#{self.name}.eventmachine_synchrony must be a boolean."
+        raise ArgumentError, "#{name}.eventmachine_synchrony must be a boolean."
       end
+
       @eventmachine_synchrony = bool
     end
 
@@ -148,67 +149,60 @@ module ExceptionHandling # never included
     # Gets called by Rack Middleware: DebugExceptions or ShowExceptions
     # it does 2 things:
     #   log the error
-    #   email the error
+    #   may send to honeybadger
     #
     # but not during functional tests, when rack middleware is not used
     #
-    def log_error_rack(exception, env, rack_filter)
+    def log_error_rack(exception, env, _rack_filter)
       timestamp = set_log_error_timestamp
       exception_info = ExceptionInfo.new(exception, env, timestamp)
 
       if stub_handler
-        return stub_handler.handle_stub_log_error(exception_info.data)
-      end
-
-      # TODO: add a more interesting custom description, like:
-      # custom_description = ": caught and processed by Rack middleware filter #{rack_filter}"
-      # which would be nice, but would also require changing quite a few tests
-      custom_description = ""
-      write_exception_to_log(exception, custom_description, timestamp)
+        stub_handler.handle_stub_log_error(exception_info.data)
+      else
+        # TODO: add a more interesting custom description, like:
+        # custom_description = ": caught and processed by Rack middleware filter #{rack_filter}"
+        # which would be nice, but would also require changing quite a few tests
+        custom_description = ""
+        write_exception_to_log(exception, custom_description, timestamp)
 
-      if honeybadger?
-        send_exception_to_honeybadger(exception_info)
-      end
+        send_external_notifications(exception_info)
 
-      if should_send_email?
-        # controller may not exist in some cases (like most 404 errors)
-        if (controller = exception_info.controller)
-          controller.session["last_exception_timestamp"] = last_exception_timestamp
-        end
-        log_error_email(exception_info)
+        nil
       end
     end
 
     #
     # Normal Operation:
     #   Called directly by our code, usually from rescue blocks.
-    #   Does three things: write to log file and send an email, may also send to honeybadger if defined
+    #   Writes to log file and may send to honeybadger
     #
     # Functional Test Operation:
-    #   Calls into handle_stub_log_error and returns. no log file. no email.
+    #   Calls into handle_stub_log_error and returns. no log file. no honeybadger
     #
     def log_error(exception_or_string, exception_context = '', controller = nil, treat_like_warning: false, **log_context, &data_callback)
-      begin
-        ex = make_exception(exception_or_string)
-        timestamp = set_log_error_timestamp
-        exception_info = ExceptionInfo.new(ex, exception_context, timestamp, controller || current_controller, data_callback)
-
-        if stub_handler
-          stub_handler.handle_stub_log_error(exception_info.data)
-        else
-          write_exception_to_log(ex, exception_context, timestamp, **log_context)
-          external_notification_results = unless treat_like_warning || ex.is_a?(Warning)
-                                            send_external_notifications(exception_info)
-                                          end || {}
-          execute_custom_log_error_callback(exception_info.enhanced_data, exception_info.exception, treat_like_warning, external_notification_results)
-          nil
-        end
-      rescue LogErrorStub::UnexpectedExceptionLogged, LogErrorStub::ExpectedExceptionNotLogged
-        raise
-      rescue Exception => ex
-        $stderr.puts("ExceptionHandlingError: log_error rescued exception while logging #{exception_context}: #{exception_or_string}:\n#{ex.class}: #{ex.message}\n#{ex.backtrace.join("\n")}")
-        write_exception_to_log(ex, "ExceptionHandlingError: log_error rescued exception while logging #{exception_context}: #{exception_or_string}", timestamp)
+      ex = make_exception(exception_or_string)
+      timestamp = set_log_error_timestamp
+      exception_info = ExceptionInfo.new(ex, exception_context, timestamp, controller || current_controller, data_callback)
+
+      if stub_handler
+        stub_handler.handle_stub_log_error(exception_info.data)
+      else
+        write_exception_to_log(ex, exception_context, timestamp, **log_context)
+        external_notification_results = unless treat_like_warning || ex.is_a?(Warning)
+                                          send_external_notifications(exception_info)
+                                        end || {}
+        execute_custom_log_error_callback(exception_info.enhanced_data.merge(log_context: log_context), exception_info.exception, treat_like_warning, external_notification_results)
       end
+
+      ExceptionHandling.last_exception_timestamp
+    rescue LogErrorStub::UnexpectedExceptionLogged, LogErrorStub::ExpectedExceptionNotLogged
+      raise
+    rescue Exception => ex
+      warn("ExceptionHandlingError: log_error rescued exception while logging #{exception_context}: #{exception_or_string}:\n#{ex.class}: #{ex.message}\n#{ex.backtrace.join("\n")}")
+      write_exception_to_log(ex, "ExceptionHandlingError: log_error rescued exception while logging #{exception_context}: #{exception_or_string}", timestamp)
+    ensure
+      ExceptionHandling.last_exception_timestamp
     end
 
     #
@@ -225,34 +219,38 @@ module ExceptionHandling # never included
     #
     def send_external_notifications(exception_info)
       results = {}
-      if honeybadger?
-        results[:honeybadger_status] = send_exception_to_honeybadger(exception_info)
+      if honeybadger_defined?
+        results[:honeybadger_status] = send_exception_to_honeybadger_unless_filtered(exception_info)
       end
+      results
+    end
 
-      if should_send_email?
-        log_error_email(exception_info)
+    # Returns :success or :failure or :skipped
+    def send_exception_to_honeybadger_unless_filtered(exception_info)
+      if exception_info.send_to_honeybadger?
+        send_exception_to_honeybadger(exception_info)
+      else
+        log_info("Filtered exception using '#{exception_info.exception_description.filter_name}'; not sending notification to Honeybadger")
+        :skipped
       end
-      results
     end
 
     #
     # Log exception to honeybadger.io.
     #
+    # Returns :success or :failure
+    #
     def send_exception_to_honeybadger(exception_info)
       exception             = exception_info.exception
       exception_description = exception_info.exception_description
-      if exception_info.send_to_honeybadger?
-        response = Honeybadger.notify(error_class:   exception_description ? exception_description.filter_name : exception.class.name,
-                                      error_message: exception.message.to_s,
-                                      exception:     exception,
-                                      context:       exception_info.honeybadger_context_data)
-        response ? :success : :failure
-      else
-        log_info("Filtered exception using '#{exception_description.filter_name}'; not sending notification to Honeybadger")
-        :skipped
-      end
+      response = Honeybadger.notify(error_class: exception_description ? exception_description.filter_name : exception.class.name,
+                                    error_message: exception.message.to_s,
+                                    exception:     exception,
+                                    context:       exception_info.honeybadger_context_data,
+                                    controller:    exception_info.controller_name)
+      response ? :success : :failure
     rescue Exception => ex
-      $stderr.puts("ExceptionHandling.send_exception_to_honeybadger rescued exception while logging #{exception_info.exception_context}:\n#{exception.class}: #{exception.message}:\n#{ex.class}: #{ex.message}\n#{ex.backtrace.join("\n")}")
+      warn("ExceptionHandling.send_exception_to_honeybadger rescued exception while logging #{exception_info.exception_context}:\n#{exception.class}: #{exception.message}:\n#{ex.class}: #{ex.message}\n#{ex.backtrace.join("\n")}")
       write_exception_to_log(ex, "ExceptionHandling.send_exception_to_honeybadger rescued exception while logging #{exception_info.exception_context}:\n#{exception.class}: #{exception.message}", exception_info.timestamp)
       :failure
     end
@@ -260,7 +258,7 @@ module ExceptionHandling # never included
     #
     # Check if Honeybadger defined.
     #
-    def honeybadger?
+    def honeybadger_defined?
       Object.const_defined?("Honeybadger")
     end
 
@@ -295,7 +293,7 @@ module ExceptionHandling # never included
       yield
     rescue => ex
       log_error ex, exception_context, **log_context
-      return nil
+      nil
     end
 
     def ensure_completely_safe(exception_context = "", **log_context)
@@ -304,33 +302,32 @@ module ExceptionHandling # never included
       raise
     rescue Exception => ex
       log_error ex, exception_context, log_context
+      nil
     end
 
     def escalate_to_production_support(exception_or_string, email_subject)
-      production_support_recipients or raise ArgumentError, "In order to escalate to production support, you must set #{self.name}.production_recipients"
+      production_support_recipients or raise ArgumentError, "In order to escalate to production support, you must set #{name}.production_recipients"
       ex = make_exception(exception_or_string)
-      escalate_custom(email_subject, ex, last_exception_timestamp, production_support_recipients)
+      escalate(email_subject, ex, last_exception_timestamp, production_support_recipients)
     end
 
-    def escalate_error(exception_or_string, email_subject, **log_context)
+    def escalate_error(exception_or_string, email_subject, custom_recipients = nil, **log_context)
       ex = make_exception(exception_or_string)
       log_error(ex, **log_context)
-      escalate(email_subject, ex, last_exception_timestamp)
+      escalate(email_subject, ex, last_exception_timestamp, custom_recipients)
     end
 
-    def escalate_warning(message, email_subject, **log_context)
+    def escalate_warning(message, email_subject, custom_recipients = nil, **log_context)
       ex = Warning.new(message)
       log_error(ex, **log_context)
-      escalate(email_subject, ex, last_exception_timestamp)
+      escalate(email_subject, ex, last_exception_timestamp, custom_recipients)
     end
 
-    def ensure_escalation(email_subject, **log_context)
-      begin
-        yield
-      rescue => ex
-        escalate_error(ex, email_subject, **log_context)
-        nil
-      end
+    def ensure_escalation(email_subject, custom_recipients = nil, **log_context)
+      yield
+    rescue => ex
+      escalate_error(ex, email_subject, custom_recipients, **log_context)
+      nil
     end
 
     def alert_warning(exception_or_string, alert_name, exception_context, **log_context)
@@ -338,28 +335,22 @@ module ExceptionHandling # never included
       log_error(ex, exception_context, **log_context)
       begin
         ExceptionHandling::Sensu.generate_event(alert_name, exception_context.to_s + "\n" + encode_utf8(ex.message.to_s))
-      rescue => send_ex
-        log_error(send_ex, 'ExceptionHandling.alert_warning')
+      rescue => ex
+        log_error(ex, 'ExceptionHandling.alert_warning')
       end
     end
 
     def ensure_alert(alert_name, exception_context, **log_context)
-      begin
-        yield
-      rescue => ex
-        alert_warning(ex, alert_name, exception_context, **log_context)
-        nil
-      end
+      yield
+    rescue => ex
+      alert_warning(ex, alert_name, exception_context, **log_context)
+      nil
     end
 
     def set_log_error_timestamp
       ExceptionHandling.last_exception_timestamp = Time.now.to_i
     end
 
-    def should_send_email?
-      ExceptionHandling.mailer_send_enabled
-    end
-
     def trace_timing(description)
       result = nil
       time = Benchmark.measure do
@@ -381,19 +372,19 @@ module ExceptionHandling # never included
     def encode_utf8(string)
       string.encode('UTF-8',
                     replace: '?',
-                    undef:   :replace,
+                    undef: :replace,
                     invalid: :replace)
     end
 
     def clean_backtrace(exception)
       backtrace = if exception.backtrace.nil?
-        ['<no backtrace>']
-      elsif exception.is_a?(ClientLoggingError)
-        exception.backtrace
-      elsif defined?(Rails) && defined?(Rails.backtrace_cleaner)
-        Rails.backtrace_cleaner.clean(exception.backtrace)
-      else
-        exception.backtrace
+                    ['<no backtrace>']
+                  elsif exception.is_a?(ClientLoggingError)
+                    exception.backtrace
+                  elsif defined?(Rails) && defined?(Rails.backtrace_cleaner)
+                    Rails.backtrace_cleaner.clean(exception.backtrace)
+                  else
+                    exception.backtrace
       end
 
       # The rails backtrace cleaner returns an empty array for a backtrace if the exception was raised outside the app (inside a gem for instance)
@@ -406,25 +397,6 @@ module ExceptionHandling # never included
 
     private
 
-    def log_error_email(exception_info)
-      data = exception_info.enhanced_data
-      exception_description = exception_info.exception_description
-
-      if exception_description && !exception_description.send_email
-        ExceptionHandling.logger.warn(
-          "Filtered exception using '#{exception_description.filter_name}'; not sending email to notify"
-        )
-      else
-        if summarize_exception(data) != :Summarized
-          deliver(ExceptionHandling::Mailer.exception_notification(data))
-        end
-      end
-      nil
-    rescue Exception => ex
-      $stderr.puts("ExceptionHandling.log_error_email rescued exception while logging #{exception_info.exception_context}: #{exception_info.exception}:\n#{ex.class}: #{ex}\n#{ex.backtrace.join("\n")}")
-      write_exception_to_log(ex, "ExceptionHandling.log_error_email rescued exception while logging #{exception_info.exception_context}: #{exception_info.exception}", exception_info.timestamp)
-    end
-
     def execute_custom_log_error_callback(exception_data, exception, treat_like_warning, external_notification_results)
       if ExceptionHandling.post_log_error_hook
         honeybadger_status = external_notification_results[:honeybadger_status] || :skipped
@@ -437,14 +409,9 @@ module ExceptionHandling # never included
       log_info("Unable to execute custom log_error callback. #{ex_message} #{ex_backtrace}")
     end
 
-    def escalate(email_subject, ex, timestamp)
+    def escalate(email_subject, ex, timestamp, custom_recipients = nil)
       exception_info = ExceptionInfo.new(ex, nil, timestamp)
-      deliver(ExceptionHandling::Mailer.escalation_notification(email_subject, exception_info.data))
-    end
-
-    def escalate_custom(email_subject, ex, timestamp, recipients)
-      exception_info = ExceptionInfo.new(ex, nil, timestamp)
-      deliver(ExceptionHandling::Mailer.escalate_custom(email_subject, exception_info.data, recipients))
+      deliver(ExceptionHandling::Mailer.escalation_notification(email_subject, exception_info.data, custom_recipients))
     end
 
     def deliver(mail_object)
@@ -455,20 +422,18 @@ module ExceptionHandling # never included
           dns_deferrable = EventMachine::DNS::Resolver.resolve(smtp_settings[:address])
           dns_deferrable.callback do |addrs|
             send_deferrable = EventMachine::Protocols::SmtpClient.__send__(
-                async_send_method,
-                {
-                  :host     => addrs.first,
-                  :port     => smtp_settings[:port],
-                  :domain   => smtp_settings[:domain],
-                  :auth     => {:type=>:plain, :username=>smtp_settings[:user_name], :password=>smtp_settings[:password]},
-                  :from     => mail_object['from'].to_s,
-                  :to       => mail_object['to'].to_s,
-                  :content     => "#{mail_object}\r\n.\r\n"
-                }
+              async_send_method,
+              host: addrs.first,
+              port: smtp_settings[:port],
+              domain: smtp_settings[:domain],
+              auth: { type: :plain, username: smtp_settings[:user_name], password: smtp_settings[:password] },
+              from: mail_object['from'].to_s,
+              to: mail_object['to'].to_s,
+              content: "#{mail_object}\r\n.\r\n"
             )
             send_deferrable.errback { |err| ExceptionHandling.logger.fatal("Failed to email by SMTP: #{err.inspect}") }
           end
-          dns_deferrable.errback  { |err| ExceptionHandling.logger.fatal("Failed to resolv DNS for #{smtp_settings[:address]}: #{err.inspect}") }
+          dns_deferrable.errback { |err| ExceptionHandling.logger.fatal("Failed to resolv DNS for #{smtp_settings[:address]}: #{err.inspect}") }
         end
       else
         safe_email_deliver do
@@ -478,73 +443,13 @@ module ExceptionHandling # never included
     end
 
     def safe_email_deliver
-      Timeout::timeout 30, MailerTimeout do
+      Timeout.timeout 30, MailerTimeout do
         yield
       end
     rescue StandardError, MailerTimeout => ex
-      #$stderr.puts("ExceptionHandling::safe_email_deliver rescued: #{ex.class}: #{ex}\n#{ex.backtrace.join("\n")}")
       log_error(ex, "ExceptionHandling::safe_email_deliver", nil, treat_like_warning: true)
     end
 
-    def clear_exception_summary
-      @last_exception = nil
-    end
-
-    # Returns :Summarized iff exception has been added to summary and therefore should not be sent.
-    def summarize_exception(data)
-      if defined?(@last_exception) && @last_exception
-        same_signature = @last_exception[:backtrace] == data[:backtrace]
-
-        case @last_exception[:state]
-
-        when :NotSummarized
-          if same_signature
-            @last_exception[:count] += 1
-            if @last_exception[:count] >= SUMMARY_THRESHOLD
-              @last_exception.merge! :state => :Summarized, :first_seen => Time.now, :count => 0
-            end
-            return nil
-          end
-
-        when :Summarized
-          if same_signature
-            @last_exception[:count] += 1
-            if Time.now - @last_exception[:first_seen] > SUMMARY_PERIOD
-              send_exception_summary(data, @last_exception[:first_seen], @last_exception[:count])
-              @last_exception.merge! :first_seen => Time.now, :count => 0
-            end
-            return :Summarized
-          elsif @last_exception[:count] > 0 # send the left-over, if any
-            send_exception_summary(@last_exception[:data], @last_exception[:first_seen], @last_exception[:count])
-          end
-
-        else
-          raise "Unknown state #{@last_exception[:state]}"
-        end
-      end
-
-      # New signature we haven't seen before.  Not summarized yet--we're just starting the count.
-      @last_exception = {
-        :data       => data,
-        :count      => 1,
-        :first_seen => Time.now,
-        :backtrace  => data[:backtrace],
-        :state      => :NotSummarized
-      }
-      nil
-    end
-
-    def send_exception_summary(exception_data, first_seen, occurrences)
-      Timeout::timeout 30, MailerTimeout do
-        deliver(ExceptionHandling::Mailer.exception_notification(exception_data, first_seen, occurrences))
-      end
-    rescue StandardError, MailerTimeout => ex
-      original_error = exception_data[:error_string]
-      log_prefix = "ExceptionHandling.log_error_email rescued exception while logging #{original_error}"
-      $stderr.puts("#{log_prefix}:\n#{ex.class}: #{ex}\n#{ex.backtrace.join("\n")}")
-      log_info(log_prefix)
-    end
-
     def make_exception(exception_or_string)
       if exception_or_string.is_a?(Exception)
         exception_or_string

data/test/helpers/controller_helpers.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module ControllerHelpers
   DummyController = Struct.new(:complete_request_uri, :request, :session)
   DummyRequest = Struct.new(:env, :parameters, :session_options)
-  
+
   class DummySession
     def initialize(data)
       @data = data

data/test/helpers/exception_helpers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ExceptionHelpers
   def raise_exception_with_nil_message
     raise exception_with_nil_message
@@ -8,4 +10,11 @@ module ExceptionHelpers
     stub(exception_with_nil_message).message { nil }
     exception_with_nil_message
   end
+
+  attr_reader :sent_notifications
+
+  def capture_notifications
+    @sent_notifications = []
+    stub(ExceptionHandling).send_exception_to_honeybadger(anything) { |exception_info| @sent_notifications << exception_info }
+  end
 end

data/test/test_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support'
 require 'active_support/time'
 require 'active_support/test_case'
@@ -67,11 +69,11 @@ class SocketStub
   end
 end
 
-  ExceptionHandling.logger = LoggerStub.new
+ExceptionHandling.logger = LoggerStub.new
 
-  def dont_stub_log_error
-    true
-  end
+def dont_stub_log_error
+  true
+end
 
 ActionMailer::Base.delivery_method = :test
 
@@ -88,12 +90,12 @@ class ActiveSupport::TestCase
 
     unless defined?(Rails) && defined?(Rails.env)
       module ::Rails
-        def self.env
-          @env ||= 'test'
-        end
+        class << self
+          attr_writer :env
 
-        def self.env=(mode)
-          @env = mode
+          def env
+            @env ||= 'test'
+          end
         end
       end
     end
@@ -107,7 +109,6 @@ class ActiveSupport::TestCase
     ExceptionHandling.exception_recipients  = 'exceptions@example.com'
     ExceptionHandling.escalation_recipients = 'escalation@example.com'
     ExceptionHandling.server_name           = 'server'
-    ExceptionHandling.mailer_send_enabled     = true
     ExceptionHandling.filter_list_filename    = "./config/exception_filters.yml"
     ExceptionHandling.eventmachine_safe       = false
     ExceptionHandling.eventmachine_synchrony  = false
@@ -117,7 +118,7 @@ class ActiveSupport::TestCase
   end
 
   teardown do
-    @@constant_overrides && @@constant_overrides.reverse.each do |parent_module, k, v|
+    @@constant_overrides&.reverse&.each do |parent_module, k, v|
       ExceptionHandling.ensure_safe "constant cleanup #{k.inspect}, #{parent_module}(#{parent_module.class})::#{v.inspect}(#{v.class})" do
         silence_warnings do
           if v == :never_defined
@@ -141,7 +142,11 @@ class ActiveSupport::TestCase
         parent_module == :never_defined and raise "You need to set each parent constant earlier! #{nested_const_name}"
         final_parent_module = parent_module
         final_const_name    = nested_const_name
-        parent_module.const_get(nested_const_name) rescue :never_defined
+        begin
+          parent_module.const_get(nested_const_name)
+        rescue
+          :never_defined
+        end
       end
 
     @@constant_overrides << [final_parent_module, final_const_name, original_value]
@@ -156,11 +161,11 @@ class ActiveSupport::TestCase
     else
       original_count = 0
     end
-    assert_equal expected, ActionMailer::Base.deliveries.size - original_count, "wrong number of emails#{ ': ' + message.to_s if message}"
+    assert_equal expected, ActionMailer::Base.deliveries.size - original_count, "wrong number of emails#{': ' + message.to_s if message}"
   end
 end
 
-def assert_equal_with_diff arg1, arg2, msg = ''
+def assert_equal_with_diff(arg1, arg2, msg = '')
   if arg1 == arg2
     assert true # To keep the assertion count accurate
   else
@@ -176,22 +181,22 @@ class Time
   class << self
     attr_reader :now_override
 
-    def now_override= override_time
-      if ActiveSupport::TimeWithZone === override_time
+    def now_override=(override_time)
+      if override_time.is_a?(ActiveSupport::TimeWithZone)
         override_time = override_time.localtime
       else
-        override_time.nil? || Time === override_time or raise "override_time should be a Time object, but was a #{override_time.class.name}"
+        override_time.nil? || override_time.is_a?(Time) or raise "override_time should be a Time object, but was a #{override_time.class.name}"
       end
       @now_override = override_time
     end
 
-    unless defined? @@_old_now_defined
+    unless defined?(@@_old_now_defined)
       alias old_now now
       @@_old_now_defined = true
     end
-  end
 
-  def self.now
-    now_override ? now_override.dup : old_now
+    def now
+      now_override ? now_override.dup : old_now
+    end
   end
 end