activesupport 5.2.0 → 6.0.3.2

data/lib/active_support/tagged_logging.rb

@@ -46,21 +46,30 @@ module ActiveSupport
 
       def current_tags
         # We use our object ID here to avoid conflicting with other instances
-        thread_key = @thread_key ||= "activesupport_tagged_logging_tags:#{object_id}".freeze
+        thread_key = @thread_key ||= "activesupport_tagged_logging_tags:#{object_id}"
         Thread.current[thread_key] ||= []
       end
 
       def tags_text
         tags = current_tags
-        if tags.any?
+        if tags.one?
+          "[#{tags[0]}] "
+        elsif tags.any?
           tags.collect { |tag| "[#{tag}] " }.join
         end
       end
     end
 
     def self.new(logger)
-      # Ensure we set a default formatter so we aren't extending nil!
-      logger.formatter ||= ActiveSupport::Logger::SimpleFormatter.new
+      logger = logger.dup
+
+      if logger.formatter
+        logger.formatter = logger.formatter.dup
+      else
+        # Ensure we set a default formatter so we aren't extending nil!
+        logger.formatter = ActiveSupport::Logger::SimpleFormatter.new
+      end
+
       logger.formatter.extend Formatter
       logger.extend(self)
     end

data/lib/active_support/test_case.rb

@@ -11,6 +11,8 @@ require "active_support/testing/isolation"
 require "active_support/testing/constant_lookup"
 require "active_support/testing/time_helpers"
 require "active_support/testing/file_fixtures"
+require "active_support/testing/parallelization"
+require "concurrent/utility/processor_counter"
 
 module ActiveSupport
   class TestCase < ::Minitest::Test
@@ -39,12 +41,101 @@ module ActiveSupport
       def test_order
         ActiveSupport.test_order ||= :random
       end
+
+      # Parallelizes the test suite.
+      #
+      # Takes a +workers+ argument that controls how many times the process
+      # is forked. For each process a new database will be created suffixed
+      # with the worker number.
+      #
+      #   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
+      # environments, or other environments where you may need more workers than
+      # you do for local testing.
+      #
+      # If the number of workers is set to +1+ or fewer, the tests will not be
+      # parallelized.
+      #
+      # If +workers+ is set to +:number_of_processors+, the number of workers will be
+      # set to the actual core count on the machine you are on.
+      #
+      # 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.
+      #
+      #   parallelize(workers: :number_of_processors, with: :threads)
+      #
+      # The threaded parallelization uses minitest's parallel executor directly.
+      # The processes parallelization uses a Ruby DRb server.
+      def parallelize(workers: :number_of_processors, with: :processes)
+        workers = Concurrent.physical_processor_count if workers == :number_of_processors
+        workers = ENV["PARALLEL_WORKERS"].to_i if ENV["PARALLEL_WORKERS"]
+
+        return if workers <= 1
+
+        executor = case with
+                   when :processes
+                     Testing::Parallelization.new(workers)
+                   when :threads
+                     Minitest::Parallel::Executor.new(workers)
+                   else
+                     raise ArgumentError, "#{with} is not a supported parallelization executor."
+        end
+
+        self.lock_threads = false if defined?(self.lock_threads) && with == :threads
+
+        Minitest.parallel_executor = executor
+
+        parallelize_me!
+      end
+
+      # Set up 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.
+      #
+      # Note: this feature is not available with the threaded parallelization.
+      #
+      # In your +test_helper.rb+ add the following:
+      #
+      #   class ActiveSupport::TestCase
+      #     parallelize_setup do
+      #       # create databases
+      #     end
+      #   end
+      def parallelize_setup(&block)
+        ActiveSupport::Testing::Parallelization.after_fork_hook do |worker|
+          yield worker
+        end
+      end
+
+      # Clean up hook for parallel testing. This can be used to drop databases
+      # if your app uses multiple write/read databases or other clean up before
+      # the tests finish. This runs before the forked process is closed.
+      #
+      # Note: this feature is not available with the threaded parallelization.
+      #
+      # In your +test_helper.rb+ add the following:
+      #
+      #   class ActiveSupport::TestCase
+      #     parallelize_teardown do
+      #       # drop databases
+      #     end
+      #   end
+      def parallelize_teardown(&block)
+        ActiveSupport::Testing::Parallelization.run_cleanup_hook do |worker|
+          yield worker
+        end
+      end
     end
 
     alias_method :method_name, :name
 
     include ActiveSupport::Testing::TaggedLogging
-    include ActiveSupport::Testing::SetupAndTeardown
+    prepend ActiveSupport::Testing::SetupAndTeardown
     include ActiveSupport::Testing::Assertions
     include ActiveSupport::Testing::Deprecation
     include ActiveSupport::Testing::TimeHelpers

data/lib/active_support/testing/assertions.rb

@@ -113,11 +113,23 @@ module ActiveSupport
       #     post :create, params: { article: invalid_attributes }
       #   end
       #
+      # A lambda can be passed in and evaluated.
+      #
+      #   assert_no_difference -> { Article.count } do
+      #     post :create, params: { article: invalid_attributes }
+      #   end
+      #
       # An error message can be specified.
       #
       #   assert_no_difference 'Article.count', 'An Article should not be created' do
       #     post :create, params: { article: invalid_attributes }
       #   end
+      #
+      # An array of expressions can also be passed in and evaluated.
+      #
+      #   assert_no_difference [ 'Article.count', -> { Post.count } ] do
+      #     post :create, params: { article: invalid_attributes }
+      #   end
       def assert_no_difference(expression, message = nil, &block)
         assert_difference expression, 0, message, &block
       end
@@ -176,7 +188,9 @@ module ActiveSupport
         assert before != after, error
 
         unless to == UNTRACKED
-          error = "#{expression.inspect} didn't change to #{to}"
+          error = "#{expression.inspect} didn't change to as expected\n"
+          error = "#{error}Expected: #{to.inspect}\n"
+          error = "#{error}  Actual: #{after.inspect}"
           error = "#{message}.\n#{error}" if message
           assert to === after, error
         end

data/lib/active_support/testing/deprecation.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "active_support/deprecation"
-require "active_support/core_ext/regexp"
 
 module ActiveSupport
   module Testing

data/lib/active_support/testing/file_fixtures.rb

@@ -1,5 +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

@@ -56,7 +56,7 @@ module ActiveSupport
           write.close
           result = read.read
           Process.wait2(pid)
-          result.unpack("m")[0]
+          result.unpack1("m")
         end
       end
 
@@ -98,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

@@ -17,7 +17,7 @@ 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)
           mock = Minitest::Mock.new
 
           if args.all? { |arg| arg.is_a?(Array) }
@@ -35,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.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "drb"
+require "drb/unix" unless Gem.win_platform?
+require "active_support/core_ext/module/attribute_accessors"
+
+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)
+        @@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(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
+      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
+        end
+      end
+
+      def <<(work)
+        @queue << 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
+      end
+
+      private
+        def add_setup_exception(result, setup_exception)
+          result.failures.prepend Minitest::UnexpectedError.new(setup_exception)
+        end
+    end
+  end
+end

data/lib/active_support/testing/setup_and_teardown.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/concern"
 require "active_support/callbacks"
 
 module ActiveSupport
@@ -19,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
@@ -47,12 +45,10 @@ module ActiveSupport
         begin
           run_callbacks :teardown
         rescue => e
-          error = e
+          self.failures << Minitest::UnexpectedError.new(e)
         end
 
         super
-      ensure
-        raise error if error
       end
     end
   end

data/lib/active_support/testing/stream.rb

@@ -4,7 +4,6 @@ module ActiveSupport
   module Testing
     module Stream #:nodoc:
       private
-
         def silence_stream(stream)
           old_stream = stream.dup
           stream.reopen(IO::NULL)
@@ -33,7 +32,7 @@ module ActiveSupport
           yield
 
           stream_io.rewind
-          return captured_stream.read
+          captured_stream.read
         ensure
           captured_stream.close
           captured_stream.unlink