activesupport 7.0.8.4 → 7.1.3.4

data/lib/active_support/tagged_logging.rb

@@ -6,14 +6,16 @@ require "logger"
 require "active_support/logger"
 
 module ActiveSupport
+  # = Active Support Tagged Logging
+  #
   # Wraps any standard Logger object to provide tagging capabilities.
   #
   # May be called with a block:
   #
   #   logger = ActiveSupport::TaggedLogging.new(Logger.new(STDOUT))
-  #   logger.tagged('BCX') { logger.info 'Stuff' }                            # Logs "[BCX] Stuff"
-  #   logger.tagged('BCX', "Jason") { logger.info 'Stuff' }                   # Logs "[BCX] [Jason] Stuff"
-  #   logger.tagged('BCX') { logger.tagged('Jason') { logger.info 'Stuff' } } # Logs "[BCX] [Jason] Stuff"
+  #   logger.tagged('BCX') { logger.info 'Stuff' }                                  # Logs "[BCX] Stuff"
+  #   logger.tagged('BCX', "Jason") { |tagged_logger| tagged_logger.info 'Stuff' }  # Logs "[BCX] [Jason] Stuff"
+  #   logger.tagged('BCX') { logger.tagged('Jason') { logger.info 'Stuff' } }       # Logs "[BCX] [Jason] Stuff"
   #
   # If called without a block, a new logger will be returned with applied tags:
   #
@@ -29,52 +31,86 @@ module ActiveSupport
     module Formatter # :nodoc:
       # This method is invoked when a log event occurs.
       def call(severity, timestamp, progname, msg)
-        super(severity, timestamp, progname, "#{tags_text}#{msg}")
+        super(severity, timestamp, progname, tag_stack.format_message(msg))
       end
 
       def tagged(*tags)
-        new_tags = push_tags(*tags)
+        pushed_count = tag_stack.push_tags(tags).size
         yield self
       ensure
-        pop_tags(new_tags.size)
+        pop_tags(pushed_count)
       end
 
       def push_tags(*tags)
-        tags.flatten!
-        tags.reject!(&:blank?)
-        current_tags.concat tags
-        tags
+        tag_stack.push_tags(tags)
       end
 
-      def pop_tags(size = 1)
-        current_tags.pop size
+      def pop_tags(count = 1)
+        tag_stack.pop_tags(count)
       end
 
       def clear_tags!
-        current_tags.clear
+        tag_stack.clear
       end
 
-      def current_tags
+      def tag_stack
         # We use our object ID here to avoid conflicting with other instances
-        thread_key = @thread_key ||= "activesupport_tagged_logging_tags:#{object_id}"
-        IsolatedExecutionState[thread_key] ||= []
+        @thread_key ||= "activesupport_tagged_logging_tags:#{object_id}"
+        IsolatedExecutionState[@thread_key] ||= TagStack.new
+      end
+
+      def current_tags
+        tag_stack.tags
       end
 
       def tags_text
-        tags = current_tags
-        if tags.one?
-          "[#{tags[0]}] "
-        elsif tags.any?
-          tags.collect { |tag| "[#{tag}] " }.join
+        tag_stack.format_message("")
+      end
+    end
+
+    class TagStack # :nodoc:
+      attr_reader :tags
+
+      def initialize
+        @tags = []
+        @tags_string = nil
+      end
+
+      def push_tags(tags)
+        @tags_string = nil
+        tags.flatten!
+        tags.reject!(&:blank?)
+        @tags.concat(tags)
+        tags
+      end
+
+      def pop_tags(count)
+        @tags_string = nil
+        @tags.pop(count)
+      end
+
+      def clear
+        @tags_string = nil
+        @tags.clear
+      end
+
+      def format_message(message)
+        if @tags.empty?
+          message
+        elsif @tags.size == 1
+          "[#{@tags[0]}] #{message}"
+        else
+          @tags_string ||= "[#{@tags.join("] [")}] "
+          "#{@tags_string}#{message}"
         end
       end
     end
 
     module LocalTagStorage # :nodoc:
-      attr_accessor :current_tags
+      attr_accessor :tag_stack
 
       def self.extended(base)
-        base.current_tags = []
+        base.tag_stack = TagStack.new
       end
     end
 
@@ -82,7 +118,7 @@ module ActiveSupport
       logger = logger.clone
 
       if logger.formatter
-        logger.formatter = logger.formatter.dup
+        logger.formatter = logger.formatter.clone
       else
         # Ensure we set a default formatter so we aren't extending nil!
         logger.formatter = ActiveSupport::Logger::SimpleFormatter.new

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
@@ -207,7 +223,7 @@ module ActiveSupport
       #     post :create, params: { status: { ok: true } }
       #   end
       #
-      # Provide the optional keyword argument :from to specify the expected
+      # Provide the optional keyword argument +:from+ to specify the expected
       # initial value.
       #
       #   assert_no_changes -> { Status.all_good? }, from: true do

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,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

@@ -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"