activesupport 6.0.6.1 → 7.1.3.2

data/lib/active_support/testing/isolation.rb

@@ -5,7 +5,7 @@ module ActiveSupport
     module Isolation
       require "thread"
 
-      def self.included(klass) #:nodoc:
+      def self.included(klass) # :nodoc:
         klass.class_eval do
           parallelize_me!
         end
@@ -25,45 +25,46 @@ module ActiveSupport
 
       module Forking
         def run_in_isolation(&blk)
-          read, write = IO.pipe
-          read.binmode
-          write.binmode
+          IO.pipe do |read, write|
+            read.binmode
+            write.binmode
 
-          pid = fork do
-            read.close
-            yield
-            begin
-              if error?
-                failures.map! { |e|
-                  begin
-                    Marshal.dump e
-                    e
-                  rescue TypeError
-                    ex = Exception.new e.message
-                    ex.set_backtrace e.backtrace
-                    Minitest::UnexpectedError.new ex
-                  end
-                }
+            pid = fork do
+              read.close
+              yield
+              begin
+                if error?
+                  failures.map! { |e|
+                    begin
+                      Marshal.dump e
+                      e
+                    rescue TypeError
+                      ex = Exception.new e.message
+                      ex.set_backtrace e.backtrace
+                      Minitest::UnexpectedError.new ex
+                    end
+                  }
+                end
+                test_result = defined?(Minitest::Result) ? Minitest::Result.from(self) : dup
+                result = Marshal.dump(test_result)
               end
-              test_result = defined?(Minitest::Result) ? Minitest::Result.from(self) : dup
-              result = Marshal.dump(test_result)
+
+              write.puts [result].pack("m")
+              exit!
             end
 
-            write.puts [result].pack("m")
-            exit!
+            write.close
+            result = read.read
+            Process.wait2(pid)
+            result.unpack1("m")
           end
-
-          write.close
-          result = read.read
-          Process.wait2(pid)
-          result.unpack1("m")
         end
       end
 
       module Subprocess
         ORIG_ARGV = ARGV.dup unless defined?(ORIG_ARGV)
 
-        # Crazy 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

@@ -6,10 +6,10 @@ module ActiveSupport
   module Testing
     module MethodCallAssertions # :nodoc:
       private
-        def assert_called(object, method_name, message = nil, times: 1, returns: nil)
+        def assert_called(object, method_name, message = nil, times: 1, returns: nil, &block)
           times_called = 0
 
-          object.stub(method_name, proc { times_called += 1; returns }) { yield }
+          object.stub(method_name, proc { times_called += 1; returns }, &block)
 
           error = "Expected #{method_name} to be called #{times} times, " \
             "but was called #{times_called} times"
@@ -17,24 +17,37 @@ module ActiveSupport
           assert_equal times, times_called, error
         end
 
-        def assert_called_with(object, method_name, args, returns: nil)
+        def assert_called_with(object, method_name, args, returns: false, **kwargs, &block)
           mock = Minitest::Mock.new
+          expect_called_with(mock, args, returns: returns, **kwargs)
 
-          if args.all? { |arg| arg.is_a?(Array) }
-            args.each { |arg| mock.expect(:call, returns, arg) }
-          else
-            mock.expect(:call, returns, args)
-          end
-
-          object.stub(method_name, mock) { yield }
+          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/parallelization/server.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "drb"
+require "drb/unix" unless Gem.win_platform?
+
+module ActiveSupport
+  module Testing
+    class Parallelization # :nodoc:
+      class Server
+        include DRb::DRbUndumped
+
+        def initialize
+          @queue = Queue.new
+          @active_workers = Concurrent::Map.new
+          @in_flight = Concurrent::Map.new
+        end
+
+        def record(reporter, result)
+          raise DRb::DRbConnError if result.is_a?(DRb::DRbUnknown)
+
+          @in_flight.delete([result.klass, result.name])
+
+          reporter.synchronize do
+            reporter.record(result)
+          end
+        end
+
+        def <<(o)
+          o[2] = DRbObject.new(o[2]) if o
+          @queue << o
+        end
+
+        def pop
+          if test = @queue.pop
+            @in_flight[[test[0].to_s, test[1]]] = test
+            test
+          end
+        end
+
+        def start_worker(worker_id)
+          @active_workers[worker_id] = true
+        end
+
+        def stop_worker(worker_id)
+          @active_workers.delete(worker_id)
+        end
+
+        def active_workers?
+          @active_workers.size > 0
+        end
+
+        def interrupt
+          @queue.clear
+        end
+
+        def shutdown
+          # Wait for initial queue to drain
+          while @queue.length != 0
+            sleep 0.1
+          end
+
+          @queue.close
+
+          # Wait until all workers have finished
+          while active_workers?
+            sleep 0.1
+          end
+
+          @in_flight.values.each do |(klass, name, reporter)|
+            result = Minitest::Result.from(klass.new(name))
+            error = RuntimeError.new("result not reported")
+            error.set_backtrace([""])
+            result.failures << Minitest::UnexpectedError.new(error)
+            reporter.synchronize do
+              reporter.record(result)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module Testing
+    class Parallelization # :nodoc:
+      class Worker
+        def initialize(number, url)
+          @id = SecureRandom.uuid
+          @number = number
+          @url = url
+          @setup_exception = nil
+        end
+
+        def start
+          fork do
+            set_process_title("(starting)")
+
+            DRb.stop_service
+
+            @queue = DRbObject.new_with_uri(@url)
+            @queue.start_worker(@id)
+
+            begin
+              after_fork
+            rescue => @setup_exception; end
+
+            work_from_queue
+          ensure
+            set_process_title("(stopping)")
+
+            run_cleanup
+            @queue.stop_worker(@id)
+          end
+        end
+
+        def work_from_queue
+          while job = @queue.pop
+            perform_job(job)
+          end
+        end
+
+        def perform_job(job)
+          klass    = job[0]
+          method   = job[1]
+          reporter = job[2]
+
+          set_process_title("#{klass}##{method}")
+
+          result = klass.with_info_handler reporter do
+            Minitest.run_one_method(klass, method)
+          end
+
+          safe_record(reporter, result)
+        end
+
+        def safe_record(reporter, result)
+          add_setup_exception(result) if @setup_exception
+
+          begin
+            @queue.record(reporter, result)
+          rescue DRb::DRbConnError
+            result.failures.map! do |failure|
+              if failure.respond_to?(:error)
+                # minitest >5.14.0
+                error = DRb::DRbRemoteError.new(failure.error)
+              else
+                error = DRb::DRbRemoteError.new(failure.exception)
+              end
+              Minitest::UnexpectedError.new(error)
+            end
+            @queue.record(reporter, result)
+          rescue Interrupt
+            @queue.interrupt
+            raise
+          end
+
+          set_process_title("(idle)")
+        end
+
+        def after_fork
+          Parallelization.after_fork_hooks.each do |cb|
+            cb.call(@number)
+          end
+        end
+
+        def run_cleanup
+          Parallelization.run_cleanup_hooks.each do |cb|
+            cb.call(@number)
+          end
+        end
+
+        private
+          def add_setup_exception(result)
+            result.failures.prepend Minitest::UnexpectedError.new(@setup_exception)
+          end
+
+          def set_process_title(status)
+            Process.setproctitle("Rails test worker #{@number} - #{status}")
+          end
+      end
+    end
+  end
+end

data/lib/active_support/testing/parallelization.rb

@@ -3,37 +3,12 @@
 require "drb"
 require "drb/unix" unless Gem.win_platform?
 require "active_support/core_ext/module/attribute_accessors"
+require "active_support/testing/parallelization/server"
+require "active_support/testing/parallelization/worker"
 
 module ActiveSupport
   module Testing
     class Parallelization # :nodoc:
-      class Server
-        include DRb::DRbUndumped
-
-        def initialize
-          @queue = Queue.new
-        end
-
-        def record(reporter, result)
-          raise DRb::DRbConnError if result.is_a?(DRb::DRbUnknown)
-
-          reporter.synchronize do
-            reporter.record(result)
-          end
-        end
-
-        def <<(o)
-          o[2] = DRbObject.new(o[2]) if o
-          @queue << o
-        end
-
-        def length
-          @queue.length
-        end
-
-        def pop; @queue.pop; end
-      end
-
       @@after_fork_hooks = []
 
       def self.after_fork_hook(&blk)
@@ -50,85 +25,31 @@ module ActiveSupport
 
       cattr_reader :run_cleanup_hooks
 
-      def initialize(queue_size)
-        @queue_size = queue_size
-        @queue      = Server.new
-        @pool       = []
-
-        @url = DRb.start_service("drbunix:", @queue).uri
-      end
-
-      def after_fork(worker)
-        self.class.after_fork_hooks.each do |cb|
-          cb.call(worker)
-        end
-      end
-
-      def run_cleanup(worker)
-        self.class.run_cleanup_hooks.each do |cb|
-          cb.call(worker)
-        end
+      def initialize(worker_count)
+        @worker_count = worker_count
+        @queue_server = Server.new
+        @worker_pool = []
+        @url = DRb.start_service("drbunix:", @queue_server).uri
       end
 
       def start
-        @pool = @queue_size.times.map do |worker|
-          fork do
-            DRb.stop_service
-
-            begin
-              after_fork(worker)
-            rescue => setup_exception; end
-
-            queue = DRbObject.new_with_uri(@url)
-
-            while job = queue.pop
-              klass    = job[0]
-              method   = job[1]
-              reporter = job[2]
-              result = klass.with_info_handler reporter do
-                Minitest.run_one_method(klass, method)
-              end
-
-              add_setup_exception(result, setup_exception) if setup_exception
-
-              begin
-                queue.record(reporter, result)
-              rescue DRb::DRbConnError
-                result.failures.map! do |failure|
-                  if failure.respond_to?(:error)
-                    # minitest >5.14.0
-                    error = DRb::DRbRemoteError.new(failure.error)
-                  else
-                    error = DRb::DRbRemoteError.new(failure.exception)
-                  end
-                  Minitest::UnexpectedError.new(error)
-                end
-                queue.record(reporter, result)
-              end
-            end
-          ensure
-            run_cleanup(worker)
-          end
+        @worker_pool = @worker_count.times.map do |worker|
+          Worker.new(worker, @url).start
         end
       end
 
       def <<(work)
-        @queue << work
+        @queue_server << work
       end
 
-      def shutdown
-        @queue_size.times { @queue << nil }
-        @pool.each { |pid| Process.waitpid pid }
-
-        if @queue.length > 0
-          raise "Queue not empty, but all workers have finished. This probably means that a worker crashed and #{@queue.length} tests were missed."
-        end
+      def size
+        @worker_count
       end
 
-      private
-        def add_setup_exception(result, setup_exception)
-          result.failures.prepend Minitest::UnexpectedError.new(setup_exception)
-        end
+      def shutdown
+        @queue_server.shutdown
+        @worker_pool.each { |pid| Process.waitpid pid }
+      end
     end
   end
 end

data/lib/active_support/testing/parallelize_executor.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module Testing
+    class ParallelizeExecutor # :nodoc:
+      attr_reader :size, :parallelize_with, :threshold
+
+      def initialize(size:, with:, threshold: ActiveSupport.test_parallelization_threshold)
+        @size = size
+        @parallelize_with = with
+        @threshold = threshold
+        @parallelized = false
+      end
+
+      def start
+        parallelize if should_parallelize?
+        show_execution_info
+
+        parallel_executor.start if parallelized?
+      end
+
+      def <<(work)
+        parallel_executor << work if parallelized?
+      end
+
+      def shutdown
+        parallel_executor.shutdown if parallelized?
+      end
+
+      private
+        def parallel_executor
+          @parallel_executor ||= build_parallel_executor
+        end
+
+        def build_parallel_executor
+          case parallelize_with
+          when :processes
+            Testing::Parallelization.new(size)
+          when :threads
+            ActiveSupport::TestCase.lock_threads = false if defined?(ActiveSupport::TestCase.lock_threads)
+            Minitest::Parallel::Executor.new(size)
+          else
+            raise ArgumentError, "#{parallelize_with} is not a supported parallelization executor."
+          end
+        end
+
+        def parallelize
+          @parallelized = true
+          Minitest::Test.parallelize_me!
+        end
+
+        def parallelized?
+          @parallelized
+        end
+
+        def should_parallelize?
+          (ENV["PARALLEL_WORKERS"] || tests_count > threshold) && many_workers?
+        end
+
+        def many_workers?
+          size > 1
+        end
+
+        def tests_count
+          @tests_count ||= Minitest::Runnable.runnables.sum { |runnable| runnable.runnable_methods.size }
+        end
+
+        def show_execution_info
+          puts execution_info
+        end
+
+        def execution_info
+          if parallelized?
+            "Running #{tests_count} tests in parallel using #{parallel_executor.size} #{parallelize_with}"
+          elsif many_workers?
+            "Running #{tests_count} tests in a single process (parallelization threshold is #{threshold})"
+          end
+        end
+    end
+  end
+end

data/lib/active_support/testing/stream.rb

@@ -2,7 +2,7 @@
 
 module ActiveSupport
   module Testing
-    module Stream #:nodoc:
+    module Stream # :nodoc:
       private
         def silence_stream(stream)
           old_stream = stream.dup
@@ -14,18 +14,16 @@ module ActiveSupport
           old_stream.close
         end
 
-        def quietly
+        def quietly(&block)
           silence_stream(STDOUT) do
-            silence_stream(STDERR) do
-              yield
-            end
+            silence_stream(STDERR, &block)
           end
         end
 
         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,39 @@
+# 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 - disp_type_s},
+      %r{/lib/mail/parsers/.*assigned but unused variable - testEof}
+    )
+
+    def warn(message, *)
+      return if SUPPRESSED_WARNINGS.match?(message)
+
+      super
+
+      return unless message.include?(PROJECT_ROOT)
+      return if ALLOWED_WARNINGS.match?(message)
+      return unless ENV["RAILS_STRICT_WARNINGS"] || ENV["CI"]
+
+      raise message
+    end
+    ruby2_keywords :warn if respond_to?(:ruby2_keywords, true)
+  end
+end
+
+Warning.singleton_class.prepend(ActiveSupport::RaiseWarnings)

data/lib/active_support/testing/tagged_logging.rb

@@ -4,7 +4,7 @@ module ActiveSupport
   module Testing
     # Logs a "PostsControllerTest: test name" heading before each test to
     # make test.log easier to search and follow along with.
-    module TaggedLogging #:nodoc:
+    module TaggedLogging # :nodoc:
       attr_writer :tagged_logger
 
       def before_setup