test-unit 1.2.3 → 2.0.0

data/test/test_emacs_runner.rb

@@ -0,0 +1,60 @@
+require 'test/unit'
+require 'test/unit/ui/emacs/testrunner'
+
+class TestUnitEmacsRunner < Test::Unit::TestCase
+  def test_format_failure_with_a_location
+    runner = create_runner
+    test_name = "test_failure"
+    file = "/home/user/test_xxx.rb"
+    line = "3"
+    info = "in `xxx'"
+    location = "#{file}:#{line}: #{info}"
+    message = "FAIL!!!"
+    failure = Test::Unit::Failure.new(test_name, [location], message)
+    assert_equal(<<-EOM.chomp, runner.send(:format_fault, failure))
+Failure:
+#{test_name} [#{file}:#{line}]:
+#{message}
+EOM
+  end
+
+  def test_format_failure_with_locations
+    runner = create_runner
+    test_name = "test_failure"
+    locations = ["/home/user/test_xxx.rb:3: in `xxx'",
+                 "/home/user/yyy/test_yyy.rb:999: in `yyy'",
+                 "/home/user/xyz/zzz.rb:29: in `zzz'"]
+    message = "Many backtrace!!!"
+    failure = Test::Unit::Failure.new(test_name, locations, message)
+    assert_equal(<<-EOM.chomp, runner.send(:format_fault, failure))
+Failure:
+#{test_name}
+#{locations.join("\n")}:
+#{message}
+EOM
+  end
+
+  def test_format_error
+    runner = create_runner
+    test_name = "test_error"
+    message = "Error Message!!!"
+    backtrace = ["/home/user/test_xxx.rb:3: in `xxx'",
+                 "/home/user/yyy/test_yyy.rb:999: in `yyy'",
+                 "/home/user/xyz/zzz.rb:29: in `zzz'"]
+    exception = RuntimeError.new(message)
+    exception.set_backtrace(backtrace)
+    error = Test::Unit::Error.new(test_name, exception)
+    assert_equal(<<-EOM.chomp, runner.send(:format_fault, error))
+Error:
+#{test_name}:
+#{exception.class.name}: #{message}
+#{backtrace.join("\n")}
+EOM
+  end
+
+  private
+  def create_runner(suite=nil)
+    suite ||= Test::Unit::TestSuite.new
+    Test::Unit::UI::Emacs::TestRunner.new(suite)
+  end
+end

data/test/test_fixture.rb

@@ -0,0 +1,275 @@
+class TestUnitFixture < Test::Unit::TestCase
+  def test_setup_without_option
+    test_case = assert_setup([:setup,
+                              :custom_setup_method0,
+                              :custom_setup_method1,
+                              :custom_setup_method3],
+                             [])
+    assert_inherited_setup([:setup,
+                            :custom_setup_method0,
+                            :custom_setup_method1,
+                            :custom_setup_method3],
+                           test_case)
+    assert_inherited_setup([:setup], nil)
+  end
+
+  def test_setup_with_before_option
+    test_case = assert_setup([:custom_setup_method3,
+                              :custom_setup_method0,
+                              :custom_setup_method1,
+                              :setup],
+                             [[{:before => :append}],
+                              [{:before => :append}],
+                              [{:before => :prepend}],
+                              [{:before => :prepend}]])
+    assert_inherited_setup([:custom_setup_method3,
+                            :custom_setup_method0,
+                            :custom_setup_method1,
+                            :setup],
+                           test_case)
+    assert_inherited_setup([:setup], nil)
+  end
+
+  def test_setup_with_after_option
+    test_case = assert_setup([:setup,
+                              :custom_setup_method3,
+                              :custom_setup_method0,
+                              :custom_setup_method1],
+                             [[{:after => :append}],
+                              [{:after => :append}],
+                              [{:after => :prepend}],
+                              [{:after => :prepend}]])
+    assert_inherited_setup([:setup,
+                            :custom_setup_method3,
+                            :custom_setup_method0,
+                            :custom_setup_method1],
+                           test_case)
+    assert_inherited_setup([:setup], nil)
+  end
+
+  def test_setup_with_invalid_option
+    assert_invalid_setup_option(:unknown => true)
+    assert_invalid_setup_option(:before => :unknown)
+    assert_invalid_setup_option(:after => :unknown)
+  end
+
+  def test_teardown_without_option
+    test_case = assert_teardown([:custom_teardown_method3,
+                                 :custom_teardown_method1,
+                                 :custom_teardown_method0,
+                                 :teardown],
+                                [])
+    assert_inherited_teardown([:custom_teardown_method3,
+                               :custom_teardown_method1,
+                               :custom_teardown_method0,
+                               :teardown],
+                              test_case)
+    assert_inherited_teardown([:teardown], nil)
+  end
+
+  def test_teardown_with_before_option
+    test_case = assert_teardown([:custom_teardown_method3,
+                                 :custom_teardown_method0,
+                                 :custom_teardown_method1,
+                                 :teardown],
+                                [[{:before => :append}],
+                                 [{:before => :append}],
+                                 [{:before => :prepend}],
+                                 [{:before => :prepend}]])
+    assert_inherited_teardown([:custom_teardown_method3,
+                               :custom_teardown_method0,
+                               :custom_teardown_method1,
+                               :teardown],
+                              test_case)
+    assert_inherited_teardown([:teardown], nil)
+  end
+
+  def test_teardown_with_after_option
+    test_case = assert_teardown([:teardown,
+                                 :custom_teardown_method3,
+                                 :custom_teardown_method0,
+                                 :custom_teardown_method1],
+                                [[{:after => :append}],
+                                 [{:after => :append}],
+                                 [{:after => :prepend}],
+                                 [{:after => :prepend}]])
+    assert_inherited_teardown([:teardown,
+                               :custom_teardown_method3,
+                               :custom_teardown_method0,
+                               :custom_teardown_method1],
+                              test_case)
+    assert_inherited_teardown([:teardown], nil)
+  end
+
+  def test_teardown_with_invalid_option
+    assert_invalid_teardown_option(:unknown => true)
+    assert_invalid_teardown_option(:before => :unknown)
+    assert_invalid_teardown_option(:after => :unknown)
+  end
+
+  private
+  def assert_setup(expected, setup_options)
+    called = []
+    test_case = Class.new(Test::Unit::TestCase) do
+      @@called = called
+      def setup
+        @@called << :setup
+      end
+
+      setup(*(setup_options[0] || []))
+      def custom_setup_method0
+        @@called << :custom_setup_method0
+      end
+
+      def custom_setup_method1
+        @@called << :custom_setup_method1
+      end
+      setup(*[:custom_setup_method1, *(setup_options[1] || [])])
+
+      setup(*(setup_options[2] || []))
+      def custom_setup_method2
+        @@called << :custom_setup_method2
+      end
+      unregister_setup(:custom_setup_method2)
+
+      setup(*(setup_options[3] || []))
+      def custom_setup_method3
+        @@called << :custom_setup_method3
+      end
+
+      def test_nothing
+      end
+    end
+
+    test_case.new("test_nothing").run(Test::Unit::TestResult.new) {}
+    assert_equal(expected, called)
+    test_case
+  end
+
+  def assert_inherited_setup(expected, parent)
+    called = []
+    inherited_test_case = Class.new(parent || Test::Unit::TestCase) do
+      @@called = called
+      def setup
+        @@called << :setup
+      end
+
+      def custom_setup_method0
+        @@called << :custom_setup_method0
+      end
+
+      def custom_setup_method1
+        @@called << :custom_setup_method1
+      end
+
+      def custom_setup_method2
+        @@called << :custom_setup_method2
+      end
+
+      def custom_setup_method3
+        @@called << :custom_setup_method3
+      end
+
+      def test_nothing
+      end
+    end
+
+    inherited_test_case.new("test_nothing").run(Test::Unit::TestResult.new) {}
+    assert_equal(expected, called)
+  end
+
+  def assert_teardown(expected, teardown_options)
+    called = []
+    test_case = Class.new(Test::Unit::TestCase) do
+      @@called = called
+      def teardown
+        @@called << :teardown
+      end
+
+      teardown(*(teardown_options[0] || []))
+      def custom_teardown_method0
+        @@called << :custom_teardown_method0
+      end
+
+      def custom_teardown_method1
+        @@called << :custom_teardown_method1
+      end
+      teardown(*[:custom_teardown_method1, *(teardown_options[1] || [])])
+
+      teardown(*(teardown_options[2] || []))
+      def custom_teardown_method2
+        @@called << :custom_teardown_method2
+      end
+      unregister_teardown(:custom_teardown_method2)
+
+      teardown(*(teardown_options[3] || []))
+      def custom_teardown_method3
+        @@called << :custom_teardown_method3
+      end
+
+      def test_nothing
+      end
+    end
+
+    test_case.new("test_nothing").run(Test::Unit::TestResult.new) {}
+    assert_equal(expected, called)
+    test_case
+  end
+
+  def assert_inherited_teardown(expected, parent)
+    called = []
+    inherited_test_case = Class.new(parent || Test::Unit::TestCase) do
+      @@called = called
+      def teardown
+        @@called << :teardown
+      end
+
+      def custom_teardown_method0
+        @@called << :custom_teardown_method0
+      end
+
+      def custom_teardown_method1
+        @@called << :custom_teardown_method1
+      end
+
+      def custom_teardown_method2
+        @@called << :custom_teardown_method2
+      end
+
+      def custom_teardown_method3
+        @@called << :custom_teardown_method3
+      end
+
+      def test_nothing
+      end
+    end
+
+    inherited_test_case.new("test_nothing").run(Test::Unit::TestResult.new) {}
+    assert_equal(expected, called)
+  end
+
+  def assert_invalid_option(fixture_type, option)
+    exception = assert_raise(ArgumentError) do
+      Class.new(Test::Unit::TestCase) do
+        def test_nothing
+        end
+
+        send(fixture_type, option)
+        def fixture
+        end
+      end
+    end
+    assert_equal("must be {:before => :prepend}, {:before => :append}, " +
+                 "{:after => :prepend} or {:after => :append}" +
+                 ": #{option.inspect}",
+                 exception.message)
+  end
+
+  def assert_invalid_setup_option(option)
+    assert_invalid_option(:setup, option)
+  end
+
+  def assert_invalid_teardown_option(option)
+    assert_invalid_option(:teardown, option)
+  end
+end

data/test/test_notification.rb

@@ -0,0 +1,33 @@
+require 'test/unit'
+require 'testunit_test_util'
+
+class TestNotification < Test::Unit::TestCase
+  include TestUnitTestUtil
+
+  class TestCase < Test::Unit::TestCase
+    class << self
+      def suite
+        Test::Unit::TestSuite.new(name)
+      end
+    end
+
+    def test_notify
+      notify("1st notify")
+      notify("2nd notify. Reach here.")
+    end
+  end
+
+  def test_notify
+    result = run_test("test_notify")
+    assert_equal("1 tests, 0 assertions, 0 failures, 0 errors, 0 pendings, " \
+                 "0 omissions, 2 notifications",
+                 result.to_s)
+    assert_fault_messages(["1st notify", "2nd notify. Reach here."],
+                          result.notifications)
+  end
+
+  private
+  def run_test(name)
+    super(TestCase, name)
+  end
+end

data/test/test_omission.rb

@@ -0,0 +1,81 @@
+require 'test/unit'
+require 'testunit_test_util'
+
+class TestUnitOmission < Test::Unit::TestCase
+  include TestUnitTestUtil
+
+  class TestCase < Test::Unit::TestCase
+    class << self
+      def suite
+        Test::Unit::TestSuite.new(name)
+      end
+    end
+
+    def test_omit
+      omit("1st omit")
+      omit("2nd omit. Should not be reached here.")
+      assert(true, "Should not be reached here too.")
+    end
+
+    def test_omit_with_condition
+      omit_if(false, "Never omit.")
+      omit_unless(true, "Never omit too.")
+      omit_if(true, "Should omit.")
+      omit("The last omit. Should not be reached here.")
+    end
+
+    def test_omit_with_block
+      omit("Omit block") do
+        flunk("Should not be reached here.")
+      end
+      assert(true, "Should be reached here.")
+    end
+
+    def test_omit_with_block_and_condition
+      omit_if(false, "Never omit.") do
+        assert(true, "Should be reached here.")
+      end
+      omit_if(true, "Should omit.") do
+        flunk("Never reached here.")
+      end
+      assert(true, "Should be reached here too.")
+    end
+  end
+
+  def test_omit
+    result = run_test("test_omit")
+    assert_equal("1 tests, 0 assertions, 0 failures, 0 errors, 0 pendings, " \
+                 "1 omissions, 0 notifications",
+                 result.to_s)
+    assert_fault_messages(["1st omit"], result.omissions)
+  end
+
+  def test_omit_with_condition
+    result = run_test("test_omit_with_condition")
+    assert_equal("1 tests, 0 assertions, 0 failures, 0 errors, 0 pendings, " \
+                 "1 omissions, 0 notifications",
+                 result.to_s)
+    assert_fault_messages(["Should omit."], result.omissions)
+  end
+
+  def test_omit_with_block
+    result = run_test("test_omit_with_block")
+    assert_equal("1 tests, 1 assertions, 0 failures, 0 errors, 0 pendings, " \
+                 "1 omissions, 0 notifications",
+                 result.to_s)
+    assert_fault_messages(["Omit block"], result.omissions)
+  end
+
+  def test_omit_with_condition_and_block
+    result = run_test("test_omit_with_block_and_condition")
+    assert_equal("1 tests, 1 assertions, 0 failures, 0 errors, 0 pendings, " \
+                 "1 omissions, 0 notifications",
+                 result.to_s)
+    assert_fault_messages(["Should omit."], result.omissions)
+  end
+
+  private
+  def run_test(name)
+    super(TestCase, name)
+  end
+end