minitest 5.10.3 → 5.15.0

data/lib/minitest/parallel.rb

@@ -53,7 +53,7 @@ module Minitest
       end
     end
 
-    module Test
+    module Test # :nodoc:
       def _synchronize; Minitest::Test.io_lock.synchronize { yield }; end # :nodoc:
 
       module ClassMethods # :nodoc:

data/lib/minitest/spec.rb

@@ -4,16 +4,21 @@ 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)'
 
     # 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
     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)
@@ -285,21 +290,28 @@ class Minitest::Spec < Minitest::Test
 
     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

data/lib/minitest/test.rb

@@ -10,6 +10,11 @@ module Minitest
   class Test < Runnable
     require "minitest/assertions"
     include Minitest::Assertions
+    include Minitest::Reportable
+
+    def class_name # :nodoc:
+      self.class.name # for Minitest::Reportable
+    end
 
     PASSTHROUGH_EXCEPTIONS = [NoMemoryError, SignalException, SystemExit] # :nodoc:
 
@@ -79,20 +84,6 @@ module Minitest
       :random
     end
 
-    ##
-    # The time it took to run this test.
-
-    attr_accessor :time
-
-    def marshal_dump # :nodoc:
-      super << self.time
-    end
-
-    def marshal_load ary # :nodoc:
-      self.time = ary.pop
-      super
-    end
-
     TEARDOWN_METHODS = %w[ before_teardown teardown after_teardown ] # :nodoc:
 
     ##
@@ -115,7 +106,7 @@ module Minitest
         end
       end
 
-      self # per contract
+      Result.from self # per contract
     end
 
     ##
@@ -207,62 +198,17 @@ module Minitest
     rescue Assertion => e
       self.failures << e
     rescue Exception => e
-      self.failures << UnexpectedError.new(e)
+      self.failures << UnexpectedError.new(sanitize_exception e)
     end
 
-    ##
-    # Did this run error?
-
-    def error?
-      self.failures.any? { |f| UnexpectedError === f }
-    end
-
-    ##
-    # The location identifier of this test.
-
-    def location
-      loc = " [#{self.failure.location}]" unless passed? or error?
-      "#{self.class}##{self.name}#{loc}"
-    end
-
-    ##
-    # Did this run pass?
-    #
-    # Note: skipped runs are not considered passing, but they don't
-    # cause the process to exit non-zero.
-
-    def passed?
-      not self.failure
-    end
-
-    ##
-    # Returns ".", "F", or "E" based on the result of the run.
-
-    def result_code
-      self.failure and self.failure.result_code or "."
-    end
-
-    ##
-    # Was this run skipped?
-
-    def skipped?
-      self.failure and Skip === self.failure
-    end
-
-    def time_it # :nodoc:
-      t0 = Minitest.clock_time
-
-      yield
-    ensure
-      self.time = Minitest.clock_time - t0
-    end
-
-    def to_s # :nodoc:
-      return location if passed? and not skipped?
-
-      failures.map { |failure|
-        "#{failure.result_label}:\n#{self.location}:\n#{failure.message}\n"
-      }.join "\n"
+    def sanitize_exception e # :nodoc:
+      Marshal.dump e
+      e
+    rescue TypeError
+      bt = e.backtrace
+      e = RuntimeError.new "Wrapped undumpable exception for: #{e.class}: #{e.message}"
+      e.set_backtrace bt
+      e
     end
 
     def with_info_handler &block # :nodoc:

data/lib/minitest.rb

@@ -3,12 +3,13 @@ require "thread"
 require "mutex_m"
 require "minitest/parallel"
 require "stringio"
+require "etc"
 
 ##
 # :include: README.rdoc
 
 module Minitest
-  VERSION = "5.10.3" # :nodoc:
+  VERSION = "5.15.0" # :nodoc:
   ENCS = "".respond_to? :encoding # :nodoc:
 
   @@installed_at_exit ||= false
@@ -21,7 +22,10 @@ module Minitest
   # Parallel test executor
 
   mc.send :attr_accessor, :parallel_executor
-  self.parallel_executor = Parallel::Executor.new((ENV["N"] || 2).to_i)
+
+  warn "DEPRECATED: use MT_CPU instead of N for parallel test runs" if ENV["N"]
+  n_threads = (ENV["MT_CPU"] || ENV["N"] || Etc.nprocessors).to_i
+  self.parallel_executor = Parallel::Executor.new n_threads
 
   ##
   # Filter object for backtraces.
@@ -50,12 +54,18 @@ module Minitest
   # 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 Process.pid != pid
         @@after_run.reverse_each(&:call)
         exit exit_code || false
       }
@@ -118,7 +128,7 @@ module Minitest
   #                   klass.new(runnable_method).run
 
   def self.run args = []
-    self.load_plugins
+    self.load_plugins unless args.delete("--no-plugins") || ENV["MT_NO_PLUGINS"]
 
     options = process_args args
 
@@ -175,6 +185,8 @@ module Minitest
         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"
       opts.on "-s", "--seed SEED", Integer, desc do |m|
         options[:seed] = m.to_i
@@ -192,6 +204,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(", ")}"
@@ -231,7 +247,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
 
   ##
@@ -252,6 +270,19 @@ module Minitest
 
     attr_accessor :failures
 
+    ##
+    # The time it took to run.
+
+    attr_accessor :time
+
+    def time_it # :nodoc:
+      t0 = Minitest.clock_time
+
+      yield
+    ensure
+      self.time = Minitest.clock_time - t0
+    end
+
     ##
     # Name of the run.
 
@@ -266,11 +297,6 @@ module Minitest
       @NAME = o
     end
 
-    def self.inherited klass # :nodoc:
-      self.runnables << klass
-      super
-    end
-
     ##
     # Returns all instance methods matching the pattern +re+.
 
@@ -291,7 +317,7 @@ module Minitest
 
     def self.run reporter, options = {}
       filter = options[:filter] || "/./"
-      filter = Regexp.new $1 if filter =~ %r%/(.*)/%
+      filter = Regexp.new $1 if filter.is_a?(String) && filter =~ %r%/(.*)/%
 
       filtered_methods = self.runnable_methods.find_all { |m|
         filter === m || filter === "#{self}##{m}"
@@ -367,12 +393,20 @@ module Minitest
       @@runnables
     end
 
+    @@marshal_dump_warned = false
+
     def marshal_dump # :nodoc:
-      [self.name, self.failures, self.assertions]
+      unless @@marshal_dump_warned then
+        warn ["Minitest::Runnable#marshal_dump is deprecated.",
+              "You might be violating internals. From", caller.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 = ary
+      self.name, self.failures, self.assertions, self.time = ary
     end
 
     def failure # :nodoc:
@@ -404,7 +438,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"
@@ -418,6 +453,109 @@ module Minitest
     end
   end
 
+  ##
+  # Shared code for anything that can get passed to a Reporter. See
+  # Minitest::Test & Minitest::Result.
+
+  module Reportable
+    ##
+    # Did this run pass?
+    #
+    # Note: skipped runs are not considered passing, but they don't
+    # cause the process to exit non-zero.
+
+    def passed?
+      not self.failure
+    end
+
+    ##
+    # The location identifier of this test. Depends on a method
+    # existing called class_name.
+
+    def location
+      loc = " [#{self.failure.location}]" unless passed? or error?
+      "#{self.class_name}##{self.name}#{loc}"
+    end
+
+    def class_name # :nodoc:
+      raise NotImplementedError, "subclass responsibility"
+    end
+
+    ##
+    # Returns ".", "F", or "E" based on the result of the run.
+
+    def result_code
+      self.failure and self.failure.result_code or "."
+    end
+
+    ##
+    # Was this run skipped?
+
+    def skipped?
+      self.failure and Skip === self.failure
+    end
+
+    ##
+    # Did this run error?
+
+    def error?
+      self.failures.any? { |f| UnexpectedError === f }
+    end
+  end
+
+  ##
+  # This represents a test result in a clean way that can be
+  # marshalled over a wire. Tests can do anything they want to the
+  # test instance and can create conditions that cause Marshal.dump to
+  # blow up. By using Result.from(a_test) you can be reasonably sure
+  # that the test result can be marshalled.
+
+  class Result < Runnable
+    include Minitest::Reportable
+
+    undef_method :marshal_dump
+    undef_method :marshal_load
+
+    ##
+    # The class name of the test result.
+
+    attr_accessor :klass
+
+    ##
+    # The location of the test method.
+
+    attr_accessor :source_location
+
+    ##
+    # Create a new test result from a Runnable instance.
+
+    def self.from runnable
+      o = runnable
+
+      r = self.new o.name
+      r.klass      = o.class.name
+      r.assertions = o.assertions
+      r.failures   = o.failures.dup
+      r.time       = o.time
+
+      r.source_location = o.method(o.name).source_location rescue ["unknown", -1]
+
+      r
+    end
+
+    def class_name # :nodoc:
+      self.klass # for Minitest::Reportable
+    end
+
+    def to_s # :nodoc:
+      return location if passed? and not skipped?
+
+      failures.map { |failure|
+        "#{failure.result_label}:\n#{self.location}:\n#{failure.message}\n"
+      }.join "\n"
+    end
+  end
+
   ##
   # Defines the API for Reporters. Subclass this and override whatever
   # you want. Go nuts.
@@ -439,8 +577,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
@@ -488,7 +628,7 @@ module Minitest
   class ProgressReporter < Reporter
     def prerecord klass, name #:nodoc:
       if options[:verbose] then
-        io.print "%s#%s = " % [klass, name]
+        io.print "%s#%s = " % [klass.name, name]
         io.flush
       end
     end
@@ -507,18 +647,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
@@ -548,7 +733,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
 
@@ -607,7 +795,11 @@ module Minitest
       filtered_results = results.dup
       filtered_results.reject!(&:skipped?) unless options[:verbose]
 
+      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
@@ -730,24 +922,21 @@ module Minitest
   # Assertion wrapping an unexpected error that was raised during a run.
 
   class UnexpectedError < Assertion
-    attr_accessor :exception # :nodoc:
+    # TODO: figure out how to use `cause` instead
+    attr_accessor :error # :nodoc:
 
-    def initialize exception # :nodoc:
+    def initialize error # :nodoc:
       super "Unexpected exception"
-      self.exception = exception
+      self.error = error
     end
 
     def backtrace # :nodoc:
-      self.exception.backtrace
-    end
-
-    def error # :nodoc:
-      self.exception
+      self.error.backtrace
     end
 
     def message # :nodoc:
       bt = Minitest.filter_backtrace(self.backtrace).join "\n    "
-      "#{self.exception.class}: #{self.exception.message}\n    #{bt}"
+      "#{self.error.class}: #{self.error.message}\n    #{bt}"
     end
 
     def result_label # :nodoc:
@@ -783,6 +972,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
 
@@ -793,10 +985,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
 
@@ -818,12 +1020,13 @@ module Minitest
     MT_RE = %r%lib/minitest% #:nodoc:
 
     ##
-    # 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?
@@ -837,7 +1040,7 @@ module Minitest
 
   def self.run_one_method klass, method_name # :nodoc:
     result = klass.new(method_name).run
-    raise "#{klass}#run _must_ return self" unless klass === result
+    raise "#{klass}#run _must_ return a Result" unless Result === result
     result
   end
 
@@ -853,6 +1056,13 @@ module Minitest
     end
   end
 
+  class Runnable # re-open
+    def self.inherited klass # :nodoc:
+      self.runnables << klass
+      super
+    end
+  end
+
   # :startdoc:
 end