activesupport 4.2.11.1 → 5.2.4

data/lib/active_support/testing/assertions.rb

@@ -1,9 +1,11 @@
-require 'active_support/core_ext/object/blank'
+# frozen_string_literal: true
 
 module ActiveSupport
   module Testing
     module Assertions
-      # Assert that an expression is not truthy. Passes if <tt>object</tt> is
+      UNTRACKED = Object.new # :nodoc:
+
+      # Asserts that an expression is not truthy. Passes if <tt>object</tt> is
       # +nil+ or +false+. "Truthy" means "considered true in a conditional"
       # like <tt>if foo</tt>.
       #
@@ -19,79 +21,194 @@ module ActiveSupport
         assert !object, message
       end
 
+      # Assertion that the block should not raise an exception.
+      #
+      # Passes if evaluated code in the yielded block raises no exception.
+      #
+      #   assert_nothing_raised do
+      #     perform_service(param: 'no_exception')
+      #   end
+      def assert_nothing_raised
+        yield
+      end
+
       # Test numeric difference between the return value of an expression as a
       # result of what is evaluated in the yielded block.
       #
       #   assert_difference 'Article.count' do
-      #     post :create, article: {...}
+      #     post :create, params: { article: {...} }
       #   end
       #
       # An arbitrary expression is passed in and evaluated.
       #
-      #   assert_difference 'assigns(:article).comments(:reload).size' do
-      #     post :create, comment: {...}
+      #   assert_difference 'Article.last.comments(:reload).size' do
+      #     post :create, params: { comment: {...} }
       #   end
       #
       # An arbitrary positive or negative difference can be specified.
       # The default is <tt>1</tt>.
       #
       #   assert_difference 'Article.count', -1 do
-      #     post :delete, id: ...
+      #     post :delete, params: { id: ... }
       #   end
       #
       # An array of expressions can also be passed in and evaluated.
       #
       #   assert_difference [ 'Article.count', 'Post.count' ], 2 do
-      #     post :create, article: {...}
+      #     post :create, params: { article: {...} }
+      #   end
+      #
+      # A hash of expressions/numeric differences can also be passed in and evaluated.
+      #
+      #   assert_difference ->{ Article.count } => 1, ->{ Notification.count } => 2 do
+      #     post :create, params: { article: {...} }
       #   end
       #
       # A lambda or a list of lambdas can be passed in and evaluated:
       #
       #   assert_difference ->{ Article.count }, 2 do
-      #     post :create, article: {...}
+      #     post :create, params: { article: {...} }
       #   end
       #
       #   assert_difference [->{ Article.count }, ->{ Post.count }], 2 do
-      #     post :create, article: {...}
+      #     post :create, params: { article: {...} }
       #   end
       #
       # An error message can be specified.
       #
       #   assert_difference 'Article.count', -1, 'An Article should be destroyed' do
-      #     post :delete, id: ...
+      #     post :delete, params: { id: ... }
       #   end
-      def assert_difference(expression, difference = 1, message = nil, &block)
-        expressions = Array(expression)
+      def assert_difference(expression, *args, &block)
+        expressions =
+          if expression.is_a?(Hash)
+            message = args[0]
+            expression
+          else
+            difference = args[0] || 1
+            message = args[1]
+            Hash[Array(expression).map { |e| [e, difference] }]
+          end
 
-        exps = expressions.map { |e|
+        exps = expressions.keys.map { |e|
           e.respond_to?(:call) ? e : lambda { eval(e, block.binding) }
         }
-        before = exps.map { |e| e.call }
+        before = exps.map(&:call)
 
-        yield
+        retval = yield
 
-        expressions.zip(exps).each_with_index do |(code, e), i|
-          error  = "#{code.inspect} didn't change by #{difference}"
+        expressions.zip(exps, before) do |(code, diff), exp, before_value|
+          error  = "#{code.inspect} didn't change by #{diff}"
           error  = "#{message}.\n#{error}" if message
-          assert_equal(before[i] + difference, e.call, error)
+          assert_equal(before_value + diff, exp.call, error)
         end
+
+        retval
       end
 
       # Assertion that the numeric result of evaluating an expression is not
       # changed before and after invoking the passed in block.
       #
       #   assert_no_difference 'Article.count' do
-      #     post :create, article: invalid_attributes
+      #     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, article: invalid_attributes
+      #     post :create, params: { article: invalid_attributes }
       #   end
       def assert_no_difference(expression, message = nil, &block)
         assert_difference expression, 0, message, &block
       end
+
+      # Assertion that the result of evaluating an expression is changed before
+      # and after invoking the passed in block.
+      #
+      #   assert_changes 'Status.all_good?' do
+      #     post :create, params: { status: { ok: false } }
+      #   end
+      #
+      # You can pass the block as a string to be evaluated in the context of
+      # the block. A lambda can be passed for the block as well.
+      #
+      #   assert_changes -> { Status.all_good? } do
+      #     post :create, params: { status: { ok: false } }
+      #   end
+      #
+      # The assertion is useful to test side effects. The passed block can be
+      # anything that can be converted to string with #to_s.
+      #
+      #   assert_changes :@object do
+      #     @object = 42
+      #   end
+      #
+      # The keyword arguments :from and :to can be given to specify the
+      # expected initial value and the expected value after the block was
+      # executed.
+      #
+      #   assert_changes :@object, from: nil, to: :foo do
+      #     @object = :foo
+      #   end
+      #
+      # An error message can be specified.
+      #
+      #   assert_changes -> { Status.all_good? }, 'Expected the status to be bad' do
+      #     post :create, params: { status: { incident: true } }
+      #   end
+      def assert_changes(expression, message = nil, from: UNTRACKED, to: UNTRACKED, &block)
+        exp = expression.respond_to?(:call) ? expression : -> { eval(expression.to_s, block.binding) }
+
+        before = exp.call
+        retval = yield
+
+        unless from == UNTRACKED
+          error = "#{expression.inspect} isn't #{from.inspect}"
+          error = "#{message}.\n#{error}" if message
+          assert from === before, error
+        end
+
+        after = exp.call
+
+        error = "#{expression.inspect} didn't change"
+        error = "#{error}. It was already #{to}" if before == to
+        error = "#{message}.\n#{error}" if message
+        assert before != after, error
+
+        unless to == UNTRACKED
+          error = "#{expression.inspect} didn't change to #{to}"
+          error = "#{message}.\n#{error}" if message
+          assert to === after, error
+        end
+
+        retval
+      end
+
+      # Assertion that the result of evaluating an expression is not changed before
+      # and after invoking the passed in block.
+      #
+      #   assert_no_changes 'Status.all_good?' do
+      #     post :create, params: { status: { ok: true } }
+      #   end
+      #
+      # An error message can be specified.
+      #
+      #   assert_no_changes -> { Status.all_good? }, 'Expected the status to be good' do
+      #     post :create, params: { status: { ok: false } }
+      #   end
+      def assert_no_changes(expression, message = nil, &block)
+        exp = expression.respond_to?(:call) ? expression : -> { eval(expression.to_s, block.binding) }
+
+        before = exp.call
+        retval = yield
+        after = exp.call
+
+        error = "#{expression.inspect} did change to #{after}"
+        error = "#{message}.\n#{error}" if message
+        assert before == after, error
+
+        retval
+      end
     end
   end
 end

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,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,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