activesupport 7.0.8 → 7.1.0.beta1

data/lib/active_support/test_case.rb

@@ -1,15 +1,16 @@
 # frozen_string_literal: true
 
-gem "minitest" # make sure we get the gem, not stdlib
 require "minitest"
 require "active_support/testing/tagged_logging"
 require "active_support/testing/setup_and_teardown"
 require "active_support/testing/assertions"
+require "active_support/testing/error_reporter_assertions"
 require "active_support/testing/deprecation"
 require "active_support/testing/declarative"
 require "active_support/testing/isolation"
 require "active_support/testing/constant_lookup"
 require "active_support/testing/time_helpers"
+require "active_support/testing/constant_stubbing"
 require "active_support/testing/file_fixtures"
 require "active_support/testing/parallelization"
 require "active_support/testing/parallelize_executor"
@@ -66,7 +67,7 @@ module ActiveSupport
       # The default parallelization method is to fork processes. If you'd like to
       # use threads instead you can pass <tt>with: :threads</tt> to the +parallelize+
       # method. Note the threaded parallelization does not create multiple
-      # database and will not work with system tests at this time.
+      # databases and will not work with system tests.
       #
       #   parallelize(workers: :number_of_processors, with: :threads)
       #
@@ -80,8 +81,6 @@ module ActiveSupport
         workers = Concurrent.physical_processor_count if workers == :number_of_processors
         workers = ENV["PARALLEL_WORKERS"].to_i if ENV["PARALLEL_WORKERS"]
 
-        return if workers <= 1
-
         Minitest.parallel_executor = ActiveSupport::Testing::ParallelizeExecutor.new(size: workers, with: with, threshold: threshold)
       end
 
@@ -118,6 +117,25 @@ module ActiveSupport
       def parallelize_teardown(&block)
         ActiveSupport::Testing::Parallelization.run_cleanup_hook(&block)
       end
+
+      # :singleton-method: fixture_paths
+      #
+      # Returns the ActiveRecord::FixtureSet collection.
+      #
+      # In your +test_helper.rb+ you must have <tt>require "rails/test_help"</tt>.
+
+      # :singleton-method: fixture_paths=
+      #
+      # :call-seq:
+      #   fixture_paths=(fixture_paths)
+      #
+      # Sets the given path to the fixture set.
+      #
+      # Can also append multiple paths.
+      #
+      #   ActiveSupport::TestCase.fixture_paths << "component1/test/fixtures"
+      #
+      # In your +test_helper.rb+ you must have <tt>require "rails/test_help"</tt>.
     end
 
     alias_method :method_name, :name
@@ -125,25 +143,154 @@ module ActiveSupport
     include ActiveSupport::Testing::TaggedLogging
     prepend ActiveSupport::Testing::SetupAndTeardown
     include ActiveSupport::Testing::Assertions
+    include ActiveSupport::Testing::ErrorReporterAssertions
     include ActiveSupport::Testing::Deprecation
+    include ActiveSupport::Testing::ConstantStubbing
     include ActiveSupport::Testing::TimeHelpers
     include ActiveSupport::Testing::FileFixtures
     extend ActiveSupport::Testing::Declarative
 
-    # test/unit backwards compatibility methods
-    alias :assert_raise :assert_raises
+    ##
+    # :method: assert_not_empty
+    #
+    # :call-seq:
+    #   assert_not_empty(obj, msg = nil)
+    #
+    # Alias for: refute_empty[https://docs.seattlerb.org/minitest/Minitest/Assertions.html#method-i-refute_empty]
+
+    #
     alias :assert_not_empty :refute_empty
+
+    ##
+    # :method: assert_not_equal
+    #
+    # :call-seq:
+    #   assert_not_equal(exp, act, msg = nil)
+    #
+    # Alias for: refute_equal[https://docs.seattlerb.org/minitest/Minitest/Assertions.html#method-i-refute_equal]
+
+    #
     alias :assert_not_equal :refute_equal
+
+    ##
+    # :method: assert_not_in_delta
+    #
+    # :call-seq:
+    #   assert_not_in_delta(exp, act, delta = 0.001, msg = nil)
+    #
+    # Alias for: refute_in_delta[https://docs.seattlerb.org/minitest/Minitest/Assertions.html#method-i-refute_in_delta]
+
+    #
     alias :assert_not_in_delta :refute_in_delta
+
+    ##
+    # :method: assert_not_in_epsilon
+    #
+    # :call-seq:
+    #   assert_not_in_epsilon(a, b, epsilon = 0.001, msg = nil)
+    #
+    # Alias for: refute_in_epsilon[https://docs.seattlerb.org/minitest/Minitest/Assertions.html#method-i-refute_in_epsilon]
+
+    #
     alias :assert_not_in_epsilon :refute_in_epsilon
+
+    ##
+    # :method: assert_not_includes
+    #
+    # :call-seq:
+    #   assert_not_includes(collection, obj, msg = nil)
+    #
+    # Alias for: refute_includes[https://docs.seattlerb.org/minitest/Minitest/Assertions.html#method-i-refute_includes]
+
+    #
     alias :assert_not_includes :refute_includes
+
+    ##
+    # :method: assert_not_instance_of
+    #
+    # :call-seq:
+    #   assert_not_instance_of(cls, obj, msg = nil)
+    #
+    # Alias for: refute_instance_of[https://docs.seattlerb.org/minitest/Minitest/Assertions.html#method-i-refute_instance_of]
+
+    #
     alias :assert_not_instance_of :refute_instance_of
+
+    ##
+    # :method: assert_not_kind_of
+    #
+    # :call-seq:
+    #   assert_not_kind_of(cls, obj, msg = nil)
+    #
+    # Alias for: refute_kind_of[https://docs.seattlerb.org/minitest/Minitest/Assertions.html#method-i-refute_kind_of]
+
+    #
     alias :assert_not_kind_of :refute_kind_of
+
+    ##
+    # :method: assert_no_match
+    #
+    # :call-seq:
+    #   assert_no_match(matcher, obj, msg = nil)
+    #
+    # Alias for: refute_match[https://docs.seattlerb.org/minitest/Minitest/Assertions.html#method-i-refute_match]
+
+    #
     alias :assert_no_match :refute_match
+
+    ##
+    # :method: assert_not_nil
+    #
+    # :call-seq:
+    #   assert_not_nil(obj, msg = nil)
+    #
+    # Alias for: refute_nil[https://docs.seattlerb.org/minitest/Minitest/Assertions.html#method-i-refute_nil]
+
+    #
     alias :assert_not_nil :refute_nil
+
+    ##
+    # :method: assert_not_operator
+    #
+    # :call-seq:
+    #   assert_not_operator(o1, op, o2 = UNDEFINED, msg = nil)
+    #
+    # Alias for: refute_operator[https://docs.seattlerb.org/minitest/Minitest/Assertions.html#method-i-refute_operator]
+
+    #
     alias :assert_not_operator :refute_operator
+
+    ##
+    # :method: assert_not_predicate
+    #
+    # :call-seq:
+    #   assert_not_predicate(o1, op, msg = nil)
+    #
+    # Alias for: refute_predicate[https://docs.seattlerb.org/minitest/Minitest/Assertions.html#method-i-refute_predicate]
+
+    #
     alias :assert_not_predicate :refute_predicate
+
+    ##
+    # :method: assert_not_respond_to
+    #
+    # :call-seq:
+    #   assert_not_respond_to(obj, meth, msg = nil)
+    #
+    # Alias for: refute_respond_to[https://docs.seattlerb.org/minitest/Minitest/Assertions.html#method-i-refute_respond_to]
+
+    #
     alias :assert_not_respond_to :refute_respond_to
+
+    ##
+    # :method: assert_not_same
+    #
+    # :call-seq:
+    #   assert_not_same(exp, act, msg = nil)
+    #
+    # Alias for: refute_same[https://docs.seattlerb.org/minitest/Minitest/Assertions.html#method-i-refute_same]
+
+    #
     alias :assert_not_same :refute_same
 
     ActiveSupport.run_load_hooks(:active_support_test_case, self)

data/lib/active_support/testing/assertions.rb

@@ -7,9 +7,9 @@ module ActiveSupport
     module Assertions
       UNTRACKED = Object.new # :nodoc:
 
-      # Asserts that an expression is not truthy. Passes if <tt>object</tt> is
-      # +nil+ or +false+. "Truthy" means "considered true in a conditional"
-      # like <tt>if foo</tt>.
+      # Asserts that an expression is not truthy. Passes if +object+ is +nil+ or
+      # +false+. "Truthy" means "considered true in a conditional" like <tt>if
+      # foo</tt>.
       #
       #   assert_not nil    # => true
       #   assert_not false  # => true
@@ -23,6 +23,21 @@ module ActiveSupport
         assert !object, message
       end
 
+      # Asserts that a block raises one of +exp+. This is an enhancement of the
+      # standard Minitest assertion method with the ability to test error
+      # messages.
+      #
+      #   assert_raises(ArgumentError, match: /incorrect param/i) do
+      #     perform_service(param: 'exception')
+      #   end
+      #
+      def assert_raises(*exp, match: nil, &block)
+        error = super(*exp, &block)
+        assert_match(match, error.message) if match
+        error
+      end
+      alias :assert_raise :assert_raises
+
       # Assertion that the block should not raise an exception.
       #
       # Passes if evaluated code in the yielded block raises no exception.
@@ -31,7 +46,7 @@ module ActiveSupport
       #     perform_service(param: 'no_exception')
       #   end
       def assert_nothing_raised
-        yield
+        yield.tap { assert(true) }
       rescue => error
         raise Minitest::UnexpectedError.new(error)
       end
@@ -50,7 +65,7 @@ module ActiveSupport
       #   end
       #
       # An arbitrary positive or negative difference can be specified.
-      # The default is <tt>1</tt>.
+      # The default is +1+.
       #
       #   assert_difference 'Article.count', -1 do
       #     post :delete, params: { id: ... }
@@ -102,9 +117,10 @@ module ActiveSupport
         retval = _assert_nothing_raised_or_warn("assert_difference", &block)
 
         expressions.zip(exps, before) do |(code, diff), exp, before_value|
-          error  = "#{code.inspect} didn't change by #{diff}"
+          actual = exp.call
+          error  = "#{code.inspect} didn't change by #{diff}, but by #{actual - before_value}"
           error  = "#{message}.\n#{error}" if message
-          assert_equal(before_value + diff, exp.call, error)
+          assert_equal(before_value + diff, actual, error)
         end
 
         retval
@@ -179,7 +195,7 @@ module ActiveSupport
         retval = _assert_nothing_raised_or_warn("assert_changes", &block)
 
         unless from == UNTRACKED
-          error = "Expected change from #{from.inspect}"
+          error = "Expected change from #{from.inspect}, got #{before}"
           error = "#{message}.\n#{error}" if message
           assert from === before, error
         end
@@ -192,7 +208,7 @@ module ActiveSupport
         refute_equal before, after, error
 
         unless to == UNTRACKED
-          error = "Expected change to #{to}\n"
+          error = "Expected change to #{to}, got #{after}\n"
           error = "#{message}.\n#{error}" if message
           assert to === after, error
         end

data/lib/active_support/testing/autorun.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-gem "minitest"
-
 require "minitest"
 
 Minitest.autorun

data/lib/active_support/testing/constant_stubbing.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module Testing
+    module ConstantStubbing
+      # Changes the value of a constant for the duration of a block. Example:
+      #
+      #   # World::List::Import::LARGE_IMPORT_THRESHOLD = 5000
+      #   stub_const(World::List::Import, :LARGE_IMPORT_THRESHOLD, 1) do
+      #     assert_equal 1, World::List::Import::LARGE_IMPORT_THRESHOLD
+      #   end
+      #
+      #   assert_equal 5000, World::List::Import::LARGE_IMPORT_THRESHOLD
+      #
+      # Using this method rather than forcing <tt>World::List::Import::LARGE_IMPORT_THRESHOLD = 5000</tt> prevents
+      # warnings from being thrown, and ensures that the old value is returned after the test has completed.
+      #
+      # Note: Stubbing a const will stub it across all threads. So if you have concurrent threads
+      # (like separate test suites running in parallel) that all depend on the same constant, it's possible
+      # divergent stubbing will trample on each other.
+      def stub_const(mod, constant, new_value)
+        old_value = mod.const_get(constant, false)
+        mod.send(:remove_const, constant)
+        mod.const_set(constant, new_value)
+        yield
+      ensure
+        mod.send(:remove_const, constant)
+        mod.const_set(constant, old_value)
+      end
+    end
+  end
+end

data/lib/active_support/testing/deprecation.rb

@@ -5,6 +5,11 @@ require "active_support/deprecation"
 module ActiveSupport
   module Testing
     module Deprecation
+      ##
+      # :call-seq:
+      #   assert_deprecated(deprecator, &block)
+      #   assert_deprecated(match, deprecator, &block)
+      #
       # Asserts that a matching deprecation warning was emitted by the given deprecator during the execution of the yielded block.
       #
       #   assert_deprecated(/foo/, CustomDeprecator) do
@@ -19,16 +24,15 @@ module ActiveSupport
       #
       # If the +match+ is omitted (or explicitly +nil+), any deprecation warning will match.
       #
-      #   assert_deprecated(nil, CustomDeprecator) do
+      #   assert_deprecated(CustomDeprecator) do
       #     CustomDeprecator.warn "foo should no longer be used"
       #   end
-      #
-      # If no +deprecator+ is given, defaults to ActiveSupport::Deprecation.
-      #
-      #   assert_deprecated do
-      #     ActiveSupport::Deprecation.warn "foo should no longer be used"
-      #   end
       def assert_deprecated(match = nil, deprecator = nil, &block)
+        match, deprecator = nil, match if match.is_a?(ActiveSupport::Deprecation)
+        unless deprecator
+          ActiveSupport.deprecator.warn("assert_deprecated without a deprecator is deprecated")
+          deprecator = ActiveSupport::Deprecation._instance
+        end
         result, warnings = collect_deprecations(deprecator, &block)
         assert !warnings.empty?, "Expected a deprecation warning within the block but received none"
         if match
@@ -44,36 +48,32 @@ module ActiveSupport
       #     CustomDeprecator.warn "message" # fails assertion
       #   end
       #
-      # If no +deprecator+ is given, defaults to ActiveSupport::Deprecation.
-      #
-      #   assert_not_deprecated do
-      #     ActiveSupport::Deprecation.warn "message" # fails assertion
-      #   end
-      #
-      #   assert_not_deprecated do
-      #     CustomDeprecator.warn "message" # passes assertion
+      #   assert_not_deprecated(ActiveSupport::Deprecation.new) do
+      #     CustomDeprecator.warn "message" # passes assertion, different deprecator
       #   end
       def assert_not_deprecated(deprecator = nil, &block)
+        unless deprecator
+          ActiveSupport.deprecator.warn("assert_not_deprecated without a deprecator is deprecated")
+          deprecator = ActiveSupport::Deprecation._instance
+        end
         result, deprecations = collect_deprecations(deprecator, &block)
         assert deprecations.empty?, "Expected no deprecation warning within the block but received #{deprecations.size}: \n  #{deprecations * "\n  "}"
         result
       end
 
-      # Returns an array of all the deprecation warnings emitted by the given
+      # Returns the return value of the block and an array of all the deprecation warnings emitted by the given
       # +deprecator+ during the execution of the yielded block.
       #
       #   collect_deprecations(CustomDeprecator) do
       #     CustomDeprecator.warn "message"
-      #   end # => ["message"]
-      #
-      # If no +deprecator+ is given, defaults to ActiveSupport::Deprecation.
-      #
-      #   collect_deprecations do
-      #     CustomDeprecator.warn "custom message"
-      #     ActiveSupport::Deprecation.warn "message"
-      #   end # => ["message"]
+      #     ActiveSupport::Deprecation.new.warn "other message"
+      #     :result
+      #   end # => [:result, ["message"]]
       def collect_deprecations(deprecator = nil)
-        deprecator ||= ActiveSupport::Deprecation
+        unless deprecator
+          ActiveSupport.deprecator.warn("collect_deprecations without a deprecator is deprecated")
+          deprecator = ActiveSupport::Deprecation._instance
+        end
         old_behavior = deprecator.behavior
         deprecations = []
         deprecator.behavior = Proc.new do |message, callstack|

data/lib/active_support/testing/error_reporter_assertions.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module Testing
+    module ErrorReporterAssertions
+      module ErrorCollector
+        @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
+
+      private
+        # 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

@@ -64,7 +64,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"

data/lib/active_support/testing/method_call_assertions.rb

@@ -17,24 +17,37 @@ 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
 
+        #--
+        # This method is a temporary wrapper for mock.expect as part of
+        # the Minitest 5.16 / Ruby 3.0 kwargs transition. It can go away
+        # when we drop support for Ruby 2.7.
+        if Minitest::Mock.instance_method(:expect).parameters.map(&:first).include?(:keyrest)
+          def expect_called_with(mock, args, returns: false, **kwargs)
+            mock.expect(:call, returns, args, **kwargs)
+          end
+        else
+          def expect_called_with(mock, args, returns: false, **kwargs)
+            if !kwargs.empty?
+              mock.expect(:call, returns, [*args, kwargs])
+            else
+              mock.expect(:call, returns, args)
+            end
+          end
+        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/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/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,38 @@
+# frozen_string_literal: true
+
+$VERBOSE = true
+Warning[:deprecated] = true
+
+module ActiveSupport
+  module RaiseWarnings # :nodoc:
+    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/,
+    )
+
+    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 - 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["CI"]
+
+      raise message
+    end
+    ruby2_keywords :warn if respond_to?(:ruby2_keywords, true)
+  end
+end
+
+Warning.singleton_class.prepend(ActiveSupport::RaiseWarnings)