minitest 5.11.3 → 5.25.4

data/lib/minitest/mock.rb

@@ -8,9 +8,9 @@ module Minitest # :nodoc:
   # All mock objects are an instance of Mock
 
   class Mock
-    alias :__respond_to? :respond_to?
+    alias __respond_to? respond_to?
 
-    overridden_methods = %w[
+    overridden_methods = %i[
       ===
       class
       inspect
@@ -23,18 +23,31 @@ module Minitest # :nodoc:
       to_s
     ]
 
+    overridden_methods << :singleton_method_added if defined?(::DEBUGGER__)
+
     instance_methods.each do |m|
-      undef_method m unless overridden_methods.include?(m.to_s) || m =~ /^__/
+      undef_method m unless overridden_methods.include?(m) || m =~ /^__/
     end
 
     overridden_methods.map(&:to_sym).each do |method_id|
-      define_method method_id do |*args, &b|
+      old_w, $-w = $-w, nil
+      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
+    ensure
+      $-w = old_w
     end
 
     def initialize delegator = nil # :nodoc:
@@ -43,9 +56,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 +93,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?
+      if blk then
         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(1..1).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 +125,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
@@ -107,18 +144,22 @@ module Minitest # :nodoc:
 
     def verify
       @expected_calls.each do |name, expected|
-        actual = @actual_calls.fetch(name, nil)
-        raise MockExpectationError, "expected #{__call name, expected[0]}" unless actual
-        raise MockExpectationError, "expected #{__call name, expected[actual.size]}, got [#{__call name, actual}]" if
+        actual = @actual_calls.fetch name, nil # defaults to []
+        raise MockExpectationError, "Expected #{__call name, expected[0]}" unless actual
+        raise MockExpectationError, "Expected #{__call name, expected[actual.size]}, got [#{__call name, actual}]" if
           actual.size < expected.size
       end
       true
     end
 
-    def method_missing sym, *args, &block # :nodoc:
-      unless @expected_calls.key?(sym) then
+    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,41 +170,69 @@ 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.to_h { |ak, av| [ak, Object] } 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)
+      zipped_args = expected_args.zip args
       fully_matched = zipped_args.all? { |mod, a|
         mod === a or mod == a
       }
 
       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.to_h { |ek, ev|
+        av = kwargs[ek]
+        [ek, [ev, av]]
+      }
+
+      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.to_h { |k, (e, a)| [k, e === a ? e : a] },
       }
 
       retval
@@ -172,20 +241,35 @@ module Minitest # :nodoc:
     def respond_to? sym, include_private = false # :nodoc:
       return true if @expected_calls.key? sym.to_sym
       return true if @delegator && @delegator.respond_to?(sym, include_private)
-      __respond_to?(sym, include_private)
+      __respond_to? sym, include_private
     end
   end
 end
 
 module Minitest::Assertions
   ##
-  # Assert that the mock verifies correctly.
+  # Assert that the mock verifies correctly and fail if not.
 
-  def assert_mock mock
+  def assert_mock mock, msg = nil
     assert mock.verify
+  rescue MockExpectationError => e
+    msg = message(msg) { e.message }
+    flunk msg
   end
 end
 
+module Minitest::Expectations
+  ##
+  # See Minitest::Assertions#assert_mock.
+  #
+  #    _(collection).must_verify
+  #
+  # :method: must_verify
+
+  infect_an_assertion :assert_mock, :must_verify, :unary if
+    defined?(infect_an_assertion)
+end
+
 ##
 # Object extensions for Minitest::Mock.
 
@@ -207,31 +291,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|
-      if val_or_callable.respond_to? :call then
-        val_or_callable.call(*args, &blk)
-      else
-        blk.call(*block_args) if blk
-        val_or_callable
+    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
+              blk.call(*block_args, **block_kwargs)
+            end
+          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

@@ -1,5 +1,5 @@
 module Minitest
-  module Parallel #:nodoc:
+  module Parallel # :nodoc:
 
     ##
     # The engine used to run multiple tests in parallel.
@@ -16,7 +16,7 @@ module Minitest
 
       def initialize size
         @size  = size
-        @queue = Queue.new
+        @queue = Thread::Queue.new
         @pool  = nil
       end
 
@@ -24,10 +24,10 @@ module Minitest
       # Start the executor
 
       def start
-        @pool  = size.times.map {
-          Thread.new(@queue) do |queue|
+        @pool  = Array.new(size) {
+          Thread.new @queue do |queue|
             Thread.current.abort_on_exception = true
-            while (job = queue.pop)
+            while job = queue.pop do
               klass, method, reporter = job
               reporter.synchronize { reporter.prerecord klass, method }
               result = Minitest.run_one_method klass, method

data/lib/minitest/pride_plugin.rb

@@ -8,13 +8,13 @@ module Minitest
   end
 
   def self.plugin_pride_init options # :nodoc:
-    if PrideIO.pride? then
-      klass = ENV["TERM"] =~ /^xterm|-256color$/ ? PrideLOL : PrideIO
-      io    = klass.new options[:io]
+    return unless PrideIO.pride?
 
-      self.reporter.reporters.grep(Minitest::Reporter).each do |rep|
-        rep.io = io if rep.io.tty?
-      end
+    klass = ENV["TERM"] =~ /^xterm|-(?:256color|direct)$/ ? PrideLOL : PrideIO
+    io    = klass.new options[:io]
+
+    self.reporter.reporters.grep(Minitest::Reporter).each do |rep|
+      rep.io = io if rep.io.tty?
     end
   end
 
@@ -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
@@ -59,12 +59,10 @@ module Minitest
 
     def print o
       case o
-      when "." then
+      when ".", "S" then
         io.print pride o
       when "E", "F" then
         io.print "#{ESC}41m#{ESC}37m#{o}#{NND}"
-      when "S" then
-        io.print pride o
       else
         io.print o
       end
@@ -72,11 +70,9 @@ module Minitest
 
     def puts *o # :nodoc:
       o.map! { |s|
-        s.to_s.sub(/Finished/) {
+        s.to_s.sub("Finished") {
           @index = 0
-          "Fabulous run".split(//).map { |c|
-            pride(c)
-          }.join
+          "Fabulous run".chars.map { |c| pride(c) }.join
         }
       }
 
@@ -113,19 +109,16 @@ module Minitest
       #
       #   plot (3*sin(x)+3), (3*sin(x+2*pi/3)+3), (3*sin(x+4*pi/3)+3)
 
-      # 6 has wide pretty gradients. 3 == lolcat, about half the width
-      @colors = (0...(6 * 7)).map { |n|
-        n *= 1.0 / 6
+      @colors = Array.new(6 * 7) { |n|
+        n *= 1.0 / 3
         r  = (3 * Math.sin(n           ) + 3).to_i
-        g  = (3 * Math.sin(n + 2 * PI_3) + 3).to_i
-        b  = (3 * Math.sin(n + 4 * PI_3) + 3).to_i
-
-        # Then we take rgb and encode them in a single number using base 6.
-        # For some mysterious reason, we add 16... to clear the bottom 4 bits?
-        # Yes... they're ugly.
+        g  = (3 * Math.sin(n + 4 * PI_3) + 3).to_i
+        b  = (3 * Math.sin(n + 2 * PI_3) + 3).to_i
 
+        # Then we take rgb and encode them in a single number using
+        # base 6, shifted by 16 for the base 16 ansi colors.
         36 * r + 6 * g + b + 16
-      }
+      }.rotate(4) # puts "red" first
 
       super
     end

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.
@@ -70,14 +81,15 @@ module Kernel
 
   def describe desc, *additional_desc, &block # :doc:
     stack = Minitest::Spec.describe_stack
-    name  = [stack.last, desc, *additional_desc].compact.join("::")
-    sclas = stack.last || if Class === self && kind_of?(Minitest::Spec::DSL) then
-                            self
-                          else
-                            Minitest::Spec.spec_type desc, *additional_desc
-                          end
+    is_spec_class = Class === self && kind_of?(Minitest::Spec::DSL)
+    name  = [stack.last, desc, *additional_desc]
+    name.prepend self if stack.empty? && is_spec_class
+    sclas =
+      stack.last                 \
+      || (is_spec_class && self) \
+      || Minitest::Spec.spec_type(desc, *additional_desc)
 
-    cls = sclas.create name, desc
+    cls = sclas.create name.compact.join("::"), desc
 
     stack.push cls
     cls.class_eval(&block)
@@ -238,7 +250,7 @@ class Minitest::Spec < Minitest::Test
       pre, post = "let '#{name}' cannot ", ". Please use another name."
       methods = Minitest::Spec.instance_methods.map(&:to_s) - %w[subject]
       raise ArgumentError, "#{pre}begin with 'test'#{post}" if
-        name =~ /\Atest/
+        name.start_with? "test"
       raise ArgumentError, "#{pre}override a method in Minitest::Spec#{post}" if
         methods.include? name
 
@@ -257,7 +269,7 @@ class Minitest::Spec < Minitest::Test
     end
 
     def create name, desc # :nodoc:
-      cls = Class.new(self) do
+      cls = Class.new self do
         @name = name
         @desc = desc
 
@@ -278,28 +290,35 @@ class Minitest::Spec < Minitest::Test
     end
 
     attr_reader :desc # :nodoc:
-    alias :specify :it
+    alias specify it
 
     ##
     # Rdoc... why are you so dumb?
 
     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