minitest 4.7.5 → 5.0.7

data/test/minitest/metametameta.rb

@@ -2,27 +2,57 @@ 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::CompositeReporter.new
+    reporter << Minitest::SummaryReporter.new(@output, options)
+    reporter << Minitest::ProgressReporter.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 first_reporter
+    reporter.reporters.first
+  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 = @output.string.dup
-    output.sub!(/Finished tests in .*/, "Finished tests in 0.00")
+    output = normalize_output @output.string.dup
+
+    assert_equal header + expected, output
+  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 = ')
@@ -36,32 +66,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,14 +66,57 @@ 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)
 
     assert mock.verify
   end
 
+  def test_set_expectation_on_special_methods
+    mock = Minitest::Mock.new
+
+    mock.expect :object_id, "received object_id"
+    assert_equal "received object_id", mock.object_id
+
+    mock.expect :respond_to_missing?, "received respond_to_missing?"
+    assert_equal "received respond_to_missing?", mock.respond_to_missing?
+
+    mock.expect :===, "received ==="
+    assert_equal "received ===", mock.===
+
+    mock.expect :inspect, "received inspect"
+    assert_equal "received inspect", mock.inspect
+
+    mock.expect :to_s, "received to_s"
+    assert_equal "received to_s", mock.to_s
+
+    mock.expect :public_send, "received public_send"
+    assert_equal "received public_send", mock.public_send
+
+    mock.expect :send, "received send"
+    assert_equal "received send", mock.send
+
+    assert mock.verify
+  end
+
+  def test_expectations_can_be_satisfied_via_send
+    @mock.send :foo
+    @mock.send :meaning_of_life
+
+    assert @mock.verify
+  end
+
+  def test_expectations_can_be_satisfied_via_public_send
+    skip "Doesn't run on 1.8" if RUBY_VERSION < "1.9"
+
+    @mock.public_send :foo
+    @mock.public_send :meaning_of_life
+
+    assert @mock.verify
+  end
+
   def test_blow_up_on_wrong_arguments
     @mock.foo
     @mock.meaning_of_life
@@ -113,8 +156,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 +167,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 +182,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 +190,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 +202,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 +216,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 +227,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 +241,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 +253,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 +266,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 +278,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 +292,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
@@ -266,24 +309,49 @@ class TestMiniTestMock < MiniTest::Unit::TestCase
 
     assert_equal exp, e.message
   end
+
+  def test_mock_called_via_send
+    mock = Minitest::Mock.new
+    mock.expect(:foo, true)
+
+    mock.send :foo
+    mock.verify
+  end
+
+  def test_mock_called_via___send__
+    mock = Minitest::Mock.new
+    mock.expect(:foo, true)
+
+    mock.__send__ :foo
+    mock.verify
+  end
+
+  def test_mock_called_via_send_with_args
+    mock = Minitest::Mock.new
+    mock.expect(:foo, true, [1,2,3])
+
+    mock.send(:foo, 1, 2, 3)
+    mock.verify
+  end
+
 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
+    assert_equal @assertion_count, @tc.assertions
   end
 
   class Time
@@ -319,22 +387,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
 
@@ -402,4 +470,20 @@ class TestMiniTestStub < MiniTest::Unit::TestCase
     @tc.assert_equal true, val
     @tc.assert_equal false, dynamic.found
   end
+
+  def test_mock_with_yield
+    mock = Minitest::Mock.new
+    mock.expect(:write, true) do
+      true
+    end
+    rs = nil
+
+    File.stub(:open, true, mock) do
+      File.open("foo.txt", "r") do |f|
+        rs = f.write
+      end
+    end
+    @tc.assert_equal true, rs
+  end
+
 end