minitest 5.26.2 → 6.0.0

data/test/minitest/test_minitest_spec.rb

@@ -1,4 +1,4 @@
-require "minitest/metametameta"
+require_relative "metametameta"
 require "stringio"
 
 class MiniSpecA < Minitest::Spec; end
@@ -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?)
 
@@ -1136,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

data/test/minitest/test_path_expander.rb

@@ -0,0 +1,229 @@
+require "minitest/autorun"
+require "minitest/path_expander"
+
+class TestPathExpander < Minitest::Test
+  attr_accessor :args
+  attr_accessor :expander
+
+  MT_VPE = Minitest::VendoredPathExpander
+
+  def setup
+    super
+
+    self.args = []
+
+    self.expander = MT_VPE.new args, "*.rb"
+
+    @pe_tmp_path = "test/pe_tmp"
+    @pe_tst_path = "test/pe_tmp/test"
+
+    @orig_pwd = Dir.pwd
+    FileUtils.mkdir_p @pe_tst_path
+    FileUtils.touch ["#{@pe_tst_path}/test_path_expander.rb", "#{@pe_tst_path}/test_bad.rb"]
+    Dir.chdir @pe_tmp_path
+  end
+
+  def teardown
+    super
+
+    Dir.chdir @orig_pwd
+
+    FileUtils.rm_rf @pe_tmp_path
+  end
+
+  def assert_filter_files exp, filter, files = %w[test/dog_and_cat.rb]
+    ignore = StringIO.new filter
+    act = expander.filter_files files, ignore
+    assert_equal exp, act
+  end
+
+  def assert_filter_files_absolute_paths exp, filter, files = [File.join(Dir.pwd, 'test/dog_and_cat.rb')]
+    assert_filter_files exp, filter, files
+  end
+
+  def assert_process_args exp_files, exp_args, *args
+    expander.args.concat args
+
+    assert_equal [exp_files.sort, exp_args], expander.process_args
+  end
+
+  def test_expand_dirs_to_files
+    exp = %w[test/test_bad.rb test/test_path_expander.rb]
+
+    assert_equal exp, expander.expand_dirs_to_files("test")
+    assert_equal %w[Rakefile], expander.expand_dirs_to_files("Rakefile")
+  end
+
+  def test_expand_dirs_to_files__sorting
+    exp = %w[test/test_bad.rb test/test_path_expander.rb]
+    input = %w[test/test_path_expander.rb test/test_bad.rb]
+
+    assert_equal exp, expander.expand_dirs_to_files(*input)
+    assert_equal %w[Rakefile], expander.expand_dirs_to_files("Rakefile")
+  end
+
+  def test_expand_dirs_to_files__leading_dot
+    exp = %w[test/test_bad.rb test/test_path_expander.rb]
+
+    assert_equal exp, expander.expand_dirs_to_files("./test")
+  end
+
+  def test_filter_files_dir
+    assert_filter_files [], "test/"
+    assert_filter_files_absolute_paths [], "test/"
+  end
+
+  def test_filter_files_files
+    example = %w[test/file.rb test/sub/file.rb top/test/perf.rb]
+    example_absolute_paths = example.map { |e| File.join(Dir.pwd, e) }
+
+    assert_filter_files [], "test/*.rb"
+
+    assert_filter_files example[1..-1], "test/*.rb", example
+
+    assert_filter_files_absolute_paths [], "test/*.rb"
+
+    assert_filter_files_absolute_paths example_absolute_paths[1..-1], "test/*.rb", example_absolute_paths
+  end
+
+  def test_filter_files_glob
+    assert_filter_files [], "test*"
+    assert_filter_files [], "test*", ["test/lib/woot.rb"]
+    assert_filter_files [], "*.rb"
+    assert_filter_files [], "*dog*.rb"
+
+    assert_filter_files_absolute_paths [], "test*"
+    assert_filter_files_absolute_paths [], "test*", [File.join(Dir.pwd, "test/lib/woot.rb")]
+    assert_filter_files_absolute_paths [], "*.rb"
+    assert_filter_files_absolute_paths [], "*dog*.rb"
+  end
+
+  def test_filter_files_glob_miss
+    miss = %w[test/dog_and_cat.rb]
+    miss_absolute = [File.join(Dir.pwd, 'test/dog_and_cat.rb')]
+
+    assert_filter_files miss, "test"
+    assert_filter_files miss, "nope"
+
+    assert_filter_files_absolute_paths miss_absolute, "test"
+    assert_filter_files_absolute_paths miss_absolute, "nope"
+  end
+
+  def test_filter_files__ignore_file
+    files = expander.expand_dirs_to_files "test"
+
+    File.write ".mtignore", "test/*.rb"
+
+    act = expander.filter_files files, ".mtignore"
+
+    assert_equal [], act
+  end
+
+  def test_process
+    self.args.concat %w[test --seed 42]
+
+    act = expander.process
+
+    assert_kind_of Enumerator, act
+    assert_equal %w[test/test_bad.rb test/test_path_expander.rb], act.to_a
+    assert_equal %w[--seed 42], expander.args
+    assert_equal %w[--seed 42], args # affected our original array (eg, ARGV)
+  end
+
+  def test_process__block
+    self.args.concat %w[test --seed 42]
+
+    act = []
+    result = expander.process { |x| act << x }
+
+    assert_same expander, result
+    assert_equal %w[test/test_bad.rb test/test_path_expander.rb], act.to_a
+    assert_equal %w[--seed 42], expander.args
+    assert_equal %w[--seed 42], args # affected our original array (eg, ARGV)
+  end
+
+  def with_tempfile *lines
+    require "tempfile"
+
+    Tempfile.open("tmp") do |f|
+      f.puts lines
+      f.flush
+      f.rewind
+
+      yield f
+    end
+  end
+
+  def test_process_args_at
+    with_tempfile %w[test -test/test_bad.rb --seed 24] do |f|
+      assert_process_args(%w[test/test_path_expander.rb],
+                          %w[--seed 24],
+                          "@#{f.path}")
+    end
+  end
+
+  def test_process_args_dash_dir
+    assert_process_args(%w[],
+                        %w[],
+                        "test", "-test")
+  end
+
+  def test_process_args_dash_file
+    assert_process_args(%w[test/test_path_expander.rb],
+                        %w[],
+                        "test", "-test/test_bad.rb")
+
+  end
+
+  def test_process_args_dash_other
+    assert_process_args(%w[],
+                        %w[--verbose],
+                        "--verbose")
+  end
+
+  def test_process_args_dir
+    assert_process_args(%w[test/test_bad.rb test/test_path_expander.rb],
+                        %w[],
+                        "test")
+  end
+
+  def test_process_args_file
+    assert_process_args(%w[test/test_path_expander.rb],
+                        %w[],
+                        "test/test_path_expander.rb")
+  end
+
+  def test_process_args_other
+    assert_process_args(%w[],
+                        %w[42],
+                        "42")
+  end
+
+  def test_process_args_root
+    assert_process_args(%w[],
+                        %w[-n /./],
+                        "-n",
+                        "/./")
+  end
+
+  def test_process_args_no_files
+    self.expander = MT_VPE.new args, "*.rb", "test" # extra test default
+
+    assert_process_args(%w[test/test_bad.rb test/test_path_expander.rb],
+                        %w[-v],
+                        "-v")
+  end
+
+  def test_process_args_dash
+    assert_process_args(%w[-],
+                        %w[-v],
+                        "-", "-v")
+  end
+
+  def test_process_flags
+    exp = %w[a b c]
+    act = expander.process_flags %w[a b c]
+
+    assert_equal exp, act
+  end
+end