activesupport 5.1.7 → 7.0.4.1

data/lib/active_support/testing/deprecation.rb

@@ -1,9 +1,33 @@
+# frozen_string_literal: true
+
 require "active_support/deprecation"
-require "active_support/core_ext/regexp"
 
 module ActiveSupport
   module Testing
-    module Deprecation #:nodoc:
+    module Deprecation
+      # Asserts that a matching deprecation warning was emitted by the given deprecator during the execution of the yielded block.
+      #
+      #   assert_deprecated(/foo/, CustomDeprecator) do
+      #     CustomDeprecator.warn "foo should no longer be used"
+      #   end
+      #
+      # The +match+ object may be a +Regexp+, or +String+ appearing in the message.
+      #
+      #   assert_deprecated('foo', CustomDeprecator) do
+      #     CustomDeprecator.warn "foo should no longer be used"
+      #   end
+      #
+      # If the +match+ is omitted (or explicitly +nil+), any deprecation warning will match.
+      #
+      #   assert_deprecated(nil, 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)
         result, warnings = collect_deprecations(deprecator, &block)
         assert !warnings.empty?, "Expected a deprecation warning within the block but received none"
@@ -14,12 +38,40 @@ module ActiveSupport
         result
       end
 
+      # Asserts that no deprecation warnings are emitted by the given deprecator during the execution of the yielded block.
+      #
+      #   assert_not_deprecated(CustomDeprecator) do
+      #     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
+      #   end
       def assert_not_deprecated(deprecator = nil, &block)
         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
+      # +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"]
       def collect_deprecations(deprecator = nil)
         deprecator ||= ActiveSupport::Deprecation
         old_behavior = deprecator.behavior

data/lib/active_support/testing/file_fixtures.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
 module ActiveSupport
   module Testing
     # Adds simple access to sample files called file fixtures.

data/lib/active_support/testing/isolation.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module ActiveSupport
   module Testing
     module Isolation
       require "thread"
 
-      def self.included(klass) #:nodoc:
+      def self.included(klass) # :nodoc:
         klass.class_eval do
           parallelize_me!
         end
@@ -54,14 +56,14 @@ module ActiveSupport
           write.close
           result = read.read
           Process.wait2(pid)
-          return result.unpack("m")[0]
+          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"
@@ -96,7 +98,7 @@ module ActiveSupport
                 nil
               end
 
-              return tmpfile.read.unpack("m")[0]
+              return tmpfile.read.unpack1("m")
             end
           end
         end

data/lib/active_support/testing/method_call_assertions.rb

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 require "minitest/mock"
 
 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"
@@ -15,16 +17,16 @@ 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: nil, &block)
           mock = Minitest::Mock.new
 
-          if args.all? { |arg| arg.is_a?(Array) }
+          if args.all?(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
         end
@@ -33,6 +35,33 @@ module ActiveSupport
           assert_called(object, method_name, message, times: 0, &block)
         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 |*|
+            times_called += 1
+
+            returns
+          end
+
+          klass.alias_method "original_#{method_name}", method_name
+          klass.alias_method method_name, "stubbed_#{method_name}"
+
+          yield
+
+          error = "Expected #{method_name} to be called #{times} times, but was called #{times_called} times"
+          error = "#{message}.\n#{error}" if message
+
+          assert_equal times, times_called, error
+        ensure
+          klass.alias_method method_name, "original_#{method_name}"
+          klass.undef_method "original_#{method_name}"
+          klass.undef_method "stubbed_#{method_name}"
+        end
+
+        def assert_not_called_on_instance_of(klass, method_name, message = nil, &block)
+          assert_called_on_instance_of(klass, method_name, message, times: 0, &block)
+        end
+
         def stub_any_instance(klass, instance: klass.new)
           klass.stub(:new, instance) { yield instance }
         end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+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:
+      @@after_fork_hooks = []
+
+      def self.after_fork_hook(&blk)
+        @@after_fork_hooks << blk
+      end
+
+      cattr_reader :after_fork_hooks
+
+      @@run_cleanup_hooks = []
+
+      def self.run_cleanup_hook(&blk)
+        @@run_cleanup_hooks << blk
+      end
+
+      cattr_reader :run_cleanup_hooks
+
+      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
+        @worker_pool = @worker_count.times.map do |worker|
+          Worker.new(worker, @url).start
+        end
+      end
+
+      def <<(work)
+        @queue_server << work
+      end
+
+      def size
+        @worker_count
+      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,76 @@
+# 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
+      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 if defined?(@parallelized)
+        end
+
+        def should_parallelize?
+          ENV["PARALLEL_WORKERS"] || tests_count > threshold
+        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}"
+          else
+            "Running #{tests_count} tests in a single process (parallelization threshold is #{threshold})"
+          end
+        end
+    end
+  end
+end

data/lib/active_support/testing/setup_and_teardown.rb

@@ -1,4 +1,5 @@
-require "active_support/concern"
+# frozen_string_literal: true
+
 require "active_support/callbacks"
 
 module ActiveSupport
@@ -17,11 +18,10 @@ module ActiveSupport
     #     end
     #   end
     module SetupAndTeardown
-      extend ActiveSupport::Concern
-
-      included do
-        include ActiveSupport::Callbacks
-        define_callbacks :setup, :teardown
+      def self.prepended(klass)
+        klass.include ActiveSupport::Callbacks
+        klass.define_callbacks :setup, :teardown
+        klass.extend ClassMethods
       end
 
       module ClassMethods
@@ -42,7 +42,12 @@ module ActiveSupport
       end
 
       def after_teardown # :nodoc:
-        run_callbacks :teardown
+        begin
+          run_callbacks :teardown
+        rescue => e
+          self.failures << Minitest::UnexpectedError.new(e)
+        end
+
         super
       end
     end

data/lib/active_support/testing/stream.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 module ActiveSupport
   module Testing
-    module Stream #:nodoc:
+    module Stream # :nodoc:
       private
-
         def silence_stream(stream)
           old_stream = stream.dup
           stream.reopen(IO::NULL)
@@ -13,11 +14,9 @@ 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
 
@@ -31,7 +30,7 @@ module ActiveSupport
           yield
 
           stream_io.rewind
-          return captured_stream.read
+          captured_stream.read
         ensure
           captured_stream.close
           captured_stream.unlink

data/lib/active_support/testing/tagged_logging.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 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