activesupport 4.2.0 → 5.2.0

data/lib/active_support/testing/autorun.rb

@@ -1,5 +1,7 @@
-gem 'minitest'
+# frozen_string_literal: true
 
-require 'minitest'
+gem "minitest"
+
+require "minitest"
 
 Minitest.autorun

data/lib/active_support/testing/constant_lookup.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/concern"
 require "active_support/inflector"
 
@@ -44,7 +46,6 @@ module ActiveSupport
           end
         end
       end
-
     end
   end
 end

data/lib/active_support/testing/declarative.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveSupport
   module Testing
     module Declarative
@@ -9,7 +11,7 @@ module ActiveSupport
         #     ...
         #   end
         def test(name, &block)
-          test_name = "test_#{name.gsub(/\s+/,'_')}".to_sym
+          test_name = "test_#{name.gsub(/\s+/, '_')}".to_sym
           defined = method_defined? test_name
           raise "#{test_name} is already defined in #{self}" if defined
           if block_given?

data/lib/active_support/testing/deprecation.rb

@@ -1,34 +1,38 @@
-require 'active_support/deprecation'
+# frozen_string_literal: true
+
+require "active_support/deprecation"
+require "active_support/core_ext/regexp"
 
 module ActiveSupport
   module Testing
     module Deprecation #:nodoc:
-      def assert_deprecated(match = nil, &block)
-        result, warnings = collect_deprecations(&block)
+      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"
         if match
           match = Regexp.new(Regexp.escape(match)) unless match.is_a?(Regexp)
-          assert warnings.any? { |w| w =~ match }, "No deprecation warning matched #{match}: #{warnings.join(', ')}"
+          assert warnings.any? { |w| match.match?(w) }, "No deprecation warning matched #{match}: #{warnings.join(', ')}"
         end
         result
       end
 
-      def assert_not_deprecated(&block)
-        result, deprecations = collect_deprecations(&block)
+      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
 
-      def collect_deprecations
-        old_behavior = ActiveSupport::Deprecation.behavior
+      def collect_deprecations(deprecator = nil)
+        deprecator ||= ActiveSupport::Deprecation
+        old_behavior = deprecator.behavior
         deprecations = []
-        ActiveSupport::Deprecation.behavior = Proc.new do |message, callstack|
+        deprecator.behavior = Proc.new do |message, callstack|
           deprecations << message
         end
         result = yield
         [result, deprecations]
       ensure
-        ActiveSupport::Deprecation.behavior = old_behavior
+        deprecator.behavior = old_behavior
       end
     end
   end

data/lib/active_support/testing/file_fixtures.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module Testing
+    # Adds simple access to sample files called file fixtures.
+    # File fixtures are normal files stored in
+    # <tt>ActiveSupport::TestCase.file_fixture_path</tt>.
+    #
+    # File fixtures are represented as +Pathname+ objects.
+    # This makes it easy to extract specific information:
+    #
+    #   file_fixture("example.txt").read # get the file's content
+    #   file_fixture("example.mp3").size # get the file size
+    module FileFixtures
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :file_fixture_path, instance_writer: false
+      end
+
+      # Returns a +Pathname+ to the fixture file named +fixture_name+.
+      #
+      # Raises +ArgumentError+ if +fixture_name+ can't be found.
+      def file_fixture(fixture_name)
+        path = Pathname.new(File.join(file_fixture_path, fixture_name))
+
+        if path.exist?
+          path
+        else
+          msg = "the directory '%s' does not contain a file named '%s'"
+          raise ArgumentError, msg % [file_fixture_path, fixture_name]
+        end
+      end
+    end
+  end
+end

data/lib/active_support/testing/isolation.rb

@@ -1,9 +1,9 @@
-require 'rbconfig'
+# frozen_string_literal: true
 
 module ActiveSupport
   module Testing
     module Isolation
-      require 'thread'
+      require "thread"
 
       def self.included(klass) #:nodoc:
         klass.class_eval do
@@ -12,18 +12,7 @@ module ActiveSupport
       end
 
       def self.forking_env?
-        !ENV["NO_FORK"] && ((RbConfig::CONFIG['host_os'] !~ /mswin|mingw/) && (RUBY_PLATFORM !~ /java/))
-      end
-
-      @@class_setup_mutex = Mutex.new
-
-      def _run_class_setup      # class setup method should only happen in parent
-        @@class_setup_mutex.synchronize do
-          unless defined?(@@ran_class_setup) || ENV['ISOLATION_TEST']
-            self.class.setup if self.class.respond_to?(:setup)
-            @@ran_class_setup = true
-          end
-        end
+        !ENV["NO_FORK"] && Process.respond_to?(:fork)
       end
 
       def run
@@ -43,14 +32,31 @@ module ActiveSupport
           pid = fork do
             read.close
             yield
-            write.puts [Marshal.dump(self.dup)].pack("m")
+            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
+
+            write.puts [result].pack("m")
             exit!
           end
 
           write.close
           result = read.read
           Process.wait2(pid)
-          return result.unpack("m")[0]
+          result.unpack("m")[0]
         end
       end
 
@@ -64,24 +70,27 @@ module ActiveSupport
 
           if ENV["ISOLATION_TEST"]
             yield
+            test_result = defined?(Minitest::Result) ? Minitest::Result.from(self) : dup
             File.open(ENV["ISOLATION_OUTPUT"], "w") do |file|
-              file.puts [Marshal.dump(self.dup)].pack("m")
+              file.puts [Marshal.dump(test_result)].pack("m")
             end
             exit!
           else
             Tempfile.open("isolation") do |tmpfile|
               env = {
-                ISOLATION_TEST: self.class.name,
-                ISOLATION_OUTPUT: tmpfile.path
+                "ISOLATION_TEST" => self.class.name,
+                "ISOLATION_OUTPUT" => tmpfile.path
               }
 
-              load_paths = $-I.map {|p| "-I\"#{File.expand_path(p)}\"" }.join(" ")
-              orig_args = ORIG_ARGV.join(" ")
-              test_opts = "-n#{self.class.name}##{self.name}"
-              command = "#{Gem.ruby} #{load_paths} #{$0} #{orig_args} #{test_opts}"
+              test_opts = "-n#{self.class.name}##{name}"
+
+              load_path_args = []
+              $-I.each do |p|
+                load_path_args << "-I"
+                load_path_args << File.expand_path(p)
+              end
 
-              # IO.popen lets us pass env in a cross-platform way
-              child = IO.popen([env, command])
+              child = IO.popen([env, Gem.ruby, *load_path_args, $0, *ORIG_ARGV, test_opts])
 
               begin
                 Process.wait(child.pid)

data/lib/active_support/testing/method_call_assertions.rb

@@ -0,0 +1,43 @@
+# 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 stub_any_instance(klass, instance: klass.new)
+          klass.stub(:new, instance) { yield instance }
+        end
+    end
+  end
+end

data/lib/active_support/testing/setup_and_teardown.rb

@@ -1,5 +1,7 @@
-require 'active_support/concern'
-require 'active_support/callbacks'
+# frozen_string_literal: true
+
+require "active_support/concern"
+require "active_support/callbacks"
 
 module ActiveSupport
   module Testing
@@ -42,8 +44,15 @@ module ActiveSupport
       end
 
       def after_teardown # :nodoc:
-        run_callbacks :teardown
+        begin
+          run_callbacks :teardown
+        rescue => e
+          error = e
+        end
+
         super
+      ensure
+        raise error if error
       end
     end
   end

data/lib/active_support/testing/stream.rb

@@ -0,0 +1,44 @@
+# 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
+          return 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,53 +1,71 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/redefine_method"
+require "active_support/core_ext/string/strip" # for strip_heredoc
+require "active_support/core_ext/time/calculations"
+require "concurrent/map"
+
 module ActiveSupport
   module Testing
     class SimpleStubs # :nodoc:
       Stub = Struct.new(:object, :method_name, :original_method)
 
       def initialize
-        @stubs = {}
+        @stubs = Concurrent::Map.new { |h, k| h[k] = {} }
       end
 
-      def stub_object(object, method_name, return_value)
-        key = [object.object_id, method_name]
-
-        if stub = @stubs[key]
+      def stub_object(object, method_name, &block)
+        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.define_singleton_method(method_name) { return_value }
+        object.define_singleton_method(method_name, &block)
       end
 
       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
+
+      def stubbing(object, method_name)
+        @stubs[object.object_id][method_name]
       end
 
       private
 
         def unstub_object(stub)
           singleton_class = stub.object.singleton_class
-          singleton_class.send :undef_method, stub.method_name
+          singleton_class.send :silence_redefinition_of_method, stub.method_name
           singleton_class.send :alias_method, stub.method_name, stub.original_method
           singleton_class.send :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+ and +Date.today+.
+      # 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
+      #   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
+      #   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:
@@ -61,13 +79,15 @@ module ActiveSupport
         travel_to Time.now + duration, &block
       end
 
-      # Changes current time to the given time by stubbing +Time.now+ and
-      # +Date.today+ to return the time or date passed into this method.
+      # 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)
-      #   Time.current # => Wed, 24 Nov 2004 01:04:44 EST -05:00
-      #   Date.current # => Wed, 24 Nov 2004
+      #   Time.current     # => Sat, 09 Nov 2013 15:34:49 EST -05:00
+      #   travel_to Time.zone.local(2004, 11, 24, 01, 04, 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,
@@ -86,19 +106,48 @@ 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, 01, 04, 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.strip_heredoc
+
+      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
           now = date_or_time.to_time.change(usec: 0)
         end
 
-        simple_stubs.stub_object(Time, :now, now)
-        simple_stubs.stub_object(Date, :today, now.to_date)
+        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
@@ -110,10 +159,10 @@ module ActiveSupport
       end
 
       # Returns the current time back to its original state, by removing the stubs added by
-      # `travel` and `travel_to`.
+      # +travel+ and +travel_to+.
       #
       #   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, 01, 04, 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
@@ -121,6 +170,26 @@ module ActiveSupport
         simple_stubs.unstub_all!
       end
 
+      # 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