test-unit 2.2.0 → 2.3.0

data/lib/test/unit/version.rb

@@ -2,6 +2,6 @@
 # HACK: quick and dirty to get integrated into the new project - ryan
 module Test
   module Unit
-    VERSION = '2.2.0'
+    VERSION = '2.3.0'
   end
 end

data/test/fixtures/plus.csv

@@ -0,0 +1,3 @@
+label,expected,augend,addend
+positive positive,4,3,1
+positive negative,-1,1,-2

data/test/test-data.rb

@@ -0,0 +1,179 @@
+class TestData < Test::Unit::TestCase
+  class Calc
+    def initialize
+    end
+
+    def plus(augend, addend)
+      augend + addend
+    end
+  end
+
+  class TestCalc < Test::Unit::TestCase
+    @@testing = false
+
+    class << self
+      def testing=(testing)
+        @@testing = testing
+      end
+    end
+
+    def valid?
+      @@testing
+    end
+
+    def setup
+      @calc = Calc.new
+    end
+
+    class TestDataSet < TestCalc
+      data("positive positive" => {:expected => 4, :augend => 3, :addend => 1},
+           "positive negative" => {:expected => -1, :augend => 1, :addend => -2})
+      def test_plus(data)
+        assert_equal(data[:expected],
+                     @calc.plus(data[:augend], data[:addend]))
+      end
+    end
+
+    class TestNData < TestCalc
+      data("positive positive", {:expected => 4, :augend => 3, :addend => 1})
+      data("positive negative", {:expected => -1, :augend => 1, :addend => -2})
+      def test_plus(data)
+        assert_equal(data[:expected],
+                     @calc.plus(data[:augend], data[:addend]))
+      end
+    end
+
+    class TestDynamicDataSet < TestCalc
+      data do
+        data_set = {}
+        data_set["positive positive"] = {
+          :expected => 3,
+          :augend => 1,
+          :addend => 2
+        }
+        data_set["positive negative"] = {
+          :expected => -1,
+          :augend => 1,
+          :addend => -2
+        }
+        data_set
+      end
+      DATA_PROC = current_attribute(:data)[:value].first
+      def test_plus(data)
+        assert_equal(data[:expected],
+                     @calc.plus(data[:augend], data[:addend]))
+      end
+    end
+
+    class TestLoadDataSet < TestCalc
+      base_dir = File.dirname(__FILE__)
+      load_data("#{base_dir}/fixtures/plus.csv")
+      def test_plus(data)
+        assert_equal(data["expected"],
+                     @calc.plus(data["augend"], data["addend"]))
+      end
+    end
+  end
+
+  def setup
+    TestCalc.testing = true
+  end
+
+  def teardown
+    TestCalc.testing = false
+  end
+
+  data("data set",
+       {
+         :test_case => TestCalc::TestDataSet,
+         :data_set => [{
+                         "positive positive" => {
+                           :expected => 4,
+                           :augend => 3,
+                           :addend => 1,
+                         },
+                         "positive negative" => {
+                           :expected => -1,
+                           :augend => 1,
+                           :addend => -2,
+                         },
+                       }],
+       })
+  data("n-data",
+       {
+         :test_case => TestCalc::TestNData,
+         :data_set => [{
+                         "positive positive" => {
+                           :expected => 4,
+                           :augend => 3,
+                           :addend => 1,
+                         },
+                       },
+                       {
+                         "positive negative" => {
+                           :expected => -1,
+                           :augend => 1,
+                           :addend => -2,
+                         },
+                       }],
+       })
+  data("dynamic-data-set",
+       {
+         :test_case => TestCalc::TestDynamicDataSet,
+         :data_set => [TestCalc::TestDynamicDataSet::DATA_PROC],
+       })
+    data("load-data-set",
+       {
+         :test_case => TestCalc::TestLoadDataSet,
+         :data_set => [{
+                         "positive positive" => {
+                           "expected" => 4,
+                           "augend" => 3,
+                           "addend" => 1,
+                         },
+                       },
+                       {
+                         "positive negative" => {
+                           "expected" => -1,
+                           "augend" => 1,
+                           "addend" => -2,
+                         },
+                       }],
+         })
+  def test_data(data)
+    test_plus = data[:test_case].new("test_plus")
+    assert_equal(data[:data_set], test_plus[:data])
+    assert_not_nil(data[:data_set])
+  end
+
+  data("data set" => TestCalc::TestDataSet,
+       "n-data" => TestCalc::TestNData,
+       "dynamic-data-set" => TestCalc::TestDynamicDataSet,
+       "load-data-set" => TestCalc::TestLoadDataSet)
+
+  def test_suite(test_case)
+    suite = test_case.suite
+    assert_equal(["test_plus[positive positive](#{test_case.name})",
+                  "test_plus[positive negative](#{test_case.name})"],
+                 suite.tests.collect {|test| test.name})
+  end
+
+  data("data set" => TestCalc::TestDataSet,
+       "n-data" => TestCalc::TestNData,
+       "dynamic-data-set" => TestCalc::TestDynamicDataSet,
+       "load-data-set" => TestCalc::TestLoadDataSet)
+
+  def test_run(test_case)
+    result = _run_test(test_case)
+    assert_equal("2 tests, 2 assertions, 0 failures, 0 errors, 0 pendings, " \
+                 "0 omissions, 0 notifications", result.to_s)
+  end
+
+  def _run_test(test_case)
+    result = Test::Unit::TestResult.new
+    test = test_case.suite
+    yield(test) if block_given?
+    test.run(result) {}
+    result
+  end
+end

data/test/test-fixture.rb

@@ -66,6 +66,104 @@ class TestUnitFixture < Test::Unit::TestCase
     assert_called_fixtures(expected_setup_calls, test_case)
   end
 
+  def test_cleanup_without_option
+    expected_cleanup_calls = [:custom_cleanup_method3,
+                              :custom_cleanup_method1,
+                              :custom_cleanup_method0,
+                              :cleanup]
+    test_case = assert_cleanup(expected_cleanup_calls, [])
+    assert_inherited_cleanup(expected_cleanup_calls, test_case)
+
+    assert_inherited_cleanup([:cleanup], nil)
+    assert_called_fixtures(expected_cleanup_calls, test_case)
+  end
+
+  def test_cleanup_with_before_option
+    expected_cleanup_calls = [:custom_cleanup_method3,
+                              :custom_cleanup_method0,
+                              :custom_cleanup_method1,
+                              :cleanup]
+    test_case = assert_cleanup(expected_cleanup_calls,
+                                [[{:before => :append}],
+                                 [{:before => :append}],
+                                 [{:before => :prepend}],
+                                 [{:before => :prepend}]])
+    assert_inherited_cleanup(expected_cleanup_calls, test_case)
+
+    assert_inherited_cleanup([:cleanup], nil)
+    assert_called_fixtures(expected_cleanup_calls, test_case)
+  end
+
+  def test_cleanup_with_after_option
+    expected_cleanup_calls = [:cleanup,
+                              :custom_cleanup_method3,
+                              :custom_cleanup_method0,
+                              :custom_cleanup_method1]
+    test_case = assert_cleanup(expected_cleanup_calls,
+                                [[{:after => :append}],
+                                 [{:after => :append}],
+                                 [{:after => :prepend}],
+                                 [{:after => :prepend}]])
+    assert_inherited_cleanup(expected_cleanup_calls, test_case)
+
+    assert_inherited_cleanup([:cleanup], nil)
+    assert_called_fixtures(expected_cleanup_calls, test_case)
+  end
+
+  def test_cleanup_with_invalid_option
+    assert_invalid_cleanup_option(:unknown => true)
+    assert_invalid_cleanup_option(:before => :unknown)
+    assert_invalid_cleanup_option(:after => :unknown)
+  end
+
+  def test_cleanup_with_option_to_inherited
+    expected_cleanup_calls = [:cleanup]
+    test_case = assert_cleanup(expected_cleanup_calls, nil)
+    assert_inherited_cleanup([:custom_cleanup_method3,
+                              :custom_cleanup_method1,
+                              :custom_cleanup_method0,
+                              :cleanup],
+                              test_case, [])
+
+    assert_inherited_cleanup([:cleanup], nil)
+    assert_called_fixtures(expected_cleanup_calls, test_case)
+  end
+
+  def test_cleanup_with_exception
+    test_case = Class.new(Test::Unit::TestCase) do
+      def called_ids
+        @called_ids ||= []
+      end
+
+      def called(id)
+        called_ids << id
+      end
+
+      def cleanup
+        called(:cleanup)
+        raise "cleanup"
+      end
+
+      cleanup
+      def custom_cleanup_method0
+        called(:custom_cleanup_method0)
+        raise "custom_cleanup_method0"
+      end
+
+      cleanup
+      def custom_cleanup_method1
+        called(:custom_cleanup_method1)
+        raise "custom_cleanup_method1"
+      end
+
+      def test_nothing
+      end
+    end
+
+    assert_called_fixtures([:custom_cleanup_method1],
+                           test_case)
+  end
+
   def test_teardown_without_option
     expected_teardown_calls = [:custom_teardown_method3,
                                :custom_teardown_method1,
@@ -236,6 +334,67 @@ class TestUnitFixture < Test::Unit::TestCase
     _test_case
   end
 
+  def assert_cleanup_customizable(expected, parent, options)
+    test_case = Class.new(parent || Test::Unit::TestCase) do
+      yield(self, :before) if block_given?
+
+      def called_ids
+        @called_ids ||= []
+      end
+
+      def called(id)
+        called_ids << id
+      end
+
+      def cleanup
+        called(:cleanup)
+      end
+
+      cleanup(*(options[0] || [])) if options
+      def custom_cleanup_method0
+        called(:custom_cleanup_method0)
+      end
+
+      def custom_cleanup_method1
+        called(:custom_cleanup_method1)
+      end
+      cleanup(*[:custom_cleanup_method1, *(options[1] || [])]) if options
+
+      cleanup(*(options[2] || [])) if options
+      def custom_cleanup_method2
+        called(:custom_cleanup_method2)
+      end
+      unregister_cleanup(:custom_cleanup_method2) if options
+
+      cleanup(*(options[3] || [])) if options
+      def custom_cleanup_method3
+        called(:custom_cleanup_method3)
+      end
+
+      def test_nothing
+      end
+
+      yield(self, :after) if block_given?
+    end
+
+    assert_called_fixtures(expected, test_case)
+    test_case
+  end
+
+  def assert_cleanup(expected, options)
+    assert_cleanup_customizable(expected, nil, options)
+    assert_cleanup_customizable(expected, nil, options) do |test_case, tag|
+      test_case.send(:include, EmptyModule) if tag == :before
+    end
+  end
+
+  def assert_inherited_cleanup(expected, parent, options=nil)
+    assert_cleanup_customizable(expected, parent, options)
+    assert_cleanup_customizable(expected, parent, options) do |test_case, tag|
+      test_case.send(:include, EmptyModule) if tag == :before
+    end
+  end
+
   def assert_teardown_customizable(expected, parent, options)
     test_case = Class.new(parent || Test::Unit::TestCase) do
       yield(self, :before) if block_given?
@@ -318,6 +477,10 @@ class TestUnitFixture < Test::Unit::TestCase
     assert_invalid_option(:setup, option)
   end
 
+  def assert_invalid_cleanup_option(option)
+    assert_invalid_option(:cleanup, option)
+  end
+
   def assert_invalid_teardown_option(option)
     assert_invalid_option(:teardown, option)
   end

data/test/test-testcase.rb

@@ -9,26 +9,20 @@ module Test
     class TestTestCase < TestCase
       self.test_order = :random
       def test_creation
-        tc = Class.new(TestCase) do
+        test_case = Class.new(TestCase) do
           def test_with_arguments(arg1, arg2)
           end
         end
-      
-        caught = true
-        catch(:invalid_test) do
-          tc.new(:test_with_arguments)
-          caught = false
-        end
-        check("Should have caught an invalid test when there are arguments", caught)
-        
-        caught = true
-        catch(:invalid_test) do
-          tc.new(:non_existent_test)
-          caught = false
-        end
-        check("Should have caught an invalid test when the method does not exist", caught)
+
+        test = test_case.new(:test_with_arguments)
+        check("Should have caught an invalid test when there are arguments",
+              !test.valid?)
+
+        test = test_case.new(:non_existent_test)
+        check("Should have caught an invalid test when the method does not exist",
+              !test.valid?)
       end
-      
+
       def setup
         @tc_failure_error = Class.new(TestCase) do
           def test_failure
@@ -75,7 +69,11 @@ module Test
         test_case.run(result) { |*arguments| progress << arguments }
         check("The failure should have triggered the listener", called)
         check("The failure should have set passed?", !test_case.return_passed?)
-        check("The progress block should have been updated correctly", [[TestCase::STARTED, test_case.name], [TestCase::FINISHED, test_case.name]] == progress)
+        check("The progress block should have been updated correctly",
+              [[TestCase::STARTED, test_case.name],
+               [TestCase::STARTED_OBJECT, test_case],
+               [TestCase::FINISHED, test_case.name],
+               [TestCase::FINISHED_OBJECT, test_case]] == progress)
       end
 
       def test_add_failure_nested
@@ -441,17 +439,14 @@ module Test
           end
         end
 
-        assert_nothing_thrown do
-          test_case.new("test_nothing")
-        end
+        test = test_case.new("test_nothing")
+        assert_predicate(test, :valid?)
 
-        assert_nothing_thrown do
-          sub_test_case.new("test_fail")
-        end
+        test = sub_test_case.new("test_fail")
+        assert_predicate(test, :valid?)
 
-        assert_throw(:invalid_test) do
-          sub_test_case.new("test_nothing")
-        end
+        test = sub_test_case.new("test_nothing")
+        assert_not_predicate(test, :valid?)
       end
 
       def test_mixin_test_should_not_be_ignored
@@ -511,9 +506,9 @@ module Test
 
         test_case.test_order = :defined
 
-        assert_equal(["test_declarative_style_test_definition",
-                      "test_include_parenthesis",
-                      "test_1_2_3"],
+        assert_equal(["declarative style test definition",
+                      "include parenthesis",
+                      "1 + 2 = 3"],
                      test_case.suite.tests.collect {|test| test.method_name})
 
         assert_equal(["declarative style test definition",
@@ -522,6 +517,19 @@ module Test
                      test_case.suite.tests.collect {|test| test.description})
       end
 
+      def test_test_mark
+        test_case = Class.new(Test::Unit::TestCase) do
+          test
+          def my_test_method
+          end
+        end
+
+        test_case.test_order = :defined
+
+        assert_equal(["my_test_method"],
+                     test_case.suite.tests.collect {|test| test.method_name})
+      end
+
       def test_redefine_method
         test_case = Class.new(Test::Unit::TestCase) do
           def test_name
@@ -542,6 +550,18 @@ module Test
                      result.summary)
       end
 
+      def test_data_driven_test
+        test_case = Class.new(TestCase) do
+          def test_with_data(data)
+          end
+        end
+
+        test = test_case.new("test_with_data")
+        assert_not_predicate(test, :valid?)
+        test.assign_test_data("label1", :test_data1)
+        assert_predicate(test, :valid?)
+      end
+
       private
       def check(message, passed)
         add_assertion