minitest 4.7.5 → 5.0.7

data/test/minitest/test_minitest_reporter.rb

@@ -0,0 +1,313 @@
+require "minitest/autorun"
+require "minitest/metametameta"
+
+class TestMinitestReporter < Minitest::Test
+
+  attr_accessor :r, :io
+
+  def new_composite_reporter
+    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
+
+    reporter
+  end
+
+  def setup
+    self.io = StringIO.new("")
+    self.r  = new_composite_reporter
+  end
+
+  def error_test
+    unless defined? @et then
+      @et = Minitest::Test.new(:woot)
+      @et.failures << Minitest::UnexpectedError.new(begin
+                                                      raise "no"
+                                                    rescue => e
+                                                      e
+                                                    end)
+    end
+    @et
+  end
+
+  def fail_test
+    unless defined? @ft then
+      @ft = Minitest::Test.new(:woot)
+      @ft.failures <<   begin
+                          raise Minitest::Assertion, "boo"
+                        rescue Minitest::Assertion => e
+                          e
+                        end
+    end
+    @ft
+  end
+
+  def passing_test
+    @pt ||= Minitest::Test.new(:woot)
+  end
+
+  def skip_test
+    unless defined? @st then
+      @st = Minitest::Test.new(:woot)
+      @st.failures << begin
+                        raise Minitest::Skip
+                      rescue Minitest::Assertion => e
+                        e
+                      end
+    end
+    @st
+  end
+
+  def test_passed_eh_empty
+    assert r.passed?
+  end
+
+  def test_passed_eh_failure
+    r.results << fail_test
+
+    refute r.passed?
+  end
+
+  SKIP_MSG = "\n\nYou have skipped tests. Run with --verbose for details."
+
+  def test_passed_eh_error
+    r.start
+
+    r.results << error_test
+
+    refute r.passed?
+
+    r.report
+
+    refute_match SKIP_MSG, io.string
+  end
+
+  def test_passed_eh_skipped
+    r.start
+    r.results << skip_test
+    assert r.passed?
+
+    restore_env do
+      r.report
+    end
+
+    assert_match SKIP_MSG, io.string
+  end
+
+  def test_passed_eh_skipped_verbose
+    r.first.options[:verbose] = true
+
+    r.start
+    r.results << skip_test
+    assert r.passed?
+    r.report
+
+    refute_match SKIP_MSG, io.string
+  end
+
+  def test_start
+    r.start
+
+    exp = "Run options: \n\n# Running:\n\n"
+
+    assert_equal exp, io.string
+  end
+
+  def test_record_pass
+    r.record passing_test
+
+    assert_equal ".", io.string
+    assert_empty r.results
+    assert_equal 1, r.count
+    assert_equal 0, r.assertions
+  end
+
+  def test_record_fail
+    r.record fail_test
+
+    assert_equal "F", io.string
+    assert_equal [fail_test], r.results
+    assert_equal 1, r.count
+    assert_equal 0, r.assertions
+  end
+
+  def test_record_error
+    r.record error_test
+
+    assert_equal "E", io.string
+    assert_equal [error_test], r.results
+    assert_equal 1, r.count
+    assert_equal 0, r.assertions
+  end
+
+  def test_record_skip
+    r.record skip_test
+
+    assert_equal "S", io.string
+    assert_equal [skip_test], r.results
+    assert_equal 1, r.count
+    assert_equal 0, r.assertions
+  end
+
+  def normalize_output output
+    output.sub!(/Finished in .*/, "Finished in 0.00")
+    output.sub!(/Loaded suite .*/, 'Loaded suite blah')
+
+    output.gsub!(/ = \d+.\d\d s = /, ' = 0.00 s = ')
+    output.gsub!(/0x[A-Fa-f0-9]+/, '0xXXX')
+    output.gsub!(/ +$/, '')
+
+    if windows? then
+      output.gsub!(/\[(?:[A-Za-z]:)?[^\]:]+:\d+\]/, '[FILE:LINE]')
+      output.gsub!(/^(\s+)(?:[A-Za-z]:)?[^:]+:\d+:in/, '\1FILE:LINE:in')
+    else
+      output.gsub!(/\[[^\]:]+:\d+\]/, '[FILE:LINE]')
+      output.gsub!(/^(\s+)[^:]+:\d+:in/, '\1FILE:LINE:in')
+    end
+
+    output
+  end
+
+  def test_report_empty
+    r.start
+    r.report
+
+    exp = clean <<-EOM
+      Run options:
+
+      # Running:
+
+
+
+      Finished in 0.00
+
+      0 runs, 0 assertions, 0 failures, 0 errors, 0 skips
+    EOM
+
+
+    assert_equal exp, normalize_output(io.string)
+  end
+
+  def test_report_passing
+    r.start
+    r.record passing_test
+    r.report
+
+    exp = clean <<-EOM
+      Run options:
+
+      # Running:
+
+      .
+
+      Finished in 0.00
+
+      1 runs, 0 assertions, 0 failures, 0 errors, 0 skips
+    EOM
+
+
+    assert_equal exp, normalize_output(io.string)
+  end
+
+  def test_report_failure
+    r.start
+    r.record fail_test
+    r.report
+
+    exp = clean <<-EOM
+      Run options:
+
+      # Running:
+
+      F
+
+      Finished in 0.00
+
+        1) Failure:
+      Minitest::Test#woot [FILE:LINE]:
+      boo
+
+      1 runs, 0 assertions, 1 failures, 0 errors, 0 skips
+    EOM
+
+
+    assert_equal exp, normalize_output(io.string)
+  end
+
+  def test_report_error
+    r.start
+    r.record error_test
+    r.report
+
+    exp = clean <<-EOM
+      Run options:
+
+      # Running:
+
+      E
+
+      Finished in 0.00
+
+        1) Error:
+      Minitest::Test#woot:
+      RuntimeError: no
+          FILE:LINE:in `error_test'
+          FILE:LINE:in `test_report_error'
+
+      1 runs, 0 assertions, 0 failures, 1 errors, 0 skips
+    EOM
+
+    assert_equal exp, normalize_output(io.string)
+  end
+
+  def restore_env
+    old_value = ENV["MT_NO_SKIP_MSG"]
+    ENV.delete "MT_NO_SKIP_MSG"
+    
+    yield
+  ensure
+    ENV["MT_NO_SKIP_MSG"] = old_value
+  end
+
+
+  def test_report_skipped
+    r.start
+    r.record skip_test
+
+    restore_env do
+      r.report
+    end
+
+    exp = clean <<-EOM
+      Run options:
+
+      # Running:
+
+      S
+
+      Finished in 0.00
+
+      1 runs, 0 assertions, 0 failures, 0 errors, 1 skips
+
+      You have skipped tests. Run with --verbose for details.
+    EOM
+
+    assert_equal exp, normalize_output(io.string)
+  end
+end

data/test/minitest/test_minitest_spec.rb

@@ -2,8 +2,8 @@
 require "minitest/autorun"
 require "stringio"
 
-class MiniSpecA < MiniTest::Spec; end
-class MiniSpecB < MiniTest::Unit::TestCase; extend MiniTest::Spec::DSL; end
+class MiniSpecA < Minitest::Spec; end
+class MiniSpecB < Minitest::Test; extend Minitest::Spec::DSL; end
 class MiniSpecC < MiniSpecB; end
 class NamedExampleA < MiniSpecA; end
 class NamedExampleB < MiniSpecB; end
@@ -11,10 +11,10 @@ class NamedExampleC < MiniSpecC; end
 class ExampleA; end
 class ExampleB < ExampleA; end
 
-describe MiniTest::Spec do
+describe Minitest::Spec do
   # do not parallelize this suite... it just can"t handle it.
 
-  def assert_triggered expected = "blah", klass = MiniTest::Assertion
+  def assert_triggered expected = "blah", klass = Minitest::Assertion
     @assertion_count += 2
 
     e = assert_raises(klass) do
@@ -32,10 +32,10 @@ describe MiniTest::Spec do
   end
 
   after do
-    self._assertions.must_equal @assertion_count if passed? and not skipped?
+    self.assertions.must_equal @assertion_count if passed? and not skipped?
   end
 
-  it "needs to be able to catch a MiniTest::Assertion exception" do
+  it "needs to be able to catch a Minitest::Assertion exception" do
     @assertion_count = 1
 
     assert_triggered "Expected 1 to not be equal to 1." do
@@ -75,7 +75,7 @@ describe MiniTest::Spec do
     @assertion_count = 2
 
     proc { raise "blah" }.must_raise RuntimeError
-    proc { raise MiniTest::Assertion }.must_raise MiniTest::Assertion
+    proc { raise Minitest::Assertion }.must_raise Minitest::Assertion
   end
 
   it "needs to catch an unexpected exception" do
@@ -83,17 +83,17 @@ describe MiniTest::Spec do
 
     msg = <<-EOM.gsub(/^ {6}/, "").chomp
       [RuntimeError] exception expected, not
-      Class: <MiniTest::Assertion>
-      Message: <"MiniTest::Assertion">
+      Class: <Minitest::Assertion>
+      Message: <"Minitest::Assertion">
       ---Backtrace---
     EOM
 
     assert_triggered msg do
-      proc { raise MiniTest::Assertion }.must_raise RuntimeError
+      proc { raise Minitest::Assertion }.must_raise RuntimeError
     end
 
     assert_triggered "msg.\n#{msg}" do
-      proc { raise MiniTest::Assertion }.must_raise RuntimeError, "msg"
+      proc { raise Minitest::Assertion }.must_raise RuntimeError, "msg"
     end
   end
 
@@ -132,7 +132,6 @@ describe MiniTest::Spec do
                         must_output
                         must_raise
                         must_respond_to
-                        must_send
                         must_throw)
 
     bad = %w[not raise throw send output be_silent]
@@ -523,7 +522,7 @@ describe MiniTest::Spec do
 
 end
 
-describe MiniTest::Spec, :let do
+describe Minitest::Spec, :let do
   i_suck_and_my_tests_are_order_dependent!
 
   def _count
@@ -552,9 +551,15 @@ describe MiniTest::Spec, :let do
 
     _count.must_equal 2
   end
+
+  it 'raises an error if the name begins with "test"' do
+    describe "let" do
+      proc { let(:test_value) { true } }.must_raise ArgumentError
+    end
+  end
 end
 
-describe MiniTest::Spec, :subject do
+describe Minitest::Spec, :subject do
   attr_reader :subject_evaluation_count
 
   subject do
@@ -570,9 +575,9 @@ describe MiniTest::Spec, :subject do
   end
 end
 
-class TestMetaStatic < MiniTest::Unit::TestCase
+class TestMetaStatic < Minitest::Test
   def test_children
-    MiniTest::Spec.children.clear # prevents parallel run
+    Minitest::Spec.children.clear # prevents parallel run
 
     x = y = z = nil
     x = describe "top-level thingy" do
@@ -583,14 +588,16 @@ class TestMetaStatic < MiniTest::Unit::TestCase
       z = describe "second thingy" do end
     end
 
-    assert_equal [x], MiniTest::Spec.children
+    assert_equal [x], Minitest::Spec.children
     assert_equal [y, z], x.children
     assert_equal [], y.children
     assert_equal [], z.children
   end
 end
 
-class TestMeta < MiniTest::Unit::TestCase
+require "minitest/metametameta"
+
+class TestMeta < MetaMetaMetaTestCase
   parallelize_me!
 
   def util_structure
@@ -623,35 +630,35 @@ class TestMeta < MiniTest::Unit::TestCase
   end
 
   def test_register_spec_type
-    original_types = MiniTest::Spec::TYPES.dup
+    original_types = Minitest::Spec::TYPES.dup
 
-    assert_equal [[//, MiniTest::Spec]], MiniTest::Spec::TYPES
+    assert_includes Minitest::Spec::TYPES, [//, Minitest::Spec]
 
-    MiniTest::Spec.register_spec_type(/woot/, TestMeta)
+    Minitest::Spec.register_spec_type(/woot/, TestMeta)
 
     p = lambda do |x| true end
-    MiniTest::Spec.register_spec_type TestMeta, &p
+    Minitest::Spec.register_spec_type TestMeta, &p
 
-    keys = MiniTest::Spec::TYPES.map(&:first)
+    keys = Minitest::Spec::TYPES.map(&:first)
 
     assert_includes keys, /woot/
     assert_includes keys, p
   ensure
-    MiniTest::Spec::TYPES.replace original_types
+    Minitest::Spec::TYPES.replace original_types
   end
 
   def test_spec_type
-    original_types = MiniTest::Spec::TYPES.dup
+    original_types = Minitest::Spec::TYPES.dup
 
-    MiniTest::Spec.register_spec_type(/A$/, MiniSpecA)
-    MiniTest::Spec.register_spec_type MiniSpecB do |desc|
+    Minitest::Spec.register_spec_type(/A$/, MiniSpecA)
+    Minitest::Spec.register_spec_type MiniSpecB do |desc|
       desc.superclass == ExampleA
     end
 
-    assert_equal MiniSpecA, MiniTest::Spec.spec_type(ExampleA)
-    assert_equal MiniSpecB, MiniTest::Spec.spec_type(ExampleB)
+    assert_equal MiniSpecA, Minitest::Spec.spec_type(ExampleA)
+    assert_equal MiniSpecB, Minitest::Spec.spec_type(ExampleB)
   ensure
-    MiniTest::Spec::TYPES.replace original_types
+    Minitest::Spec::TYPES.replace original_types
   end
 
   def test_name
@@ -698,16 +705,13 @@ class TestMeta < MiniTest::Unit::TestCase
   def test_setup_teardown_behavior
     _, _, z, before_list, after_list = util_structure
 
-    @tu = MiniTest::Unit.new
-    MiniTest::Unit.runner = nil # protect the outer runner from the inner tests
+    @tu = z
 
-    with_output do
-      tc = z.new :test_0002_anonymous
-      tc.run @tu
-    end
+    run_tu_with_fresh_reporter
 
-    assert_equal [1, 2, 3], before_list
-    assert_equal [3, 2, 1], after_list
+    size = z.runnable_methods.size
+    assert_equal [1, 2, 3] * size, before_list
+    assert_equal [3, 2, 1] * size, after_list
   end
 
   def test_describe_first_structure
@@ -732,7 +736,7 @@ class TestMeta < MiniTest::Unit::TestCase
 
   def test_structure_subclasses
     z = nil
-    x = Class.new MiniTest::Spec do
+    x = Class.new Minitest::Spec do
       def xyz; end
     end
     y = Class.new x do
@@ -743,32 +747,19 @@ class TestMeta < MiniTest::Unit::TestCase
     assert_respond_to y.new(nil), "xyz"
     assert_respond_to z.new(nil), "xyz"
   end
-
-  def with_output # REFACTOR: dupe from metametameta
-    synchronize do
-      begin
-        @output = StringIO.new("")
-        MiniTest::Unit.output = @output
-
-        yield
-      ensure
-        MiniTest::Unit.output = STDOUT
-      end
-    end
-  end
 end
 
-require "minitest/metametameta"
-
 class TestSpecInTestCase < MetaMetaMetaTestCase
   def setup
     super
 
-    @tc = MiniTest::Unit::TestCase.new "fake tc"
+    @tc = self
     @assertion_count = 1
   end
 
-  def util_assert_triggered expected, klass = MiniTest::Assertion # REFACTOR
+  def assert_triggered expected, klass = Minitest::Assertion
+    @assertion_count += 1
+
     e = assert_raises klass do
       yield
     end
@@ -779,25 +770,23 @@ class TestSpecInTestCase < MetaMetaMetaTestCase
     assert_equal expected, msg
   end
 
-  def teardown # REFACTOR
-    assert_equal(@assertion_count, @tc._assertions,
-                 "expected #{@assertion_count} assertions to be fired during the test, not #{@tc._assertions}") if @tc.passed?
+  def teardown
+    msg = "expected #{@assertion_count} assertions, not #{@tc.assertions}"
+    assert_equal @assertion_count, @tc.assertions, msg
   end
 
   def test_expectation
-    @assertion_count = 2
-
     @tc.assert_equal true, 1.must_equal(1)
   end
 
   def test_expectation_triggered
-    util_assert_triggered "Expected: 2\n  Actual: 1" do
+    assert_triggered "Expected: 2\n  Actual: 1" do
       1.must_equal 2
     end
   end
 
   def test_expectation_with_a_message
-    util_assert_triggered "Expected: 2\n  Actual: 1" do
+    assert_triggered "Expected: 2\n  Actual: 1" do
       1.must_equal 2, ""
     end
   end