minitest 5.25.5 → 6.0.0

data/lib/minitest/assertions.rb

@@ -62,11 +62,11 @@ module Minitest
       return "Expected: #{mu_pp exp}\n  Actual: #{mu_pp act}" unless
         expect
 
-      Tempfile.open "expect" do |a|
+      Tempfile.create "expect" do |a|
         a.puts expect
         a.flush
 
-        Tempfile.open "butwas" do |b|
+        Tempfile.create "butwas" do |b|
           b.puts butwas
           b.flush
 
@@ -186,9 +186,8 @@ module Minitest
     # Fails unless +obj+ is empty.
 
     def assert_empty obj, msg = nil
-      msg = message(msg) { "Expected #{mu_pp obj} to be empty" }
-      assert_respond_to obj, :empty?
-      assert obj.empty?, msg
+      msg = message(msg) { "Expected #{mu_pp(obj)} to be empty" }
+      assert_predicate obj, :empty?, msg
     end
 
     def _where # :nodoc:
@@ -196,8 +195,6 @@ module Minitest
         .split(":in ", 2).first # clean up noise
     end
 
-    E = "" # :nodoc:
-
     ##
     # Fails unless <tt>exp == act</tt> printing the difference between
     # the two, if possible.
@@ -212,18 +209,11 @@ module Minitest
     # See also: Minitest::Assertions.diff
 
     def assert_equal exp, act, msg = nil
-      msg = message(msg, E) { diff exp, act }
-      result = assert exp == act, msg
+      msg = message(msg, nil) { diff exp, act }
 
-      if nil == exp then
-        if Minitest::VERSION >= "6" then
-          refute_nil exp, "Use assert_nil if expecting nil."
-        else
-          warn "DEPRECATED: Use assert_nil if expecting nil from #{_where}. This will fail in Minitest 6."
-        end
-      end
+      refute_nil exp, message { "Use assert_nil if expecting nil" } if exp.nil? # don't count
 
-      result
+      assert exp == act, msg
     end
 
     ##
@@ -255,8 +245,7 @@ module Minitest
       msg = message(msg) {
         "Expected #{mu_pp collection} to include #{mu_pp obj}"
       }
-      assert_respond_to collection, :include?
-      assert collection.include?(obj), msg
+      assert_operator collection, :include?, obj, msg
     end
 
     ##
@@ -308,6 +297,7 @@ module Minitest
 
     def assert_operator o1, op, o2 = UNDEFINED, msg = nil
       return assert_predicate o1, op, msg if UNDEFINED == o2
+      assert_respond_to o1, op
       msg = message(msg) { "Expected #{mu_pp o1} to be #{op} #{mu_pp o2}" }
       assert o1.__send__(op, o2), msg
     end
@@ -368,15 +358,12 @@ module Minitest
     # error.
 
     def assert_pattern
-      raise NotImplementedError, "only available in Ruby 3.0+" unless RUBY_VERSION >= "3.0"
       flunk "assert_pattern requires a block to capture errors." unless block_given?
 
-      begin # TODO: remove after ruby 2.6 dropped
-        yield
-        pass
-      rescue NoMatchingPatternError => e
-        flunk e.message
-      end
+      yield
+      pass
+    rescue NoMatchingPatternError => e
+      flunk e.message
     end
 
     ##
@@ -389,6 +376,7 @@ module Minitest
     #   str.must_be :empty?
 
     def assert_predicate o1, op, msg = nil
+      assert_respond_to o1, op, include_all:true
       msg = message(msg) { "Expected #{mu_pp o1} to be #{op}" }
       assert o1.__send__(op), msg
     end
@@ -448,9 +436,7 @@ module Minitest
     # include_all defaults to false to match Object#respond_to?
 
     def assert_respond_to obj, meth, msg = nil, include_all: false
-      msg = message(msg) {
-        "Expected #{mu_pp obj} (#{obj.class}) to respond to ##{meth}"
-      }
+      msg = message(msg) { "Expected #{mu_pp obj} (#{obj.class}) to respond to ##{meth}" }
       assert obj.respond_to?(meth, include_all), msg
     end
 
@@ -465,21 +451,6 @@ module Minitest
       assert exp.equal?(act), msg
     end
 
-    ##
-    # +send_ary+ is a receiver, message and arguments.
-    #
-    # Fails unless the call returns a true value
-
-    def assert_send send_ary, m = nil
-      warn "DEPRECATED: assert_send. From #{_where}"
-
-      recv, msg, *args = send_ary
-      m = message(m) {
-        "Expected #{mu_pp recv}.#{msg}(*#{mu_pp args}) to return true"
-      }
-      assert recv.__send__(msg, *args), m
-    end
-
     ##
     # Fails if the block outputs anything to stderr or stdout.
     #
@@ -500,14 +471,9 @@ module Minitest
       value = catch sym do
         begin
           yield
-        rescue ThreadError => e       # wtf?!? 1.8 + threads == suck
-          default += ", not :#{e.message[/uncaught throw \`(\w+?)\'/, 1]}"
-        rescue ArgumentError => e     # 1.9 exception
+        rescue ArgumentError => e     # 1.9+ exception
           raise e unless e.message.include? "uncaught throw"
           default += ", not #{e.message.split(/ /).last}"
-        rescue NameError => e         # 1.8 exception
-          raise e unless e.name == sym
-          default += ", not #{e.name.inspect}"
         end
         caught = false
       end
@@ -629,13 +595,16 @@ module Minitest
     end
 
     ##
-    # Returns a proc that will output +msg+ along with the default message.
+    # Returns a proc that delays generation of an output message. If
+    # +msg+ is a proc (eg, from another +message+ call) return +msg+
+    # as-is. Otherwise, return a proc that will output +msg+ along
+    # with the value of the result of the block passed to +message+.
 
-    def message msg = nil, ending = nil, &default
+    def message msg = nil, ending = ".", &default
+      return msg if Proc === msg
       proc {
-        msg = msg.call.chomp(".") if Proc === msg
         custom_message = "#{msg}.\n" unless msg.nil? or msg.to_s.empty?
-        "#{custom_message}#{default.call}#{ending || "."}"
+        "#{custom_message}#{default.call}#{ending}"
       }
     end
 
@@ -659,8 +628,7 @@ module Minitest
 
     def refute_empty obj, msg = nil
       msg = message(msg) { "Expected #{mu_pp obj} to not be empty" }
-      assert_respond_to obj, :empty?
-      refute obj.empty?, msg
+      refute_predicate obj, :empty?, msg
     end
 
     ##
@@ -692,19 +660,16 @@ module Minitest
     # For comparing Floats.  Fails if +exp+ and +act+ have a relative error
     # less than +epsilon+.
 
-    def refute_in_epsilon a, b, epsilon = 0.001, msg = nil
-      refute_in_delta a, b, a * epsilon, msg
+    def refute_in_epsilon exp, act, epsilon = 0.001, msg = nil
+      refute_in_delta exp, act, [exp.abs, act.abs].min * epsilon, msg
     end
 
     ##
-    # Fails if +collection+ includes +obj+.
+    # Fails if +obj+ includes +sub+.
 
-    def refute_includes collection, obj, msg = nil
-      msg = message(msg) {
-        "Expected #{mu_pp collection} to not include #{mu_pp obj}"
-      }
-      assert_respond_to collection, :include?
-      refute collection.include?(obj), msg
+    def refute_includes obj, sub, msg = nil
+      msg = message(msg) { "Expected #{mu_pp obj} to not include #{mu_pp sub}" }
+      refute_operator obj, :include?, sub, msg
     end
 
     ##
@@ -730,9 +695,8 @@ module Minitest
 
     def refute_match matcher, obj, msg = nil
       msg = message(msg) { "Expected #{mu_pp matcher} to not match #{mu_pp obj}" }
-      assert_respond_to matcher, :=~
       matcher = Regexp.new Regexp.escape matcher if String === matcher
-      refute matcher =~ obj, msg
+      refute_operator matcher, :=~, obj, msg
     end
 
     ##
@@ -756,15 +720,12 @@ module Minitest
     # other exceptions will be raised as normal and generate a test error.
 
     def refute_pattern
-      raise NotImplementedError, "only available in Ruby 3.0+" unless RUBY_VERSION >= "3.0"
       flunk "refute_pattern requires a block to capture errors." unless block_given?
 
-      begin
-        yield
-        flunk "NoMatchingPatternError expected, but nothing was raised."
-      rescue NoMatchingPatternError
-        pass
-      end
+      yield
+      flunk "NoMatchingPatternError expected, but nothing was raised."
+    rescue NoMatchingPatternError
+      pass
     end
 
     ##
@@ -775,6 +736,7 @@ module Minitest
 
     def refute_operator o1, op, o2 = UNDEFINED, msg = nil
       return refute_predicate o1, op, msg if UNDEFINED == o2
+      assert_respond_to o1, op
       msg = message(msg) { "Expected #{mu_pp o1} to not be #{op} #{mu_pp o2}" }
       refute o1.__send__(op, o2), msg
     end
@@ -797,6 +759,7 @@ module Minitest
     #   str.wont_be :empty?
 
     def refute_predicate o1, op, msg = nil
+      assert_respond_to o1, op
       msg = message(msg) { "Expected #{mu_pp o1} to not be #{op}" }
       refute o1.__send__(op), msg
     end

data/lib/minitest/autorun.rb

@@ -1,6 +1,5 @@
-require "minitest"
-require "minitest/spec"
-require "minitest/mock"
-require "minitest/hell" if ENV["MT_HELL"]
+require_relative "../minitest"
+require_relative "spec"
+require_relative "hell" if ENV["MT_HELL"]
 
 Minitest.autorun

data/lib/minitest/benchmark.rb

@@ -1,5 +1,5 @@
-require "minitest/test"
-require "minitest/spec"
+require_relative "test"
+require_relative "spec"
 
 module Minitest
   ##

data/lib/minitest/bisect.rb

@@ -0,0 +1,306 @@
+require_relative "find_minimal_combination"
+require_relative "server"
+require "shellwords"
+require "rbconfig"
+require_relative "path_expander" # this is gonna break some shit?
+
+module Minitest; end # :nodoc:
+
+##
+# Minitest::Bisect helps you isolate and debug random test failures.
+
+class Minitest::Bisect
+  VERSION = "1.8.0" # :nodoc:
+
+  class PathExpander < Minitest::VendoredPathExpander # :nodoc:
+    TEST_GLOB = "**/{test_*,*_test,spec_*,*_spec}.rb" # :nodoc:
+
+    attr_accessor :rb_flags
+
+    def initialize args = ARGV # :nodoc:
+      super args, TEST_GLOB, "test"
+      self.rb_flags = %w[-Itest:lib]
+    end
+
+    ##
+    # Overrides PathExpander#process_flags to filter out ruby flags
+    # from minitest flags. Only supports -I<paths>, -d, and -w for
+    # ruby.
+
+    def process_flags flags
+      flags.reject { |flag| # all hits are truthy, so this works out well
+        case flag
+        when /^-I(.*)/ then
+          rb_flags << flag
+        when /^-d/ then
+          rb_flags << flag
+        when /^-w/ then
+          rb_flags << flag
+        else
+          false
+        end
+      }
+    end
+  end
+
+  mtbv = ENV["MTB_VERBOSE"].to_i
+  SHH = case # :nodoc:
+        when mtbv == 1 then " > /dev/null"
+        when mtbv >= 2 then nil
+        else " > /dev/null 2>&1"
+        end
+
+  # Borrowed from rake
+  RUBY = ENV['RUBY'] ||
+    File.join(RbConfig::CONFIG['bindir'],
+              RbConfig::CONFIG['ruby_install_name'] +
+                RbConfig::CONFIG['EXEEXT']).sub(/.*\s.*/m, '"\&"')
+
+  ##
+  # True if this run has seen a failure.
+
+  attr_accessor :tainted
+  alias :tainted? :tainted
+
+  ##
+  # Failures seen in this run. Shape:
+  #
+  #   {"file.rb"=>{"Class"=>["test_method1", "test_method2"] ...} ...}
+
+  attr_accessor :failures
+
+  ##
+  # An array of tests seen so far. NOT cleared by #reset.
+
+  attr_accessor :culprits
+
+  attr_accessor :seen_bad # :nodoc:
+
+  ##
+  # Top-level runner. Instantiate and call +run+, handling exceptions.
+
+  def self.run files
+    new.run files
+  rescue => e
+    warn e.message
+    warn "Try running with MTB_VERBOSE=2 to verify."
+    exit 1
+  end
+
+  ##
+  # Instantiate a new Bisect.
+
+  def initialize
+    self.culprits = []
+    self.failures = Hash.new { |h, k| h[k] = Hash.new { |h2, k2| h2[k2] = [] } }
+  end
+
+  ##
+  # Reset per-bisect-run variables.
+
+  def reset
+    self.seen_bad = false
+    self.tainted  = false
+    failures.clear
+    # not clearing culprits on purpose
+  end
+
+  ##
+  # Instance-level runner. Handles Minitest::Server, argument
+  # processing, and invoking +bisect_methods+.
+
+  def run args
+    Minitest::Server.run self
+
+    cmd = nil
+
+    mt_flags = args.dup
+    expander = Minitest::Bisect::PathExpander.new mt_flags
+
+    files = expander.process.to_a
+    rb_flags = expander.rb_flags
+    mt_flags += ["--server", $$.to_s]
+
+    cmd = bisect_methods files, rb_flags, mt_flags
+
+    puts "Final reproduction:"
+    puts
+
+    system cmd.sub(/--server \d+/, "")
+  ensure
+    Minitest::Server.stop
+  end
+
+  ##
+  # Normal: find "what is the minimal combination of tests to run to
+  #         make X fail?"
+  #
+  # Run with: minitest_bisect ... --seed=N
+  #
+  # 1. Verify the failure running normally with the seed.
+  #    2. If no failure, punt.
+  #    3. If no passing tests before failure, punt. (No culprits == no debug)
+  # 4. Verify the failure doesn't fail in isolation.
+  #    5. If it still fails by itself, warn that it might not be an ordering
+  #       issue.
+  # 6. Cull all tests after the failure, they're not involved.
+  # 7. Bisect the culprits + bad until you find a minimal combo that fails.
+  # 8. Display minimal combo by running one last time.
+  #
+  # Inverted: find "what is the minimal combination of tests to run to
+  #           make this test pass?"
+  #
+  # Run with: minitest_bisect ... --seed=N -n="/failing_test_name_regexp/"
+  #
+  # 1. Verify the failure by running normally w/ the seed and -n=/.../
+  #    2. If no failure, punt.
+  # 3. Verify the passing case by running everything.
+  #    4. If failure, punt. This is not a false positive.
+  # 5. Cull all tests after the bad test from #1, they're not involved.
+  # 6. Bisect the culprits + bad until you find a minimal combo that passes.
+  # 7. Display minimal combo by running one last time.
+
+  def bisect_methods files, rb_flags, mt_flags
+    bad_names, mt_flags = mt_flags.partition { |s| s =~ /^(?:-n|--name)/ }
+    normal   = bad_names.empty?
+    inverted = !normal
+
+    if inverted then
+      time_it "reproducing w/ scoped failure (inverted run!)...", build_methods_cmd(build_files_cmd(files, rb_flags, mt_flags + bad_names))
+      raise "No failures. Probably not a false positive. Aborting." if failures.empty?
+      bad = map_failures
+    end
+
+    cmd = build_files_cmd(files, rb_flags, mt_flags)
+
+    msg = normal ? "reproducing..." : "reproducing false positive..."
+    time_it msg, build_methods_cmd(cmd)
+
+    if normal then
+      raise "Reproduction run passed? Aborting." unless tainted?
+      raise "Verification failed. No culprits? Aborting." if culprits.empty? && seen_bad
+    else
+      raise "Reproduction failed? Not false positive. Aborting." if tainted?
+      raise "Verification failed. No culprits? Aborting." if culprits.empty? || seen_bad
+    end
+
+    if normal then
+      bad = map_failures
+
+      time_it "verifying...", build_methods_cmd(cmd, [], bad)
+
+      new_bad = map_failures
+
+      if bad == new_bad then
+        warn "Tests fail by themselves. This may not be an ordering issue."
+      end
+    end
+
+    idx = culprits.index bad.first
+    self.culprits = culprits.take idx+1 if idx # cull tests after bad
+
+    # culprits populated by initial reproduction via minitest/server
+    found, count = culprits.find_minimal_combination_and_count do |test|
+      prompt = "# of culprit methods: #{test.size}"
+
+      time_it prompt, build_methods_cmd(cmd, test, bad)
+
+      normal == tainted? # either normal and failed, or inverse and passed
+    end
+
+    puts
+    puts "Minimal methods found in #{count} steps:"
+    puts
+    puts "Culprit methods: %p" % [found + bad]
+    puts
+    cmd = build_methods_cmd cmd, found, bad
+    puts cmd.sub(/--server \d+/, "")
+    puts
+    cmd
+  end
+
+  def time_it prompt, cmd # :nodoc:
+    print prompt
+    t0 = Time.now
+    system "#{cmd} #{SHH}"
+    puts " in %.2f sec" % (Time.now - t0)
+  end
+
+  def map_failures # :nodoc:
+    # from: {"file.rb"=>{"Class"=>["test_method1", "test_method2"]}}
+    #   to: ["Class#test_method1", "Class#test_method2"]
+    failures.values.map { |h|
+      h.map { |k,vs| vs.map { |v| "#{k}##{v}" } }
+    }.flatten.sort
+  end
+
+  def build_files_cmd culprits, rb, mt # :nodoc:
+    tests = culprits.flatten.compact.map { |f| %(require "./#{f}") }.join " ; "
+
+    %(#{RUBY} #{rb.shelljoin} -e '#{tests}' -- #{mt.map(&:to_s).shelljoin})
+  end
+
+  def build_methods_cmd cmd, culprits = [], bad = nil # :nodoc:
+    reset
+
+    if bad then
+      re = build_re culprits + bad
+
+      cmd += " -n \"#{re}\"" if bad
+    end
+
+    if ENV["MTB_VERBOSE"].to_i >= 1 then
+      puts
+      puts cmd
+      puts
+    end
+
+    cmd
+  end
+
+  def build_re bad # :nodoc:
+    re = []
+
+    # bad by class, you perv
+    bbc = bad.map { |s| s.split(/#/, 2) }.group_by(&:first)
+
+    bbc.each do |klass, methods|
+      methods = methods.map(&:last).flatten.uniq.map { |method|
+        re_escape method
+      }
+
+      methods = methods.join "|"
+      re << /#{re_escape klass}#(?:#{methods})/.to_s[7..-2] # (?-mix:...)
+    end
+
+    re = re.join("|").to_s.gsub(/-mix/, "")
+
+    "/^(?:#{re})$/"
+  end
+
+  def re_escape str # :nodoc:
+    str.gsub(/([`'"!?&\[\]\(\)\{\}\|\+])/, '\\\\\1')
+  end
+
+  ############################################################
+  # Server Methods:
+
+  def minitest_start # :nodoc:
+    self.failures.clear
+  end
+
+  def minitest_result file, klass, method, fails, assertions, time # :nodoc:
+    fails.reject! { |fail| Minitest::Skip === fail }
+
+    if fails.empty? then
+      culprits << "#{klass}##{method}" unless seen_bad # UGH
+    else
+      self.seen_bad = true
+    end
+
+    return if fails.empty?
+
+    self.tainted = true
+    self.failures[file][klass] << method
+  end
+end

data/lib/minitest/complete.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env -S ruby
+
+# :stopdoc:
+
+require "optparse"
+require "shellwords"
+
+# complete -o bashdefault -f -C 'ruby lib/minitest/complete.rb' minitest
+# using eg:
+#    COMP_LINE="blah test/test_file.rb -n test_pattern"
+# or test directly with:
+#    ./lib/minitest/complete.rb test/test_file.rb -n test_pattern
+
+argv = Shellwords.split ENV["COMP_LINE"] || ARGV.join(" ")
+comp_re = nil
+
+begin
+  OptionParser.new do |opts|
+    # part of my unofficial embedded gem "makeoptparseworkwell"
+    def opts.topdict(name)   = (name.length > 1 ? top.long : top.short)
+    def opts.alias(from, to) = (dict = topdict(from) ; dict[to] = dict[from])
+
+    opts.on "-n", "--name [METHOD]", "minitest option" do |m|
+      comp_re = Regexp.new m
+    end
+
+    opts.alias "name", "include"
+    opts.alias "name", "exclude"
+    opts.alias "n",    "i"
+    opts.alias "n",    "e"
+    opts.alias "n",    "x"
+  end.parse! argv
+rescue
+  retry # ignore options passed to Ruby
+end
+
+path = argv.find_all { |f| File.file? f }.last
+
+exit unless comp_re && path
+
+require "prism"
+
+names, queue = [], [Prism.parse_file(path).value]
+
+while node = queue.shift do
+  if node.type == :def_node then
+    name = node.name
+    names << name if name =~ comp_re
+  else
+    queue.concat node.compact_child_nodes # no need to process def body
+  end
+end
+
+puts names.sort
+
+# :startdoc: