minitest 5.26.0 → 6.0.0

data/test/minitest/test_minitest_reporter.rb

@@ -1,5 +1,5 @@
 require "minitest/autorun"
-require "minitest/metametameta"
+require_relative "metametameta"
 require "forwardable"
 
 class FakeTest < Minitest::Test
@@ -29,10 +29,11 @@ class TestMinitestReporter < MetaMetaMetaTestCase
     super
     self.io = StringIO.new(+"")
     self.r  = new_composite_reporter
+    @et = @ft = @pt = @st = @sse = nil
   end
 
   def error_test
-    unless defined? @et then
+    unless @et then
       @et = FakeTest.new :woot
       @et.failures << Minitest::UnexpectedError.new(begin
                                                       raise "no"
@@ -45,7 +46,7 @@ class TestMinitestReporter < MetaMetaMetaTestCase
   end
 
   def system_stack_error_test
-    unless defined? @sse then
+    unless @sse then
 
       ex = SystemStackError.new
 
@@ -64,7 +65,7 @@ class TestMinitestReporter < MetaMetaMetaTestCase
   end
 
   def fail_test
-    unless defined? @ft then
+    unless @ft then
       @ft = FakeTest.new :woot
       @ft.failures <<   begin
                           raise Minitest::Assertion, "boo"
@@ -87,7 +88,7 @@ class TestMinitestReporter < MetaMetaMetaTestCase
   end
 
   def skip_test
-    unless defined? @st then
+    unless @st then
       @st = FakeTest.new :woot
       @st.failures << begin
                         raise Minitest::Skip

data/test/minitest/test_minitest_spec.rb

@@ -1,4 +1,4 @@
-require "minitest/metametameta"
+require_relative "metametameta"
 require "stringio"
 
 class MiniSpecA < Minitest::Spec; end
@@ -108,7 +108,7 @@ describe Minitest::Spec do
   end
 
   it "needs to catch an expected exception" do
-    @assertion_count = 2
+    @assertion_count -= 2
 
     expect { raise "blah" }.must_raise RuntimeError
     expect { raise Minitest::Assertion }.must_raise Minitest::Assertion
@@ -148,25 +148,13 @@ describe Minitest::Spec do
   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
+    expect { good_pattern }.must_pattern_match
   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
+    exp = /length mismatch/
 
     assert_triggered exp do
       expect { bad_pattern }.must_pattern_match
@@ -212,11 +200,16 @@ describe Minitest::Spec do
                         must_raise
                         must_respond_to
                         must_throw
-                        must_verify
                         path_must_exist]
 
     bad = %w[not raise throw send output be_silent verify]
 
+    if methods.include? "must_infect" then # from test_minitest_mock.rb
+      expected_musts += %w[must_infect must_infect_without_flipping]
+      expected_musts.sort!
+      bad << "infect"
+    end
+
     expected_wonts = expected_musts.map { |m| m.sub("must", "wont") }.sort
     expected_wonts.reject! { |m| m =~ /wont_#{Regexp.union(*bad)}/ }
 
@@ -237,6 +230,8 @@ describe Minitest::Spec do
   end
 
   it "needs to verify binary messages" do
+    @assertion_count += 3
+
     assert_success _(42).wont_be(:<, 24)
 
     assert_triggered "Expected 24 to not be < 42." do
@@ -280,15 +275,9 @@ describe Minitest::Spec do
     end
   end
 
-  it "needs to warn on equality with nil" do
-    @assertion_count = 3
-    @assertion_count += 2 unless error_on_warn? # 2 extra assertions
-
-    exp = /DEPRECATED: Use assert_nil if expecting nil from .* This will fail in Minitest 6./
-
-    assert_deprecation exp do
-      assert_success _(nil).must_equal(nil)
-    end
+  it "needs to fail on equality with nil" do
+    @assertion_count -= 2
+    expect { _(nil).must_equal(nil) }.must_raise Minitest::Assertion
   end
 
   it "needs to verify floats outside a delta" do
@@ -300,12 +289,11 @@ describe Minitest::Spec do
       _(6 * 7.0).wont_be_close_to 42
     end
 
-    x = "1.0e-05"
-    assert_triggered "Expected |42 - 42.0| (0.0) to not be <= #{x}." do
+    assert_triggered "Expected |42 - 42.0| (0.0) to not be <= 1.0e-05." do
       _(6 * 7.0).wont_be_close_to 42, 0.00001
     end
 
-    assert_triggered "msg.\nExpected |42 - 42.0| (0.0) to not be <= #{x}." do
+    assert_triggered "msg.\nExpected |42 - 42.0| (0.0) to not be <= 1.0e-05." do
       _(6 * 7.0).wont_be_close_to 42, 0.00001, "msg"
     end
   end
@@ -315,17 +303,15 @@ describe Minitest::Spec do
 
     assert_success _(24).wont_be_within_epsilon(42)
 
-    x = "0.042"
-    assert_triggered "Expected |42 - 42.0| (0.0) to not be <= #{x}." do
+    assert_triggered "Expected |42 - 42.0| (0.0) to not be <= 0.042." do
       _(6 * 7.0).wont_be_within_epsilon 42
     end
 
-    x = "0.00042"
-    assert_triggered "Expected |42 - 42.0| (0.0) to not be <= #{x}." do
+    assert_triggered "Expected |42 - 42.0| (0.0) to not be <= 0.00042." do
       _(6 * 7.0).wont_be_within_epsilon 42, 0.00001
     end
 
-    assert_triggered "msg.\nExpected |42 - 42.0| (0.0) to not be <= #{x}." do
+    assert_triggered "msg.\nExpected |42 - 42.0| (0.0) to not be <= 0.00042." do
       _(6 * 7.0).wont_be_within_epsilon 42, 0.00001, "msg"
     end
   end
@@ -339,12 +325,11 @@ describe Minitest::Spec do
       _(1.0 / 100).must_be_close_to 0.0
     end
 
-    x = "1.0e-06"
-    assert_triggered "Expected |0.0 - 0.001| (0.001) to be <= #{x}." do
+    assert_triggered "Expected |0.0 - 0.001| (0.001) to be <= 1.0e-06." do
       _(1.0 / 1000).must_be_close_to 0.0, 0.000001
     end
 
-    assert_triggered "msg.\nExpected |0.0 - 0.001| (0.001) to be <= #{x}." do
+    assert_triggered "msg.\nExpected |0.0 - 0.001| (0.001) to be <= 1.0e-06." do
       _(1.0 / 1000).must_be_close_to 0.0, 0.000001, "msg"
     end
   end
@@ -566,67 +551,6 @@ describe Minitest::Spec do
     it "can use expect in a thread" do
       Thread.new { _(1 + 1).must_equal 2 }.join
     end
-
-    it "can NOT use must_equal in a thread. It must use expect in a thread" do
-      skip "N/A" if ENV["MT_NO_EXPECTATIONS"]
-
-      assert_raises RuntimeError, Minitest::UnexpectedWarning do
-        capture_io do
-          Thread.new { (1 + 1).must_equal 2 }.join
-        end
-      end
-    end
-
-    it "fails gracefully when expectation used outside of `it`" do
-      skip "N/A" if ENV["MT_NO_EXPECTATIONS"]
-
-      @assertion_count += 2 # assert_match is compound
-
-      e = assert_raises RuntimeError, Minitest::UnexpectedWarning do
-        capture_io do
-          Thread.new { # forces ctx to be nil
-            describe "woot" do
-              (1 + 1).must_equal 2
-            end
-          }.join
-        end
-      end
-
-      exp = "Calling #must_equal outside of test."
-      exp = "DEPRECATED: global use of must_equal from" if error_on_warn?
-
-      assert_match exp, e.message
-    end
-
-    it "deprecates expectation used without _" do
-      skip "N/A" if ENV["MT_NO_EXPECTATIONS"]
-
-      @assertion_count += 1
-      @assertion_count += 2 unless error_on_warn?
-
-      exp = /DEPRECATED: global use of must_equal from/
-
-      assert_deprecation exp do
-        (1 + 1).must_equal 2
-      end
-    end
-
-    # https://github.com/seattlerb/minitest/issues/837
-    # https://github.com/rails/rails/pull/39304
-    it "deprecates expectation used without _ with empty backtrace_filter" do
-      skip "N/A" if ENV["MT_NO_EXPECTATIONS"]
-
-      @assertion_count += 1
-      @assertion_count += 2 unless error_on_warn?
-
-      exp = /DEPRECATED: global use of must_equal from/
-
-      with_empty_backtrace_filter do
-        assert_deprecation exp do
-          (1 + 1).must_equal 2
-        end
-      end
-    end
   end
 
   it "needs to verify throw" do
@@ -667,7 +591,7 @@ describe Minitest::Spec do
   end
 
   it "needs to verify using any (negative) predicate" do
-    @assertion_count -= 1 # doesn"t take a message
+    @assertion_count += 1
 
     assert_success _("blah").wont_be(:empty?)
 
@@ -677,7 +601,7 @@ describe Minitest::Spec do
   end
 
   it "needs to verify using any binary operator" do
-    @assertion_count -= 1 # no msg
+    @assertion_count += 1
 
     assert_success _(41).must_be(:<, 42)
 
@@ -687,7 +611,7 @@ describe Minitest::Spec do
   end
 
   it "needs to verify using any predicate" do
-    @assertion_count -= 1 # no msg
+    @assertion_count += 1
 
     assert_success _("").must_be(:empty?)
 
@@ -939,6 +863,16 @@ class TestMeta < MetaMetaMetaTestCase
     assert_equal "ExampleB::random_method::addl_context", spec_c.name
   end
 
+  def test_inspect
+    spec_a = describe ExampleA do; end
+    spec_b = describe ExampleB, :random_method do; end
+    spec_c = describe ExampleB, :random_method, :addl_context do; end
+
+    assert_equal "ExampleA", spec_a.inspect
+    assert_equal "ExampleB::random_method", spec_b.inspect
+    assert_equal "ExampleB::random_method::addl_context", spec_c.inspect
+  end
+
   def test_name2
     assert_equal "NamedExampleA", NamedExampleA.name
     assert_equal "NamedExampleB", NamedExampleB.name
@@ -1126,36 +1060,36 @@ class ValueMonadTest < Minitest::Test
 end
 
 describe Minitest::Spec, :infect_an_assertion do
-  class << self
-    attr_accessor :infect_mock
+  attr_accessor :infect_mock
+
+  before do
+    mock = Object.new
+    mock.singleton_class.attr_accessor :a, :k
+    def mock.assert_infects *args, **kwargs
+      self.a, self.k = args, kwargs
+    end
+
+    self.infect_mock = 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
+    self.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
+  Minitest::Expectations.infect_an_assertion :assert_infects, :must_infect
+  Minitest::Expectations.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
+    assert_equal [:exp, :act, nil], infect_mock.a
+    assert_equal({foo: :foo, bar: :bar}, infect_mock.k)
   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
+    assert_equal [:act, :exp, nil], infect_mock.a
+    assert_equal({foo: :foo, bar: :bar}, infect_mock.k)
   end
 end

data/test/minitest/test_minitest_test.rb

@@ -1,4 +1,4 @@
-require "minitest/metametameta"
+require_relative "metametameta"
 
 e = Encoding.default_external
 if e != Encoding::UTF_8 then
@@ -342,6 +342,20 @@ class TestMinitestRunner < MetaMetaMetaTestCase
     assert_instance_of Integer, Minitest.seed
   end
 
+  def test_filter_runnable_methods
+    cls = Class.new Minitest::Runnable
+    def cls.runnable_methods
+      %w[ x y z ]
+    end
+
+    assert_equal %w[x y z], cls.filter_runnable_methods
+    assert_equal %w[x y],   cls.filter_runnable_methods(exclude: "z")
+    assert_equal %w[x],     cls.filter_runnable_methods(include: "x")
+
+    assert_empty            cls.filter_runnable_methods(exclude: "/./")
+    assert_empty            cls.filter_runnable_methods(include: "x", exclude: "x")
+  end
+
   def test_run_failing_filtered
     setup_basic_tu
 
@@ -566,7 +580,7 @@ class TestMinitestRunner < MetaMetaMetaTestCase
 
   def test_run_with_other_runner
     @tu = Class.new FakeNamedTest do
-      def self.run reporter, options = {}
+      def self.run_suite reporter, options = {}
         @reporter = reporter
         before_my_suite
         super
@@ -795,40 +809,6 @@ class BetterError < RuntimeError # like better_error w/o infecting RuntimeError
 end
 
 class TestMinitestRunnable < Minitest::Test
-  def setup_marshal klass
-    tc = klass.new "whatever"
-    tc.assertions = 42
-    tc.failures << "a failure"
-
-    yield tc if block_given?
-
-    def tc.setup
-      @blah = "blah"
-    end
-    tc.setup
-
-    @tc = Minitest::Result.from tc
-  end
-
-  def assert_marshal expected_ivars
-    new_tc = Marshal.load Marshal.dump @tc
-
-    ivars = new_tc.instance_variables.map(&:to_s).sort
-    ivars.delete "@gc_stats" # only needed if running w/ minitest-gcstats
-    assert_equal expected_ivars, ivars
-    assert_equal "whatever",     new_tc.name
-    assert_equal 42,             new_tc.assertions
-    assert_equal ["a failure"],  new_tc.failures
-
-    yield new_tc if block_given?
-  end
-
-  def test_marshal
-    setup_marshal Minitest::Runnable
-
-    assert_marshal %w[@NAME @assertions @failures @klass @source_location @time]
-  end
-
   def test_spec_marshal
     klass = describe("whatever") { it("passes") { assert true } }
     rm = klass.runnable_methods.first
@@ -988,18 +968,6 @@ class TestMinitestRunnable < Minitest::Test
   end
 end
 
-class TestMinitestTest < TestMinitestRunnable
-  def test_dup
-    setup_marshal Minitest::Test do |tc|
-      tc.time = 3.14
-    end
-
-    assert_marshal %w[@NAME @assertions @failures @klass @source_location @time] do |new_tc|
-      assert_in_epsilon 3.14, new_tc.time
-    end
-  end
-end
-
 class TestMinitestUnitTestCase < Minitest::Test
   # do not call parallelize_me! - teardown accesses @tc._assertions
   # which is not threadsafe. Nearly every method in here is an
@@ -1017,7 +985,7 @@ class TestMinitestUnitTestCase < Minitest::Test
 
   def teardown
     assert_equal(@assertion_count, @tc.assertions,
-                 "expected #{@assertion_count} assertions to be fired during the test, not #{@tc.assertions}") if @tc.passed?
+                 message { "expected #{@assertion_count} assertions to be fired during the test, not #{@tc.assertions}" }) if @tc.passed?
   end
 
   def non_verbose
@@ -1054,7 +1022,7 @@ class TestMinitestUnitTestCase < Minitest::Test
     @assertion_count = 0
 
     sample_test_case = Class.new FakeNamedTest do
-      def self.test_order; :sorted end
+      def self.run_order; :sorted end
       def test_test3; assert "does not matter" end
       def test_test2; assert "does not matter" end
       def test_test1; assert "does not matter" end
@@ -1064,14 +1032,14 @@ class TestMinitestUnitTestCase < Minitest::Test
     assert_equal expected, sample_test_case.runnable_methods
   end
 
-  def test_i_suck_and_my_tests_are_order_dependent_bang_sets_test_order_alpha
+  def test_i_suck_and_my_tests_are_order_dependent_bang_sets_run_order_alpha
     @assertion_count = 0
 
     shitty_test_case = Class.new FakeNamedTest
 
     shitty_test_case.i_suck_and_my_tests_are_order_dependent!
 
-    assert_equal :alpha, shitty_test_case.test_order
+    assert_equal :alpha, shitty_test_case.run_order
   end
 
   def test_i_suck_and_my_tests_are_order_dependent_bang_does_not_warn
@@ -1079,7 +1047,7 @@ class TestMinitestUnitTestCase < Minitest::Test
 
     shitty_test_case = Class.new FakeNamedTest
 
-    def shitty_test_case.test_order; :lol end
+    def shitty_test_case.run_order; :lol end
 
     assert_silent do
       shitty_test_case.i_suck_and_my_tests_are_order_dependent!
@@ -1124,24 +1092,6 @@ class TestMinitestGuard < Minitest::Test
     assert self.jruby? "java"
   end
 
-  def test_rubinius_eh
-    assert_deprecation do
-      assert self.class.rubinius? "rbx"
-    end
-    assert_deprecation do
-      assert self.rubinius? "rbx"
-    end
-  end
-
-  def test_maglev_eh
-    assert_deprecation do
-      assert self.class.maglev? "maglev"
-    end
-    assert_deprecation do
-      assert self.maglev? "maglev"
-    end
-  end
-
   def test_osx_eh
     assert self.class.osx? "darwin"
     assert self.osx? "darwin"
@@ -1166,35 +1116,6 @@ class TestMinitestUnitRecording < MetaMetaMetaTestCase
     assert_equal expected, recorded
   end
 
-  def test_run_with_bogus_reporter
-    # https://github.com/seattlerb/minitest/issues/659
-    # TODO: remove test for minitest 6
-    @tu = Class.new FakeNamedTest do
-      def test_method
-        assert true
-      end
-    end
-
-    bogus_reporter = Class.new do      # doesn't subclass AbstractReporter
-      def start; @success = false; end
-      # def prerecord klass, name; end # doesn't define full API
-      def record _result; @success = true; end
-      def report; end
-      def passed?; end
-      def results; end
-      def success?; @success; end
-    end.new
-
-    self.reporter = Minitest::CompositeReporter.new
-    reporter << bogus_reporter
-
-    Minitest::Runnable.runnables.delete @tu
-
-    @tu.run reporter, {}
-
-    assert_predicate bogus_reporter, :success?
-  end
-
   def test_record_passing
     assert_run_record do
       def test_method