minitest 5.16.2 → 6.0.5

data/lib/minitest/spec.rb

@@ -1,22 +1,15 @@
-require "minitest/test"
+require_relative "test"
 
 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
+    # https://eregon.me/blog/2021/02/13/correct-delegation-in-ruby-2-27-3.html
+    # Drop this when we can drop ruby 2.6 (aka after rails 6.1 EOL, ~2024-06)
+    kw_extra = "ruby2_keywords %p" % [new_name] if respond_to? :ruby2_keywords, true
 
-    Minitest::Expectation.class_eval <<-EOM, __FILE__, __LINE__ + 1
+    self.class_eval <<-EOM, __FILE__, __LINE__ + 1
       def #{new_name} *args
         raise "Calling ##{new_name} outside of test." unless ctx
         case
@@ -28,11 +21,16 @@ class Module # :nodoc:
           ctx.#{meth}(args.first, target, *args[1..-1])
         end
       end
+      #{kw_extra}
     EOM
   end
 end
 
-Minitest::Expectation = Struct.new :target, :ctx # :nodoc:
+# :stopdoc:
+module Minitest # fucking hell rdoc...
+  Expectation = Struct.new :target, :ctx
+end
+# :startdoc:
 
 ##
 # Kernel extensions for minitest
@@ -75,14 +73,15 @@ module Kernel
 
   def describe desc, *additional_desc, &block # :doc:
     stack = Minitest::Spec.describe_stack
-    name  = [stack.last, desc, *additional_desc].compact.join("::")
-    sclas = stack.last || if Class === self && kind_of?(Minitest::Spec::DSL) then
-                            self
-                          else
-                            Minitest::Spec.spec_type desc, *additional_desc
-                          end
+    is_spec_class = Class === self && kind_of?(Minitest::Spec::DSL)
+    name  = [stack.last, desc, *additional_desc]
+    name.prepend self if stack.empty? && is_spec_class
+    sclas =
+      stack.last                 \
+      || (is_spec_class && self) \
+      || Minitest::Spec.spec_type(desc, *additional_desc)
 
-    cls = sclas.create name, desc
+    cls = sclas.create name.compact.join("::"), desc
 
     stack.push cls
     cls.class_eval(&block)
@@ -99,15 +98,6 @@ end
 
 class Minitest::Spec < Minitest::Test
 
-  def self.current # :nodoc:
-    Thread.current[:current_spec]
-  end
-
-  def initialize name # :nodoc:
-    super
-    Thread.current[:current_spec] = self
-  end
-
   ##
   # Oh look! A Minitest::Spec::DSL module! Eat your heart out DHH.
 
@@ -243,7 +233,7 @@ class Minitest::Spec < Minitest::Test
       pre, post = "let '#{name}' cannot ", ". Please use another name."
       methods = Minitest::Spec.instance_methods.map(&:to_s) - %w[subject]
       raise ArgumentError, "#{pre}begin with 'test'#{post}" if
-        name =~ /\Atest/
+        name.start_with? "test"
       raise ArgumentError, "#{pre}override a method in Minitest::Spec#{post}" if
         methods.include? name
 
@@ -262,7 +252,7 @@ class Minitest::Spec < Minitest::Test
     end
 
     def create name, desc # :nodoc:
-      cls = Class.new(self) do
+      cls = Class.new self do
         @name = name
         @desc = desc
 
@@ -278,12 +268,11 @@ class Minitest::Spec < Minitest::Test
       defined?(@name) ? @name : super
     end
 
-    def to_s # :nodoc:
-      name # Can't alias due to 1.8.7, not sure why
-    end
+    alias to_s name
+    alias inspect name
 
     attr_reader :desc # :nodoc:
-    alias :specify :it
+    alias specify it
 
     ##
     # Rdoc... why are you so dumb?
@@ -303,9 +292,6 @@ class Minitest::Spec < Minitest::Test
       # straight-expectation methods (on Object) because it stores its
       # test context, bypassing our hacky use of thread-local variables.
       #
-      # 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:
       #
@@ -319,11 +305,6 @@ class Minitest::Spec < Minitest::Test
 
       alias value _
       alias expect _
-
-      def before_setup # :nodoc:
-        super
-        Thread.current[:current_spec] = self
-      end
     end
 
     def self.extended obj # :nodoc:
@@ -336,8 +317,8 @@ class Minitest::Spec < Minitest::Test
   TYPES = DSL::TYPES # :nodoc:
 end
 
-require "minitest/expectations"
+require_relative "expectations"
 
-class Object # :nodoc:
-  include Minitest::Expectations unless ENV["MT_NO_EXPECTATIONS"]
+class Minitest::Expectation
+  include Minitest::Expectations
 end

data/lib/minitest/sprint.rb

@@ -0,0 +1,105 @@
+$LOAD_PATH.unshift "test", "lib"
+
+require "simplecov" if ENV["MT_COV"] || ARGV.delete("--simplecov")
+require_relative "autorun"
+require_relative "path_expander"
+
+module Minitest
+
+  ##
+  # Runs (Get it? It's fast!) your tests and makes it easier to rerun
+  # individual failures.
+
+  class Sprint
+    # extracted version = "1.5.0"
+
+    ##
+    # Process and run minitest cmdline.
+
+    def self.run args = ARGV
+      if args.delete("--bisect") or args.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,16 +8,16 @@ module Minitest
   # See Minitest::Assertions
 
   class Test < Runnable
-    require "minitest/assertions"
-    include Minitest::Assertions
+    require_relative "assertions"
     include Minitest::Reportable
-
-    def class_name # :nodoc:
-      self.class.name # for Minitest::Reportable
-    end
+    include Minitest::Assertions
 
     PASSTHROUGH_EXCEPTIONS = [NoMemoryError, SignalException, SystemExit] # :nodoc:
 
+    SETUP_METHODS = %w[ before_setup setup after_setup ] # :nodoc:
+
+    TEARDOWN_METHODS = %w[ before_teardown teardown after_teardown ] # :nodoc:
+
     # :stopdoc:
     class << self; attr_accessor :io_lock; end
     self.io_lock = Mutex.new
@@ -30,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
 
@@ -48,60 +48,52 @@ module Minitest
     end
 
     ##
-    # Call this at the top of your tests when you want to run your
-    # tests in parallel. In doing so, you're admitting that you rule
-    # and your tests are awesome.
+    # Call this at the top of your tests (inside the +Minitest::Test+
+    # subclass or +describe+ block) when you want to run your tests in
+    # parallel. In doing so, you're admitting that you rule and your
+    # tests are awesome.
 
     def self.parallelize_me!
+      return unless Minitest.parallel_executor
       include Minitest::Parallel::Test
       extend Minitest::Parallel::Test::ClassMethods
     end
 
     ##
     # 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
 
-    ##
-    # 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
-
-    TEARDOWN_METHODS = %w[ before_teardown teardown after_teardown ] # :nodoc:
-
     ##
     # Runs a single test with setup/teardown hooks.
 
     def run
-      with_info_handler do
-        time_it do
-          capture_exceptions do
-            before_setup; setup; after_setup
-
-            self.send self.name
+      time_it do
+        capture_exceptions do
+          SETUP_METHODS.each do |hook|
+            self.send hook
           end
 
-          TEARDOWN_METHODS.each do |hook|
-            capture_exceptions do
-              self.send hook
-            end
+          self.send self.name
+        end
+
+        TEARDOWN_METHODS.each do |hook|
+          capture_exceptions do
+            self.send hook
           end
         end
       end
@@ -145,7 +137,7 @@ module Minitest
       #     end
       #   end
       #
-      #   class MiniTest::Test
+      #   class Minitest::Test
       #     include MyMinitestPlugin
       #   end
 
@@ -204,22 +196,22 @@ module Minitest
     def sanitize_exception e # :nodoc:
       Marshal.dump e
       e                                         # good: use as-is
-    rescue TypeError
+    rescue
       neuter_exception e
     end
 
-    def neuter_exception e
+    def neuter_exception e # :nodoc:
       bt = e.backtrace
       msg = e.message.dup
 
       new_exception e.class, msg, bt            # e.class can be a problem...
-    rescue TypeError
+    rescue
       msg.prepend "Neutered Exception #{e.class}: "
 
       new_exception RuntimeError, msg, bt, true # but if this raises, we die
     end
 
-    def new_exception klass, msg, bt, kill = false
+    def new_exception klass, msg, bt, kill = false # :nodoc:
       ne = klass.new msg
       ne.set_backtrace bt
 
@@ -233,20 +225,8 @@ module Minitest
       ne
     end
 
-    def with_info_handler &block # :nodoc:
-      t0 = Minitest.clock_time
-
-      handler = lambda do
-        warn "\nCurrent: %s#%s %.2fs" % [self.class, self.name, Minitest.clock_time - t0]
-      end
-
-      self.class.on_signal ::Minitest.info_signal, handler, &block
-    end
-
     include LifecycleHooks
     include Guard
     extend Guard
   end # Test
 end
-
-require "minitest/unit" unless defined?(MiniTest) # compatibility layer only

data/lib/minitest/test_task.rb

@@ -1,6 +1,12 @@
 require "shellwords"
 require "rbconfig"
-require "rake/tasklib"
+
+begin
+  require "rake/tasklib"
+rescue LoadError => e
+  warn e.message
+  return
+end
 
 module Minitest # :nodoc:
 
@@ -29,13 +35,25 @@ module Minitest # :nodoc:
   #   end
   #
   # Customize the name and only run unit tests.
+  #
+  # NOTE: To hook this task up to the default, make it a dependency:
+  #
+  #   task default: :unit
 
   class TestTask < Rake::TaskLib
     WINDOWS = RbConfig::CONFIG["host_os"] =~ /mswin|mingw/ # :nodoc:
 
     ##
-    # Create several test-oriented tasks under +name+. Takes an
-    # optional block to customize variables.
+    # Create several test-oriented tasks under +name+ (default:
+    # "test"). Takes an optional block to customize variables.
+    # Examples:
+    #
+    #   Minitest::TestTask.create # named "test", all defaults
+    #
+    #   Minitest::TestTask.create do |t|
+    #     t.warning = false # my tests are noisy
+    #     t.framework = %(require_relative "./test/helper.rb")
+    #   end
 
     def self.create name = :test, &block
       task = new name
@@ -59,9 +77,18 @@ module Minitest # :nodoc:
 
     ##
     # The code to load the framework. Defaults to requiring
-    # minitest/autorun...
+    # minitest/autorun.
+    #
+    # If you have a test helper file that requires minitest/autorun
+    # and anything else your project standardizes on, then you'll
+    # probably want to change this to:
+    #
+    #   Minitest::TestTask.create do |t|
+    #     t.framework = %(require_relative "./test/helper.rb")
+    #   end
     #
-    # Why do I have this as an option?
+    # or something similar. NOTE: if you do this, then helper must
+    # require "minitest/autorun" at the top to start the tests.
 
     attr_accessor :framework
 
@@ -90,6 +117,11 @@ module Minitest # :nodoc:
 
     ##
     # Optional: Additional ruby to run before the test framework is loaded.
+    # Example:
+    #
+    #   Minitest::TestTask.create "test:cov" do |t|
+    #     t.test_prelude = %(require "simplecov")
+    #   end
 
     attr_accessor :test_prelude
 
@@ -110,7 +142,7 @@ module Minitest # :nodoc:
       self.test_globs   = ["test/**/test_*.rb",
                            "test/**/*_test.rb"]
       self.test_prelude = nil
-      self.verbose      = Rake.application.options.trace
+      self.verbose      = Rake.application.options.trace || Rake.verbose == true
       self.warning      = true
     end
 
@@ -136,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
+      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"]
 
@@ -157,11 +187,14 @@ module Minitest # :nodoc:
     end
 
     def define # :nodoc:
-      default_tasks = []
-
-      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
+        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."
@@ -175,14 +208,14 @@ module Minitest # :nodoc:
 
         # 3 seems to be the magic number... (tho not by that much)
         bad, good, n = {}, [], (ENV.delete("K") || 3).to_i
-        file = ENV.delete("F")
+        file = ENV.delete "F"
         times = {}
 
         tt0 = Time.now
 
         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
@@ -236,24 +269,21 @@ module Minitest # :nodoc:
 
       task "#{name}:deps" => "#{name}:isolated" # now just an alias
 
-      desc "Show bottom 25 tests wrt time."
+      desc "Run the test suite and report the slowest 25 tests."
       task "#{name}:slow" do
-        sh ["rake #{name} TESTOPTS=-v",
+        sh ["rake #{name} A=-v",
             "egrep '#test_.* s = .'",
             "sort -n -k2 -t=",
             "tail -25"].join " | "
       end
-
-      default_tasks << name
-
-      desc "Run the default task(s)."
-      task :default => default_tasks
     end
 
     ##
     # 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}") }
@@ -264,12 +294,14 @@ 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 << "-I#{libs.join File::PATH_SEPARATOR}" unless libs.empty?
       args << "-w" if warning
-      args << '-e'
+      args << "-e"
       args << "'#{runner}'"
-      args << '--'
+      args << "--"
       args << extra_args.map(&:shellescape)
 
       args.join " "
@@ -277,24 +309,18 @@ module Minitest # :nodoc:
   end
 end
 
-class Work < Queue
-  def initialize jobs = []
-    super()
-
-    jobs.each do |job|
-      self << job
-    end
-
+class Work < Queue # :nodoc:
+  def initialize jobs # :nodoc:
+    super
     close
   end
 end
 
-class Integer
-  def threads_do(jobs) # :nodoc:
-    require "thread"
+class Integer # :nodoc:
+  def threads_do jobs # :nodoc:
     q = Work.new jobs
 
-    self.times.map {
+    Array.new(self) {
       Thread.new do
         while job = q.pop # go until quit value
           yield job