minitest 5.26.2 → 6.0.1

data/lib/minitest/sprint.rb

@@ -0,0 +1,104 @@
+$LOAD_PATH.unshift "test", "lib"
+
+require "simplecov" if ENV["MT_COV"] || ARGV.delete("--simplecov")
+require_relative "autorun"
+require_relative "path_expander"
+
+##
+# Runs (Get it? It's fast!) your tests and makes it easier to rerun individual
+# failures.
+
+module Minitest
+  class Sprint
+    # extracted version = "1.5.0"
+
+    ##
+    # Process and run minitest cmdline.
+
+    def self.run args = ARGV
+      if ARGV.delete("--bisect") or ARGV.delete("-b") then
+        require_relative "bisect"
+
+        return Minitest::Bisect.run ARGV
+      end
+
+      Minitest::PathExpander.new(args).process { |f|
+        require "./#{f}" if File.file? f
+      }
+    end
+
+    ##
+    # An extra minitest reporter to output how to rerun failures in
+    # various styles.
+
+    class SprintReporter < AbstractReporter
+      ##
+      # The style to report, either lines or regexp. Defaults to lines.
+      attr_accessor :style
+      attr_accessor :results # :nodoc:
+
+      def initialize style = :regexp # :nodoc:
+        self.results = []
+        self.style = style
+      end
+
+      def record result # :nodoc:
+        results << result unless result.passed? or result.skipped?
+      end
+
+      def report # :nodoc:
+        return if results.empty?
+
+        puts
+        puts "Happy Happy Sprint List:"
+        puts
+        print_list
+        puts
+      end
+
+      def print_list # :nodoc:
+        case style
+        when :regexp
+          results.each do |result|
+            puts "  minitest -n #{result.class_name}##{result.name}"
+          end
+        when :lines
+          files = Hash.new { |h,k| h[k] = [] }
+          results.each do |result|
+            path, line = result.source_location
+            path = path.delete_prefix "#{Dir.pwd}/"
+            files[path] << line
+          end
+
+          files.sort.each do |path, lines|
+            puts "  minitest %s:%s" % [path, lines.sort.join(",")]
+          end
+        else
+          raise "unsupported style: %p" % [style]
+        end
+      end
+    end
+
+    ##
+    # An extra minitest reporter to output how to rerun failures using
+    # rake.
+
+    class RakeReporter < SprintReporter
+      ##
+      # The name of the rake task to rerun. Defaults to nil.
+
+      attr_accessor :name
+
+      def initialize name = nil # :nodoc:
+        super()
+        self.name    = name
+      end
+
+      def print_list # :nodoc:
+        results.each do |result|
+          puts ["  rake", name, "N=#{result.class_name}##{result.name}"].compact.join(" ")
+        end
+      end
+    end
+  end
+end

data/lib/minitest/sprint_plugin.rb

@@ -0,0 +1,39 @@
+require_relative "../minitest"
+
+# :stopdoc:
+class OptionParser # unofficial embedded gem "makeoptparseworkwell"
+  def hidden(...)         = define(...).tap { |sw| def sw.summarize(*) = nil }
+  def deprecate(from, to) = hidden(from) { abort "#{from} is deprecated. Use #{to}." }
+  def topdict(name)       = name.length > 1 ? top.long : top.short
+  def alias(from, to)     = (dict = topdict(from) and dict[to] = dict[from])
+end unless OptionParser.method_defined? :hidden
+# :startdoc:
+
+module Minitest # :nodoc:
+  def self.plugin_sprint_options opts, options # :nodoc:
+    opts.on "--rake [TASK]", "Report how to re-run failures with rake." do |task|
+      options[:sprint] = :rake
+      options[:rake_task] = task
+    end
+
+    opts.deprecate "--binstub", "--rerun"
+
+    sprint_styles = %w[rake lines names binstub]
+
+    opts.on "-r", "--rerun [STYLE]", sprint_styles, "Report how to re-run failures using STYLE (names, lines)." do |style|
+      options[:sprint] = (style || :lines).to_sym
+    end
+  end
+
+  def self.plugin_sprint_init options
+    require_relative "sprint"
+    case options[:sprint]
+    when :rake then
+      self.reporter << Minitest::Sprint::RakeReporter.new(options[:rake_task])
+    when :binstub, :names then
+      self.reporter << Minitest::Sprint::SprintReporter.new
+    when :lines then
+      self.reporter << Minitest::Sprint::SprintReporter.new(:lines)
+    end
+  end
+end

data/lib/minitest/test.rb

@@ -1,4 +1,4 @@
-require "minitest" unless defined? Minitest::Runnable
+require_relative "../minitest" unless defined? Minitest::Runnable
 
 module Minitest
   ##
@@ -8,14 +8,10 @@ module Minitest
   # See Minitest::Assertions
 
   class Test < Runnable
-    require "minitest/assertions"
+    require_relative "assertions"
     include Minitest::Reportable
     include Minitest::Assertions
 
-    def class_name # :nodoc:
-      self.class.name # for Minitest::Reportable
-    end
-
     PASSTHROUGH_EXCEPTIONS = [NoMemoryError, SignalException, SystemExit] # :nodoc:
 
     SETUP_METHODS = %w[ before_setup setup after_setup ] # :nodoc:
@@ -34,8 +30,8 @@ module Minitest
 
     def self.i_suck_and_my_tests_are_order_dependent!
       class << self
-        undef_method :test_order if method_defined? :test_order
-        define_method :test_order do :alpha end
+        undef_method :run_order if method_defined? :run_order
+        define_method :run_order do :alpha end
       end
     end
 
@@ -65,20 +61,20 @@ module Minitest
 
     ##
     # Returns all instance methods starting with "test_". Based on
-    # #test_order, the methods are either sorted, randomized
+    # #run_order, the methods are either sorted, randomized
     # (default), or run in parallel.
 
     def self.runnable_methods
       methods = methods_matching(/^test_/)
 
-      case self.test_order
+      case self.run_order
       when :random, :parallel then
         srand Minitest.seed
         methods.sort.shuffle
       when :alpha, :sorted then
         methods.sort
       else
-        raise "Unknown test_order: #{self.test_order.inspect}"
+        raise "Unknown_order: %p" % [self.run_order]
       end
     end
 
@@ -234,5 +230,3 @@ module Minitest
     extend Guard
   end # Test
 end
-
-require "minitest/unit" if ENV["MT_COMPAT"] # compatibility layer only

data/lib/minitest/test_task.rb

@@ -168,20 +168,18 @@ module Minitest # :nodoc:
         ENV["TESTOPTS"]
       warn "FILTER is deprecated in Minitest::TestTask. Use A instead" if
         ENV["FILTER"]
-      warn "N is deprecated in Minitest::TestTask. Use MT_CPU instead" if
-        ENV["N"] && ENV["N"].to_i > 0
 
       lib_extras = (ENV["MT_LIB_EXTRAS"] || "").split File::PATH_SEPARATOR
       self.libs[0, 0] = lib_extras
 
-      extra_args << "-n" << ENV["N"]                      if ENV["N"]
-      extra_args << "-e" << ENV["X"]                      if ENV["X"]
+      extra_args << "-i" << ENV["N"]                      if ENV["N"]
+      extra_args << "-i" << ENV["I"]                      if ENV["I"]
+      extra_args << "-x" << ENV["X"]                      if ENV["X"]
+      extra_args << "-x" << ENV["E"]                      if ENV["E"]
       extra_args.concat Shellwords.split(ENV["TESTOPTS"]) if ENV["TESTOPTS"]
       extra_args.concat Shellwords.split(ENV["FILTER"])   if ENV["FILTER"]
       extra_args.concat Shellwords.split(ENV["A"])        if ENV["A"]
 
-      ENV.delete "N" if ENV["N"]
-
       # TODO? RUBY_DEBUG = ENV["RUBY_DEBUG"]
       # TODO? ENV["RUBY_FLAGS"]
 
@@ -189,11 +187,16 @@ module Minitest # :nodoc:
     end
 
     def define # :nodoc:
-      desc "Run the test suite. Use N, X, A, and TESTOPTS to add flags/args."
+      desc "Run the test suite. Use I, X, and A to add flags/args."
       task name do
         ruby make_test_cmd, verbose: verbose
       end
 
+      desc "Run the test suite, filtering for 'FU' in name (focused units?)."
+      task "#{name}:fu" do
+        ruby make_test_cmd(include:"/FU/"), verbose: verbose
+      end
+
       desc "Print out the test command. Good for profiling and other tools."
       task "#{name}:cmd" do
         puts "ruby #{make_test_cmd}"
@@ -212,7 +215,7 @@ module Minitest # :nodoc:
 
         n.threads_do tests.sort do |path|
           t0 = Time.now
-          output = `#{Gem.ruby} #{make_test_cmd path} 2>&1`
+          output = `#{Gem.ruby} #{make_test_cmd path:path} 2>&1`
           t1 = Time.now - t0
 
           times[path] = t1
@@ -278,7 +281,9 @@ module Minitest # :nodoc:
     ##
     # Generate the test command-line.
 
-    def make_test_cmd globs = test_globs
+    def make_test_cmd **option
+      globs = option[:path] || test_globs
+
       tests = []
       tests.concat Dir[*globs].sort.shuffle # TODO: SEED -> srand first?
       tests.map! { |f| %(require "#{f}") }
@@ -289,6 +294,8 @@ module Minitest # :nodoc:
       runner.concat tests
       runner = runner.join "; "
 
+      extra_args << "-i" << option[:include] if option[:include]
+
       args  = []
       args << "-I#{libs.join File::PATH_SEPARATOR}" unless libs.empty?
       args << "-w" if warning
@@ -303,13 +310,8 @@ module Minitest # :nodoc:
 end
 
 class Work < Queue # :nodoc:
-  def initialize jobs = [] # :nodoc:
-    super()
-
-    jobs.each do |job|
-      self << job
-    end
-
+  def initialize jobs # :nodoc:
+    super
     close
   end
 end

data/lib/minitest.rb

@@ -10,7 +10,7 @@ require_relative "minitest/compress"
 # runtime. See +Minitest.run+ for more information.
 
 module Minitest
-  VERSION = "5.26.2" # :nodoc:
+  VERSION = "6.0.1" # :nodoc:
 
   @@installed_at_exit ||= false
   @@after_run = []
@@ -33,8 +33,7 @@ module Minitest
 
   cattr_accessor :parallel_executor
 
-  warn "DEPRECATED: use MT_CPU instead of N for parallel test runs" if ENV["N"] && ENV["N"].to_i > 0
-  n_threads = (ENV["MT_CPU"] || ENV["N"] || Etc.nprocessors).to_i
+  n_threads = (ENV["MT_CPU"] || Etc.nprocessors).to_i
 
   self.parallel_executor = Parallel::Executor.new n_threads if n_threads > 1
 
@@ -68,8 +67,7 @@ module Minitest
   # Registers Minitest to run at process exit
 
   def self.autorun
-    Warning[:deprecated] = true if
-      Object.const_defined?(:Warning) && Warning.respond_to?(:[]=)
+    Warning[:deprecated] = true
 
     at_exit {
       next if $! and not ($!.kind_of? SystemExit and $!.success?)
@@ -98,6 +96,17 @@ module Minitest
     @@after_run << block
   end
 
+  ##
+  # Manually load plugins by name.
+
+  def self.load *names
+    names.each do |name|
+      require "minitest/#{name}_plugin"
+
+      self.extensions << name.to_s
+    end
+  end
+
   ##
   # Register a plugin to be used. Does NOT require / load it.
 
@@ -146,22 +155,27 @@ module Minitest
               }
     orig_args = args.dup
 
+    warn "--no-plugins is a no-op" if args.delete "--no-plugins" # TODO: remove me! when?
+
     OptionParser.new do |opts|
       opts.program_name = "minitest"
       opts.version = Minitest::VERSION
 
       opts.banner = [
-        "Usage: rake test [A=options]        (see Minitest::TestTask for more options)",
-        "minitest [paths] [options]   (with minitest-sprint gem)",
-        "ruby path/to/test.rb [options]\n\n",
+        "Usage: minitest [paths]     [options]",
+        "ruby path/to/test.rb [options]",
+        "rake test          [A=options] (see Minitest::TestTask for more options)\n\n",
       ].join "\n   or: "
 
       opts.on "-h", "--help", "Display this help." do
         puts opts
-        exit
+        exit! true
       end
 
-      opts.on "--no-plugins", "Bypass minitest plugin auto-loading (or env: MT_NO_PLUGINS=1)."
+      opts.on "-V", "--version", "Display the version." do
+        puts "#{opts.program_name} #{Minitest::VERSION}"
+        exit! true
+      end
 
       desc = "Sets random seed. Also via env, eg: SEED=42"
       opts.on "-s", "--seed SEED", Integer, desc do |m|
@@ -180,22 +194,24 @@ module Minitest
         options[:show_skips] = true
       end
 
-      opts.on "-n", "--name PATTERN", "Include /regexp/ or string for run." do |a|
-        options[:filter] = a
+      opts.on "-b", "--bisect", "Run minitest in bisect-mode to isolate flaky tests."
+
+      opts.on "-i", "--include PATTERN", "Include /regexp/ or string for run." do |a|
+        options[:include] = a
       end
 
       opts.on "-e", "--exclude PATTERN", "Exclude /regexp/ or string from run." do |a|
         options[:exclude] = a
       end
 
-      # omg wtf
-      def opts.short_alias(from, to) = top.short[to] = top.short[from]
-      def opts.long_alias(from, to)  = top.long[to]  = top.long[from]
+      # 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])
 
       # these will work but won't show up in --help output:
-      opts.long_alias  "name", "include"
-      opts.short_alias "n",       "i"
-      opts.short_alias "e",       "x"
+      opts.alias "include", "name"
+      opts.alias "i",       "n"
+      opts.alias "e",       "x"
 
       opts.on "-S", "--skip CODES", String, "Skip reporting of certain types of results (eg E)." do |s|
         options[:skip] = s.chars.to_a
@@ -205,7 +221,7 @@ module Minitest
         options[:Werror] = true
         case s
         when "error", "all", nil then
-          require "minitest/error_on_warning"
+          require_relative "minitest/error_on_warning"
           $VERBOSE = true
           ::Warning[:deprecated] = true
         else
@@ -266,23 +282,20 @@ module Minitest
   #
   # The overall structure of a run looks like this:
   #
+  #   [Minitest.load_plugins] optional, called by user, or require what you want
   #   Minitest.autorun
   #     Minitest.run(args)
-  #       Minitest.load_plugins
   #       Minitest.process_args
   #       Minitest.init_plugins
-  #       Minitest.__run(reporter, options)
+  #       Minitest.run_all_suites(reporter, options)
   #         Runnable.runnables.each |runnable_klass|
-  #           runnable_klass.run(reporter, options)
-  #             filtered_methods = runnable_methods.select {...}.reject {...}
+  #           runnable_klass.run_suite(reporter, options)
+  #             filtered_methods = runnable_klass.filter_runnable_methods options
   #             filtered_methods.each |runnable_method|
-  #               runnable_klass.run_one_method(self, runnable_method, reporter)
-  #                 Minitest.run_one_method(runnable_klass, runnable_method)
-  #                   runnable_klass.new(runnable_method).run
+  #               runnable_klass.run(self, runnable_method, reporter)
+  #                 runnable_klass.new(runnable_method).run
 
   def self.run args = []
-    self.load_plugins unless args.delete("--no-plugins") || ENV["MT_NO_PLUGINS"]
-
     options = process_args args
 
     Minitest.seed = options[:seed]
@@ -299,7 +312,7 @@ module Minitest
     self.parallel_executor.start if parallel_executor.respond_to? :start
     reporter.start
     begin
-      __run reporter, options
+      run_all_suites reporter, options
       finished = true
     rescue Interrupt
       warn "Interrupted. Exiting..."
@@ -316,7 +329,7 @@ module Minitest
   end
 
   def self.empty_run! options # :nodoc:
-    filter = options[:filter]
+    filter = options[:include]
     return true unless filter # no filter, but nothing ran == success
 
     warn "Nothing ran for filter: %s" % [filter]
@@ -335,17 +348,17 @@ module Minitest
   # Internal run method. Responsible for telling all Runnable
   # sub-classes to run.
 
-  def self.__run reporter, options
+  def self.run_all_suites reporter, options
     suites = Runnable.runnables.shuffle
-    parallel, serial = suites.partition { |s| s.test_order == :parallel }
+    parallel, serial = suites.partition { |s| s.run_order == :parallel }
 
     # If we run the parallel tests before the serial tests, the parallel tests
     # could run in parallel with the serial tests. This would be bad because
     # the serial tests won't lock around Reporter#record. Run the serial tests
     # first, so that after they complete, the parallel tests will lock when
     # recording results.
-    serial.map { |suite| suite.run reporter, options } +
-      parallel.map { |suite| suite.run reporter, options }
+    serial.map { |suite| suite.run_suite reporter, options } +
+      parallel.map { |suite| suite.run_suite reporter, options }
   end
 
   def self.filter_backtrace bt # :nodoc:
@@ -413,21 +426,30 @@ module Minitest
     reset
 
     ##
-    # Responsible for running all runnable methods in a given class,
-    # each in its own instance. Each instance is passed to the
-    # reporter to record.
+    # Returns an array of filtered +runnable_methods+. Uses
+    # options[:include] (--include arguments) and options[:exclude]
+    # (--exclude arguments) values to filter.
 
-    def self.run reporter, options = {}
-      pos = options[:filter]
+    def self.filter_runnable_methods options={}
+      pos = options[:include]
       neg = options[:exclude]
 
       pos = Regexp.new $1 if pos.kind_of?(String) && pos =~ %r%/(.*)/%
       neg = Regexp.new $1 if neg.kind_of?(String) && neg =~ %r%/(.*)/%
 
       # at most 1-2% slower than a 1-pass version, stop optimizing this
-      filtered_methods = self.runnable_methods
+      self.runnable_methods
         .select { |m| !pos ||  pos === m || pos === "#{self}##{m}"  }
         .reject { |m|  neg && (neg === m || neg === "#{self}##{m}") }
+    end
+
+    ##
+    # Responsible for running all runnable methods in a given class,
+    # each in its own instance. Each instance is passed to the
+    # reporter to record.
+
+    def Runnable.run_suite reporter, options = {}
+      filtered_methods = filter_runnable_methods options
 
       return if filtered_methods.empty?
 
@@ -442,12 +464,12 @@ module Minitest
         warn "Current: %s#%s %.2fs" % [self, name, Minitest.clock_time - t0]
       end
 
-      with_info_handler reporter do
+      with_info_handler do
         filtered_methods.each do |method_name|
           name = method_name
           t0 = Minitest.clock_time
 
-          run_one_method self, method_name, reporter
+          run self, method_name, reporter
         end
       end
     end
@@ -458,20 +480,20 @@ module Minitest
     # that subclasses can specialize the running of an individual
     # test. See Minitest::ParallelTest::ClassMethods for an example.
 
-    def self.run_one_method klass, method_name, reporter
+    def Runnable.run klass, method_name, reporter
       reporter.prerecord klass, method_name
-      reporter.record Minitest.run_one_method(klass, method_name)
+      reporter.record klass.new(method_name).run
     end
 
     ##
     # Defines the order to run tests (:random by default). Override
     # this or use a convenience method to change it for your tests.
 
-    def self.test_order
+    def self.run_order
       :random
     end
 
-    def self.with_info_handler reporter, &block # :nodoc:
+    def self.with_info_handler _reporter=nil, &block # :nodoc:
       on_signal ::Minitest.info_signal, @_info_handler, &block
     end
 
@@ -505,22 +527,6 @@ module Minitest
       @@runnables
     end
 
-    @@marshal_dump_warned = false
-
-    def marshal_dump # :nodoc:
-      unless @@marshal_dump_warned then
-        warn ["Minitest::Runnable#marshal_dump is deprecated.",
-              "You might be violating internals. From", caller(1..1).first].join " "
-        @@marshal_dump_warned = true
-      end
-
-      [self.name, self.failures, self.assertions, self.time]
-    end
-
-    def marshal_load ary # :nodoc:
-      self.name, self.failures, self.assertions, self.time = ary
-    end
-
     def failure # :nodoc:
       self.failures.first
     end
@@ -652,9 +658,6 @@ module Minitest
   class Result < Runnable
     include Minitest::Reportable
 
-    undef_method :marshal_dump
-    undef_method :marshal_load
-
     ##
     # The class name of the test result.
 
@@ -1014,8 +1017,7 @@ module Minitest
 
     def prerecord klass, name # :nodoc:
       self.reporters.each do |reporter|
-        # TODO: remove conditional for minitest 6
-        reporter.prerecord klass, name if reporter.respond_to? :prerecord
+        reporter.prerecord klass, name
       end
     end
 
@@ -1141,16 +1143,6 @@ module Minitest
       "java" == platform
     end
 
-    ##
-    # Is this running on maglev?
-
-    def maglev? platform = defined?(RUBY_ENGINE) && RUBY_ENGINE
-      where = Minitest.filter_backtrace(caller).first
-      where = where.split(":in ", 2).first # clean up noise
-      warn "DEPRECATED: `maglev?` called from #{where}. This will fail in Minitest 6."
-      "maglev" == platform
-    end
-
     ##
     # Is this running on mri?
 
@@ -1165,16 +1157,6 @@ module Minitest
       platform.include? "darwin"
     end
 
-    ##
-    # Is this running on rubinius?
-
-    def rubinius? platform = defined?(RUBY_ENGINE) && RUBY_ENGINE
-      where = Minitest.filter_backtrace(caller).first
-      where = where.split(":in ", 2).first # clean up noise
-      warn "DEPRECATED: `rubinius?` called from #{where}. This will fail in Minitest 6."
-      "rbx" == platform
-    end
-
     ##
     # Is this running on windows?
 
@@ -1220,12 +1202,6 @@ module Minitest
 
   self.backtrace_filter = BacktraceFilter.new
 
-  def self.run_one_method klass, method_name # :nodoc:
-    result = klass.new(method_name).run
-    raise "#{klass}#run _must_ return a Result" unless Result === result
-    result
-  end
-
   # :stopdoc:
 
   if defined? Process::CLOCK_MONOTONIC # :nodoc:
@@ -1248,4 +1224,4 @@ module Minitest
   # :startdoc:
 end
 
-require "minitest/test"
+require_relative "minitest/test"

data/test/minitest/metametameta.rb

@@ -79,7 +79,7 @@ class MetaMetaMetaTestCase < Minitest::Test
       @tus.each do |tu|
         Minitest::Runnable.runnables.delete tu
 
-        tu.run reporter, options
+        tu.run_suite reporter, options
       end
 
       reporter.report