minitest 4.7.5 → 5.0.0

data/test/minitest/metametameta.rb

@@ -2,27 +2,49 @@ require 'tempfile'
 require 'stringio'
 require 'minitest/autorun'
 
-class MiniTest::Unit::TestCase
+class Minitest::Test
   def clean s
     s.gsub(/^ {6}/, '')
   end
 end
 
-class MetaMetaMetaTestCase < MiniTest::Unit::TestCase
+class MetaMetaMetaTestCase < Minitest::Test
+  attr_accessor :reporter, :output, :tu
+
+  def run_tu_with_fresh_reporter flags = %w[--seed 42]
+    options = Minitest.process_args flags
+
+    @output = StringIO.new("")
+    self.reporter = Minitest::Reporter.new @output, options
+    reporter.start
+
+    @tus ||= [@tu]
+    @tus.each do |tu|
+      Minitest::Runnable.runnables.delete tu
+
+      tu.run reporter, options
+    end
+
+    reporter.report
+  end
+
   def assert_report expected, flags = %w[--seed 42]
     header = clean <<-EOM
       Run options: #{flags.map { |s| s =~ /\|/ ? s.inspect : s }.join " "}
 
-      # Running tests:
+      # Running:
 
     EOM
 
-    with_output do
-      @tu.run flags
-    end
+    run_tu_with_fresh_reporter flags
+
+    output = normalize_output @output.string.dup
+
+    assert_equal header + expected, output
+  end
 
-    output = @output.string.dup
-    output.sub!(/Finished tests in .*/, "Finished tests in 0.00")
+  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 = ')
@@ -36,32 +58,13 @@ class MetaMetaMetaTestCase < MiniTest::Unit::TestCase
       output.gsub!(/^(\s+)[^:]+:\d+:in/, '\1FILE:LINE:in')
     end
 
-    assert_equal header + expected, output
+    output
   end
 
   def setup
     super
     srand 42
-    MiniTest::Unit::TestCase.reset
-    @tu = MiniTest::Unit.new
-
-    MiniTest::Unit.runner = nil # protect the outer runner from the inner tests
-  end
-
-  def teardown
-    super
-  end
-
-  def with_output
-    synchronize do
-      begin
-        @output = StringIO.new("")
-        MiniTest::Unit.output = @output
-
-        yield
-      ensure
-        MiniTest::Unit.output = STDOUT
-      end
-    end
+    Minitest::Test.reset
+    @tu = nil
   end
 end

data/test/minitest/test_minitest_benchmark.rb

@@ -5,28 +5,28 @@ require 'minitest/benchmark'
 # Used to verify data:
 # http://www.wolframalpha.com/examples/RegressionAnalysis.html
 
-class TestMiniTestBenchmark < MiniTest::Unit::TestCase
+class TestMinitestBenchmark < Minitest::Test
   def test_cls_bench_exp
-    assert_equal [2, 4, 8, 16, 32], self.class.bench_exp(2, 32, 2)
+    assert_equal [2, 4, 8, 16, 32], Minitest::Benchmark.bench_exp(2, 32, 2)
   end
 
   def test_cls_bench_linear
-    assert_equal [2, 4, 6, 8, 10], self.class.bench_linear(2, 10, 2)
+    assert_equal [2, 4, 6, 8, 10], Minitest::Benchmark.bench_linear(2, 10, 2)
   end
 
-  def test_cls_benchmark_methods
-    assert_equal [], self.class.benchmark_methods
+  def test_cls_runnable_methods
+    assert_equal [], Minitest::Benchmark.runnable_methods
 
-    c = Class.new(MiniTest::Unit::TestCase) do
+    c = Class.new(Minitest::Benchmark) do
       def bench_blah
       end
     end
 
-    assert_equal ["bench_blah"], c.benchmark_methods
+    assert_equal ["bench_blah"], c.runnable_methods
   end
 
   def test_cls_bench_range
-    assert_equal [1, 10, 100, 1_000, 10_000], self.class.bench_range
+    assert_equal [1, 10, 100, 1_000, 10_000], Minitest::Benchmark.bench_range
   end
 
   def test_fit_exponential_clean
@@ -119,7 +119,9 @@ class TestMiniTestBenchmark < MiniTest::Unit::TestCase
   end
 
   def assert_fit msg, x, y, fit, exp_a, exp_b
-    a, b, rr = send "fit_#{msg}", x, y
+    bench = Minitest::Benchmark.new :blah
+
+    a, b, rr = bench.send "fit_#{msg}", x, y
 
     assert_operator rr, :>=, fit if fit
     assert_in_delta exp_a, a

data/test/minitest/test_minitest_mock.rb

@@ -1,10 +1,10 @@
 require 'minitest/autorun'
 
-class TestMiniTestMock < MiniTest::Unit::TestCase
+class TestMinitestMock < Minitest::Test
   parallelize_me!
 
   def setup
-    @mock = MiniTest::Mock.new.expect(:foo, nil)
+    @mock = Minitest::Mock.new.expect(:foo, nil)
     @mock.expect(:meaning_of_life, 42)
   end
 
@@ -55,8 +55,8 @@ class TestMiniTestMock < MiniTest::Unit::TestCase
   end
 
   def test_return_mock_does_not_raise
-    retval = MiniTest::Mock.new
-    mock = MiniTest::Mock.new
+    retval = Minitest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect(:foo, retval)
     mock.foo
 
@@ -66,8 +66,8 @@ class TestMiniTestMock < MiniTest::Unit::TestCase
   def test_mock_args_does_not_raise
     skip "non-opaque use of ==" if maglev?
 
-    arg = MiniTest::Mock.new
-    mock = MiniTest::Mock.new
+    arg = Minitest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect(:foo, nil, [arg])
     mock.foo(arg)
 
@@ -113,8 +113,8 @@ class TestMiniTestMock < MiniTest::Unit::TestCase
   end
 
   def test_assign_per_mock_return_values
-    a = MiniTest::Mock.new
-    b = MiniTest::Mock.new
+    a = Minitest::Mock.new
+    b = Minitest::Mock.new
 
     a.expect(:foo, :a)
     b.expect(:foo, :b)
@@ -124,10 +124,10 @@ class TestMiniTestMock < MiniTest::Unit::TestCase
   end
 
   def test_do_not_create_stub_method_on_new_mocks
-    a = MiniTest::Mock.new
+    a = Minitest::Mock.new
     a.expect(:foo, :a)
 
-    assert !MiniTest::Mock.new.respond_to?(:foo)
+    assert !Minitest::Mock.new.respond_to?(:foo)
   end
 
   def test_mock_is_a_blank_slate
@@ -139,7 +139,7 @@ class TestMiniTestMock < MiniTest::Unit::TestCase
   end
 
   def test_verify_allows_called_args_to_be_loosely_specified
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect :loose_expectation, true, [Integer]
     mock.loose_expectation 1
 
@@ -147,7 +147,7 @@ class TestMiniTestMock < MiniTest::Unit::TestCase
   end
 
   def test_verify_raises_with_strict_args
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect :strict_expectation, true, [2]
 
     e = assert_raises MockExpectationError do
@@ -159,7 +159,7 @@ class TestMiniTestMock < MiniTest::Unit::TestCase
   end
 
   def test_method_missing_empty
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
 
     mock.expect :a, nil
 
@@ -173,7 +173,7 @@ class TestMiniTestMock < MiniTest::Unit::TestCase
   end
 
   def test_same_method_expects_are_verified_when_all_called
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect :foo, nil, [:bar]
     mock.expect :foo, nil, [:baz]
 
@@ -184,7 +184,7 @@ class TestMiniTestMock < MiniTest::Unit::TestCase
   end
 
   def test_same_method_expects_blow_up_when_not_all_called
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect :foo, nil, [:bar]
     mock.expect :foo, nil, [:baz]
 
@@ -198,7 +198,7 @@ class TestMiniTestMock < MiniTest::Unit::TestCase
   end
 
   def test_verify_passes_when_mock_block_returns_true
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect :foo, nil do
       true
     end
@@ -210,7 +210,7 @@ class TestMiniTestMock < MiniTest::Unit::TestCase
 
   def test_mock_block_is_passed_function_params
     arg1, arg2, arg3 = :bar, [1,2,3], {:a => 'a'}
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect :foo, nil do |a1, a2, a3|
       a1 == arg1 &&
       a2 == arg2 &&
@@ -223,7 +223,7 @@ class TestMiniTestMock < MiniTest::Unit::TestCase
   end
 
   def test_verify_fails_when_mock_block_returns_false
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect :foo, nil do
       false
     end
@@ -235,7 +235,7 @@ class TestMiniTestMock < MiniTest::Unit::TestCase
   end
 
   def test_mock_block_throws_if_args_passed
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
 
     e = assert_raises(ArgumentError) do
       mock.expect :foo, nil, [:a, :b, :c] do
@@ -249,7 +249,7 @@ class TestMiniTestMock < MiniTest::Unit::TestCase
   end
 
   def test_mock_returns_retval_when_called_with_block
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect(:foo, 32) do
       true
     end
@@ -270,38 +270,34 @@ end
 
 require "minitest/metametameta"
 
-class TestMiniTestStub < MiniTest::Unit::TestCase
+class TestMinitestStub < Minitest::Test
   parallelize_me!
 
   def setup
     super
-    MiniTest::Unit::TestCase.reset
+    Minitest::Test.reset
 
-    @tc = MiniTest::Unit::TestCase.new 'fake tc'
+    @tc = Minitest::Test.new 'fake tc'
     @assertion_count = 1
   end
 
   def teardown
     super
-    assert_equal @assertion_count, @tc._assertions
-  end
-
-  class Time
-    def self.now
-      24
-    end
+    assert_equal @assertion_count, @tc.assertions
   end
 
   def assert_stub val_or_callable
     @assertion_count += 1
 
-    t = Time.now.to_i
+    Minitest::Test.synchronize do
+      t = Time.now.to_i
 
-    Time.stub :now, val_or_callable do
-      @tc.assert_equal 42, Time.now
-    end
+      Time.stub :now, val_or_callable do
+        @tc.assert_equal 42, Time.now
+      end
 
-    @tc.assert_operator Time.now.to_i, :>=, t
+      @tc.assert_operator Time.now.to_i, :>=, t
+    end
   end
 
   def test_stub_private_module_method
@@ -319,22 +315,22 @@ class TestMiniTestStub < MiniTest::Unit::TestCase
   def test_stub_private_module_method_indirect
     @assertion_count += 1
 
-    slow_clapper = Class.new do
-      def slow_clap
-        sleep 3
+    fail_clapper = Class.new do
+      def fail_clap
+        fail
         :clap
       end
     end.new
 
-    slow_clapper.stub :sleep, nil do |fast_clapper|
-      @tc.assert_equal :clap, fast_clapper.slow_clap # either form works
-      @tc.assert_equal :clap, slow_clapper.slow_clap # yay closures
+    fail_clapper.stub :fail, nil do |safe_clapper|
+      @tc.assert_equal :clap, safe_clapper.fail_clap # either form works
+      @tc.assert_equal :clap, fail_clapper.fail_clap # yay closures
     end
   end
 
   def test_stub_public_module_method
-    Math.stub(:log10, 42.0) do
-      @tc.assert_in_delta 42.0, Math.log10(1000)
+    Math.stub :log10, :stubbed do
+      @tc.assert_equal :stubbed, Math.log10(1000)
     end
   end
 
@@ -349,13 +345,15 @@ class TestMiniTestStub < MiniTest::Unit::TestCase
   def test_stub_block_args
     @assertion_count += 1
 
-    t = Time.now.to_i
+    Minitest::Test.synchronize do
+      t = Time.now.to_i
 
-    Time.stub :now,  lambda { |n| n * 2 } do
-      @tc.assert_equal 42, Time.now(21)
-    end
+      Time.stub :now,  lambda { |n| n * 2 } do
+        @tc.assert_equal 42, Time.now(21)
+      end
 
-    @tc.assert_operator Time.now.to_i, :>=, t
+      @tc.assert_operator Time.now.to_i, :>=, t
+    end
   end
 
   def test_stub_callable

data/test/minitest/test_minitest_reporter.rb

@@ -0,0 +1,245 @@
+require "minitest/autorun"
+require "minitest/metametameta"
+
+class TestMinitestReporter < Minitest::Test
+
+  attr_accessor :r, :io
+
+  def setup
+    self.io = StringIO.new("")
+    self.r  = Minitest::Reporter.new io
+  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 << Minitest::Skip.new
+    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
+
+  def test_passed_eh_error
+    r.results << error_test
+
+    refute r.passed?
+  end
+
+  def test_passed_eh_skipped
+    r.results << skip_test
+
+    assert r.passed?
+  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 test_report_skipped
+    r.start
+    r.record skip_test
+    r.report
+
+    exp = clean <<-EOM
+      Run options:
+
+      # Running:
+
+      S
+
+      Finished in 0.00
+
+      1 runs, 0 assertions, 0 failures, 0 errors, 1 skips
+    EOM
+
+    assert_equal exp, normalize_output(io.string)
+  end
+end