activesupport 4.0.12 → 7.0.2.4

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,33 +1,53 @@
-require 'active_support/concern'
-require 'active_support/callbacks'
+# frozen_string_literal: true
+
+require "active_support/callbacks"
 
 module ActiveSupport
   module Testing
+    # Adds support for +setup+ and +teardown+ callbacks.
+    # These callbacks serve as a replacement to overwriting the
+    # <tt>#setup</tt> and <tt>#teardown</tt> methods of your TestCase.
+    #
+    #   class ExampleTest < ActiveSupport::TestCase
+    #     setup do
+    #       # ...
+    #     end
+    #
+    #     teardown do
+    #       # ...
+    #     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
+        # Add a callback, which runs before <tt>TestCase#setup</tt>.
         def setup(*args, &block)
           set_callback(:setup, :before, *args, &block)
         end
 
+        # Add a callback, which runs after <tt>TestCase#teardown</tt>.
         def teardown(*args, &block)
           set_callback(:teardown, :after, *args, &block)
         end
       end
 
-      def before_setup
+      def before_setup # :nodoc:
         super
         run_callbacks :setup
       end
 
-      def after_teardown
-        run_callbacks :teardown
+      def after_teardown # :nodoc:
+        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,41 @@
+# 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(&block)
+          silence_stream(STDOUT) do
+            silence_stream(STDERR, &block)
+          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,14 +1,16 @@
+# 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
-        if tagged_logger
-          heading = "#{self.class}: #{__name__}"
-          divider = '-' * heading.size
+        if tagged_logger && tagged_logger.info?
+          heading = "#{self.class}: #{name}"
+          divider = "-" * heading.size
           tagged_logger.info divider
           tagged_logger.info heading
           tagged_logger.info divider

data/lib/active_support/testing/time_helpers.rb

@@ -0,0 +1,246 @@
+# 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 = 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)
+        if stub = stubbing(object, method_name)
+          unstub_object(stub)
+        end
+
+        new_name = "__simple_stub__#{method_name}"
+
+        @stubs[object.object_id][method_name] = Stub.new(object, method_name, new_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 |object_stubs|
+          object_stubs.each_value do |stub|
+            unstub_object(stub)
+          end
+        end
+        @stubs.clear
+      end
+
+      # 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.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
+
+    # 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+. 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
+      #   Time.current     # => Sun, 10 Nov 2013 15:34:49 EST -05:00
+      #   Date.current     # => Sun, 10 Nov 2013
+      #   DateTime.current # => Sun, 10 Nov 2013 15:34:49 -0500
+      #
+      # 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 # => Sat, 09 Nov 2013 15:34:49 EST -05:00
+      #   travel 1.day do
+      #     User.create.created_at # => Sun, 10 Nov 2013 15:34:49 EST -05:00
+      #   end
+      #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
+      def travel(duration, &block)
+        travel_to Time.now + duration, &block
+      end
+
+      # 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.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
+      #
+      # Dates are taken as their timestamp at the beginning of the day in the
+      # application time zone. <tt>Time.current</tt> returns said timestamp,
+      # and <tt>Time.now</tt> its equivalent in the system time zone. Similarly,
+      # <tt>Date.current</tt> returns a date equal to the argument, and
+      # <tt>Date.today</tt> the date according to <tt>Time.now</tt>, which may
+      # be different. (Note that you rarely want to deal with <tt>Time.now</tt>,
+      # or <tt>Date.today</tt>, in order to honor the application time zone
+      # please always use <tt>Time.current</tt> and <tt>Date.current</tt>.)
+      #
+      # Note that the usec for the time passed will be set to 0 to prevent rounding
+      # errors with external services, like MySQL (which will round instead of floor,
+      # leading to off-by-one-second errors).
+      #
+      # 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 # => Sat, 09 Nov 2013 15:34:49 EST -05:00
+      #   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? && in_block
+          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
+        elsif date_or_time.is_a?(String)
+          now = Time.zone.parse(date_or_time)
+        else
+          now = date_or_time.to_time.change(usec: 0)
+        end
+
+        stubbed_time = Time.now if simple_stubs.stubbing(Time, :now)
+        simple_stubs.stub_object(Time, :now) { at(now.to_i) }
+        simple_stubs.stub_object(Date, :today) { jd(now.to_date.jd) }
+        simple_stubs.stub_object(DateTime, :now) { jd(now.to_date.jd, now.hour, now.min, now.sec, Rational(now.utc_offset, 86400)) }
+
+        if block_given?
+          begin
+            self.in_block = true
+            yield
+          ensure
+            if stubbed_time
+              travel_to stubbed_time
+            else
+              travel_back
+            end
+            self.in_block = false
+          end
+        end
+      end
+
+      # Returns the current time back to its original state, by removing the stubs added by
+      # +travel+, +travel_to+, and +freeze_time+.
+      #
+      #   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
+      #   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
+
+      # 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
+
+        attr_accessor :in_block
+    end
+  end
+end

data/lib/active_support/time.rb

@@ -1,20 +1,20 @@
-require 'active_support'
+# 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"