activesupport 8.0.3 → 8.1.0.beta1

data/lib/active_support/message_verifiers.rb

@@ -26,6 +26,9 @@ module ActiveSupport
     # as the first rotation and <tt>transitional = true</tt>. Then, after all
     # servers have been updated, perform a second rolling deploy with
     # <tt>transitional = false</tt>.
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#transitional
 
     ##
     # :singleton-method: new
@@ -42,6 +45,9 @@ module ActiveSupport
     #   end
     #
     #   verifiers.rotate(base: "...")
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#initialize
 
     ##
     # :method: []
@@ -50,12 +56,18 @@ module ActiveSupport
     # Returns a MessageVerifier configured with a secret derived from the
     # given +salt+, and options from #rotate. MessageVerifier instances will
     # be memoized, so the same +salt+ will return the same instance.
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#[]
 
     ##
     # :method: []=
     # :call-seq: []=(salt, verifier)
     #
     # Overrides a MessageVerifier instance associated with a given +salt+.
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#[]=
 
     ##
     # :method: rotate
@@ -104,18 +116,55 @@ module ActiveSupport
     #
     #   # Uses `serializer: Marshal, url_safe: false`.
     #   verifiers[:baz]
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#rotate
+
+    ##
+    # :method: prepend
+    # :call-seq:
+    #   prepend(**options)
+    #   prepend(&block)
+    #
+    # Just like #rotate, but prepends the given options or block to the list of
+    # option sets.
+    #
+    # This can be useful when you have an already-configured +MessageVerifiers+
+    # instance, but you want to override the way messages are signed.
+    #
+    #   module ThirdParty
+    #     VERIFIERS = ActiveSupport::MessageVerifiers.new { ... }.
+    #       rotate(serializer: Marshal, url_safe: true).
+    #       rotate(serializer: Marshal, url_safe: false)
+    #   end
+    #
+    #   ThirdParty.VERIFIERS.prepend(serializer: JSON, url_safe: true)
+    #
+    #   # Uses `serializer: JSON, url_safe: true`.
+    #   # Falls back to `serializer: Marshal, url_safe: true` or
+    #   # `serializer: Marshal, url_safe: false`.
+    #   ThirdParty.VERIFIERS[:foo]
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#prepend
 
     ##
     # :method: rotate_defaults
     # :call-seq: rotate_defaults
     #
     # Invokes #rotate with the default options.
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#rotate_defaults
 
     ##
     # :method: clear_rotations
     # :call-seq: clear_rotations
     #
     # Clears the list of option sets.
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#clear_rotations
 
     ##
     # :method: on_rotation
@@ -127,6 +176,9 @@ module ActiveSupport
     # For example, this callback could log each time it is called, and thus
     # indicate whether old option sets are still in use or can be removed from
     # rotation.
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#on_rotation
 
     ##
     private

data/lib/active_support/messages/rotation_coordinator.rb

@@ -32,6 +32,15 @@ module ActiveSupport
         self
       end
 
+      def prepend(**options, &block)
+        raise ArgumentError, "Options cannot be specified when using a block" if block && !options.empty?
+        changing_configuration!
+
+        @rotate_options.unshift(block || options)
+
+        self
+      end
+
       def rotate_defaults
         rotate()
       end

data/lib/active_support/messages/rotator.rb

@@ -45,6 +45,11 @@ module ActiveSupport
         end
       end
 
+      def initialize_dup(*)
+        super
+        @rotations = @rotations.dup
+      end
+
       private
         def build_rotation(*args, **options)
           self.class.new(*args, *@args.drop(args.length), **@options, **options)

data/lib/active_support/multibyte/chars.rb

@@ -53,7 +53,14 @@ module ActiveSupport # :nodoc:
       delegate :<=>, :=~, :match?, :acts_like_string?, to: :wrapped_string
 
       # Creates a new Chars instance by wrapping _string_.
-      def initialize(string)
+      def initialize(string, deprecation: true)
+        if deprecation
+          ActiveSupport.deprecator.warn(
+            "ActiveSupport::Multibyte::Chars is deprecated and will be removed in Rails 8.2. " \
+            "Use normal string methods instead."
+          )
+        end
+
         @wrapped_string = string
         if string.encoding != Encoding::UTF_8
           @wrapped_string = @wrapped_string.dup

data/lib/active_support/multibyte.rb

@@ -12,6 +12,10 @@ module ActiveSupport # :nodoc:
     #
     #   ActiveSupport::Multibyte.proxy_class = CharsForUTF32
     def self.proxy_class=(klass)
+      ActiveSupport.deprecator.warn(
+        "ActiveSupport::Multibyte.proxy_class= is deprecated and will be removed in Rails 8.2. " \
+        "Use normal string methods instead."
+      )
       @proxy_class = klass
     end
 

data/lib/active_support/railtie.rb

@@ -15,7 +15,7 @@ module ActiveSupport
 
     initializer "active_support.isolation_level" do |app|
       config.after_initialize do
-        if level = app.config.active_support.delete(:isolation_level)
+        if level = app.config.active_support.isolation_level
           ActiveSupport::IsolatedExecutionState.isolation_level = level
         end
       end
@@ -38,19 +38,35 @@ module ActiveSupport
       end
     end
 
-    initializer "active_support.reset_execution_context" do |app|
-      app.reloader.before_class_unload { ActiveSupport::ExecutionContext.clear }
-      app.executor.to_run              { ActiveSupport::ExecutionContext.clear }
-      app.executor.to_complete         { ActiveSupport::ExecutionContext.clear }
+    initializer "active_support.set_event_reporter_context_store" do |app|
+      config.after_initialize do
+        if klass = app.config.active_support.event_reporter_context_store
+          ActiveSupport::EventReporter.context_store = klass
+        end
+      end
     end
 
-    initializer "active_support.reset_all_current_attributes_instances" do |app|
-      app.reloader.before_class_unload { ActiveSupport::CurrentAttributes.clear_all }
-      app.executor.to_run              { ActiveSupport::CurrentAttributes.reset_all }
-      app.executor.to_complete         { ActiveSupport::CurrentAttributes.reset_all }
+    initializer "active_support.reset_execution_context" do |app|
+      app.reloader.before_class_unload do
+        ActiveSupport::CurrentAttributes.clear_all
+        ActiveSupport::ExecutionContext.clear
+        ActiveSupport.event_reporter.clear_context
+      end
+
+      app.executor.to_run do
+        ActiveSupport::ExecutionContext.push
+      end
+
+      app.executor.to_complete do
+        ActiveSupport::CurrentAttributes.clear_all
+        ActiveSupport::ExecutionContext.pop
+        ActiveSupport.event_reporter.clear_context
+      end
 
       ActiveSupport.on_load(:active_support_test_case) do
         if app.config.active_support.executor_around_test_case
+          ActiveSupport::ExecutionContext.nestable = true
+
           require "active_support/executor/test_helper"
           include ActiveSupport::Executor::TestHelper
         else
@@ -97,9 +113,7 @@ module ActiveSupport
     end
 
     initializer "active_support.to_time_preserves_timezone" do |app|
-      config.after_initialize do
-        ActiveSupport.to_time_preserves_timezone = app.config.active_support.to_time_preserves_timezone
-      end
+      ActiveSupport.to_time_preserves_timezone = app.config.active_support.to_time_preserves_timezone
     end
 
     # Sets the default week start

data/lib/active_support/syntax_error_proxy.rb

@@ -18,6 +18,9 @@ module ActiveSupport
 
       def label
       end
+
+      def base_label
+      end
     end
 
     class BacktraceLocationProxy < DelegateClass(Thread::Backtrace::Location) # :nodoc:

data/lib/active_support/test_case.rb

@@ -6,6 +6,7 @@ require "active_support/testing/setup_and_teardown"
 require "active_support/testing/tests_without_assertions"
 require "active_support/testing/assertions"
 require "active_support/testing/error_reporter_assertions"
+require "active_support/testing/event_reporter_assertions"
 require "active_support/testing/deprecation"
 require "active_support/testing/declarative"
 require "active_support/testing/isolation"
@@ -15,13 +16,29 @@ require "active_support/testing/constant_stubbing"
 require "active_support/testing/file_fixtures"
 require "active_support/testing/parallelization"
 require "active_support/testing/parallelize_executor"
+require "active_support/testing/notification_assertions"
 require "concurrent/utility/processor_counter"
 
 module ActiveSupport
   class TestCase < ::Minitest::Test
     Assertion = Minitest::Assertion
 
+    # Class variable to store the parallel worker ID
+    @@parallel_worker_id = nil
+
     class << self
+      # Returns the current parallel worker ID if tests are running in parallel,
+      # nil otherwise.
+      #
+      #   ActiveSupport::TestCase.parallel_worker_id # => 2
+      def parallel_worker_id
+        @@parallel_worker_id
+      end
+
+      def parallel_worker_id=(value) # :nodoc:
+        @@parallel_worker_id = value
+      end
+
       # Sets the order in which test cases are run.
       #
       #   ActiveSupport::TestCase.test_order = :random # => :random
@@ -51,8 +68,8 @@ module ActiveSupport
       # is forked. For each process a new database will be created suffixed
       # with the worker number.
       #
-      #   test-database-0
-      #   test-database-1
+      #   test-database_0
+      #   test-database_1
       #
       # If <tt>ENV["PARALLEL_WORKERS"]</tt> is set the workers argument will be ignored
       # and the environment variable will be used instead. This is useful for CI
@@ -78,14 +95,45 @@ module ActiveSupport
       # Because parallelization presents an overhead, it is only enabled when the
       # number of tests to run is above the +threshold+ param. The default value is
       # 50, and it's configurable via +config.active_support.test_parallelization_threshold+.
-      def parallelize(workers: :number_of_processors, with: :processes, threshold: ActiveSupport.test_parallelization_threshold)
-        workers = Concurrent.processor_count if workers == :number_of_processors
-        workers = ENV["PARALLEL_WORKERS"].to_i if ENV["PARALLEL_WORKERS"]
+      #
+      # If you want to skip Rails default creation of one database per process in favor of
+      # writing your own implementation, you can set +parallelize_databases+, or configure it
+      # via +config.active_support.parallelize_test_databases+.
+      #
+      #   parallelize(workers: :number_of_processors, parallelize_databases: false)
+      #
+      # Note that your test suite may deadlock if you attempt to use only one database
+      # with multiple processes.
+      def parallelize(workers: :number_of_processors, with: :processes, threshold: ActiveSupport.test_parallelization_threshold, parallelize_databases: ActiveSupport.parallelize_test_databases)
+        case
+        when ENV["PARALLEL_WORKERS"]
+          workers = ENV["PARALLEL_WORKERS"].to_i
+        when workers == :number_of_processors
+          workers = (Concurrent.available_processor_count || Concurrent.processor_count).floor
+        end
+
+        if with == :processes
+          ActiveSupport.parallelize_test_databases = parallelize_databases
+        end
 
         Minitest.parallel_executor = ActiveSupport::Testing::ParallelizeExecutor.new(size: workers, with: with, threshold: threshold)
       end
 
-      # Set up hook for parallel testing. This can be used if you have multiple
+      # Before fork hook for parallel testing. This can be used to run anything
+      # before the processes are forked.
+      #
+      # In your +test_helper.rb+ add the following:
+      #
+      #   class ActiveSupport::TestCase
+      #     parallelize_before_fork do
+      #       # run this before fork
+      #     end
+      #   end
+      def parallelize_before_fork(&block)
+        ActiveSupport::Testing::Parallelization.before_fork_hook(&block)
+      end
+
+      # Setup hook for parallel testing. This can be used if you have multiple
       # databases or any behavior that needs to be run after the process is forked
       # but before the tests run.
       #
@@ -141,11 +189,18 @@ module ActiveSupport
 
     alias_method :method_name, :name
 
+    # Returns the current parallel worker ID if tests are running in parallel
+    def parallel_worker_id
+      self.class.parallel_worker_id
+    end
+
     include ActiveSupport::Testing::TaggedLogging
     prepend ActiveSupport::Testing::SetupAndTeardown
     prepend ActiveSupport::Testing::TestsWithoutAssertions
     include ActiveSupport::Testing::Assertions
     include ActiveSupport::Testing::ErrorReporterAssertions
+    include ActiveSupport::Testing::EventReporterAssertions
+    include ActiveSupport::Testing::NotificationAssertions
     include ActiveSupport::Testing::Deprecation
     include ActiveSupport::Testing::ConstantStubbing
     include ActiveSupport::Testing::TimeHelpers

data/lib/active_support/testing/assertions.rb

@@ -71,19 +71,19 @@ module ActiveSupport
       #     post :delete, params: { id: ... }
       #   end
       #
-      # An array of expressions can also be passed in and evaluated.
+      # An array of expressions can be passed in and evaluated.
       #
       #   assert_difference [ 'Article.count', 'Post.count' ], 2 do
       #     post :create, params: { article: {...} }
       #   end
       #
-      # A hash of expressions/numeric differences can also be passed in and evaluated.
+      # A hash of expressions/numeric differences can be passed in and evaluated.
       #
-      #   assert_difference ->{ Article.count } => 1, ->{ Notification.count } => 2 do
+      #   assert_difference({ 'Article.count' => 1, 'Notification.count' => 2 }) do
       #     post :create, params: { article: {...} }
       #   end
       #
-      # A lambda or a list of lambdas can be passed in and evaluated:
+      # A lambda, a list of lambdas or a hash of lambdas/numeric differences can be passed in and evaluated:
       #
       #   assert_difference ->{ Article.count }, 2 do
       #     post :create, params: { article: {...} }
@@ -93,6 +93,10 @@ module ActiveSupport
       #     post :create, params: { article: {...} }
       #   end
       #
+      #   assert_difference ->{ Article.count } => 1, ->{ Notification.count } => 2 do
+      #     post :create, params: { article: {...} }
+      #   end
+      #
       # An error message can be specified.
       #
       #   assert_difference 'Article.count', -1, 'An Article should be destroyed' do
@@ -181,12 +185,24 @@ module ActiveSupport
       #
       # The keyword arguments +:from+ and +:to+ can be given to specify the
       # expected initial value and the expected value after the block was
-      # executed.
+      # executed. The comparison is done using case equality (===), which means
+      # you can specify patterns or classes:
       #
+      #   # Exact value match
       #   assert_changes :@object, from: nil, to: :foo do
       #     @object = :foo
       #   end
       #
+      #   # Case equality
+      #   assert_changes -> { user.token }, to: /\w{32}/ do
+      #     user.generate_token
+      #   end
+      #
+      #   # Type check
+      #   assert_changes -> { current_error }, from: nil, to: RuntimeError do
+      #     raise "Oops"
+      #   end
+      #
       # An error message can be specified.
       #
       #   assert_changes -> { Status.all_good? }, 'Expected the status to be bad' do
@@ -238,12 +254,24 @@ module ActiveSupport
       #   end
       #
       # Provide the optional keyword argument +:from+ to specify the expected
-      # initial value.
+      # initial value. The comparison is done using case equality (===), which means
+      # you can specify patterns or classes:
       #
+      #   # Exact value match
       #   assert_no_changes -> { Status.all_good? }, from: true do
       #     post :create, params: { status: { ok: true } }
       #   end
       #
+      #   # Case equality
+      #   assert_no_changes -> { user.token }, from: /\w{32}/ do
+      #     user.touch
+      #   end
+      #
+      #   # Type check
+      #   assert_no_changes -> { current_error }, from: RuntimeError do
+      #     retry_operation
+      #   end
+      #
       # An error message can be specified.
       #
       #   assert_no_changes -> { Status.all_good? }, 'Expected the status to be good' do

data/lib/active_support/testing/error_reporter_assertions.rb

@@ -44,7 +44,7 @@ module ActiveSupport
                   ActiveSupport.error_reporter.subscribe(self)
                   @subscribed = true
                 else
-                  raise Minitest::Assertion, "No error reporter is configured"
+                  flunk("No error reporter is configured")
                 end
               end
             end
@@ -102,6 +102,23 @@ module ActiveSupport
           assert(false, message)
         end
       end
+
+      # Captures reported errors from within the block that match the given
+      # error class.
+      #
+      #   reports = capture_error_reports(IOError) do
+      #     Rails.error.report(IOError.new("Oops"))
+      #     Rails.error.report(IOError.new("Oh no"))
+      #     Rails.error.report(StandardError.new)
+      #   end
+      #
+      #   assert_equal 2, reports.size
+      #   assert_equal "Oops", reports.first.error.message
+      #   assert_equal "Oh no", reports.last.error.message
+      def capture_error_reports(error_class = StandardError, &block)
+        reports = ErrorCollector.record(&block)
+        reports.select { |r| error_class === r.error }
+      end
     end
   end
 end

data/lib/active_support/testing/event_reporter_assertions.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module Testing
+    # Provides test helpers for asserting on ActiveSupport::EventReporter events.
+    module EventReporterAssertions
+      module EventCollector # :nodoc:
+        @subscribed = false
+        @mutex = Mutex.new
+
+        class Event # :nodoc:
+          attr_reader :event_data
+
+          def initialize(event_data)
+            @event_data = event_data
+          end
+
+          def inspect
+            "#{event_data[:name]} (payload: #{event_data[:payload].inspect}, tags: #{event_data[:tags].inspect})"
+          end
+
+          def matches?(name, payload, tags)
+            return false unless name.to_s == event_data[:name]
+
+            if payload && payload.is_a?(Hash)
+              return false unless matches_hash?(payload, :payload)
+            end
+
+            return false unless matches_hash?(tags, :tags)
+            true
+          end
+
+          private
+            def matches_hash?(expected_hash, event_key)
+              expected_hash.all? do |k, v|
+                if v.is_a?(Regexp)
+                  event_data.dig(event_key, k).to_s.match?(v)
+                else
+                  event_data.dig(event_key, k) == v
+                end
+              end
+            end
+        end
+
+        class << self
+          def emit(event)
+            event_recorders&.each do |events|
+              events << Event.new(event)
+            end
+            true
+          end
+
+          def record
+            subscribe
+            events = []
+            event_recorders << events
+            begin
+              yield
+              events
+            ensure
+              event_recorders.delete_if { |r| events.equal?(r) }
+            end
+          end
+
+          private
+            def subscribe
+              return if @subscribed
+
+              @mutex.synchronize do
+                unless @subscribed
+                  if ActiveSupport.event_reporter
+                    ActiveSupport.event_reporter.subscribe(self)
+                    @subscribed = true
+                  else
+                    raise Minitest::Assertion, "No event reporter is configured"
+                  end
+                end
+              end
+            end
+
+            def event_recorders
+              ActiveSupport::IsolatedExecutionState[:active_support_event_reporter_assertions] ||= []
+            end
+        end
+      end
+
+      # Asserts that the block does not cause an event to be reported to +Rails.event+.
+      #
+      # If no name is provided, passes if evaluated code in the yielded block reports no events.
+      #
+      #   assert_no_event_reported do
+      #     service_that_does_not_report_events.perform
+      #   end
+      #
+      # If a name is provided, passes if evaluated code in the yielded block reports no events
+      # with that name.
+      #
+      #   assert_no_event_reported("user.created") do
+      #     service_that_does_not_report_events.perform
+      #   end
+      def assert_no_event_reported(name = nil, payload: {}, tags: {}, &block)
+        events = EventCollector.record(&block)
+
+        if name.nil?
+          assert_predicate(events, :empty?)
+        else
+          matching_event = events.find { |event| event.matches?(name, payload, tags) }
+          if matching_event
+            message = "Expected no '#{name}' event to be reported, but found:\n  " \
+              "#{matching_event.inspect}"
+            flunk(message)
+          end
+          assert(true)
+        end
+      end
+
+      # Asserts that the block causes an event with the given name to be reported
+      # to +Rails.event+.
+      #
+      # Passes if the evaluated code in the yielded block reports a matching event.
+      #
+      #   assert_event_reported("user.created") do
+      #     Rails.event.notify("user.created", { id: 123 })
+      #   end
+      #
+      # To test further details about the reported event, you can specify payload and tag matchers.
+      #
+      #   assert_event_reported("user.created",
+      #     payload: { id: 123, name: "John Doe" },
+      #     tags: { request_id: /[0-9]+/ }
+      #   ) do
+      #     Rails.event.tagged(request_id: "123") do
+      #       Rails.event.notify("user.created", { id: 123, name: "John Doe" })
+      #     end
+      #   end
+      #
+      # The matchers support partial matching - only the specified keys need to match.
+      #
+      #   assert_event_reported("user.created", payload: { id: 123 }) do
+      #     Rails.event.notify("user.created", { id: 123, name: "John Doe" })
+      #   end
+      def assert_event_reported(name, payload: nil, tags: {}, &block)
+        events = EventCollector.record(&block)
+
+        if events.empty?
+          flunk("Expected an event to be reported, but there were no events reported.")
+        elsif (event = events.find { |event| event.matches?(name, payload, tags) })
+          assert(true)
+          event.event_data
+        else
+          message = "Expected an event to be reported matching:\n  " \
+            "name: #{name}\n  " \
+            "payload: #{payload.inspect}\n  " \
+            "tags: #{tags.inspect}\n" \
+            "but none of the #{events.size} reported events matched:\n  " \
+            "#{events.map(&:inspect).join("\n  ")}"
+          flunk(message)
+        end
+      end
+
+      # Asserts that the provided events were reported, regardless of order.
+      #
+      #   assert_events_reported([
+      #     { name: "user.created", payload: { id: 123 } },
+      #     { name: "email.sent", payload: { to: "user@example.com" } }
+      #   ]) do
+      #     create_user_and_send_welcome_email
+      #   end
+      #
+      # Supports the same payload and tag matching as +assert_event_reported+.
+      #
+      #   assert_events_reported([
+      #     {
+      #       name: "process.started",
+      #       payload: { id: 123 },
+      #       tags: { request_id: /[0-9]+/ }
+      #     },
+      #     { name: "process.completed" }
+      #   ]) do
+      #     Rails.event.tagged(request_id: "456") do
+      #       start_and_complete_process(123)
+      #     end
+      #   end
+      def assert_events_reported(expected_events, &block)
+        events = EventCollector.record(&block)
+
+        if events.empty? && expected_events.size > 0
+          flunk("Expected #{expected_events.size} events to be reported, but there were no events reported.")
+        end
+
+        events_copy = events.dup
+
+        expected_events.each do |expected_event|
+          name = expected_event[:name]
+          payload = expected_event[:payload] || {}
+          tags = expected_event[:tags] || {}
+
+          matching_event_index = events_copy.find_index { |event| event.matches?(name, payload, tags) }
+
+          if matching_event_index
+            events_copy.delete_at(matching_event_index)
+          else
+            message = "Expected an event to be reported matching:\n  " \
+              "name: #{name.inspect}\n  " \
+              "payload: #{payload.inspect}\n  " \
+              "tags: #{tags.inspect}\n" \
+              "but none of the #{events.size} reported events matched:\n  " \
+              "#{events.map(&:inspect).join("\n  ")}"
+            flunk(message)
+          end
+        end
+
+        assert(true)
+      end
+    end
+  end
+end