minitest 5.12.0 → 5.22.2

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
@@ -64,8 +70,6 @@ class TestMinitestMock < Minitest::Test
   end
 
   def test_mock_args_does_not_raise
-    skip "non-opaque use of ==" if maglev?
-
     arg = Minitest::Mock.new
     mock = Minitest::Mock.new
     mock.expect(:foo, nil, [arg])
@@ -135,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
@@ -152,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
@@ -212,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
@@ -254,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
@@ -272,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" }
@@ -288,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
@@ -295,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
@@ -311,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
@@ -501,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
 
@@ -520,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:
@@ -593,6 +833,38 @@ class TestMinitestStub < Minitest::Test
     end
   end
 
+  class Keywords
+    def self.args req, kw1:, kw2:24
+      [req, kw1, kw2]
+    end
+  end
+
+  def test_stub_callable_keyword_args
+    Keywords.stub :args, ->(*args, **kws) { [args, kws] } do
+      @tc.assert_equal [["woot"], { kw1: 42 }], Keywords.args("woot", kw1: 42)
+    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
@@ -811,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
@@ -53,6 +48,25 @@ class TestMinitestReporter < MetaMetaMetaTestCase
     @et
   end
 
+  def system_stack_error_test
+    unless defined? @sse then
+
+      ex = SystemStackError.new
+
+      pre  = ("a".."c").to_a
+      mid  = ("aa".."ad").to_a * 67
+      post = ("d".."f").to_a
+      ary  = pre + mid + post
+
+      ex.set_backtrace ary
+
+      @sse = Minitest::Test.new(:woot)
+      @sse.failures << Minitest::UnexpectedError.new(ex)
+      @sse = Minitest::Result.from @sse
+    end
+    @sse
+  end
+
   def fail_test
     unless defined? @ft then
       @ft = Minitest::Test.new(:woot)
@@ -70,6 +84,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 +106,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 +164,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 +191,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
@@ -272,6 +333,42 @@ class TestMinitestReporter < MetaMetaMetaTestCase
     assert_equal exp, normalize_output(io.string)
   end
 
+  def test_report_error__sse
+    r.start
+    r.record system_stack_error_test
+    r.report
+
+    exp = clean <<-EOM
+      Run options:
+
+      # Running:
+
+      E
+
+      Finished in 0.00
+
+        1) Error:
+      Minitest::Test#woot:
+      SystemStackError: 274 -> 12
+          a
+          b
+          c
+           +->> 67 cycles of 4 lines:
+           | aa
+           | ab
+           | ac
+           | ad
+           +-<<
+          d
+          e
+          f
+
+      1 runs, 0 assertions, 0 failures, 1 errors, 0 skips
+    EOM
+
+    assert_equal exp, normalize_output(io.string)
+  end
+
   def test_report_skipped
     r.start
     r.record skip_test
@@ -296,4 +393,48 @@ class TestMinitestReporter < MetaMetaMetaTestCase
 
     assert_equal exp, normalize_output(io.string)
   end
+
+  def test_report_failure_uses_backtrace_filter
+    filter = Minitest::BacktraceFilter.new
+    def filter.filter _bt
+      ["foo.rb:123:in `foo'"]
+    end
+
+    with_backtrace_filter filter do
+      r.start
+      r.record fail_test
+      r.report
+    end
+
+    exp = "Minitest::Test#woot [foo.rb:123]"
+
+    assert_includes io.string, exp
+  end
+
+  def test_report_failure_uses_backtrace_filter_complex_sorbet
+    backtrace = <<~EOBT
+      /Users/user/.gem/ruby/3.2.2/gems/minitest-5.20.0/lib/minitest/assertions.rb:183:in `assert'
+      example_test.rb:9:in `assert_false'
+      /Users/user/.gem/ruby/3.2.2/gems/sorbet-runtime-0.5.11068/lib/types/private/methods/call_validation.rb:256:in `bind_call'
+      /Users/user/.gem/ruby/3.2.2/gems/sorbet-runtime-0.5.11068/lib/types/private/methods/call_validation.rb:256:in `validate_call'
+      /Users/user/.gem/ruby/3.2.2/gems/sorbet-runtime-0.5.11068/lib/types/private/methods/_methods.rb:275:in `block in _on_method_added'
+      example_test.rb:25:in `test_something'
+      /Users/user/.gem/ruby/3.2.2/gems/minitest-5.20.0/lib/minitest/test.rb:94:in `block (3 levels) in run'
+      /Users/user/.gem/ruby/3.2.2/gems/minitest-5.20.0/lib/minitest/test.rb:191:in `capture_exceptions'
+      /Users/user/.gem/ruby/3.2.2/gems/minitest-5.20.0/lib/minitest/test.rb:89:in `block (2 levels) in run'
+      ... so many lines ...
+    EOBT
+
+    filter = Minitest::BacktraceFilter.new %r%lib/minitest|gems/sorbet%
+
+    with_backtrace_filter filter do
+      begin
+        assert_equal 1, 2
+      rescue Minitest::Assertion => e
+        e.set_backtrace backtrace.lines.map(&:chomp)
+
+        assert_match "example_test.rb:25", e.location
+      end
+    end
+  end
 end