minitest 5.14.4 → 5.20.0

data/test/minitest/test_minitest_mock.rb

@@ -1,8 +1,14 @@
 require "minitest/autorun"
 
-class TestMinitestMock < Minitest::Test
-  parallelize_me!
+def with_kwargs_env
+  ENV["MT_KWARGS_HAC\K"] = "1"
+
+  yield
+ensure
+  ENV.delete "MT_KWARGS_HAC\K"
+end
 
+class TestMinitestMock < Minitest::Test
   def setup
     @mock = Minitest::Mock.new.expect(:foo, nil)
     @mock.expect(:meaning_of_life, 42)
@@ -51,7 +57,7 @@ class TestMinitestMock < Minitest::Test
       @mock.sum
     end
 
-    assert_equal "mocked method :sum expects 2 arguments, got 0", e.message
+    assert_equal "mocked method :sum expects 2 arguments, got []", e.message
   end
 
   def test_return_mock_does_not_raise
@@ -133,7 +139,7 @@ class TestMinitestMock < Minitest::Test
       @mock.expect :blah, 3, false
     end
 
-    assert_equal "args must be an array", e.message
+    assert_match "args must be an array", e.message
   end
 
   def test_respond_appropriately
@@ -150,7 +156,7 @@ class TestMinitestMock < Minitest::Test
 
     expected = "unmocked method :bar, expected one of [:foo, :meaning_of_life]"
 
-    assert_equal expected, e.message
+    assert_match expected, e.message
   end
 
   def test_assign_per_mock_return_values
@@ -210,7 +216,7 @@ class TestMinitestMock < Minitest::Test
       mock.a
     end
 
-    assert_equal "No more expects available for :a: []", e.message
+    assert_equal "No more expects available for :a: [] {}", e.message
   end
 
   def test_same_method_expects_are_verified_when_all_called
@@ -252,6 +258,30 @@ class TestMinitestMock < Minitest::Test
     assert_equal exp, e.message
   end
 
+  def test_delegator_calls_are_propagated
+    delegator = Object.new
+    mock = Minitest::Mock.new delegator
+
+    refute delegator.nil?
+    refute mock.nil?
+    assert_mock mock
+  end
+
+  def test_handles_kwargs_in_error_message
+    mock = Minitest::Mock.new
+
+    mock.expect :foo, nil, [], kw: true
+    mock.expect :foo, nil, [], kw: false
+
+    mock.foo kw: true
+
+    e = assert_raises(MockExpectationError) { mock.verify }
+
+    exp = "expected foo(:kw=>false) => nil, got [foo(:kw=>true) => nil]"
+
+    assert_equal exp, e.message
+  end
+
   def test_verify_passes_when_mock_block_returns_true
     mock = Minitest::Mock.new
     mock.expect :foo, nil do
@@ -270,11 +300,188 @@ class TestMinitestMock < Minitest::Test
       a1 == arg1 && a2 == arg2 && a3 == arg3
     end
 
-    mock.foo arg1, arg2, arg3
+    assert_silent do
+      if RUBY_VERSION > "3" then
+        mock.foo arg1, arg2, arg3
+      else
+        mock.foo arg1, arg2, **arg3 # oddity just for ruby 2.7
+      end
+    end
+
+    assert_mock mock
+  end
+
+  def test_mock_block_is_passed_keyword_args__block
+    arg1, arg2, arg3 = :bar, [1, 2, 3], { :a => "a" }
+    mock = Minitest::Mock.new
+    mock.expect :foo, nil do |k1:, k2:, k3:|
+      k1 == arg1 && k2 == arg2 && k3 == arg3
+    end
+
+    mock.foo(k1: arg1, k2: arg2, k3: arg3)
+
+    assert_mock mock
+  end
+
+  def test_mock_block_is_passed_keyword_args__block_bad_missing
+    arg1, arg2, arg3 = :bar, [1, 2, 3], { :a => "a" }
+    mock = Minitest::Mock.new
+    mock.expect :foo, nil do |k1:, k2:, k3:|
+      k1 == arg1 && k2 == arg2 && k3 == arg3
+    end
+
+    e = assert_raises ArgumentError do
+      mock.foo(k1: arg1, k2: arg2)
+    end
+
+    # basically testing ruby ... need ? for ruby < 2.7 :(
+    assert_match(/missing keyword: :?k3/, e.message)
+  end
+
+  def test_mock_block_is_passed_keyword_args__block_bad_extra
+    arg1, arg2, arg3 = :bar, [1, 2, 3], { :a => "a" }
+    mock = Minitest::Mock.new
+    mock.expect :foo, nil do |k1:, k2:|
+      k1 == arg1 && k2 == arg2 && k3 == arg3
+    end
+
+    e = assert_raises ArgumentError do
+      mock.foo(k1: arg1, k2: arg2, k3: arg3)
+    end
+
+    # basically testing ruby ... need ? for ruby < 2.7 :(
+    assert_match(/unknown keyword: :?k3/, e.message)
+  end
+
+  def test_mock_block_is_passed_keyword_args__block_bad_value
+    arg1, arg2, arg3 = :bar, [1, 2, 3], { :a => "a" }
+    mock = Minitest::Mock.new
+    mock.expect :foo, nil do |k1:, k2:, k3:|
+      k1 == arg1 && k2 == arg2 && k3 == arg3
+    end
+
+    e = assert_raises MockExpectationError do
+      mock.foo(k1: arg1, k2: arg2, k3: :BAD!)
+    end
+
+    exp = "mocked method :foo failed block w/ [] {:k1=>:bar, :k2=>[1, 2, 3], :k3=>:BAD!}"
+    assert_equal exp, e.message
+  end
+
+  def test_mock_block_is_passed_keyword_args__args
+    arg1, arg2, arg3 = :bar, [1, 2, 3], { :a => "a" }
+    mock = Minitest::Mock.new
+    mock.expect :foo, nil, k1: arg1, k2: arg2, k3: arg3
+
+    mock.foo(k1: arg1, k2: arg2, k3: arg3)
 
     assert_mock mock
   end
 
+  def test_mock_allow_all_kwargs__old_style_env
+    with_kwargs_env do
+      mock = Minitest::Mock.new
+      mock.expect :foo, true, [Hash]
+      assert_equal true, mock.foo(bar: 42)
+    end
+  end
+
+  def test_mock_allow_all_kwargs__old_style_env__rewrite
+    with_kwargs_env do
+      mock = Minitest::Mock.new
+      mock.expect :foo, true, [], bar: Integer
+      assert_equal true, mock.foo(bar: 42)
+    end
+  end
+
+  def test_mock_block_is_passed_keyword_args__args__old_style_bad
+    arg1, arg2, arg3 = :bar, [1, 2, 3], { :a => "a" }
+    mock = Minitest::Mock.new
+    mock.expect :foo, nil, [{k1: arg1, k2: arg2, k3: arg3}]
+
+    e = assert_raises ArgumentError do
+      mock.foo(k1: arg1, k2: arg2, k3: arg3)
+    end
+
+    assert_equal "mocked method :foo expects 1 arguments, got []", e.message
+  end
+
+  def test_mock_block_is_passed_keyword_args__args__old_style_env
+    with_kwargs_env do
+      arg1, arg2, arg3 = :bar, [1, 2, 3], { :a => "a" }
+      mock = Minitest::Mock.new
+      mock.expect :foo, nil, [{k1: arg1, k2: arg2, k3: arg3}]
+
+      mock.foo(k1: arg1, k2: arg2, k3: arg3)
+
+      assert_mock mock
+    end
+  end
+
+  def test_mock_block_is_passed_keyword_args__args__old_style_both
+    with_kwargs_env do
+      arg1, arg2, arg3 = :bar, [1, 2, 3], { :a => "a" }
+      mock = Minitest::Mock.new
+
+      assert_output nil, /Using MT_KWARGS_HAC. yet passing kwargs/ do
+        mock.expect :foo, nil, [{}], k1: arg1, k2: arg2, k3: arg3
+      end
+
+      mock.foo({}, k1: arg1, k2: arg2, k3: arg3)
+
+      assert_mock mock
+    end
+  end
+
+  def test_mock_block_is_passed_keyword_args__args_bad_missing
+    arg1, arg2, arg3 = :bar, [1, 2, 3], { :a => "a" }
+    mock = Minitest::Mock.new
+    mock.expect :foo, nil, k1: arg1, k2: arg2, k3: arg3
+
+    e = assert_raises ArgumentError do
+      mock.foo(k1: arg1, k2: arg2)
+    end
+
+    assert_equal "mocked method :foo expects 3 keyword arguments, got %p" % {k1: arg1, k2: arg2}, e.message
+  end
+
+  def test_mock_block_is_passed_keyword_args__args_bad_extra
+    arg1, arg2, arg3 = :bar, [1, 2, 3], { :a => "a" }
+    mock = Minitest::Mock.new
+    mock.expect :foo, nil, k1: arg1, k2: arg2
+
+    e = assert_raises ArgumentError do
+      mock.foo(k1: arg1, k2: arg2, k3: arg3)
+    end
+
+    assert_equal "mocked method :foo expects 2 keyword arguments, got %p" % {k1: arg1, k2: arg2, k3: arg3}, e.message
+  end
+
+  def test_mock_block_is_passed_keyword_args__args_bad_key
+    arg1, arg2, arg3 = :bar, [1, 2, 3], { :a => "a" }
+    mock = Minitest::Mock.new
+    mock.expect :foo, nil, k1: arg1, k2: arg2, k3: arg3
+
+    e = assert_raises MockExpectationError do
+      mock.foo(k1: arg1, k2: arg2, BAD: arg3)
+    end
+
+    assert_includes e.message, "unexpected keywords [:k1, :k2, :k3]"
+    assert_includes e.message, "vs [:k1, :k2, :BAD]"
+  end
+
+  def test_mock_block_is_passed_keyword_args__args_bad_val
+    arg1, arg2, arg3 = :bar, [1, 2, 3], { :a => "a" }
+    mock = Minitest::Mock.new
+    mock.expect :foo, nil, k1: arg1, k2: arg2, k3: arg3
+
+    e = assert_raises MockExpectationError do
+      mock.foo(k1: arg1, k2: :BAD!, k3: arg3)
+    end
+
+    assert_match(/unexpected keyword arguments.* vs .*:k2=>:BAD!/, e.message)
+  end
+
   def test_mock_block_is_passed_function_block
     mock = Minitest::Mock.new
     block = proc { "bar" }
@@ -286,6 +493,13 @@ class TestMinitestMock < Minitest::Test
     assert_mock mock
   end
 
+  def test_mock_forward_keyword_arguments
+    mock = Minitest::Mock.new
+    mock.expect(:foo, nil) { |bar:| bar == 'bar' }
+    mock.foo(bar: 'bar')
+    assert_mock mock
+  end
+
   def test_verify_fails_when_mock_block_returns_false
     mock = Minitest::Mock.new
     mock.expect :foo, nil do
@@ -293,12 +507,12 @@ class TestMinitestMock < Minitest::Test
     end
 
     e = assert_raises(MockExpectationError) { mock.foo }
-    exp = "mocked method :foo failed block w/ []"
+    exp = "mocked method :foo failed block w/ [] {}"
 
     assert_equal exp, e.message
   end
 
-  def test_mock_block_throws_if_args_passed
+  def test_mock_block_raises_if_args_passed
     mock = Minitest::Mock.new
 
     e = assert_raises(ArgumentError) do
@@ -309,7 +523,21 @@ class TestMinitestMock < Minitest::Test
 
     exp = "args ignored when block given"
 
-    assert_equal exp, e.message
+    assert_match exp, e.message
+  end
+
+  def test_mock_block_raises_if_kwargs_passed
+    mock = Minitest::Mock.new
+
+    e = assert_raises(ArgumentError) do
+      mock.expect :foo, nil, kwargs:1 do
+        true
+      end
+    end
+
+    exp = "kwargs ignored when block given"
+
+    assert_match exp, e.message
   end
 
   def test_mock_returns_retval_when_called_with_block
@@ -499,7 +727,8 @@ class TestMinitestStub < Minitest::Test
       end
     end
 
-    exp = /undefined method `nope_nope_nope' for( class)? `#{self.class}::Time'/
+    exp = jruby? ? /Undefined method nope_nope_nope for '#{self.class}::Time'/ :
+      /undefined method `nope_nope_nope' for( class)? `#{self.class}::Time'/
     assert_match exp, e.message
   end
 
@@ -518,6 +747,19 @@ class TestMinitestStub < Minitest::Test
     @tc.assert_equal true, rs
   end
 
+  def test_mock_with_yield_kwargs
+    mock = Minitest::Mock.new
+    rs = nil
+
+    File.stub :open, true, mock, kw:42 do
+      File.open "foo.txt", "r" do |f, kw:|
+        rs = kw
+      end
+    end
+
+    @tc.assert_equal 42, rs
+  end
+
   alias test_stub_value__old test_stub_value # TODO: remove/rename
 
   ## Permutation Sets:
@@ -603,6 +845,26 @@ class TestMinitestStub < Minitest::Test
     end
   end
 
+  def test_stub__hash_as_last_real_arg
+    with_kwargs_env do
+      token = Object.new
+      def token.create_with_retry u, p; raise "shouldn't see this"; end
+
+      controller = Object.new
+      controller.define_singleton_method :create do |u, p|
+        token.create_with_retry u, p
+      end
+
+      params = Object.new
+      def params.to_hash; raise "nah"; end
+
+      token.stub(:create_with_retry, ->(u, p) { 42 }) do
+        act = controller.create :u, params
+        @tc.assert_equal 42, act
+      end
+    end
+  end
+
   def test_stub_callable_block_5 # from tenderlove
     @assertion_count += 1
     Foo.stub5 :blocking, Bar.new do
@@ -821,8 +1083,8 @@ class TestMinitestStub < Minitest::Test
         end
       end
     end
-    exp = "undefined method `write' for nil:NilClass"
-    assert_equal exp, e.message
+    exp = /undefined method `write' for nil/
+    assert_match exp, e.message
   end
 
   def test_stub_value_block_args_6

data/test/minitest/test_minitest_reporter.rb

@@ -1,5 +1,6 @@
 require "minitest/autorun"
 require "minitest/metametameta"
+require "forwardable"
 
 class Runnable
   def woot
@@ -12,30 +13,24 @@ class TestMinitestReporter < MetaMetaMetaTestCase
   attr_accessor :r, :io
 
   def new_composite_reporter
+    # Ruby bug in older versions of 2.2 & 2.3 on all platforms
+    # Latest Windows builds were 2.2.6 and 2.3.3.  Latest Ruby releases were
+    # 2.2.10 and 2.3.8.
+    skip if windows? && RUBY_VERSION < '2.4'
     reporter = Minitest::CompositeReporter.new
     reporter << Minitest::SummaryReporter.new(self.io)
     reporter << Minitest::ProgressReporter.new(self.io)
 
-    def reporter.first
-      reporters.first
-    end
-
-    def reporter.results
-      first.results
-    end
-
-    def reporter.count
-      first.count
-    end
-
-    def reporter.assertions
-      first.assertions
-    end
+    # eg reporter.results -> reporters.first.results
+    reporter.extend Forwardable
+    reporter.delegate :first => :reporters
+    reporter.delegate %i[results count assertions options to_s] => :first
 
     reporter
   end
 
   def setup
+    super
     self.io = StringIO.new("")
     self.r  = new_composite_reporter
   end
@@ -70,6 +65,12 @@ class TestMinitestReporter < MetaMetaMetaTestCase
     @pt ||= Minitest::Result.from Minitest::Test.new(:woot)
   end
 
+  def passing_test_with_metadata
+    test = Minitest::Test.new(:woot)
+    test.metadata[:meta] = :data
+    @pt ||= Minitest::Result.from test
+  end
+
   def skip_test
     unless defined? @st then
       @st = Minitest::Test.new(:woot)
@@ -86,7 +87,25 @@ class TestMinitestReporter < MetaMetaMetaTestCase
   def test_to_s
     r.record passing_test
     r.record fail_test
-    assert_match "woot", r.first.to_s
+    assert_match "woot", r.to_s
+  end
+
+  def test_options_skip_F
+    r.options[:skip] = "F"
+
+    r.record passing_test
+    r.record fail_test
+
+    refute_match "woot", r.to_s
+  end
+
+  def test_options_skip_E
+    r.options[:skip] = "E"
+
+    r.record passing_test
+    r.record error_test
+
+    refute_match "RuntimeError: no", r.to_s
   end
 
   def test_passed_eh_empty
@@ -126,7 +145,7 @@ class TestMinitestReporter < MetaMetaMetaTestCase
   end
 
   def test_passed_eh_skipped_verbose
-    r.first.options[:verbose] = true
+    r.options[:verbose] = true
 
     r.start
     r.results << skip_test
@@ -153,6 +172,29 @@ class TestMinitestReporter < MetaMetaMetaTestCase
     assert_equal 0, r.assertions
   end
 
+  def test_record_pass_with_metadata
+    reporter = self.r
+
+    def reporter.metadata
+      @metadata
+    end
+
+    def reporter.record result
+      super
+      @metadata = result.metadata if result.metadata?
+    end
+
+    r.record passing_test_with_metadata
+
+    exp = { :meta => :data }
+    assert_equal exp, reporter.metadata
+
+    assert_equal ".", io.string
+    assert_empty r.results
+    assert_equal 1, r.count
+    assert_equal 0, r.assertions
+  end
+
   def test_record_fail
     fail_test = self.fail_test
     r.record fail_test

data/test/minitest/test_minitest_spec.rb

@@ -137,6 +137,46 @@ describe Minitest::Spec do
     end
   end
 
+  def good_pattern
+    capture_io do # 3.0 is noisy
+      eval "[1,2,3] => [Integer, Integer, Integer]" # eval to escape parser for ruby<3
+    end
+  end
+
+  def bad_pattern
+    capture_io do # 3.0 is noisy
+      eval "[1,2,3] => [Integer, Integer]" # eval to escape parser for ruby<3
+    end
+  end
+
+  it "needs to pattern match" do
+    @assertion_count = 1
+
+    if RUBY_VERSION > "3" then
+      expect { good_pattern }.must_pattern_match
+    else
+      assert_raises NotImplementedError do
+        expect {}.must_pattern_match
+      end
+    end
+  end
+
+  it "needs to error on bad pattern match" do
+    skip unless RUBY_VERSION > "3"
+
+    @assertion_count = 1
+
+    exp = if RUBY_VERSION.start_with? "3.0"
+            "[1, 2, 3]" # terrible error message!
+          else
+            /length mismatch/
+          end
+
+    assert_triggered exp do
+      expect { bad_pattern }.must_pattern_match
+    end
+  end
+
   it "needs to ensure silence" do
     @assertion_count -= 1 # no msg
     @assertion_count += 2 # assert_output is 2 assertions
@@ -172,6 +212,7 @@ describe Minitest::Spec do
                         must_include
                         must_match
                         must_output
+                        must_pattern_match
                         must_raise
                         must_respond_to
                         must_throw
@@ -505,7 +546,7 @@ describe Minitest::Spec do
   it "needs to verify regexp matches" do
     @assertion_count += 3 # must_match is 2 assertions
 
-    assert_success _("blah").must_match(/\w+/)
+    assert_kind_of MatchData, _("blah").must_match(/\w+/)
 
     assert_triggered "Expected /\\d+/ to match \"blah\"." do
       _("blah").must_match(/\d+/)
@@ -590,9 +631,10 @@ describe Minitest::Spec do
   end
 
   it "needs to verify throw" do
-    @assertion_count += 2 # 2 extra tests
+    @assertion_count += 4 # 2 extra tests
 
-    assert_success expect { throw :blah }.must_throw(:blah)
+    assert_nil expect { throw :blah }.must_throw(:blah)
+    assert_equal 42, expect { throw :blah, 42 }.must_throw(:blah)
 
     assert_triggered "Expected :blah to have been thrown." do
       expect {}.must_throw :blah
@@ -743,6 +785,10 @@ describe Minitest::Spec, :subject do
 end
 
 class TestMetaStatic < Minitest::Test
+  def assert_method_count expected, klass
+    assert_equal expected, klass.public_instance_methods.grep(/^test_/).count
+  end
+
   def test_children
     Minitest::Spec.children.clear # prevents parallel run
 
@@ -776,8 +822,8 @@ class TestMetaStatic < Minitest::Test
       end
     end
 
-    assert_equal 1, outer.public_instance_methods.grep(/^test_/).count
-    assert_equal 1, inner.public_instance_methods.grep(/^test_/).count
+    assert_method_count 1, outer
+    assert_method_count 1, inner
   end
 
   def test_it_wont_add_test_methods_to_children
@@ -791,14 +837,18 @@ class TestMetaStatic < Minitest::Test
       end
     end
 
-    assert_equal 1, outer.public_instance_methods.grep(/^test_/).count
-    assert_equal 0, inner.public_instance_methods.grep(/^test_/).count
+    assert_method_count 1, outer
+    assert_method_count 0, inner
   end
 end
 
 class TestMeta < MetaMetaMetaTestCase
   # do not call parallelize_me! here because specs use register_spec_type globally
 
+  def assert_defined_methods expected, klass
+    assert_equal expected, klass.instance_methods(false).sort.map(&:to_s)
+  end
+
   def util_structure
     y = z = nil
     before_list = []
@@ -871,7 +921,7 @@ class TestMeta < MetaMetaMetaTestCase
       end
     end
 
-    test_name = spec_class.instance_methods.sort.grep(/test/).first
+    test_name = spec_class.instance_methods.sort.grep(/test_/).first
 
     spec = spec_class.new test_name
 
@@ -920,9 +970,9 @@ class TestMeta < MetaMetaMetaTestCase
     inner_methods2 = inner_methods1 +
       %w[test_0002_anonymous test_0003_anonymous]
 
-    assert_equal top_methods,    x.instance_methods(false).sort.map(&:to_s)
-    assert_equal inner_methods1, y.instance_methods(false).sort.map(&:to_s)
-    assert_equal inner_methods2, z.instance_methods(false).sort.map(&:to_s)
+    assert_defined_methods top_methods, x
+    assert_defined_methods inner_methods1, y
+    assert_defined_methods inner_methods2, z
   end
 
   def test_structure_postfix_it
@@ -939,8 +989,8 @@ class TestMeta < MetaMetaMetaTestCase
       it "inner-it" do end
     end
 
-    assert_equal %w[test_0001_inner-it], y.instance_methods(false).map(&:to_s)
-    assert_equal %w[test_0001_inner-it], z.instance_methods(false).map(&:to_s)
+    assert_defined_methods %w[test_0001_inner-it], y
+    assert_defined_methods %w[test_0001_inner-it], z
   end
 
   def test_setup_teardown_behavior
@@ -971,9 +1021,9 @@ class TestMeta < MetaMetaMetaTestCase
                    ].sort
 
     assert_equal test_methods, [x1, x2]
-    assert_equal test_methods, x.instance_methods.grep(/^test/).map(&:to_s).sort
-    assert_equal [], y.instance_methods.grep(/^test/)
-    assert_equal [], z.instance_methods.grep(/^test/)
+    assert_defined_methods test_methods, x
+    assert_defined_methods [], y
+    assert_defined_methods [], z
   end
 
   def test_structure_subclasses
@@ -1059,3 +1109,38 @@ class ValueMonadTest < Minitest::Test
     assert_equal "c", struct.expect
   end
 end
+
+describe Minitest::Spec, :infect_an_assertion do
+  class << self
+    attr_accessor :infect_mock
+  end
+
+  def assert_infects exp, act, msg = nil, foo: nil, bar: nil
+    self.class.infect_mock.assert_infects exp, act, msg, foo: foo, bar: bar
+  end
+
+  infect_an_assertion :assert_infects, :must_infect
+  infect_an_assertion :assert_infects, :must_infect_without_flipping, :dont_flip
+
+  it "infects assertions with kwargs" do
+    mock = Minitest::Mock.new
+    mock.expect :assert_infects, true, [:exp, :act, nil], foo: :foo, bar: :bar
+
+    self.class.infect_mock = mock
+
+    _(:act).must_infect :exp, foo: :foo, bar: :bar
+
+    assert_mock mock
+  end
+
+  it "infects assertions with kwargs (dont_flip)" do
+    mock = Minitest::Mock.new
+    mock.expect :assert_infects, true, [:act, :exp, nil], foo: :foo, bar: :bar
+
+    self.class.infect_mock = mock
+
+    _(:act).must_infect_without_flipping :exp, foo: :foo, bar: :bar
+
+    assert_mock mock
+  end
+end