minitest 5.27.0 → 6.0.0.a1

data/test/minitest/test_server.rb

@@ -0,0 +1,149 @@
+require "minitest/autorun"
+require "minitest/server"
+require "minitest/server_plugin"
+
+require "minitest"
+require "minitest/test"
+require "minitest/server"
+require "minitest/server_plugin"
+require "minitest/autorun"
+
+class BogoTests < Minitest::Test
+  def pass_test
+    assert true
+  end
+
+  def fail_test
+    assert false, "fail"
+  end
+
+  def error_test
+    raise "error"
+  end
+
+  def unmarshalable_ivar_test
+    raise "error"
+  rescue => e
+    e.instance_variable_set :@binding, binding
+    raise
+  end
+
+  def unmarshalable_class_test
+    exc = Class.new RuntimeError
+    raise exc, "error"
+  rescue => e
+    e.instance_variable_set :@binding, binding
+    raise
+  end
+
+  def wtf_test
+    assert false, "wtf"
+  rescue Minitest::Assertion => e
+    e.instance_variable_set :@proc, proc { 42 }
+    raise e
+  end
+end
+
+class TestServerReporter < Minitest::ServerReporter
+  def record o
+    super
+
+    Marshal.dump o
+  end
+end
+
+class Client
+  def run pid, type
+    reporter = TestServerReporter.new pid
+
+    unless Minitest.respond_to? :run_one_method then # MT6
+      BogoTests.run BogoTests, "#{type}_test", reporter
+    else
+      reporter.start
+      reporter.record Minitest.run_one_method(BogoTests, "#{type}_test")
+    end
+  end
+end
+
+class Server
+  attr_accessor :results
+
+  def self.run type = nil
+    s = self.new
+    s.run type
+    s.results
+  end
+
+  def run type = nil
+    Minitest::Server.run self
+
+    Client.new.run $$, type
+  ensure
+    Minitest::Server.stop
+  end
+
+  def minitest_start
+    # do nothing
+  end
+
+  def minitest_result(*vals)
+    self.results = vals
+  end
+end
+
+class ServerTest < Minitest::Test
+  def test_pass
+    assert_run "pass", [], 1
+  end
+
+  def test_fail
+    assert_run "fail", ["fail"], 1
+  end
+
+  FILE = __FILE__.delete_prefix "#{Dir.pwd}/"
+
+  def test_error
+    msg = <<~EOM.chomp
+      RuntimeError: error
+          #{FILE}:21:in `error_test'
+    EOM
+
+    assert_run "error", [msg], 0
+  end
+
+  def test_error_unmarshalable__ivar
+    msg = <<~EOM.chomp
+      RuntimeError: error
+          #{FILE}:25:in `unmarshalable_ivar_test'
+    EOM
+
+    assert_run "unmarshalable_ivar", [msg], 0
+  end
+
+  def test_error_unmarshalable__class
+    msg = <<~EOM.chomp
+      RuntimeError: Neutered Exception #<Class:0xXXXXXX>: error
+          #{FILE}:33:in `unmarshalable_class_test'
+    EOM
+
+    assert_run "unmarshalable_class", [msg], 0
+  end
+
+  def test_wtf
+    assert_run "wtf", ["wtf"], 1
+  end
+
+  def assert_run type, e, n
+    e[0] = e[0].sub "`", "'BogoTests#" if RUBY_VERSION > "3.4" if e[0]
+
+    act = Server.run type
+    act[-1] = 0 # time
+    act[-3].map!(&:message)
+
+    act[-3][0] = act[-3][0].gsub(/0x\h+/, "0xXXXXXX") if act[-3][0]
+
+    exp = ["test/minitest/test_server.rb", "BogoTests", "#{type}_test", e, n, 0]
+
+    assert_equal exp, act
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: minitest
 version: !ruby/object:Gem::Version
-  version: 5.27.0
+  version: 6.0.0.a1
 platform: ruby
 authors:
 - Ryan Davis
@@ -30,6 +30,20 @@ cert_chain:
   -----END CERTIFICATE-----
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: prism
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
@@ -50,6 +64,20 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '7'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
 - !ruby/object:Gem::Dependency
   name: hoe
   requirement: !ruby/object:Gem::Requirement
@@ -66,7 +94,7 @@ dependencies:
         version: '4.3'
 description: |-
   minitest provides a complete suite of testing facilities supporting
-  TDD, BDD, mocking, and benchmarking.
+  TDD, BDD, and benchmarking.
 
       "I had a class with Jim Weirich on testing last week and we were
        allowed to choose our testing frameworks. Kirk Haines and I were
@@ -92,9 +120,6 @@ description: |-
   co-worker doesn't replace your linear algorithm with an exponential
   one!
 
-  minitest/mock by Steven Baker, is a beautifully tiny mock (and stub)
-  object framework.
-
   minitest/pride shows pride in testing and adds coloring to your test
   output. I guess it is an example of how to write IO pipes too. :P
 
@@ -120,45 +145,55 @@ description: |-
   extract-method refactorings still apply.
 email:
 - ryand-ruby@zenspider.com
-executables: []
+executables:
+- minitest
 extensions: []
 extra_rdoc_files:
 - History.rdoc
 - Manifest.txt
 - README.rdoc
 files:
-- ".autotest"
 - History.rdoc
 - Manifest.txt
 - README.rdoc
 - Rakefile
+- bin/minitest
 - design_rationale.rb
 - lib/hoe/minitest.rb
 - lib/minitest.rb
 - lib/minitest/assertions.rb
 - lib/minitest/autorun.rb
 - lib/minitest/benchmark.rb
+- lib/minitest/bisect.rb
+- lib/minitest/complete.rb
 - lib/minitest/compress.rb
 - lib/minitest/error_on_warning.rb
 - lib/minitest/expectations.rb
+- lib/minitest/find_minimal_combination.rb
 - lib/minitest/hell.rb
 - lib/minitest/manual_plugins.rb
-- lib/minitest/mock.rb
 - lib/minitest/parallel.rb
+- lib/minitest/path_expander.rb
 - lib/minitest/pride.rb
 - lib/minitest/pride_plugin.rb
+- lib/minitest/server.rb
+- lib/minitest/server_plugin.rb
 - lib/minitest/spec.rb
+- lib/minitest/sprint.rb
+- lib/minitest/sprint_plugin.rb
 - lib/minitest/test.rb
 - lib/minitest/test_task.rb
-- lib/minitest/unit.rb
 - test/minitest/metametameta.rb
+- test/minitest/test_bisect.rb
+- test/minitest/test_find_minimal_combination.rb
 - test/minitest/test_minitest_assertions.rb
 - test/minitest/test_minitest_benchmark.rb
-- test/minitest/test_minitest_mock.rb
 - test/minitest/test_minitest_reporter.rb
 - test/minitest/test_minitest_spec.rb
 - test/minitest/test_minitest_test.rb
 - test/minitest/test_minitest_test_task.rb
+- test/minitest/test_path_expander.rb
+- test/minitest/test_server.rb
 homepage: https://minite.st/
 licenses:
 - MIT
@@ -167,21 +202,6 @@ metadata:
   source_code_uri: https://github.com/minitest/minitest
   bug_tracker_uri: https://github.com/minitest/minitest/issues
   changelog_uri: https://github.com/minitest/minitest/blob/master/History.rdoc
-post_install_message: |
-  NOTE: minitest 5 will be the last in the minitest family to support
-        ruby 1.8 to 2.7. If you need to keep using these versions,
-        you need to pin your dependency to minitest with something
-        like "~> 5.0". See History.rdoc to locate compatible
-        versions.
-
-        Further, minitest 6 will be dropping the following:
-
-        + MiniTest (it's been Minitest for >10 years)
-        + MiniTest::Unit
-        + MiniTest::Unit::TestCase
-        + assert_send (unless you argue for it well)
-        + assert_equal nil, obj
-        + mocks and stubs: moving minitest/mock.rb to its own gem
 rdoc_options:
 - "--main"
 - README.rdoc
@@ -191,7 +211,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.1'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -201,5 +221,5 @@ requirements: []
 rubygems_version: 3.7.2
 specification_version: 4
 summary: minitest provides a complete suite of testing facilities supporting TDD,
-  BDD, mocking, and benchmarking
+  BDD, and benchmarking
 test_files: []

data/.autotest

@@ -1,34 +0,0 @@
-# -*- ruby -*-
-
-require 'autotest/restart'
-require 'autotest/rcov' if ENV['RCOV']
-
-Autotest.add_hook :initialize do |at|
-  at.testlib = 'minitest/autorun'
-
-  bench_tests = %w(TestMinitestBenchmark)
-  mock_tests = %w(TestMinitestMock TestMinitestStub)
-  spec_tests = %w(TestMinitestReporter TestMetaStatic TestMeta
-                  TestSpecInTestCase)
-  unit_tests = %w(TestMinitestGuard TestMinitestRunnable
-                  TestMinitestRunner TestMinitestTest TestMinitestUnit
-                  TestMinitestUnitInherited TestMinitestUnitOrder
-                  TestMinitestUnitRecording TestMinitestUnitTestCase)
-
-  {
-    bench_tests => "test/minitest/test_minitest_benchmark.rb",
-    mock_tests  => "test/minitest/test_minitest_mock.rb",
-    spec_tests  => "test/minitest/test_minitest_reporter.rb",
-    unit_tests  => "test/minitest/test_minitest_unit.rb",
-  }.each do |klasses, file|
-    klasses.each do |klass|
-      at.extra_class_map[klass] = file
-    end
-  end
-
-  at.add_exception 'coverage.info'
-  at.add_exception 'coverage'
-end
-
-# require 'autotest/rcov'
-# Autotest::RCov.command = 'rcov_info'

data/lib/minitest/mock.rb

@@ -1,327 +0,0 @@
-class MockExpectationError < StandardError; end # :nodoc:
-
-module Minitest # :nodoc:
-
-  ##
-  # A simple and clean mock object framework.
-  #
-  # All mock objects are an instance of Mock
-
-  class Mock
-    alias __respond_to? respond_to?
-
-    overridden_methods = %i[
-      ===
-      class
-      inspect
-      instance_eval
-      instance_variables
-      object_id
-      public_send
-      respond_to_missing?
-      send
-      to_s
-    ]
-
-    overridden_methods << :singleton_method_added if defined?(::DEBUGGER__)
-
-    instance_methods.each do |m|
-      undef_method m unless overridden_methods.include?(m) || m =~ /^__/
-    end
-
-    overridden_methods.map(&:to_sym).each do |method_id|
-      old_w, $-w = $-w, nil
-      define_method method_id do |*args, **kwargs, &b|
-        if @expected_calls.key? method_id then
-          method_missing(method_id, *args, **kwargs, &b)
-        else
-          super(*args, **kwargs, &b)
-        end
-      end
-    ensure
-      $-w = old_w
-    end
-
-    def initialize delegator = nil # :nodoc:
-      @delegator = delegator
-      @expected_calls = Hash.new { |calls, name| calls[name] = [] }
-      @actual_calls   = Hash.new { |calls, name| calls[name] = [] }
-    end
-
-    @@KW_WARNED = false # :nodoc:
-
-    ##
-    # Expect that method +name+ is called, optionally with +args+ (and
-    # +kwargs+ or a +blk+), and returns +retval+.
-    #
-    #   @mock.expect(:meaning_of_life, 42)
-    #   @mock.meaning_of_life # => 42
-    #
-    #   @mock.expect(:do_something_with, true, [some_obj, true])
-    #   @mock.do_something_with(some_obj, true) # => true
-    #
-    #   @mock.expect(:do_something_else, true) do |a1, a2|
-    #     a1 == "buggs" && a2 == :bunny
-    #   end
-    #
-    # +args+ is compared to the expected args using case equality (ie, the
-    # '===' operator), allowing for less specific expectations.
-    #
-    #   @mock.expect(:uses_any_string, true, [String])
-    #   @mock.uses_any_string("foo") # => true
-    #   @mock.verify  # => true
-    #
-    #   @mock.expect(:uses_one_string, true, ["foo"])
-    #   @mock.uses_one_string("bar") # => raises MockExpectationError
-    #
-    # If a method will be called multiple times, specify a new expect for each one.
-    # They will be used in the order you define them.
-    #
-    #   @mock.expect(:ordinal_increment, 'first')
-    #   @mock.expect(:ordinal_increment, 'second')
-    #
-    #   @mock.ordinal_increment # => 'first'
-    #   @mock.ordinal_increment # => 'second'
-    #   @mock.ordinal_increment # => raises MockExpectationError "No more expects available for :ordinal_increment"
-    #
-
-    def expect name, retval, args = [], **kwargs, &blk
-      name = name.to_sym
-
-      if blk then
-        raise ArgumentError, "args ignored when block given" unless args.empty?
-        raise ArgumentError, "kwargs ignored when block given" unless kwargs.empty?
-        @expected_calls[name] << { :retval => retval, :block => blk }
-      else
-        raise ArgumentError, "args must be an array" unless Array === args
-
-        if ENV["MT_KWARGS_HAC\K"] && (Hash === args.last ||
-                                      Hash ==  args.last) then
-          if kwargs.empty? then
-            kwargs = args.pop
-          else
-            unless @@KW_WARNED then
-              from = caller(1..1).first
-              warn "Using MT_KWARGS_HAC\K yet passing kwargs. From #{from}"
-              @@KW_WARNED = true
-            end
-          end
-        end
-
-        @expected_calls[name] <<
-          { :retval => retval, :args => args, :kwargs => kwargs }
-      end
-      self
-    end
-
-    def __call name, data # :nodoc:
-      case data
-      when Hash then
-        args   = data[:args].inspect[1..-2]
-        kwargs = data[:kwargs]
-        if kwargs && !kwargs.empty? then
-          args << ", " unless args.empty?
-          args << kwargs.inspect[1..-2]
-        end
-        "#{name}(#{args}) => #{data[:retval].inspect}"
-      else
-        data.map { |d| __call name, d }.join ", "
-      end
-    end
-
-    ##
-    # Verify that all methods were called as expected. Raises
-    # +MockExpectationError+ if the mock object was not called as
-    # expected.
-
-    def verify
-      @expected_calls.each do |name, expected|
-        actual = @actual_calls.fetch name, nil # defaults to []
-        raise MockExpectationError, "Expected #{__call name, expected[0]}" unless actual
-        raise MockExpectationError, "Expected #{__call name, expected[actual.size]}, got [#{__call name, actual}]" if
-          actual.size < expected.size
-      end
-      true
-    end
-
-    def method_missing sym, *args, **kwargs, &block # :nodoc:
-      unless @expected_calls.key? sym then
-        if @delegator && @delegator.respond_to?(sym)
-          return @delegator.public_send(sym, *args, **kwargs, &block)
-        else
-          raise NoMethodError, "unmocked method %p, expected one of %p" %
-            [sym, @expected_calls.keys.sort_by(&:to_s)]
-        end
-      end
-
-      index = @actual_calls[sym].length
-      expected_call = @expected_calls[sym][index]
-
-      unless expected_call then
-        raise MockExpectationError, "No more expects available for %p: %p %p" %
-          [sym, args, kwargs]
-      end
-
-      expected_args, expected_kwargs, retval, val_block =
-        expected_call.values_at :args, :kwargs, :retval, :block
-
-      expected_kwargs = kwargs.to_h { |ak, av| [ak, Object] } if
-        Hash == expected_kwargs
-
-      if val_block then
-        # keep "verify" happy
-        @actual_calls[sym] << expected_call
-
-        raise MockExpectationError, "mocked method %p failed block w/ %p %p" %
-          [sym, args, kwargs] unless val_block.call(*args, **kwargs, &block)
-
-        return retval
-      end
-
-      if expected_args.size != args.size then
-        raise ArgumentError, "mocked method %p expects %d arguments, got %p" %
-          [sym, expected_args.size, args]
-      end
-
-      if expected_kwargs.size != kwargs.size then
-        raise ArgumentError, "mocked method %p expects %d keyword arguments, got %p" %
-          [sym, expected_kwargs.size, kwargs]
-      end
-
-      zipped_args = expected_args.zip args
-      fully_matched = zipped_args.all? { |mod, a|
-        mod === a or mod == a
-      }
-
-      unless fully_matched then
-        fmt = "mocked method %p called with unexpected arguments %p"
-        raise MockExpectationError, fmt % [sym, args]
-      end
-
-      unless expected_kwargs.keys.sort == kwargs.keys.sort then
-        fmt = "mocked method %p called with unexpected keywords %p vs %p"
-        raise MockExpectationError, fmt % [sym, expected_kwargs.keys, kwargs.keys]
-      end
-
-      zipped_kwargs = expected_kwargs.to_h { |ek, ev|
-        av = kwargs[ek]
-        [ek, [ev, av]]
-      }
-
-      fully_matched = zipped_kwargs.all? { |ek, (ev, av)|
-        ev === av or ev == av
-      }
-
-      unless fully_matched then
-        fmt = "mocked method %p called with unexpected keyword arguments %p vs %p"
-        raise MockExpectationError, fmt % [sym, expected_kwargs, kwargs]
-      end
-
-      @actual_calls[sym] << {
-        :retval => retval,
-        :args   => zipped_args.map { |e, a| e === a ? e : a },
-        :kwargs => zipped_kwargs.to_h { |k, (e, a)| [k, e === a ? e : a] },
-      }
-
-      retval
-    end
-
-    def respond_to? sym, include_private = false # :nodoc:
-      return true if @expected_calls.key? sym.to_sym
-      return true if @delegator && @delegator.respond_to?(sym, include_private)
-      __respond_to? sym, include_private
-    end
-  end
-end
-
-module Minitest::Assertions
-  ##
-  # Assert that the mock verifies correctly and fail if not.
-
-  def assert_mock mock, msg = nil
-    assert mock.verify
-  rescue MockExpectationError => e
-    msg = message(msg) { e.message }
-    flunk msg
-  end
-end
-
-module Minitest::Expectations
-  ##
-  # See Minitest::Assertions#assert_mock.
-  #
-  #    _(collection).must_verify
-  #
-  # :method: must_verify
-
-  infect_an_assertion :assert_mock, :must_verify, :unary if
-    defined?(infect_an_assertion)
-end
-
-##
-# Object extensions for Minitest::Mock.
-
-class Object
-
-  ##
-  # Add a temporary stubbed method replacing +name+ for the duration
-  # of the +block+. If +val_or_callable+ responds to #call, then it
-  # returns the result of calling it, otherwise returns the value
-  # as-is. If stubbed method yields a block, +block_args+ will be
-  # passed along. Cleans up the stub at the end of the +block+. The
-  # method +name+ must exist before stubbing.
-  #
-  #     def test_stale_eh
-  #       obj_under_test = Something.new
-  #       refute obj_under_test.stale?
-  #
-  #       Time.stub :now, Time.at(0) do
-  #         assert obj_under_test.stale?
-  #       end
-  #     end
-  #--
-  # NOTE: keyword args in callables are NOT checked for correctness
-  # against the existing method. Too many edge cases to be worth it.
-
-  def stub name, val_or_callable, *block_args, **block_kwargs, &block
-    new_name = "__minitest_stub__#{name}"
-
-    metaclass = class << self; self; end
-
-    if respond_to? name and not methods.map(&:to_s).include? name.to_s then
-      metaclass.send :define_method, name do |*args, **kwargs|
-        super(*args, **kwargs)
-      end
-    end
-
-    metaclass.send :alias_method, new_name, name
-
-    if ENV["MT_KWARGS_HAC\K"] then
-      metaclass.send :define_method, name do |*args, &blk|
-        if val_or_callable.respond_to? :call then
-          val_or_callable.call(*args, &blk)
-        else
-          blk.call(*block_args, **block_kwargs) if blk
-          val_or_callable
-        end
-      end
-    else
-      metaclass.send :define_method, name do |*args, **kwargs, &blk|
-        if val_or_callable.respond_to? :call then
-          val_or_callable.call(*args, **kwargs, &blk)
-        else
-          if blk then
-            blk.call(*block_args, **block_kwargs)
-          end
-          val_or_callable
-        end
-      end
-    end
-
-    block[self]
-  ensure
-    metaclass.send :undef_method, name
-    metaclass.send :alias_method, name, new_name
-    metaclass.send :undef_method, new_name
-  end
-end