activesupport 7.0.8 → 7.2.2

data/lib/active_support/testing/error_reporter_assertions.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module Testing
+    module ErrorReporterAssertions
+      module ErrorCollector # :nodoc:
+        @subscribed = false
+        @mutex = Mutex.new
+
+        Report = Struct.new(:error, :handled, :severity, :context, :source, keyword_init: true)
+        class Report
+          alias_method :handled?, :handled
+        end
+
+        class << self
+          def record
+            subscribe
+            recorders = ActiveSupport::IsolatedExecutionState[:active_support_error_reporter_assertions] ||= []
+            reports = []
+            recorders << reports
+            begin
+              yield
+              reports
+            ensure
+              recorders.delete_if { |r| reports.equal?(r) }
+            end
+          end
+
+          def report(error, **kwargs)
+            report = Report.new(error: error, **kwargs)
+            ActiveSupport::IsolatedExecutionState[:active_support_error_reporter_assertions]&.each do |reports|
+              reports << report
+            end
+            true
+          end
+
+          private
+            def subscribe
+              return if @subscribed
+              @mutex.synchronize do
+                return if @subscribed
+
+                if ActiveSupport.error_reporter
+                  ActiveSupport.error_reporter.subscribe(self)
+                  @subscribed = true
+                else
+                  raise Minitest::Assertion, "No error reporter is configured"
+                end
+              end
+            end
+        end
+      end
+
+      # Assertion that the block should not cause an exception to be reported
+      # to +Rails.error+.
+      #
+      # Passes if evaluated code in the yielded block reports no exception.
+      #
+      #   assert_no_error_reported do
+      #     perform_service(param: 'no_exception')
+      #   end
+      def assert_no_error_reported(&block)
+        reports = ErrorCollector.record do
+          _assert_nothing_raised_or_warn("assert_no_error_reported", &block)
+        end
+        assert_predicate(reports, :empty?)
+      end
+
+      # Assertion that the block should cause at least one exception to be reported
+      # to +Rails.error+.
+      #
+      # Passes if the evaluated code in the yielded block reports a matching exception.
+      #
+      #   assert_error_reported(IOError) do
+      #     Rails.error.report(IOError.new("Oops"))
+      #   end
+      #
+      # To test further details about the reported exception, you can use the return
+      # value.
+      #
+      #   report = assert_error_reported(IOError) do
+      #     # ...
+      #   end
+      #   assert_equal "Oops", report.error.message
+      #   assert_equal "admin", report.context[:section]
+      #   assert_equal :warning, report.severity
+      #   assert_predicate report, :handled?
+      def assert_error_reported(error_class = StandardError, &block)
+        reports = ErrorCollector.record do
+          _assert_nothing_raised_or_warn("assert_error_reported", &block)
+        end
+
+        if reports.empty?
+          assert(false, "Expected a #{error_class.name} to be reported, but there were no errors reported.")
+        elsif (report = reports.find { |r| error_class === r.error })
+          self.assertions += 1
+          report
+        else
+          message = "Expected a #{error_class.name} to be reported, but none of the " \
+            "#{reports.size} reported errors matched:  \n" \
+            "#{reports.map { |r| r.error.class.name }.join("\n  ")}"
+          assert(false, message)
+        end
+      end
+    end
+  end
+end

data/lib/active_support/testing/isolation.rb

@@ -1,13 +1,17 @@
 # frozen_string_literal: true
 
+require "active_support/testing/parallelize_executor"
+
 module ActiveSupport
   module Testing
     module Isolation
       require "thread"
 
+      SubprocessCrashed = Class.new(StandardError)
+
       def self.included(klass) # :nodoc:
         klass.class_eval do
-          parallelize_me!
+          parallelize_me! unless Minitest.parallel_executor.is_a?(ActiveSupport::Testing::ParallelizeExecutor)
         end
       end
 
@@ -16,10 +20,17 @@ module ActiveSupport
       end
 
       def run
-        serialized = run_in_isolation do
+        status, serialized = run_in_isolation do
           super
         end
 
+        unless status&.success?
+          error = SubprocessCrashed.new("Subprocess exited with an error: #{status.inspect}\noutput: #{serialized.inspect}")
+          error.set_backtrace(caller)
+          self.failures << Minitest::UnexpectedError.new(error)
+          return defined?(Minitest::Result) ? Minitest::Result.from(self) : dup
+        end
+
         Marshal.load(serialized)
       end
 
@@ -50,13 +61,13 @@ module ActiveSupport
               end
 
               write.puts [result].pack("m")
-              exit!
+              exit!(0)
             end
 
             write.close
             result = read.read
-            Process.wait2(pid)
-            result.unpack1("m")
+            _, status = Process.wait2(pid)
+            return status, result.unpack1("m")
           end
         end
       end
@@ -64,7 +75,7 @@ module ActiveSupport
       module Subprocess
         ORIG_ARGV = ARGV.dup unless defined?(ORIG_ARGV)
 
-        # Complicated H4X to get this working in windows / jruby with
+        # Complicated H4X to get this working in Windows / JRuby with
         # no forking.
         def run_in_isolation(&blk)
           require "tempfile"
@@ -75,7 +86,7 @@ module ActiveSupport
             File.open(ENV["ISOLATION_OUTPUT"], "w") do |file|
               file.puts [Marshal.dump(test_result)].pack("m")
             end
-            exit!
+            exit!(0)
           else
             Tempfile.open("isolation") do |tmpfile|
               env = {
@@ -93,13 +104,14 @@ module ActiveSupport
 
               child = IO.popen([env, Gem.ruby, *load_path_args, $0, *ORIG_ARGV, test_opts])
 
+              status = nil
               begin
-                Process.wait(child.pid)
+                _, status = Process.wait2(child.pid)
               rescue Errno::ECHILD # The child process may exit before we wait
                 nil
               end
 
-              return tmpfile.read.unpack1("m")
+              return status, tmpfile.read.unpack1("m")
             end
           end
         end

data/lib/active_support/testing/method_call_assertions.rb

@@ -17,24 +17,23 @@ module ActiveSupport
           assert_equal times, times_called, error
         end
 
-        def assert_called_with(object, method_name, args, returns: nil, &block)
+        def assert_called_with(object, method_name, args, returns: false, **kwargs, &block)
           mock = Minitest::Mock.new
-
-          if args.all?(Array)
-            args.each { |arg| mock.expect(:call, returns, arg) }
-          else
-            mock.expect(:call, returns, args)
-          end
+          expect_called_with(mock, args, returns: returns, **kwargs)
 
           object.stub(method_name, mock, &block)
 
-          mock.verify
+          assert_mock(mock)
         end
 
         def assert_not_called(object, method_name, message = nil, &block)
           assert_called(object, method_name, message, times: 0, &block)
         end
 
+        def expect_called_with(mock, args, returns: false, **kwargs)
+          mock.expect(:call, returns, args, **kwargs)
+        end
+
         def assert_called_on_instance_of(klass, method_name, message = nil, times: 1, returns: nil)
           times_called = 0
           klass.define_method("stubbed_#{method_name}") do |*|

data/lib/active_support/testing/parallelization/server.rb

@@ -6,6 +6,8 @@ require "drb/unix" unless Gem.win_platform?
 module ActiveSupport
   module Testing
     class Parallelization # :nodoc:
+      PrerecordResultClass = Struct.new(:name)
+
       class Server
         include DRb::DRbUndumped
 
@@ -21,6 +23,7 @@ module ActiveSupport
           @in_flight.delete([result.klass, result.name])
 
           reporter.synchronize do
+            reporter.prerecord(PrerecordResultClass.new(result.klass), result.name)
             reporter.record(result)
           end
         end

data/lib/active_support/testing/parallelize_executor.rb

@@ -9,6 +9,7 @@ module ActiveSupport
         @size = size
         @parallelize_with = with
         @threshold = threshold
+        @parallelized = false
       end
 
       def start
@@ -49,11 +50,15 @@ module ActiveSupport
         end
 
         def parallelized?
-          @parallelized if defined?(@parallelized)
+          @parallelized
         end
 
         def should_parallelize?
-          ENV["PARALLEL_WORKERS"] || tests_count > threshold
+          (ENV["PARALLEL_WORKERS"] || tests_count > threshold) && many_workers?
+        end
+
+        def many_workers?
+          size > 1
         end
 
         def tests_count
@@ -67,7 +72,7 @@ module ActiveSupport
         def execution_info
           if parallelized?
             "Running #{tests_count} tests in parallel using #{parallel_executor.size} #{parallelize_with}"
-          else
+          elsif many_workers?
             "Running #{tests_count} tests in a single process (parallelization threshold is #{threshold})"
           end
         end

data/lib/active_support/testing/setup_and_teardown.rb

@@ -46,6 +46,8 @@ module ActiveSupport
           run_callbacks :teardown
         rescue => e
           self.failures << Minitest::UnexpectedError.new(e)
+        rescue Minitest::Assertion => e
+          self.failures << e
         end
 
         super

data/lib/active_support/testing/stream.rb

@@ -23,7 +23,7 @@ module ActiveSupport
         def capture(stream)
           stream = stream.to_s
           captured_stream = Tempfile.new(stream)
-          stream_io = eval("$#{stream}")
+          stream_io = eval("$#{stream}", binding, __FILE__, __LINE__)
           origin_stream = stream_io.dup
           stream_io.reopen(captured_stream)
 

data/lib/active_support/testing/strict_warnings.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+$VERBOSE = true
+Warning[:deprecated] = true
+
+module ActiveSupport
+  module RaiseWarnings # :nodoc:
+    class WarningError < StandardError; end
+
+    PROJECT_ROOT = File.expand_path("../../../../", __dir__)
+    ALLOWED_WARNINGS = Regexp.union(
+      /circular require considered harmful.*delayed_job/, # Bug in delayed job.
+
+      # Expected non-verbose warning emitted by Rails.
+      /Ignoring .*\.yml because it has expired/,
+      /Failed to validate the schema cache because/,
+
+      # TODO: We need to decide what to do with this.
+      /Status code :unprocessable_entity is deprecated/
+    )
+
+    SUPPRESSED_WARNINGS = Regexp.union(
+      # TODO: remove if https://github.com/mikel/mail/pull/1557 or similar fix
+      %r{/lib/mail/parsers/.*statement not reached},
+      %r{/lib/mail/parsers/.*assigned but unused variable - disp_type_s},
+      %r{/lib/mail/parsers/.*assigned but unused variable - testEof}
+    )
+
+    def warn(message, ...)
+      return if SUPPRESSED_WARNINGS.match?(message)
+
+      super
+
+      return unless message.include?(PROJECT_ROOT)
+      return if ALLOWED_WARNINGS.match?(message)
+      return unless ENV["RAILS_STRICT_WARNINGS"] || ENV["BUILDKITE"]
+
+      raise WarningError.new(message)
+    end
+  end
+end
+
+Warning.singleton_class.prepend(ActiveSupport::RaiseWarnings)

data/lib/active_support/testing/tests_without_assertions.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module Testing
+    # Warns when a test case does not perform any assertions.
+    #
+    # This is helpful in detecting broken tests that do not perform intended assertions.
+    module TestsWithoutAssertions # :nodoc:
+      def after_teardown
+        super
+
+        if assertions.zero? && !skipped? && !error?
+          file, line = method(name).source_location
+          warn "Test is missing assertions: `#{name}` #{file}:#{line}"
+        end
+      end
+    end
+  end
+end

data/lib/active_support/testing/time_helpers.rb

@@ -2,7 +2,6 @@
 
 require "active_support/core_ext/module/redefine_method"
 require "active_support/core_ext/time/calculations"
-require "concurrent/map"
 
 module ActiveSupport
   module Testing
@@ -11,7 +10,7 @@ module ActiveSupport
       Stub = Struct.new(:object, :method_name, :original_method)
 
       def initialize
-        @stubs = Concurrent::Map.new { |h, k| h[k] = {} }
+        @stubs = Hash.new { |h, k| h[k] = {} }
       end
 
       # Stubs object.method_name with the given block
@@ -26,7 +25,7 @@ module ActiveSupport
           unstub_object(stub)
         end
 
-        new_name = "__simple_stub__#{method_name}"
+        new_name = "__simple_stub__#{method_name}__#{object_id}"
 
         @stubs[object.object_id][method_name] = Stub.new(object, method_name, new_name)
 
@@ -76,6 +75,11 @@ module ActiveSupport
       # stubbing +Time.now+, +Date.today+, and +DateTime.now+. The stubs are automatically removed
       # at the end of the test.
       #
+      # Note that the usec for the resulting time will be set to 0 to prevent rounding
+      # errors with external services, like MySQL (which will round instead of floor,
+      # leading to off-by-one-second errors), unless the <tt>with_usec</tt> argument
+      # is set to <tt>true</tt>.
+      #
       #   Time.current     # => Sat, 09 Nov 2013 15:34:49 EST -05:00
       #   travel 1.day
       #   Time.current     # => Sun, 10 Nov 2013 15:34:49 EST -05:00
@@ -90,11 +94,11 @@ module ActiveSupport
       #     User.create.created_at # => Sun, 10 Nov 2013 15:34:49 EST -05:00
       #   end
       #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
-      def travel(duration, &block)
-        travel_to Time.now + duration, &block
+      def travel(duration, with_usec: false, &block)
+        travel_to Time.now + duration, with_usec: with_usec, &block
       end
 
-      # Changes current time to the given time by stubbing +Time.now+,
+      # Changes current time to the given time by stubbing +Time.now+, +Time.new+,
       # +Date.today+, and +DateTime.now+ to return the time or date passed into this method.
       # The stubs are automatically removed at the end of the test.
       #
@@ -115,7 +119,8 @@ module ActiveSupport
       #
       # Note that the usec for the time passed will be set to 0 to prevent rounding
       # errors with external services, like MySQL (which will round instead of floor,
-      # leading to off-by-one-second errors).
+      # leading to off-by-one-second errors), unless the <tt>with_usec</tt> argument
+      # is set to <tt>true</tt>.
       #
       # This method also accepts a block, which will return the current time back to its original
       # state at the end of the block:
@@ -125,7 +130,7 @@ module ActiveSupport
       #     Time.current # => Wed, 24 Nov 2004 01:04:44 EST -05:00
       #   end
       #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
-      def travel_to(date_or_time)
+      def travel_to(date_or_time, with_usec: false)
         if block_given? && in_block
           travel_to_nested_block_call = <<~MSG
 
@@ -159,13 +164,30 @@ module ActiveSupport
         elsif date_or_time.is_a?(String)
           now = Time.zone.parse(date_or_time)
         else
-          now = date_or_time.to_time.change(usec: 0)
+          now = date_or_time
+          now = now.to_time unless now.is_a?(Time)
+          now = now.change(usec: 0) unless with_usec
+        end
+
+        # +now+ must be in local system timezone, because +Time.at(now)+
+        # and +now.to_date+ (see stubs below) will use +now+'s timezone too!
+        now = now.getlocal
+
+        stubs = simple_stubs
+        stubbed_time = Time.now if stubs.stubbing(Time, :now)
+        stubs.stub_object(Time, :now) { at(now) }
+
+        stubs.stub_object(Time, :new) do |*args, **options|
+          if args.empty? && options.empty?
+            at(now)
+          else
+            stub = stubs.stubbing(Time, :new)
+            Time.send(stub.original_method, *args, **options)
+          end
         end
 
-        stubbed_time = Time.now if simple_stubs.stubbing(Time, :now)
-        simple_stubs.stub_object(Time, :now) { at(now.to_i) }
-        simple_stubs.stub_object(Date, :today) { jd(now.to_date.jd) }
-        simple_stubs.stub_object(DateTime, :now) { jd(now.to_date.jd, now.hour, now.min, now.sec, Rational(now.utc_offset, 86400)) }
+        stubs.stub_object(Date, :today) { jd(now.to_date.jd) }
+        stubs.stub_object(DateTime, :now) { jd(now.to_date.jd, now.hour, now.min, now.sec, Rational(now.utc_offset, 86400)) }
 
         if block_given?
           begin
@@ -215,7 +237,7 @@ module ActiveSupport
       end
       alias_method :unfreeze_time, :travel_back
 
-      # Calls +travel_to+ with +Time.now+.
+      # Calls +travel_to+ with +Time.now+. Forwards optional <tt>with_usec</tt> argument.
       #
       #   Time.current # => Sun, 09 Jul 2017 15:34:49 EST -05:00
       #   freeze_time
@@ -231,8 +253,8 @@ module ActiveSupport
       #     User.create.created_at # => Sun, 09 Jul 2017 15:34:49 EST -05:00
       #   end
       #   Time.current # => Sun, 09 Jul 2017 15:34:50 EST -05:00
-      def freeze_time(&block)
-        travel_to Time.now, &block
+      def freeze_time(with_usec: false, &block)
+        travel_to Time.now, with_usec: with_usec, &block
       end
 
       private

data/lib/active_support/time_with_zone.rb

@@ -8,6 +8,8 @@ require "active_support/core_ext/object/acts_like"
 require "active_support/core_ext/date_and_time/compatibility"
 
 module ActiveSupport
+  # = Active Support \Time With Zone
+  #
   # A Time-like class that can represent a time in any time zone. Necessary
   # because standard Ruby Time instances are limited to UTC and the
   # system's <tt>ENV['TZ']</tt> zone.
@@ -40,18 +42,6 @@ module ActiveSupport
   #   t.is_a?(Time)                         # => true
   #   t.is_a?(ActiveSupport::TimeWithZone)  # => true
   class TimeWithZone
-    # Report class name as 'Time' to thwart type checking.
-    def self.name
-      ActiveSupport::Deprecation.warn(<<~EOM)
-        ActiveSupport::TimeWithZone.name has been deprecated and
-        from Rails 7.1 will use the default Ruby implementation.
-        You can set `config.active_support.remove_deprecated_time_with_zone_name = true`
-        to enable the new behavior now.
-      EOM
-
-      "Time"
-    end
-
     PRECISIONS = Hash.new { |h, n| h[n] = "%FT%T.%#{n}N" }
     PRECISIONS[0] = "%FT%T"
 
@@ -78,7 +68,7 @@ module ActiveSupport
     alias_method :getutc, :utc
     alias_method :gmtime, :utc
 
-    # Returns the underlying <tt>TZInfo::TimezonePeriod</tt>.
+    # Returns the underlying +TZInfo::TimezonePeriod+.
     def period
       @period ||= time_zone.period_for_utc(@utc)
     end
@@ -95,7 +85,7 @@ module ActiveSupport
     end
     alias_method :getlocal, :localtime
 
-    # Returns true if the current time is within Daylight Savings Time for the
+    # Returns true if the current time is within Daylight Savings \Time for the
     # specified time zone.
     #
     #   Time.zone = 'Eastern Time (US & Canada)'    # => 'Eastern Time (US & Canada)'
@@ -218,7 +208,7 @@ module ActiveSupport
     # Accepts an optional <tt>format</tt>:
     # * <tt>:default</tt> - default value, mimics Ruby Time#to_s format.
     # * <tt>:db</tt> - format outputs time in UTC :db time. See Time#to_fs(:db).
-    # * Any key in <tt>Time::DATE_FORMATS</tt> can be used. See active_support/core_ext/time/conversions.rb.
+    # * Any key in +Time::DATE_FORMATS+ can be used. See active_support/core_ext/time/conversions.rb.
     def to_fs(format = :default)
       if format == :db
         utc.to_fs(format)
@@ -342,7 +332,7 @@ module ActiveSupport
     #
     def -(other)
       if other.acts_like?(:time)
-        to_time - other.to_time
+        getutc - other.getutc
       elsif duration_of_variable_length?(other)
         method_missing(:-, other)
       else
@@ -385,8 +375,8 @@ module ActiveSupport
     #
     #   t = Time.zone.now          # => Fri, 14 Apr 2017 11:45:15.116992711 EST -05:00
     #   t.change(year: 2020)       # => Tue, 14 Apr 2020 11:45:15.116992711 EST -05:00
-    #   t.change(hour: 12)         # => Fri, 14 Apr 2017 12:00:00.116992711 EST -05:00
-    #   t.change(min: 30)          # => Fri, 14 Apr 2017 11:30:00.116992711 EST -05:00
+    #   t.change(hour: 12)         # => Fri, 14 Apr 2017 12:00:00.000000000 EST -05:00
+    #   t.change(min: 30)          # => Fri, 14 Apr 2017 11:30:00.000000000 EST -05:00
     #   t.change(offset: "-10:00") # => Fri, 14 Apr 2017 11:45:15.116992711 HST -10:00
     #   t.change(zone: "Hawaii")   # => Fri, 14 Apr 2017 11:45:15.116992711 HST -10:00
     def change(options)
@@ -516,6 +506,10 @@ module ActiveSupport
       false
     end
 
+    def present? # :nodoc:
+      true
+    end
+
     def freeze
       # preload instance variables before freezing
       period; utc; time; to_datetime; to_time