minitest 5.25.5 → 6.0.0

data/lib/minitest.rb

@@ -10,7 +10,7 @@ require_relative "minitest/compress"
 # runtime. See +Minitest.run+ for more information.
 
 module Minitest
-  VERSION = "5.25.5" # :nodoc:
+  VERSION = "6.0.0" # :nodoc:
 
   @@installed_at_exit ||= false
   @@after_run = []
@@ -33,10 +33,9 @@ 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
+  self.parallel_executor = Parallel::Executor.new n_threads if n_threads > 1
 
   ##
   # Filter object for backtraces.
@@ -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,27 +155,33 @@ 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.banner  = "minitest options:"
+      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",
+      ].join "\n   or: "
+
       opts.on "-h", "--help", "Display this help." do
         puts opts
         exit
       end
 
-      opts.on "--no-plugins", "Bypass minitest plugin auto-loading (or set $MT_NO_PLUGINS)."
-
-      desc = "Sets random seed. Also via env. Eg: SEED=n rake"
+      desc = "Sets random seed. Also via env, eg: SEED=42"
       opts.on "-s", "--seed SEED", Integer, desc do |m|
-        options[:seed] = m.to_i
+        options[:seed] = m
       end
 
-      opts.on "-v", "--verbose", "Verbose. Show progress processing files." do
+      opts.on "-v", "--verbose", "Verbose. Print each name as they run." do
         options[:verbose] = true
       end
 
-      opts.on "-q", "--quiet", "Quiet. Show no progress processing files." do
+      opts.on "-q", "--quiet", "Quiet. Show no dots while processing files." do
         options[:quiet] = true
       end
 
@@ -174,29 +189,38 @@ module Minitest
         options[:show_skips] = true
       end
 
-      opts.on "-n", "--name PATTERN", "Filter run on /regexp/ or string." 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
 
+      # 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.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
       end
 
-      ruby27plus = ::Warning.respond_to? :[]=
-
       opts.on "-W[error]", String, "Turn Ruby warnings into errors" do |s|
         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 if ruby27plus
+          ::Warning[:deprecated] = true
         else
-          ::Warning[s.to_sym] = true if ruby27plus # check validity of category
+          ::Warning[s.to_sym] = true # check validity of category
         end
       end
 
@@ -253,22 +277,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)
-  #         Runnable.runnables.each
-  #           runnable_klass.run(reporter, options)
-  #             self.runnable_methods.each
-  #               self.run_one_method(self, runnable_method, reporter)
-  #                 Minitest.run_one_method(klass, runnable_method)
-  #                   klass.new(runnable_method).run
+  #       Minitest.run_all_suites(reporter, options)
+  #         Runnable.runnables.each |runnable_klass|
+  #           runnable_klass.run_suite(reporter, options)
+  #             filtered_methods = runnable_klass.filter_runnable_methods options
+  #             filtered_methods.each |runnable_method|
+  #               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]
@@ -285,23 +307,24 @@ 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..."
     end
-    self.parallel_executor.shutdown
+    self.parallel_executor.shutdown if parallel_executor.respond_to? :shutdown
 
     # might have been removed/replaced during init_plugins:
     summary = reporter.reporters.grep(SummaryReporter).first
 
     reporter.report
 
-    return empty_run! options if summary && summary.count == 0
-    reporter.passed?
+    return empty_run! options if finished && summary && summary.count == 0
+    finished and reporter.passed?
   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]
@@ -320,17 +343,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:
@@ -398,20 +421,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%/(.*)/%
 
-      filtered_methods = self.runnable_methods
+      # at most 1-2% slower than a 1-pass version, stop optimizing this
+      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?
 
@@ -426,12 +459,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
@@ -442,20 +475,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
 
@@ -489,22 +522,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
@@ -572,7 +589,7 @@ module Minitest
     def skipped?
       raise NotImplementedError, "subclass responsibility"
     end
-  end
+  end # Runnable
 
   ##
   # Shared code for anything that can get passed to a Reporter. See
@@ -624,7 +641,7 @@ module Minitest
     def error?
       self.failures.any? UnexpectedError
     end
-  end
+  end # Reportable
 
   ##
   # This represents a test result in a clean way that can be
@@ -636,9 +653,6 @@ module Minitest
   class Result < Runnable
     include Minitest::Reportable
 
-    undef_method :marshal_dump
-    undef_method :marshal_load
-
     ##
     # The class name of the test result.
 
@@ -678,7 +692,7 @@ module Minitest
         "#{failure.result_label}:\n#{self.location}:\n#{failure.message}\n"
       }.join "\n"
     end
-  end
+  end # Result
 
   ##
   # Defines the API for Reporters. Subclass this and override whatever
@@ -728,7 +742,7 @@ module Minitest
     def synchronize &block # :nodoc:
       @mutex.synchronize(&block)
     end
-  end
+  end # AbstractReportera
 
   class Reporter < AbstractReporter # :nodoc:
     ##
@@ -883,7 +897,7 @@ module Minitest
       self.warnings   = aggregate[UnexpectedWarning].size
       self.skips      = aggregate[Skip].size
     end
-  end
+  end # StatisticsReporter
 
   ##
   # A reporter that prints the header, summary, and failure details at
@@ -961,7 +975,7 @@ module Minitest
       "%d runs, %d assertions, %d failures, %d errors, %d skips%s" %
         [count, assertions, failures, errors, skips, extra.join]
     end
-  end
+  end # SummaryReporter
 
   ##
   # Dispatch to multiple reporters as one.
@@ -998,8 +1012,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
 
@@ -1012,7 +1025,7 @@ module Minitest
     def report # :nodoc:
       self.reporters.each(&:report)
     end
-  end
+  end # CompositeReporter
 
   ##
   # Represents run failures.
@@ -1079,7 +1092,7 @@ module Minitest
       self.error.backtrace
     end
 
-    BASE_RE = %r%#{Dir.pwd}/% # :nodoc:
+    BASE_RE = %r%#{Regexp.escape Dir.pwd}/% # :nodoc:
 
     def message # :nodoc:
       bt = Minitest.filter_backtrace(self.backtrace).join("\n    ")
@@ -1125,16 +1138,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?
 
@@ -1149,16 +1152,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?
 
@@ -1204,12 +1197,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:
@@ -1232,4 +1219,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

data/test/minitest/test_bisect.rb

@@ -0,0 +1,235 @@
+require "minitest/autorun"
+require "minitest/bisect"
+
+module TestMinitest; end
+
+class TestMinitest::TestBisect < Minitest::Test
+  attr_accessor :bisect
+
+  def setup
+    self.bisect = Minitest::Bisect.new
+    bisect.reset
+  end
+
+  def test_class_run
+    skip "Need to write test_class_run"
+  end
+
+  def test_bisect_files
+    skip "Need to write test_bisect_files"
+  end
+
+  def test_bisect_methods
+    skip "Need to write test_bisect_methods"
+  end
+
+  def test_build_files_cmd
+    files = %w[a.rb b.rb c.rb]
+    rb    = %w[-Ilib:test]
+    mt    = %w[--seed 42]
+
+    ruby = Minitest::Bisect::RUBY
+    body = "require \"./a.rb\" ; require \"./b.rb\" ; require \"./c.rb\""
+
+    exp = "#{ruby} -Ilib:test -e '#{body}' -- --seed 42"
+    act = bisect.build_files_cmd(files, rb, mt)
+
+    assert_equal exp, act
+  end
+
+  def test_build_methods_cmd
+    cmd = "cmd"
+    assert_equal "cmd", bisect.build_methods_cmd(cmd)
+  end
+
+  def test_build_methods_cmd_verify
+    cmd = "cmd"
+    cul = []
+    bad = %w[A#test_1 B#test_2]
+
+    exp = "cmd -n \"/^(?:A#(?:test_1)|B#(?:test_2))$/\""
+
+    assert_equal exp, bisect.build_methods_cmd(cmd, cul, bad)
+  end
+
+  def test_build_methods_cmd_verify_same
+    cmd = "cmd"
+    cul = []
+    bad = %w[C#test_5 C#test_6]
+
+    exp = "cmd -n \"/^(?:C#(?:test_5|test_6))$/\""
+
+    assert_equal exp, bisect.build_methods_cmd(cmd, cul, bad)
+  end
+
+  def test_build_methods_cmd_full
+    cmd = "cmd"
+    cul = %w[A#test_1 A#test_2 B#test_3 B#test_4]
+    bad = %w[C#test_5 C#test_6]
+
+    a = "A#(?:test_1|test_2)"
+    b = "B#(?:test_3|test_4)"
+    c = "C#(?:test_5|test_6)"
+    exp = "cmd -n \"/^(?:#{a}|#{b}|#{c})$/\""
+
+    assert_equal exp, bisect.build_methods_cmd(cmd, cul, bad)
+  end
+
+  def test_build_re
+    bad = %w[A#test_1 B#test_2]
+
+    exp = "/^(?:A#(?:test_1)|B#(?:test_2))$/"
+
+    assert_equal exp, bisect.build_re(bad)
+  end
+
+  def test_build_re_same
+    bad = %w[C#test_5 C#test_6]
+
+    exp = "/^(?:C#(?:test_5|test_6))$/"
+
+    assert_equal exp, bisect.build_re(bad)
+  end
+
+  def test_build_re_class_escaping
+    bad = ["{}#[]"]
+
+    exp = "/^(?:\\{\\}#(?:\\[\\]))$/"
+
+    assert_equal exp, bisect.build_re(bad)
+  end
+
+  def test_build_re_method_escaping
+    bad = ["Some Class#It shouldn't care what the name is"]
+
+    exp = "/^(?:Some Class#(?:It shouldn\\'t care what the name is))$/"
+
+    assert_equal exp, bisect.build_re(bad)
+  end
+
+  def test_map_failures
+    bisect.failures =
+      {
+       "file.rb" => { "Class" => %w[test_method1 test_method2] },
+       "blah.rb" => { "Apple" => %w[test_method3 test_method4] },
+      }
+
+    exp = %w[
+           Apple#test_method3
+           Apple#test_method4
+           Class#test_method1
+           Class#test_method2
+          ]
+
+    assert_equal exp, bisect.map_failures
+  end
+
+  def test_minitest_result
+    bisect.minitest_result "file.rb", "TestClass", "test_method", [], 1, 1
+
+    assert_equal false, bisect.tainted
+    assert_empty bisect.failures
+    assert_equal ["TestClass#test_method"], bisect.culprits
+  end
+
+  def test_minitest_result_skip
+    fail = Minitest::Skip.new("woot")
+
+    bisect.minitest_result "file.rb", "TestClass", "test_method", [fail], 1, 1
+
+    assert_equal false, bisect.tainted
+    assert_empty bisect.failures
+    assert_equal ["TestClass#test_method"], bisect.culprits
+  end
+
+  def test_minitest_result_fail
+    fail = Minitest::Assertion.new "msg"
+
+    bisect.minitest_result "file.rb", "TestClass", "test_method", [fail], 1, 1
+
+    exp = {"file.rb" => {"TestClass" => ["test_method"] }}
+
+    assert_equal true, bisect.tainted
+    assert_equal exp, bisect.failures
+    assert_empty bisect.culprits
+  end
+
+  def test_minitest_result_error
+    fail = Minitest::UnexpectedError.new RuntimeError.new("woot")
+
+    bisect.minitest_result "file.rb", "TestClass", "test_method", [fail], 1, 1
+
+    exp = {"file.rb" => {"TestClass" => ["test_method"] }}
+
+    assert_equal true, bisect.tainted
+    assert_equal exp, bisect.failures
+    assert_empty bisect.culprits
+  end
+
+  def test_minitest_start
+    bisect.failures["file.rb"]["Class"] << "test_bad1"
+
+    bisect.minitest_start
+
+    assert_empty bisect.failures
+  end
+
+  def test_reset
+    bisect.seen_bad = true
+    bisect.tainted  = true
+    bisect.failures["file.rb"]["Class"] << "test_bad1"
+    bisect.culprits << "A#test_1" << "B#test_2"
+
+    bisect.reset
+
+    assert_equal false, bisect.seen_bad
+    assert_equal false, bisect.tainted
+    assert_empty bisect.failures
+    assert_equal %w[A#test_1 B#test_2], bisect.culprits
+  end
+
+  def test_run
+    skip "Need to write test_run"
+  end
+
+  def test_time_it
+    exp = /\Ado stuff: in 0.\d\d sec\n\z/
+
+    assert_output exp, "" do
+      bisect.time_it "do stuff:", "echo you should not see me"
+    end
+  end
+end
+
+class TestMinitest::TestBisect::TestPathExpander < Minitest::Test
+  def test_sanity
+    args = %w[1 -Iblah 2 -d 3 -w 4 5 6]
+
+    mtbpe = Minitest::Bisect::PathExpander
+    expander = mtbpe.new args
+
+    assert_equal %w[-Itest:lib], expander.rb_flags
+    assert_same mtbpe::TEST_GLOB, expander.glob
+  end
+
+  def test_process_flags
+    args = %w[1 -Iblah 2 -d 3 -w 4 5 6]
+
+    expander = Minitest::Bisect::PathExpander.new args
+
+    exp_files = %w[1 2 3 4 5 6]
+    exp_flags = %w[-Itest:lib -Iblah -d -w]
+
+    files = expander.process_flags(args)
+
+    assert_equal files, exp_files
+
+    # process_flags only filters and does not mutate args
+    assert_same args, expander.args
+    refute_equal args, exp_files
+    refute_equal files, args
+
+    # separates rb_flags out for separate handling
+    assert_equal exp_flags, expander.rb_flags
+  end
+end