minitest 5.10.3 → 5.18.0

data/lib/minitest/expectations.rb

@@ -9,10 +9,11 @@
 #
 #     it "should still work in threads" do
 #       my_threaded_thingy do
-#         (1+1).must_equal 2         # bad
-#         assert_equal 2, 1+1        # good
-#         _(1 + 1).must_equal 2      # good
-#         value(1 + 1).must_equal 2  # good, also #expect
+#         (1+1).must_equal 2                  # bad
+#         assert_equal 2, 1+1                 # good
+#         _(1 + 1).must_equal 2               # good
+#         value(1 + 1).must_equal 2           # good, also #expect
+#         _ { 1 + "1" }.must_raise TypeError  # good
 #       end
 #     end
 
@@ -21,7 +22,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#assert_empty.
   #
-  #    collection.must_be_empty
+  #    _(collection).must_be_empty
   #
   # :method: must_be_empty
 
@@ -30,7 +31,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#assert_equal
   #
-  #    a.must_equal b
+  #    _(a).must_equal b
   #
   # :method: must_equal
 
@@ -39,18 +40,18 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#assert_in_delta
   #
-  #    n.must_be_close_to m [, delta]
+  #    _(n).must_be_close_to m [, delta]
   #
   # :method: must_be_close_to
 
   infect_an_assertion :assert_in_delta, :must_be_close_to
 
-  alias :must_be_within_delta :must_be_close_to # :nodoc:
+  infect_an_assertion :assert_in_delta, :must_be_within_delta # :nodoc:
 
   ##
   # See Minitest::Assertions#assert_in_epsilon
   #
-  #    n.must_be_within_epsilon m [, epsilon]
+  #    _(n).must_be_within_epsilon m [, epsilon]
   #
   # :method: must_be_within_epsilon
 
@@ -59,7 +60,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#assert_includes
   #
-  #    collection.must_include obj
+  #    _(collection).must_include obj
   #
   # :method: must_include
 
@@ -68,7 +69,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#assert_instance_of
   #
-  #    obj.must_be_instance_of klass
+  #    _(obj).must_be_instance_of klass
   #
   # :method: must_be_instance_of
 
@@ -77,7 +78,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#assert_kind_of
   #
-  #    obj.must_be_kind_of mod
+  #    _(obj).must_be_kind_of mod
   #
   # :method: must_be_kind_of
 
@@ -86,7 +87,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#assert_match
   #
-  #    a.must_match b
+  #    _(a).must_match b
   #
   # :method: must_match
 
@@ -95,7 +96,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#assert_nil
   #
-  #    obj.must_be_nil
+  #    _(obj).must_be_nil
   #
   # :method: must_be_nil
 
@@ -104,11 +105,11 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#assert_operator
   #
-  #    n.must_be :<=, 42
+  #    _(n).must_be :<=, 42
   #
   # This can also do predicates:
   #
-  #    str.must_be :empty?
+  #    _(str).must_be :empty?
   #
   # :method: must_be
 
@@ -117,16 +118,25 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#assert_output
   #
-  #    proc { ... }.must_output out_or_nil [, err]
+  #    _ { ... }.must_output out_or_nil [, err]
   #
   # :method: must_output
 
   infect_an_assertion :assert_output, :must_output, :block
 
+  ##
+  # See Minitest::Assertions#assert_pattern_match
+  #
+  #    _ { ... }.must_pattern_match [...]
+  #
+  # :method: must_pattern_match
+
+  infect_an_assertion :assert_pattern, :must_pattern_match, :block
+
   ##
   # See Minitest::Assertions#assert_raises
   #
-  #    proc { ... }.must_raise exception
+  #    _ { ... }.must_raise exception
   #
   # :method: must_raise
 
@@ -135,7 +145,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#assert_respond_to
   #
-  #    obj.must_respond_to msg
+  #    _(obj).must_respond_to msg
   #
   # :method: must_respond_to
 
@@ -144,7 +154,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#assert_same
   #
-  #    a.must_be_same_as b
+  #    _(a).must_be_same_as b
   #
   # :method: must_be_same_as
 
@@ -153,7 +163,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#assert_silent
   #
-  #    proc { ... }.must_be_silent
+  #    _ { ... }.must_be_silent
   #
   # :method: must_be_silent
 
@@ -162,16 +172,34 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#assert_throws
   #
-  #    proc { ... }.must_throw sym
+  #    _ { ... }.must_throw sym
   #
   # :method: must_throw
 
   infect_an_assertion :assert_throws, :must_throw, :block
 
+  ##
+  # See Minitest::Assertions#assert_path_exists
+  #
+  #   _(some_path).path_must_exist
+  #
+  # :method: path_must_exist
+
+  infect_an_assertion :assert_path_exists, :path_must_exist, :unary
+
+  ##
+  # See Minitest::Assertions#refute_path_exists
+  #
+  #   _(some_path).path_wont_exist
+  #
+  # :method: path_wont_exist
+
+  infect_an_assertion :refute_path_exists, :path_wont_exist, :unary
+
   ##
   # See Minitest::Assertions#refute_empty
   #
-  #    collection.wont_be_empty
+  #    _(collection).wont_be_empty
   #
   # :method: wont_be_empty
 
@@ -180,7 +208,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#refute_equal
   #
-  #    a.wont_equal b
+  #    _(a).wont_equal b
   #
   # :method: wont_equal
 
@@ -189,18 +217,18 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#refute_in_delta
   #
-  #    n.wont_be_close_to m [, delta]
+  #    _(n).wont_be_close_to m [, delta]
   #
   # :method: wont_be_close_to
 
   infect_an_assertion :refute_in_delta, :wont_be_close_to
 
-  alias :wont_be_within_delta :wont_be_close_to # :nodoc:
+  infect_an_assertion :refute_in_delta, :wont_be_within_delta # :nodoc:
 
   ##
   # See Minitest::Assertions#refute_in_epsilon
   #
-  #    n.wont_be_within_epsilon m [, epsilon]
+  #    _(n).wont_be_within_epsilon m [, epsilon]
   #
   # :method: wont_be_within_epsilon
 
@@ -209,7 +237,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#refute_includes
   #
-  #    collection.wont_include obj
+  #    _(collection).wont_include obj
   #
   # :method: wont_include
 
@@ -218,7 +246,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#refute_instance_of
   #
-  #    obj.wont_be_instance_of klass
+  #    _(obj).wont_be_instance_of klass
   #
   # :method: wont_be_instance_of
 
@@ -227,7 +255,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#refute_kind_of
   #
-  #    obj.wont_be_kind_of mod
+  #    _(obj).wont_be_kind_of mod
   #
   # :method: wont_be_kind_of
 
@@ -236,7 +264,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#refute_match
   #
-  #    a.wont_match b
+  #    _(a).wont_match b
   #
   # :method: wont_match
 
@@ -245,7 +273,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#refute_nil
   #
-  #    obj.wont_be_nil
+  #    _(obj).wont_be_nil
   #
   # :method: wont_be_nil
 
@@ -254,7 +282,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#refute_operator
   #
-  #    n.wont_be :<=, 42
+  #    _(n).wont_be :<=, 42
   #
   # This can also do predicates:
   #
@@ -264,10 +292,19 @@ module Minitest::Expectations
 
   infect_an_assertion :refute_operator, :wont_be, :reverse
 
+  ##
+  # See Minitest::Assertions#refute_pattern_match
+  #
+  #    _ { ... }.wont_pattern_match [...]
+  #
+  # :method: wont_pattern_match
+
+  infect_an_assertion :refute_pattern, :wont_pattern_match, :block
+
   ##
   # See Minitest::Assertions#refute_respond_to
   #
-  #    obj.wont_respond_to msg
+  #    _(obj).wont_respond_to msg
   #
   # :method: wont_respond_to
 
@@ -276,7 +313,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#refute_same
   #
-  #    a.wont_be_same_as b
+  #    _(a).wont_be_same_as b
   #
   # :method: wont_be_same_as
 

data/lib/minitest/mock.rb

@@ -28,11 +28,19 @@ module Minitest # :nodoc:
     end
 
     overridden_methods.map(&:to_sym).each do |method_id|
-      define_method method_id do |*args, &b|
+      define_method method_id do |*args, **kwargs, &b|
         if @expected_calls.key? method_id then
-          method_missing(method_id, *args, &b)
+          if kwargs.empty? then # FIX: drop this after 2.7 dead
+            method_missing(method_id, *args, &b)
+          else
+            method_missing(method_id, *args, **kwargs, &b)
+          end
         else
-          super(*args, &b)
+          if kwargs.empty? then # FIX: drop this after 2.7 dead
+            super(*args, &b)
+          else
+            super(*args, **kwargs, &b)
+          end
         end
       end
     end
@@ -43,9 +51,11 @@ module Minitest # :nodoc:
       @actual_calls   = Hash.new { |calls, name| calls[name] = [] }
     end
 
+    @@KW_WARNED = false # :nodoc:
+
     ##
-    # Expect that method +name+ is called, optionally with +args+ or a
-    # +blk+, and returns +retval+.
+    # Expect that method +name+ is called, optionally with +args+ (and
+    # +kwargs+ or a +blk+), and returns +retval+.
     #
     #   @mock.expect(:meaning_of_life, 42)
     #   @mock.meaning_of_life # => 42
@@ -78,15 +88,31 @@ module Minitest # :nodoc:
     #   @mock.ordinal_increment # => raises MockExpectationError "No more expects available for :ordinal_increment"
     #
 
-    def expect name, retval, args = [], &blk
+    def expect name, retval, args = [], **kwargs, &blk
       name = name.to_sym
 
       if block_given?
         raise ArgumentError, "args ignored when block given" unless args.empty?
+        raise ArgumentError, "kwargs ignored when block given" unless kwargs.empty?
         @expected_calls[name] << { :retval => retval, :block => blk }
       else
         raise ArgumentError, "args must be an array" unless Array === args
-        @expected_calls[name] << { :retval => retval, :args => args }
+
+        if ENV["MT_KWARGS_HAC\K"] && (Hash === args.last ||
+                                      Hash ==  args.last) then
+          if kwargs.empty? then
+            kwargs = args.pop
+          else
+            unless @@KW_WARNED then
+              from = caller.first
+              warn "Using MT_KWARGS_HAC\K yet passing kwargs. From #{from}"
+              @@KW_WARNED = true
+            end
+          end
+        end
+
+        @expected_calls[name] <<
+          { :retval => retval, :args => args, :kwargs => kwargs }
       end
       self
     end
@@ -94,7 +120,13 @@ module Minitest # :nodoc:
     def __call name, data # :nodoc:
       case data
       when Hash then
-        "#{name}(#{data[:args].inspect[1..-2]}) => #{data[:retval].inspect}"
+        args   = data[:args].inspect[1..-2]
+        kwargs = data[:kwargs]
+        if kwargs && !kwargs.empty? then
+          args << ", " unless args.empty?
+          args << kwargs.inspect[1..-2]
+        end
+        "#{name}(#{args}) => #{data[:retval].inspect}"
       else
         data.map { |d| __call name, d }.join ", "
       end
@@ -115,10 +147,14 @@ module Minitest # :nodoc:
       true
     end
 
-    def method_missing sym, *args, &block # :nodoc:
+    def method_missing sym, *args, **kwargs, &block # :nodoc:
       unless @expected_calls.key?(sym) then
         if @delegator && @delegator.respond_to?(sym)
-          return @delegator.public_send(sym, *args, &block)
+          if kwargs.empty? then # FIX: drop this after 2.7 dead
+            return @delegator.public_send(sym, *args, &block)
+          else
+            return @delegator.public_send(sym, *args, **kwargs, &block)
+          end
         else
           raise NoMethodError, "unmocked method %p, expected one of %p" %
             [sym, @expected_calls.keys.sort_by(&:to_s)]
@@ -129,26 +165,34 @@ module Minitest # :nodoc:
       expected_call = @expected_calls[sym][index]
 
       unless expected_call then
-        raise MockExpectationError, "No more expects available for %p: %p" %
-          [sym, args]
+        raise MockExpectationError, "No more expects available for %p: %p %p" %
+          [sym, args, kwargs]
       end
 
-      expected_args, retval, val_block =
-        expected_call.values_at(:args, :retval, :block)
+      expected_args, expected_kwargs, retval, val_block =
+        expected_call.values_at(:args, :kwargs, :retval, :block)
+
+      expected_kwargs = kwargs.map { |ak, av| [ak, Object] }.to_h if
+        Hash == expected_kwargs
 
       if val_block then
         # keep "verify" happy
         @actual_calls[sym] << expected_call
 
-        raise MockExpectationError, "mocked method %p failed block w/ %p" %
-          [sym, args] unless val_block.call(*args, &block)
+        raise MockExpectationError, "mocked method %p failed block w/ %p %p" %
+          [sym, args, kwargs] unless val_block.call(*args, **kwargs, &block)
 
         return retval
       end
 
       if expected_args.size != args.size then
-        raise ArgumentError, "mocked method %p expects %d arguments, got %d" %
-          [sym, expected_args.size, args.size]
+        raise ArgumentError, "mocked method %p expects %d arguments, got %p" %
+          [sym, expected_args.size, args]
+      end
+
+      if expected_kwargs.size != kwargs.size then
+        raise ArgumentError, "mocked method %p expects %d keyword arguments, got %p" %
+          [sym, expected_kwargs.size, kwargs]
       end
 
       zipped_args = expected_args.zip(args)
@@ -157,13 +201,33 @@ module Minitest # :nodoc:
       }
 
       unless fully_matched then
-        raise MockExpectationError, "mocked method %p called with unexpected arguments %p" %
-          [sym, args]
+        fmt = "mocked method %p called with unexpected arguments %p"
+        raise MockExpectationError, fmt % [sym, args]
+      end
+
+      unless expected_kwargs.keys.sort == kwargs.keys.sort then
+        fmt = "mocked method %p called with unexpected keywords %p vs %p"
+        raise MockExpectationError, fmt % [sym, expected_kwargs.keys, kwargs.keys]
+      end
+
+      zipped_kwargs = expected_kwargs.map { |ek, ev|
+        av = kwargs[ek]
+        [ek, [ev, av]]
+      }.to_h
+
+      fully_matched = zipped_kwargs.all? { |ek, (ev, av)|
+        ev === av or ev == av
+      }
+
+      unless fully_matched then
+        fmt = "mocked method %p called with unexpected keyword arguments %p vs %p"
+        raise MockExpectationError, fmt % [sym, expected_kwargs, kwargs]
       end
 
       @actual_calls[sym] << {
         :retval => retval,
-        :args => zipped_args.map! { |mod, a| mod === a ? mod : a },
+        :args => zipped_args.map { |e, a| e === a ? e : a },
+        :kwargs => zipped_kwargs.map { |k, (e, a)| [k, e === a ? e : a] }.to_h,
       }
 
       retval
@@ -207,34 +271,54 @@ class Object
   #         assert obj_under_test.stale?
   #       end
   #     end
-  #
+  #--
+  # NOTE: keyword args in callables are NOT checked for correctness
+  # against the existing method. Too many edge cases to be worth it.
 
-  def stub name, val_or_callable, *block_args
+  def stub name, val_or_callable, *block_args, **block_kwargs, &block
     new_name = "__minitest_stub__#{name}"
 
     metaclass = class << self; self; end
 
     if respond_to? name and not methods.map(&:to_s).include? name.to_s then
-      metaclass.send :define_method, name do |*args|
-        super(*args)
+      metaclass.send :define_method, name do |*args, **kwargs|
+        super(*args, **kwargs)
       end
     end
 
     metaclass.send :alias_method, new_name, name
 
-    metaclass.send :define_method, name do |*args, &blk|
-      ret = if val_or_callable.respond_to? :call then
-              val_or_callable.call(*args)
+    if ENV["MT_KWARGS_HAC\K"] then
+      metaclass.send :define_method, name do |*args, &blk|
+        if val_or_callable.respond_to? :call then
+          val_or_callable.call(*args, &blk)
+        else
+          blk.call(*block_args, **block_kwargs) if blk
+          val_or_callable
+        end
+      end
+    else
+      metaclass.send :define_method, name do |*args, **kwargs, &blk|
+        if val_or_callable.respond_to? :call then
+          if kwargs.empty? then # FIX: drop this after 2.7 dead
+            val_or_callable.call(*args, &blk)
+          else
+            val_or_callable.call(*args, **kwargs, &blk)
+          end
+        else
+          if blk then
+            if block_kwargs.empty? then # FIX: drop this after 2.7 dead
+              blk.call(*block_args)
             else
-              val_or_callable
+              blk.call(*block_args, **block_kwargs)
             end
-
-      blk.call(*block_args) if blk
-
-      ret
+          end
+          val_or_callable
+        end
+      end
     end
 
-    yield self
+    block[self]
   ensure
     metaclass.send :undef_method, name
     metaclass.send :alias_method, name, new_name

data/lib/minitest/parallel.rb

@@ -53,7 +53,7 @@ module Minitest
       end
     end
 
-    module Test
+    module Test # :nodoc:
       def _synchronize; Minitest::Test.io_lock.synchronize { yield }; end # :nodoc:
 
       module ClassMethods # :nodoc:

data/lib/minitest/pride_plugin.rb

@@ -48,7 +48,7 @@ module Minitest
     def initialize io # :nodoc:
       @io = io
       # stolen from /System/Library/Perl/5.10.0/Term/ANSIColor.pm
-      # also reference http://en.wikipedia.org/wiki/ANSI_escape_code
+      # also reference https://en.wikipedia.org/wiki/ANSI_escape_code
       @colors ||= (31..36).to_a
       @size   = @colors.size
       @index  = 0

data/lib/minitest/spec.rb

@@ -4,16 +4,26 @@ class Module # :nodoc:
   def infect_an_assertion meth, new_name, dont_flip = false # :nodoc:
     block = dont_flip == :block
     dont_flip = false if block
+    target_obj = block ? '_{obj.method}' : '_(obj)'
+
+    # https://eregon.me/blog/2021/02/13/correct-delegation-in-ruby-2-27-3.html
+    # Drop this when we can drop ruby 2.6 (aka after rails 6.1 EOL, ~2024-06)
+    kw_extra = "ruby2_keywords %p" % [new_name] if respond_to?(:ruby2_keywords, true)
 
     # warn "%-22p -> %p %p" % [meth, new_name, dont_flip]
     self.class_eval <<-EOM, __FILE__, __LINE__ + 1
       def #{new_name} *args
+        where = Minitest.filter_backtrace(caller).first
+        where = where.split(/:in /, 2).first # clean up noise
+        Kernel.warn "DEPRECATED: global use of #{new_name} from #\{where}. Use #{target_obj}.#{new_name} instead. This will fail in Minitest 6."
         Minitest::Expectation.new(self, Minitest::Spec.current).#{new_name}(*args)
       end
+      #{kw_extra}
     EOM
 
     Minitest::Expectation.class_eval <<-EOM, __FILE__, __LINE__ + 1
       def #{new_name} *args
+        raise "Calling ##{new_name} outside of test." unless ctx
         case
         when #{!!dont_flip} then
           ctx.#{meth}(target, *args)
@@ -23,6 +33,7 @@ class Module # :nodoc:
           ctx.#{meth}(args.first, target, *args[1..-1])
         end
       end
+      #{kw_extra}
     EOM
   end
 end
@@ -61,7 +72,7 @@ module Kernel
   #
   # For some suggestions on how to improve your specs, try:
   #
-  # http://betterspecs.org
+  # https://betterspecs.org
   #
   # but do note that several items there are debatable or specific to
   # rspec.
@@ -285,21 +296,28 @@ class Minitest::Spec < Minitest::Test
 
     module InstanceMethods
       ##
-      # Returns a value monad that has all of Expectations methods
-      # available to it.
+      # Takes a value or a block and returns a value monad that has
+      # all of Expectations methods available to it.
       #
-      # Also aliased to #value and #expect for your aesthetic pleasure:
+      #   _(1 + 1).must_equal 2
       #
-      #         _(1 + 1).must_equal 2
-      #     value(1 + 1).must_equal 2
-      #    expect(1 + 1).must_equal 2
+      # And for blocks:
+      #
+      #   _ { 1 + "1" }.must_raise TypeError
       #
       # This method of expectation-based testing is preferable to
       # straight-expectation methods (on Object) because it stores its
       # test context, bypassing our hacky use of thread-local variables.
       #
-      # At some point, the methods on Object will be deprecated and then
-      # removed.
+      # NOTE: At some point, the methods on Object will be deprecated
+      # and then removed.
+      #
+      # It is also aliased to #value and #expect for your aesthetic
+      # pleasure:
+      #
+      #         _(1 + 1).must_equal 2
+      #     value(1 + 1).must_equal 2
+      #    expect(1 + 1).must_equal 2
 
       def _ value = nil, &block
         Minitest::Expectation.new block || value, self