minitest 5.12.0 → 5.22.2

data/lib/minitest.rb

@@ -1,64 +1,84 @@
 require "optparse"
-require "thread"
-require "mutex_m"
-require "minitest/parallel"
 require "stringio"
+require "etc"
+
+require_relative "minitest/parallel"
+require_relative "minitest/compress"
 
 ##
 # :include: README.rdoc
 
 module Minitest
-  VERSION = "5.12.0" # :nodoc:
-  ENCS = "".respond_to? :encoding # :nodoc:
+  VERSION = "5.22.2" # :nodoc:
 
   @@installed_at_exit ||= false
   @@after_run = []
   @extensions = []
 
-  mc = (class << self; self; end)
+  def self.cattr_accessor name # :nodoc:
+    (class << self; self; end).attr_accessor name
+  end
+
+  ##
+  # The random seed used for this run. This is used to srand at the
+  # start of the run and between each +Runnable.run+.
+  #
+  # Set via Minitest.run after processing args.
+
+  cattr_accessor :seed
 
   ##
   # Parallel test executor
 
-  mc.send :attr_accessor, :parallel_executor
+  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
 
-  warn "DEPRECATED: use MT_CPU instead of N for parallel test runs" if ENV["N"]
-  n_threads = (ENV["MT_CPU"] || ENV["N"] || 2).to_i
   self.parallel_executor = Parallel::Executor.new n_threads
 
   ##
   # Filter object for backtraces.
 
-  mc.send :attr_accessor, :backtrace_filter
+  cattr_accessor :backtrace_filter
 
   ##
   # Reporter object to be used for all runs.
   #
   # NOTE: This accessor is only available during setup, not during runs.
 
-  mc.send :attr_accessor, :reporter
+  cattr_accessor :reporter
 
   ##
   # Names of known extension plugins.
 
-  mc.send :attr_accessor, :extensions
+  cattr_accessor :extensions
 
   ##
   # The signal to use for dumping information to STDERR. Defaults to "INFO".
 
-  mc.send :attr_accessor, :info_signal
+  cattr_accessor :info_signal
   self.info_signal = "INFO"
 
+  cattr_accessor :allow_fork
+  self.allow_fork = false
+
   ##
   # Registers Minitest to run at process exit
 
   def self.autorun
+    if Object.const_defined?(:Warning) && Warning.respond_to?(:[]=)
+      Warning[:deprecated] = true
+    end
+
     at_exit {
       next if $! and not ($!.kind_of? SystemExit and $!.success?)
 
       exit_code = nil
 
+      pid = Process.pid
       at_exit {
+        next if !Minitest.allow_fork && Process.pid != pid
         @@after_run.reverse_each(&:call)
         exit exit_code || false
       }
@@ -114,7 +134,7 @@ module Minitest
   #     Minitest.run(args)
   #       Minitest.__run(reporter, options)
   #         Runnable.runnables.each
-  #           runnable.run(reporter, options)
+  #           runnable_klass.run(reporter, options)
   #             self.runnable_methods.each
   #               self.run_one_method(self, runnable_method, reporter)
   #                 Minitest.run_one_method(klass, runnable_method)
@@ -125,9 +145,12 @@ module Minitest
 
     options = process_args args
 
+    Minitest.seed = options[:seed]
+    srand Minitest.seed
+
     reporter = CompositeReporter.new
     reporter << SummaryReporter.new(options[:io], options)
-    reporter << ProgressReporter.new(options[:io], options)
+    reporter << ProgressReporter.new(options[:io], options) unless options[:quiet]
 
     self.reporter = reporter # this makes it available to plugins
     self.init_plugins options
@@ -141,17 +164,38 @@ module Minitest
       warn "Interrupted. Exiting..."
     end
     self.parallel_executor.shutdown
+
+    # might have been removed/replaced during init_plugins:
+    summary = reporter.reporters.grep(SummaryReporter).first
+    return empty_run! options if summary && summary.count == 0
+
     reporter.report
 
     reporter.passed?
   end
 
+  def self.empty_run! options # :nodoc:
+    filter = options[:filter]
+    return true unless filter # no filter, but nothing ran == success
+
+    warn "Nothing ran for filter: %s" % [filter]
+
+    require "did_you_mean" # soft dependency, punt if it doesn't load
+
+    ms = Runnable.runnables.flat_map(&:runnable_methods)
+    cs = DidYouMean::SpellChecker.new(dictionary: ms).correct filter
+
+    warn DidYouMean::Formatter.message_for cs unless cs.empty?
+  rescue LoadError
+    # do nothing
+  end
+
   ##
   # Internal run method. Responsible for telling all Runnable
   # sub-classes to run.
 
   def self.__run reporter, options
-    suites = Runnable.runnables.reject { |s| s.runnable_methods.empty? }.shuffle
+    suites = Runnable.runnables.shuffle
     parallel, serial = suites.partition { |s| s.test_order == :parallel }
 
     # If we run the parallel tests before the serial tests, the parallel tests
@@ -189,6 +233,14 @@ module Minitest
         options[:verbose] = true
       end
 
+      opts.on "-q", "--quiet", "Quiet. Show no progress processing files." do
+        options[:quiet] = true
+      end
+
+      opts.on "--show-skips", "Show skipped at the end of run." do
+        options[:show_skips] = true
+      end
+
       opts.on "-n", "--name PATTERN", "Filter run on /regexp/ or string." do |a|
         options[:filter] = a
       end
@@ -197,6 +249,10 @@ module Minitest
         options[:exclude] = a
       end
 
+      opts.on "-S", "--skip CODES", String, "Skip reporting of certain types of results (eg E)." do |s|
+        options[:skip] = s.chars.to_a
+      end
+
       unless extensions.empty?
         opts.separator ""
         opts.separator "Known extensions: #{extensions.join(", ")}"
@@ -226,8 +282,6 @@ module Minitest
       orig_args << "--seed" << options[:seed].to_s
     end
 
-    srand options[:seed]
-
     options[:args] = orig_args.map { |s|
       s =~ /[\s|&<>$()]/ ? s.inspect : s
     }.join " "
@@ -236,7 +290,9 @@ module Minitest
   end
 
   def self.filter_backtrace bt # :nodoc:
-    backtrace_filter.filter bt
+    result = backtrace_filter.filter bt
+    result = bt.dup if result.empty?
+    result
   end
 
   ##
@@ -303,19 +359,15 @@ module Minitest
     # reporter to record.
 
     def self.run reporter, options = {}
-      filter = options[:filter] || "/./"
-      filter = Regexp.new $1 if filter.is_a?(String) && filter =~ %r%/(.*)/%
+      pos = options[:filter]
+      neg = options[:exclude]
 
-      filtered_methods = self.runnable_methods.find_all { |m|
-        filter === m || filter === "#{self}##{m}"
-      }
-
-      exclude = options[:exclude]
-      exclude = Regexp.new $1 if exclude =~ %r%/(.*)/%
+      pos = Regexp.new $1 if pos.is_a?(String) && pos =~ %r%/(.*)/%
+      neg = Regexp.new $1 if neg.is_a?(String) && neg =~ %r%/(.*)/%
 
-      filtered_methods.delete_if { |m|
-        exclude === m || exclude === "#{self}##{m}"
-      }
+      filtered_methods = self.runnable_methods
+        .select { |m| !pos ||  pos === m || pos === "#{self}##{m}"  }
+        .reject { |m|  neg && (neg === m || neg === "#{self}##{m}") }
 
       return if filtered_methods.empty?
 
@@ -337,6 +389,14 @@ module Minitest
       reporter.record Minitest.run_one_method(klass, method_name)
     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
+      :random
+    end
+
     def self.with_info_handler reporter, &block # :nodoc:
       handler = lambda do
         unless reporter.passed? then
@@ -404,6 +464,31 @@ module Minitest
       self.name       = name
       self.failures   = []
       self.assertions = 0
+      # lazy initializer for metadata
+    end
+
+    ##
+    # Metadata you attach to the test results that get sent to the reporter.
+    #
+    # Lazily initializes to a hash, to keep memory down.
+    #
+    # NOTE: this data *must* be plain (read: marshal-able) data!
+    # Hashes! Arrays! Strings!
+
+    def metadata
+      @metadata ||= {}
+    end
+
+    ##
+    # Sets metadata, mainly used for +Result.from+.
+
+    attr_writer :metadata
+
+    ##
+    # Returns true if metadata exists.
+
+    def metadata?
+      defined? @metadata
     end
 
     ##
@@ -425,7 +510,8 @@ module Minitest
 
     ##
     # Returns a single character string to print based on the result
-    # of the run. Eg ".", "F", or "E".
+    # of the run. One of <tt>"."</tt>, <tt>"F"</tt>,
+    # <tt>"E"</tt> or <tt>"S"</tt>.
 
     def result_code
       raise NotImplementedError, "subclass responsibility"
@@ -454,12 +540,14 @@ module Minitest
       not self.failure
     end
 
+    BASE_DIR = "#{Dir.pwd}/" # :nodoc:
+
     ##
     # The location identifier of this test. Depends on a method
     # existing called class_name.
 
     def location
-      loc = " [#{self.failure.location}]" unless passed? or error?
+      loc = " [#{self.failure.location.delete_prefix BASE_DIR}]" unless passed? or error?
       "#{self.class_name}##{self.name}#{loc}"
     end
 
@@ -523,6 +611,7 @@ module Minitest
       r.assertions = o.assertions
       r.failures   = o.failures.dup
       r.time       = o.time
+      r.metadata   = o.metadata if o.metadata?
 
       r.source_location = o.method(o.name).source_location rescue ["unknown", -1]
 
@@ -547,7 +636,10 @@ module Minitest
   # you want. Go nuts.
 
   class AbstractReporter
-    include Mutex_m
+
+    def initialize # :nodoc:
+      @mutex = Mutex.new
+    end
 
     ##
     # Starts reporting on the run.
@@ -563,8 +655,10 @@ module Minitest
     end
 
     ##
-    # Record a result and output the Runnable#result_code. Stores the
-    # result of the run if the run did not pass.
+    # Output and record the result of the test. Call
+    # {result#result_code}[rdoc-ref:Runnable#result_code] to get the
+    # result character string. Stores the result of the run if the run
+    # did not pass.
 
     def record result
     end
@@ -581,6 +675,10 @@ module Minitest
     def passed?
       true
     end
+
+    def synchronize(&block) # :nodoc:
+      @mutex.synchronize(&block)
+    end
   end
 
   class Reporter < AbstractReporter # :nodoc:
@@ -631,18 +729,63 @@ module Minitest
   #
   # If you want to create an entirely different type of output (eg,
   # CI, HTML, etc), this is the place to start.
+  #
+  # Example:
+  #
+  #   class JenkinsCIReporter < StatisticsReporter
+  #     def report
+  #       super  # Needed to calculate some statistics
+  #
+  #       print "<testsuite "
+  #       print "tests='#{count}' "
+  #       print "failures='#{failures}' "
+  #       # Remaining XML...
+  #     end
+  #   end
 
   class StatisticsReporter < Reporter
-    # :stopdoc:
+    ##
+    # Total number of assertions.
+
     attr_accessor :assertions
+
+    ##
+    # Total number of test cases.
+
     attr_accessor :count
+
+    ##
+    # An +Array+ of test cases that failed or were skipped.
+
     attr_accessor :results
+
+    ##
+    # Time the test run started. If available, the monotonic clock is
+    # used and this is a +Float+, otherwise it's an instance of
+    # +Time+.
+
     attr_accessor :start_time
+
+    ##
+    # Test run time. If available, the monotonic clock is used and
+    # this is a +Float+, otherwise it's an instance of +Time+.
+
     attr_accessor :total_time
+
+    ##
+    # Total number of tests that failed.
+
     attr_accessor :failures
+
+    ##
+    # Total number of tests that erred.
+
     attr_accessor :errors
+
+    ##
+    # Total number of tests that where skipped.
+
     attr_accessor :skips
-    # :startdoc:
 
     def initialize io = $stdout, options = {} # :nodoc:
       super
@@ -672,7 +815,10 @@ module Minitest
       results << result if not result.passed? or result.skipped?
     end
 
-    def report # :nodoc:
+    ##
+    # Report on the tracked statistics.
+
+    def report
       aggregate = results.group_by { |r| r.failure.class }
       aggregate.default = [] # dumb. group_by should provide this
 
@@ -706,7 +852,7 @@ module Minitest
       io.puts "# Running:"
       io.puts
 
-      self.sync = io.respond_to? :"sync=" # stupid emacs
+      self.sync = io.respond_to? :"sync="
       self.old_sync, io.sync = io.sync, true if self.sync
     end
 
@@ -729,9 +875,14 @@ module Minitest
 
     def aggregated_results io # :nodoc:
       filtered_results = results.dup
-      filtered_results.reject!(&:skipped?) unless options[:verbose]
+      filtered_results.reject!(&:skipped?) unless
+        options[:verbose] or options[:show_skips]
+
+      skip = options[:skip] || []
 
       filtered_results.each_with_index { |result, i|
+        next if skip.include? result.result_code
+
         io.puts "\n%3d) %s" % [i+1, result]
       }
       io.puts
@@ -739,26 +890,19 @@ module Minitest
     end
 
     def to_s # :nodoc:
-      aggregated_results(StringIO.new(binary_string)).string
+      aggregated_results(StringIO.new(''.b)).string
     end
 
     def summary # :nodoc:
       extra = ""
 
       extra = "\n\nYou have skipped tests. Run with --verbose for details." if
-        results.any?(&:skipped?) unless options[:verbose] or ENV["MT_NO_SKIP_MSG"]
+        results.any?(&:skipped?) unless
+        options[:verbose] or options[:show_skips] or ENV["MT_NO_SKIP_MSG"]
 
       "%d runs, %d assertions, %d failures, %d errors, %d skips%s" %
         [count, assertions, failures, errors, skips, extra]
     end
-
-    private
-
-    if '<3'.respond_to? :b
-      def binary_string; ''.b; end
-    else
-      def binary_string; ''.force_encoding(Encoding::ASCII_8BIT); end
-    end
   end
 
   ##
@@ -816,6 +960,8 @@ module Minitest
   # Represents run failures.
 
   class Assertion < Exception
+    RE = /in .(?:assert|refute|flunk|pass|fail|raise|must|wont)/ # :nodoc:
+
     def error # :nodoc:
       self
     end
@@ -824,12 +970,11 @@ module Minitest
     # Where was this run before an assertion was raised?
 
     def location
-      last_before_assertion = ""
-      self.backtrace.reverse_each do |s|
-        break if s =~ /in .(assert|refute|flunk|pass|fail|raise|must|wont)/
-        last_before_assertion = s
-      end
-      last_before_assertion.sub(/:in .*$/, "")
+      bt  = Minitest.filter_backtrace self.backtrace
+      idx = bt.rindex { |s| s.match? RE } || -1 # fall back to first item
+      loc = bt[idx+1] || bt.last || "unknown:-1"
+
+      loc.sub(/:in .*$/, "")
     end
 
     def result_code # :nodoc:
@@ -854,24 +999,34 @@ module Minitest
   # Assertion wrapping an unexpected error that was raised during a run.
 
   class UnexpectedError < Assertion
-    attr_accessor :exception # :nodoc:
+    include Minitest::Compress
 
-    def initialize exception # :nodoc:
+    # TODO: figure out how to use `cause` instead
+    attr_accessor :error # :nodoc:
+
+    def initialize error # :nodoc:
       super "Unexpected exception"
-      self.exception = exception
+
+      if SystemStackError === error then
+        bt = error.backtrace
+        new_bt = compress bt
+        error = error.exception "#{bt.size} -> #{new_bt.size}"
+        error.set_backtrace new_bt
+      end
+
+      self.error = error
     end
 
     def backtrace # :nodoc:
-      self.exception.backtrace
+      self.error.backtrace
     end
 
-    def error # :nodoc:
-      self.exception
-    end
+    BASE_RE = %r%#{Dir.pwd}/% # :nodoc:
 
     def message # :nodoc:
-      bt = Minitest.filter_backtrace(self.backtrace).join "\n    "
-      "#{self.exception.class}: #{self.exception.message}\n    #{bt}"
+      bt = Minitest.filter_backtrace(self.backtrace).join("\n    ")
+        .gsub(BASE_RE, "")
+      "#{self.error.class}: #{self.error.message}\n    #{bt}"
     end
 
     def result_label # :nodoc:
@@ -907,6 +1062,9 @@ module Minitest
     # 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
 
@@ -917,10 +1075,20 @@ module Minitest
       /^ruby/ =~ platform
     end
 
+    ##
+    # Is this running on macOS?
+
+    def osx? platform = RUBY_PLATFORM
+      /darwin/ =~ platform
+    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
 
@@ -941,17 +1109,24 @@ module Minitest
 
     MT_RE = %r%lib/minitest% #:nodoc:
 
+    attr_accessor :regexp
+
+    def initialize regexp = MT_RE
+      self.regexp = regexp
+    end
+
     ##
-    # Filter +bt+ to something useful. Returns the whole thing if $DEBUG.
+    # Filter +bt+ to something useful. Returns the whole thing if
+    # $DEBUG (ruby) or $MT_DEBUG (env).
 
     def filter bt
       return ["No backtrace"] unless bt
 
-      return bt.dup if $DEBUG
+      return bt.dup if $DEBUG || ENV["MT_DEBUG"]
 
-      new_bt = bt.take_while { |line| line !~ MT_RE }
-      new_bt = bt.select     { |line| line !~ MT_RE } if new_bt.empty?
-      new_bt = bt.dup                                 if new_bt.empty?
+      new_bt = bt.take_while { |line| line.to_s !~ regexp }
+      new_bt = bt.select     { |line| line.to_s !~ regexp } if new_bt.empty?
+      new_bt = bt.dup                                       if new_bt.empty?
 
       new_bt
     end

data/test/minitest/metametameta.rb

@@ -6,8 +6,28 @@ class Minitest::Test
   def clean s
     s.gsub(/^ {6}/, "")
   end
+
+  def with_empty_backtrace_filter
+    with_backtrace_filter Minitest::BacktraceFilter.new %r%.% do
+      yield
+    end
+  end
+
+  def with_backtrace_filter filter
+    original = Minitest.backtrace_filter
+
+    Minitest::Test.io_lock.synchronize do # try not to trounce in parallel
+      begin
+        Minitest.backtrace_filter = filter
+        yield
+      ensure
+        Minitest.backtrace_filter = original
+      end
+    end
+  end
 end
 
+
 class FakeNamedTest < Minitest::Test
   @@count = 0
 
@@ -25,6 +45,14 @@ class AnError < StandardError; include MyModule; end
 class MetaMetaMetaTestCase < Minitest::Test
   attr_accessor :reporter, :output, :tu
 
+  def with_stderr err
+    old = $stderr
+    $stderr = err
+    yield
+  ensure
+    $stderr = old
+  end
+
   def run_tu_with_fresh_reporter flags = %w[--seed 42]
     options = Minitest.process_args flags
 
@@ -34,18 +62,20 @@ class MetaMetaMetaTestCase < Minitest::Test
     reporter << Minitest::SummaryReporter.new(@output, options)
     reporter << Minitest::ProgressReporter.new(@output, options)
 
-    reporter.start
+    with_stderr @output do
+      reporter.start
 
-    yield(reporter) if block_given?
+      yield(reporter) if block_given?
 
-    @tus ||= [@tu]
-    @tus.each do |tu|
-      Minitest::Runnable.runnables.delete tu
+      @tus ||= [@tu]
+      @tus.each do |tu|
+        Minitest::Runnable.runnables.delete tu
 
-      tu.run reporter, options
-    end
+        tu.run reporter, options
+      end
 
-    reporter.report
+      reporter.report
+    end
   end
 
   def first_reporter
@@ -76,14 +106,18 @@ class MetaMetaMetaTestCase < Minitest::Test
     output.gsub!(/0x[A-Fa-f0-9]+/, "0xXXX")
     output.gsub!(/ +$/, "")
 
+    file = ->(s) { s.start_with?("/") ? "FULLFILE" : "FILE" }
+
     if windows? then
       output.gsub!(/\[(?:[A-Za-z]:)?[^\]:]+:\d+\]/, "[FILE:LINE]")
       output.gsub!(/^(\s+)(?:[A-Za-z]:)?[^:]+:\d+:in/, '\1FILE:LINE:in')
     else
-      output.gsub!(/\[[^\]:]+:\d+\]/, "[FILE:LINE]")
-      output.gsub!(/^(\s+)[^:]+:\d+:in/, '\1FILE:LINE:in')
+      output.gsub!(/\[([^\]:]+):\d+\]/)    {     "[#{file[$1]}:LINE]"   }
+      output.gsub!(/^(\s+)([^:]+):\d+:in/) { "#{$1}#{file[$2]}:LINE:in" }
     end
 
+    output.gsub!(/( at )[^:]+:\d+/) { "#{$1}[#{file[$2]}:LINE]" } # eval?
+
     output
   end
 
@@ -98,7 +132,7 @@ class MetaMetaMetaTestCase < Minitest::Test
 
   def setup
     super
-    srand 42
+    Minitest.seed = 42
     Minitest::Test.reset
     @tu = nil
   end