activesupport 8.0.4 → 8.1.0.beta1

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

data/lib/active_support/testing/notification_assertions.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module Testing
+    module NotificationAssertions
+      # Assert a notification was emitted with a given +pattern+ and optional +payload+.
+      #
+      # You can assert that a notification was emitted by passing a pattern, which accepts
+      # either a string or regexp, an optional payload, and a block. While the block
+      # is executed, if a matching notification is emitted, the assertion will pass
+      # and the notification will be returned.
+      #
+      # Note that the payload is matched as a subset, meaning that the notification must
+      # contain at least the specified keys and values, but may contain additional ones.
+      #
+      #     assert_notification("post.submitted", title: "Cool Post") do
+      #       post.submit(title: "Cool Post", body: "Cool Body") # => emits matching notification
+      #     end
+      #
+      # Using the returned notification, you can make more customized assertions.
+      #
+      #     notification = assert_notification("post.submitted", title: "Cool Post") do
+      #       ActiveSupport::Notifications.instrument("post.submitted", title: "Cool Post", body: Body.new("Cool Body"))
+      #     end
+      #
+      #     assert_instance_of(Body, notification.payload[:body])
+      #
+      def assert_notification(pattern, payload = nil, &block)
+        notifications = capture_notifications(pattern, &block)
+        assert_not_empty(notifications, "No #{pattern} notifications were found")
+
+        return notifications.first if payload.nil?
+
+        notification = notifications.find { |notification| notification.payload.slice(*payload.keys) == payload }
+        assert_not_nil(notification, "No #{pattern} notification with payload #{payload} was found")
+
+        notification
+      end
+
+      # Assert the number of notifications emitted with a given +pattern+.
+      #
+      # You can assert the number of notifications emitted by passing a pattern, which accepts
+      # either a string or regexp, a count, and a block. While the block is executed,
+      # the number of matching notifications emitted will be counted. After the block's
+      # execution completes, the assertion will pass if the count matches.
+      #
+      #     assert_notifications_count("post.submitted", 1) do
+      #       post.submit(title: "Cool Post") # => emits matching notification
+      #     end
+      #
+      def assert_notifications_count(pattern, count, &block)
+        actual_count = capture_notifications(pattern, &block).count
+        assert_equal(count, actual_count, "Expected #{count} instead of #{actual_count} notifications for #{pattern}")
+      end
+
+      # Assert no notifications were emitted for a given +pattern+.
+      #
+      # You can assert no notifications were emitted by passing a pattern, which accepts
+      # either a string or regexp, and a block. While the block is executed, if no
+      # matching notifications are emitted, the assertion will pass.
+      #
+      #     assert_no_notifications("post.submitted") do
+      #       post.destroy # => emits non-matching notification
+      #     end
+      #
+      def assert_no_notifications(pattern = nil, &block)
+        notifications = capture_notifications(pattern, &block)
+        error_message = if pattern
+          "Expected no notifications for #{pattern} but found #{notifications.size}"
+        else
+          "Expected no notifications but found #{notifications.size}"
+        end
+        assert_empty(notifications, error_message)
+      end
+
+      # Capture emitted notifications, optionally filtered by a +pattern+.
+      #
+      # You can capture emitted notifications, optionally filtered by a pattern,
+      # which accepts either a string or regexp, and a block.
+      #
+      #     notifications = capture_notifications("post.submitted") do
+      #       post.submit(title: "Cool Post") # => emits matching notification
+      #     end
+      #
+      def capture_notifications(pattern = nil, &block)
+        notifications = []
+        ActiveSupport::Notifications.subscribed(->(n) { notifications << n }, pattern, &block)
+        notifications
+      end
+    end
+  end
+end

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

@@ -14,7 +14,6 @@ module ActiveSupport
         def initialize
           @queue = Queue.new
           @active_workers = Concurrent::Map.new
-          @worker_pids = Concurrent::Map.new
           @in_flight = Concurrent::Map.new
         end
 
@@ -41,24 +40,12 @@ module ActiveSupport
           end
         end
 
-        def start_worker(worker_id, worker_pid)
+        def start_worker(worker_id)
           @active_workers[worker_id] = true
-          @worker_pids[worker_id] = worker_pid
         end
 
-        def stop_worker(worker_id, worker_pid)
+        def stop_worker(worker_id)
           @active_workers.delete(worker_id)
-          @worker_pids.delete(worker_id)
-        end
-
-        def remove_dead_workers(dead_pids)
-          dead_pids.each do |dead_pid|
-            worker_id = @worker_pids.key(dead_pid)
-            if worker_id
-              @active_workers.delete(worker_id)
-              @worker_pids.delete(worker_id)
-            end
-          end
         end
 
         def active_workers?

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

@@ -18,7 +18,7 @@ module ActiveSupport
             DRb.stop_service
 
             @queue = DRbObject.new_with_uri(@url)
-            @queue.start_worker(@id, Process.pid)
+            @queue.start_worker(@id)
 
             begin
               after_fork
@@ -29,7 +29,7 @@ module ActiveSupport
             set_process_title("(stopping)")
 
             run_cleanup
-            @queue.stop_worker(@id, Process.pid)
+            @queue.stop_worker(@id)
           end
         end
 
@@ -78,6 +78,8 @@ module ActiveSupport
         end
 
         def after_fork
+          ActiveSupport::TestCase.parallel_worker_id = @number
+
           Parallelization.after_fork_hooks.each do |cb|
             cb.call(@number)
           end

data/lib/active_support/testing/parallelization.rb

@@ -9,6 +9,14 @@ require "active_support/testing/parallelization/worker"
 module ActiveSupport
   module Testing
     class Parallelization # :nodoc:
+      @@before_fork_hooks = []
+
+      def self.before_fork_hook(&blk)
+        @@before_fork_hooks << blk
+      end
+
+      cattr_reader :before_fork_hooks
+
       @@after_fork_hooks = []
 
       def self.after_fork_hook(&blk)
@@ -32,7 +40,12 @@ module ActiveSupport
         @url = DRb.start_service("drbunix:", @queue_server).uri
       end
 
+      def before_fork
+        Parallelization.before_fork_hooks.each(&:call)
+      end
+
       def start
+        before_fork
         @worker_pool = @worker_count.times.map do |worker|
           Worker.new(worker, @url).start
         end
@@ -47,19 +60,8 @@ module ActiveSupport
       end
 
       def shutdown
-        dead_worker_pids = @worker_pool.filter_map do |pid|
-          Process.waitpid(pid, Process::WNOHANG)
-        rescue Errno::ECHILD
-          pid
-        end
-        @queue_server.remove_dead_workers(dead_worker_pids)
-
         @queue_server.shutdown
-        @worker_pool.each do |pid|
-          Process.waitpid(pid)
-        rescue Errno::ECHILD
-          nil
-        end
+        @worker_pool.each { |pid| Process.waitpid pid }
       end
     end
   end

data/lib/active_support/testing/tests_without_assertions.rb

@@ -11,7 +11,7 @@ module ActiveSupport
 
         if assertions.zero? && !skipped? && !error?
           file, line = method(name).source_location
-          warn "Test is missing assertions: `#{name}` #{file}:#{line}"
+          warn "Test is missing assertions: `#{name}` #{File.expand_path(file)}:#{line}"
         end
       end
     end

data/lib/active_support/testing/time_helpers.rb

@@ -238,12 +238,16 @@ module ActiveSupport
       end
       alias_method :unfreeze_time, :travel_back
 
-      # Calls +travel_to+ with +Time.now+. Forwards optional <tt>with_usec</tt> argument.
+      # Calls +travel_to+ with +date_or_time+, which defaults to +Time.now+.
+      # Forwards optional <tt>with_usec</tt> argument.
       #
       #   Time.current # => Sun, 09 Jul 2017 15:34:49 EST -05:00
       #   freeze_time
       #   sleep(1)
       #   Time.current # => Sun, 09 Jul 2017 15:34:49 EST -05:00
+      #   freeze_time Time.current + 1.day
+      #   sleep(1)
+      #   Time.current # => Mon, 10 Jul 2017 15:34:49 EST -05:00
       #
       # This method also accepts a block, which will return the current time back to its original
       # state at the end of the block:
@@ -254,8 +258,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(with_usec: false, &block)
-        travel_to Time.now, with_usec: with_usec, &block
+      def freeze_time(date_or_time = Time.now, with_usec: false, &block)
+        travel_to date_or_time, with_usec: with_usec, &block
       end
 
       private

data/lib/active_support/time_with_zone.rb

@@ -49,9 +49,15 @@ module ActiveSupport
     attr_reader :time_zone
 
     def initialize(utc_time, time_zone, local_time = nil, period = nil)
-      @utc = utc_time ? transfer_time_values_to_utc_constructor(utc_time) : nil
       @time_zone, @time = time_zone, local_time
-      @period = @utc ? period : get_period_and_ensure_valid_local_time(period)
+      if utc_time
+        @utc = transfer_time_values_to_utc_constructor(utc_time)
+        @period = period
+      else
+        @utc = nil
+        @period = get_period_and_ensure_valid_local_time(period)
+      end
+      @is_utc = zone == "UTC" || zone == "UCT"
     end
 
     # Returns a <tt>Time</tt> instance that represents the time in +time_zone+.
@@ -103,7 +109,7 @@ module ActiveSupport
     #   Time.zone = 'Eastern Time (US & Canada)'    # => 'Eastern Time (US & Canada)'
     #   Time.zone.now.utc?                          # => false
     def utc?
-      zone == "UTC" || zone == "UCT"
+      @is_utc
     end
     alias_method :gmt?, :utc?
 
@@ -146,7 +152,13 @@ module ActiveSupport
     #
     #   Time.zone.now.xmlschema  # => "2014-12-04T11:02:37-05:00"
     def xmlschema(fraction_digits = 0)
-      "#{time.strftime(PRECISIONS[fraction_digits.to_i])}#{formatted_offset(true, 'Z')}"
+      if @is_utc
+        utc.iso8601(fraction_digits || 0)
+      else
+        str = time.iso8601(fraction_digits || 0)
+        str[-1] = formatted_offset(true, "Z")
+        str
+      end
     end
     alias_method :iso8601, :xmlschema
     alias_method :rfc3339, :xmlschema
@@ -560,7 +572,9 @@ module ActiveSupport
       SECONDS_PER_DAY = 86400
 
       def incorporate_utc_offset(time, offset)
-        if time.kind_of?(Date)
+        if offset.zero?
+          time
+        elsif time.kind_of?(Date)
           time + Rational(offset, SECONDS_PER_DAY)
         else
           time + offset

data/lib/active_support/values/time_zone.rb

@@ -57,13 +57,14 @@ module ActiveSupport
       "Caracas"                      => "America/Caracas",
       "La Paz"                       => "America/La_Paz",
       "Santiago"                     => "America/Santiago",
+      "Asuncion"                     => "America/Asuncion",
       "Newfoundland"                 => "America/St_Johns",
       "Brasilia"                     => "America/Sao_Paulo",
       "Buenos Aires"                 => "America/Argentina/Buenos_Aires",
       "Montevideo"                   => "America/Montevideo",
       "Georgetown"                   => "America/Guyana",
       "Puerto Rico"                  => "America/Puerto_Rico",
-      "Greenland"                    => "America/Godthab",
+      "Greenland"                    => "America/Nuuk",
       "Mid-Atlantic"                 => "Atlantic/South_Georgia",
       "Azores"                       => "Atlantic/Azores",
       "Cape Verde Is."               => "Atlantic/Cape_Verde",
@@ -313,6 +314,12 @@ module ActiveSupport
     end
     # :startdoc:
 
+    # Returns a standard time zone name defined by IANA
+    # https://www.iana.org/time-zones
+    def standard_name
+      MAPPING[name] || name
+    end
+
     # Returns the offset of this time zone from UTC in seconds.
     def utc_offset
       @utc_offset || tzinfo&.current_period&.base_utc_offset

data/lib/active_support/xml_mini.rb

@@ -62,11 +62,10 @@ module ActiveSupport
       "yaml"     => Proc.new { |yaml| yaml.to_yaml }
     } unless defined?(FORMATTING)
 
-    # TODO use regexp instead of Date.parse
     unless defined?(PARSING)
       PARSING = {
         "symbol"       => Proc.new { |symbol|  symbol.to_s.to_sym },
-        "date"         => Proc.new { |date|    ::Date.parse(date) },
+        "date"         => Proc.new { |date|    ::Date.strptime(date, "%Y-%m-%d") },
         "datetime"     => Proc.new { |time|    Time.xmlschema(time).utc rescue ::DateTime.parse(time).utc },
         "duration"     => Proc.new { |duration| Duration.parse(duration) },
         "integer"      => Proc.new { |integer| integer.to_i },
@@ -74,8 +73,6 @@ module ActiveSupport
         "decimal"      => Proc.new do |number|
           if String === number
             number.to_d
-          elsif Float === number
-            BigDecimal(number, 0)
           else
             BigDecimal(number)
           end

data/lib/active_support.rb

@@ -40,12 +40,15 @@ module ActiveSupport
   autoload :CodeGenerator
   autoload :ActionableError
   autoload :ConfigurationFile
+  autoload :ContinuousIntegration
   autoload :CurrentAttributes
   autoload :Dependencies
   autoload :DescendantsTracker
+  autoload :Editor
   autoload :ExecutionWrapper
   autoload :Executor
   autoload :ErrorReporter
+  autoload :EventReporter
   autoload :FileUpdateChecker
   autoload :EventedFileUpdateChecker
   autoload :ForkTracker
@@ -91,6 +94,10 @@ module ActiveSupport
   autoload :SafeBuffer, "active_support/core_ext/string/output_safety"
   autoload :TestCase
 
+  include Deprecation::DeprecatedConstantAccessor
+
+  deprecate_constant :Configurable, "class_attribute :config, default: {}", deprecator: ActiveSupport.deprecator
+
   def self.eager_load!
     super
 
@@ -99,10 +106,14 @@ module ActiveSupport
 
   cattr_accessor :test_order # :nodoc:
   cattr_accessor :test_parallelization_threshold, default: 50 # :nodoc:
+  cattr_accessor :parallelize_test_databases, default: true # :nodoc:
 
   @error_reporter = ActiveSupport::ErrorReporter.new
   singleton_class.attr_accessor :error_reporter # :nodoc:
 
+  @event_reporter = ActiveSupport::EventReporter.new
+  singleton_class.attr_accessor :event_reporter # :nodoc:
+
   def self.cache_format_version
     Cache.format_version
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activesupport
 version: !ruby/object:Gem::Version
-  version: 8.0.4
+  version: 8.1.0.beta1
 platform: ruby
 authors:
 - David Heinemeier Hansson
@@ -235,6 +235,7 @@ files:
 - lib/active_support/concurrency/share_lock.rb
 - lib/active_support/configurable.rb
 - lib/active_support/configuration_file.rb
+- lib/active_support/continuous_integration.rb
 - lib/active_support/core_ext.rb
 - lib/active_support/core_ext/array.rb
 - lib/active_support/core_ext/array/access.rb
@@ -327,7 +328,6 @@ files:
 - lib/active_support/core_ext/range.rb
 - lib/active_support/core_ext/range/compare_range.rb
 - lib/active_support/core_ext/range/conversions.rb
-- lib/active_support/core_ext/range/each.rb
 - lib/active_support/core_ext/range/overlap.rb
 - lib/active_support/core_ext/range/sole.rb
 - lib/active_support/core_ext/regexp.rb
@@ -377,11 +377,14 @@ files:
 - lib/active_support/duration.rb
 - lib/active_support/duration/iso8601_parser.rb
 - lib/active_support/duration/iso8601_serializer.rb
+- lib/active_support/editor.rb
 - lib/active_support/encrypted_configuration.rb
 - lib/active_support/encrypted_file.rb
 - lib/active_support/environment_inquirer.rb
 - lib/active_support/error_reporter.rb
 - lib/active_support/error_reporter/test_helper.rb
+- lib/active_support/event_reporter.rb
+- lib/active_support/event_reporter/test_helper.rb
 - lib/active_support/evented_file_update_checker.rb
 - lib/active_support/execution_context.rb
 - lib/active_support/execution_context/test_helper.rb
@@ -466,9 +469,11 @@ files:
 - lib/active_support/testing/declarative.rb
 - lib/active_support/testing/deprecation.rb
 - lib/active_support/testing/error_reporter_assertions.rb
+- lib/active_support/testing/event_reporter_assertions.rb
 - lib/active_support/testing/file_fixtures.rb
 - lib/active_support/testing/isolation.rb
 - lib/active_support/testing/method_call_assertions.rb
+- lib/active_support/testing/notification_assertions.rb
 - lib/active_support/testing/parallelization.rb
 - lib/active_support/testing/parallelization/server.rb
 - lib/active_support/testing/parallelization/worker.rb
@@ -494,10 +499,10 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/rails/rails/issues
-  changelog_uri: https://github.com/rails/rails/blob/v8.0.4/activesupport/CHANGELOG.md
-  documentation_uri: https://api.rubyonrails.org/v8.0.4/
+  changelog_uri: https://github.com/rails/rails/blob/v8.1.0.beta1/activesupport/CHANGELOG.md
+  documentation_uri: https://api.rubyonrails.org/v8.1.0.beta1/
   mailing_list_uri: https://discuss.rubyonrails.org/c/rubyonrails-talk
-  source_code_uri: https://github.com/rails/rails/tree/v8.0.4/activesupport
+  source_code_uri: https://github.com/rails/rails/tree/v8.1.0.beta1/activesupport
   rubygems_mfa_required: 'true'
 rdoc_options:
 - "--encoding"