activesupport 4.2.11.1 → 6.1.7.3

data/lib/active_support/testing/method_call_assertions.rb

@@ -0,0 +1,70 @@
+# 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)
+          times_called = 0
+
+          object.stub(method_name, proc { times_called += 1; returns }) { 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
+        end
+
+        def assert_called_with(object, method_name, args, returns: nil)
+          mock = Minitest::Mock.new
+
+          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 }
+
+          mock.verify
+        end
+
+        def assert_not_called(object, method_name, message = nil, &block)
+          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
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# 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 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,100 @@
+# 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)
+          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,51 @@
+# 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 shutdown
+        @queue_server.shutdown
+        @worker_pool.each { |pid| Process.waitpid pid }
+      end
+    end
+  end
+end

data/lib/active_support/testing/setup_and_teardown.rb

@@ -1,5 +1,6 @@
-require 'active_support/concern'
-require 'active_support/callbacks'
+# frozen_string_literal: true
+
+require "active_support/callbacks"
 
 module ActiveSupport
   module Testing
@@ -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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module Testing
+    module Stream #:nodoc:
+      private
+        def silence_stream(stream)
+          old_stream = stream.dup
+          stream.reopen(IO::NULL)
+          stream.sync = true
+          yield
+        ensure
+          stream.reopen(old_stream)
+          old_stream.close
+        end
+
+        def quietly
+          silence_stream(STDOUT) do
+            silence_stream(STDERR) do
+              yield
+            end
+          end
+        end
+
+        def capture(stream)
+          stream = stream.to_s
+          captured_stream = Tempfile.new(stream)
+          stream_io = eval("$#{stream}")
+          origin_stream = stream_io.dup
+          stream_io.reopen(captured_stream)
+
+          yield
+
+          stream_io.rewind
+          captured_stream.read
+        ensure
+          captured_stream.close
+          captured_stream.unlink
+          stream_io.reopen(origin_stream)
+        end
+    end
+  end
+end

data/lib/active_support/testing/tagged_logging.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveSupport
   module Testing
     # Logs a "PostsControllerTest: test name" heading before each test to
@@ -8,7 +10,7 @@ module ActiveSupport
       def before_setup
         if tagged_logger && tagged_logger.info?
           heading = "#{self.class}: #{name}"
-          divider = '-' * heading.size
+          divider = "-" * heading.size
           tagged_logger.info divider
           tagged_logger.info heading
           tagged_logger.info divider

data/lib/active_support/testing/time_helpers.rb

@@ -1,48 +1,80 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/redefine_method"
+require "active_support/core_ext/time/calculations"
+require "concurrent/map"
+
 module ActiveSupport
   module Testing
+    # Manages stubs for TimeHelpers
     class SimpleStubs # :nodoc:
       Stub = Struct.new(:object, :method_name, :original_method)
 
       def initialize
-        @stubs = {}
+        @stubs = Concurrent::Map.new { |h, k| h[k] = {} }
       end
 
+      # Stubs object.method_name with the given block
+      # If the method is already stubbed, remove that stub
+      # so that removing this stub will restore the original implementation.
+      #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
+      #   target = Time.zone.local(2004, 11, 24, 1, 4, 44)
+      #   simple_stubs.stub_object(Time, :now) { at(target.to_i) }
+      #   Time.current # => Wed, 24 Nov 2004 01:04:44 EST -05:00
       def stub_object(object, method_name, &block)
-        key = [object.object_id, method_name]
-
-        if stub = @stubs[key]
+        if stub = stubbing(object, method_name)
           unstub_object(stub)
         end
 
         new_name = "__simple_stub__#{method_name}"
 
-        @stubs[key] = Stub.new(object, method_name, new_name)
+        @stubs[object.object_id][method_name] = Stub.new(object, method_name, new_name)
 
-        object.singleton_class.send :alias_method, new_name, method_name
+        object.singleton_class.alias_method new_name, method_name
         object.define_singleton_method(method_name, &block)
       end
 
+      # Remove all object-method stubs held by this instance
       def unstub_all!
-        @stubs.each_value do |stub|
-          unstub_object(stub)
+        @stubs.each_value do |object_stubs|
+          object_stubs.each_value do |stub|
+            unstub_object(stub)
+          end
         end
-        @stubs = {}
+        @stubs.clear
       end
 
-      private
+      # Returns the Stub for object#method_name
+      # (nil if it is not stubbed)
+      def stubbing(object, method_name)
+        @stubs[object.object_id][method_name]
+      end
+
+      # Returns true if any stubs are set, false if there are none
+      def stubbed?
+        !@stubs.empty?
+      end
 
+      private
+        # Restores the original object.method described by the Stub
         def unstub_object(stub)
           singleton_class = stub.object.singleton_class
-          singleton_class.send :undef_method, stub.method_name
-          singleton_class.send :alias_method, stub.method_name, stub.original_method
-          singleton_class.send :undef_method, stub.original_method
+          singleton_class.silence_redefinition_of_method stub.method_name
+          singleton_class.alias_method stub.method_name, stub.original_method
+          singleton_class.undef_method stub.original_method
         end
     end
 
-    # Containing helpers that helps you test passage of time.
+    # Contains helpers that help you test passage of time.
     module TimeHelpers
+      def after_teardown
+        travel_back
+        super
+      end
+
       # Changes current time to the time in the future or in the past by a given time difference by
-      # stubbing +Time.now+, +Date.today+, and +DateTime.now+.
+      # stubbing +Time.now+, +Date.today+, and +DateTime.now+. The stubs are automatically removed
+      # at the end of the test.
       #
       #   Time.current     # => Sat, 09 Nov 2013 15:34:49 EST -05:00
       #   travel 1.day
@@ -64,9 +96,10 @@ module ActiveSupport
 
       # Changes current time to the given time by stubbing +Time.now+,
       # +Date.today+, and +DateTime.now+ to return the time or date passed into this method.
+      # The stubs are automatically removed at the end of the test.
       #
       #   Time.current     # => Sat, 09 Nov 2013 15:34:49 EST -05:00
-      #   travel_to Time.new(2004, 11, 24, 01, 04, 44)
+      #   travel_to Time.zone.local(2004, 11, 24, 1, 4, 44)
       #   Time.current     # => Wed, 24 Nov 2004 01:04:44 EST -05:00
       #   Date.current     # => Wed, 24 Nov 2004
       #   DateTime.current # => Wed, 24 Nov 2004 01:04:44 -0500
@@ -88,11 +121,39 @@ module ActiveSupport
       # state at the end of the block:
       #
       #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
-      #   travel_to Time.new(2004, 11, 24, 01, 04, 44) do
+      #   travel_to Time.zone.local(2004, 11, 24, 1, 4, 44) do
       #     Time.current # => Wed, 24 Nov 2004 01:04:44 EST -05:00
       #   end
       #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
       def travel_to(date_or_time)
+        if block_given? && simple_stubs.stubbing(Time, :now)
+          travel_to_nested_block_call = <<~MSG
+
+      Calling `travel_to` with a block, when we have previously already made a call to `travel_to`, can lead to confusing time stubbing.
+
+      Instead of:
+
+         travel_to 2.days.from_now do
+           # 2 days from today
+           travel_to 3.days.from_now do
+             # 5 days from today
+           end
+         end
+
+      preferred way to achieve above is:
+
+         travel 2.days do
+           # 2 days from today
+         end
+
+         travel 5.days do
+           # 5 days from today
+         end
+
+          MSG
+          raise travel_to_nested_block_call
+        end
+
         if date_or_time.is_a?(Date) && !date_or_time.is_a?(DateTime)
           now = date_or_time.midnight.to_time
         else
@@ -113,19 +174,59 @@ module ActiveSupport
       end
 
       # Returns the current time back to its original state, by removing the stubs added by
-      # `travel` and `travel_to`.
+      # +travel+, +travel_to+, and +freeze_time+.
       #
       #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
-      #   travel_to Time.new(2004, 11, 24, 01, 04, 44)
+      #
+      #   travel_to Time.zone.local(2004, 11, 24, 1, 4, 44)
       #   Time.current # => Wed, 24 Nov 2004 01:04:44 EST -05:00
+      #
       #   travel_back
       #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
+      #
+      # This method also accepts a block, which brings the stubs back at the end of the block:
+      #
+      #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
+      #
+      #   travel_to Time.zone.local(2004, 11, 24, 1, 4, 44)
+      #   Time.current # => Wed, 24 Nov 2004 01:04:44 EST -05:00
+      #
+      #   travel_back do
+      #     Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
+      #   end
+      #
+      #   Time.current # => Wed, 24 Nov 2004 01:04:44 EST -05:00
       def travel_back
+        stubbed_time = Time.current if block_given? && simple_stubs.stubbed?
+
         simple_stubs.unstub_all!
+        yield if block_given?
+      ensure
+        travel_to stubbed_time if stubbed_time
       end
+      alias_method :unfreeze_time, :travel_back
 
-      private
+      # Calls +travel_to+ with +Time.now+.
+      #
+      #   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
+      #
+      # This method also accepts a block, which will return the current time back to its original
+      # state at the end of the block:
+      #
+      #   Time.current # => Sun, 09 Jul 2017 15:34:49 EST -05:00
+      #   freeze_time do
+      #     sleep(1)
+      #     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(&block)
+        travel_to Time.now, &block
+      end
 
+      private
         def simple_stubs
           @simple_stubs ||= SimpleStubs.new
         end

data/lib/active_support/time.rb

@@ -1,18 +1,20 @@
+# frozen_string_literal: true
+
 module ActiveSupport
-  autoload :Duration, 'active_support/duration'
-  autoload :TimeWithZone, 'active_support/time_with_zone'
-  autoload :TimeZone, 'active_support/values/time_zone'
+  autoload :Duration, "active_support/duration"
+  autoload :TimeWithZone, "active_support/time_with_zone"
+  autoload :TimeZone, "active_support/values/time_zone"
 end
 
-require 'date'
-require 'time'
+require "date"
+require "time"
 
-require 'active_support/core_ext/time'
-require 'active_support/core_ext/date'
-require 'active_support/core_ext/date_time'
+require "active_support/core_ext/time"
+require "active_support/core_ext/date"
+require "active_support/core_ext/date_time"
 
-require 'active_support/core_ext/integer/time'
-require 'active_support/core_ext/numeric/time'
+require "active_support/core_ext/integer/time"
+require "active_support/core_ext/numeric/time"
 
-require 'active_support/core_ext/string/conversions'
-require 'active_support/core_ext/string/zones'
+require "active_support/core_ext/string/conversions"
+require "active_support/core_ext/string/zones"