test-unit 2.0.0 → 2.0.1

data/lib/test/unit/ui/console/testrunner.rb

@@ -4,7 +4,7 @@
 # Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
 # License:: Ruby license.
 
-require 'test/unit/color'
+require 'test/unit/color-scheme'
 require 'test/unit/ui/testrunner'
 require 'test/unit/ui/testrunnermediator'
 require 'test/unit/ui/console/outputlevel'
@@ -18,17 +18,6 @@ module Test
         class TestRunner < UI::TestRunner
           include OutputLevel
 
-          COLOR_SCHEMES = {
-            :default => {
-              "success" => Color.new("green", :bold => true),
-              "failure" => Color.new("red", :bold => true),
-              "pending" => Color.new("magenta", :bold => true),
-              "omission" => Color.new("blue", :bold => true),
-              "notification" => Color.new("cyan", :bold => true),
-              "error" => Color.new("yellow", :bold => true),
-            },
-          }
-
           # Creates a new TestRunner for running the passed
           # suite. If quiet_mode is true, the output while
           # running is limited to progress dots, errors and
@@ -41,8 +30,11 @@ module Test
             @output = @options[:output] || STDOUT
             @use_color = @options[:use_color]
             @use_color = guess_color_availability if @use_color.nil?
-            @color_scheme = COLOR_SCHEMES[:default]
+            @color_scheme = @options[:color_scheme] || ColorScheme.default
             @reset_color = Color.new("reset")
+            @progress_row = 0
+            @progress_row_max = @options[:progress_row_max]
+            @progress_row_max ||= guess_progress_row_max
             @already_outputted = false
             @faults = []
           end
@@ -84,9 +76,7 @@ module Test
           
           def add_fault(fault)
             @faults << fault
-            output_single(fault.single_character_display,
-                          fault_color(fault),
-                          PROGRESS_ONLY)
+            output_progress(fault.single_character_display, fault_color(fault))
             @already_outputted = true
           end
           
@@ -124,7 +114,7 @@ module Test
           
           def test_finished(name)
             unless @already_outputted
-              output_single(".", @color_scheme["success"], PROGRESS_ONLY)
+              output_progress(".", color("success"))
             end
             nl(VERBOSE)
             @already_outputted = false
@@ -141,7 +131,7 @@ module Test
           end
           
           def output_single(something, color=nil, level=NORMAL)
-            return unless output?(level)
+            return false unless output?(level)
             if @use_color and color
               something = "%s%s%s" % [color.escape_sequence,
                                       something,
@@ -149,31 +139,47 @@ module Test
             end
             @output.write(something)
             @output.flush
+            true
           end
-          
+
+          def output_progress(mark, color=nil)
+            if output_single(mark, color, PROGRESS_ONLY)
+              return unless @progress_row_max > 0
+              @progress_row += mark.size
+              if @progress_row >= @progress_row_max
+                nl unless @output_level == VERBOSE
+                @progress_row = 0
+              end
+            end
+          end
+
           def output?(level)
             level <= @output_level
           end
 
+          def color(name)
+            @color_scheme[name] || ColorScheme.default[name]
+          end
+
           def fault_color(fault)
-            @color_scheme[fault.class.name.split(/::/).last.downcase]
+            color(fault.class.name.split(/::/).last.downcase)
           end
 
           def result_color
             if @result.passed?
               if @result.pending_count > 0
-                @color_scheme["pending"]
+                color("pending")
               elsif @result.omission_count > 0
-                @color_scheme["omission"]
+                color("omission")
               elsif @result.notification_count > 0
-                @color_scheme["notification"]
+                color("notification")
               else
-                @color_scheme["success"]
+                color("success")
               end
             elsif @result.error_count > 0
-              @color_scheme["error"]
+              color("error")
             elsif @result.failure_count > 0
-              @color_scheme["failure"]
+              color("failure")
             end
           end
 
@@ -184,6 +190,25 @@ module Test
             return true if ENV["EMACS"] == "t"
             false
           end
+
+          def guess_progress_row_max
+            term_width = guess_term_width
+            if term_width.zero?
+              if ENV["EMACS"] == "t"
+                -1
+              else
+                79
+              end
+            else
+              term_width
+            end
+          end
+
+          def guess_term_width
+            Integer(ENV["TERM_WIDTH"] || 0)
+          rescue ArgumentError
+            0
+          end
         end
       end
     end

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.0.0'
+    VERSION = '2.0.1'
   end
 end

data/sample/test_user.rb

@@ -0,0 +1,22 @@
+# nested test case example.
+
+class UserTest < Test::Unit::TestCase
+  def setup
+    @user = "me"
+  end
+
+  def test_full_name
+    assert_equal("me", @user)
+  end
+
+  class ProfileTest < UserTest
+    setup
+    def setup_profile
+      @user += ": profile"
+    end
+
+    def test_has_profile
+      assert_match(/: profile/, @user)
+    end
+  end
+end

data/test/collector/{test_load.rb → test-load.rb}

@@ -268,7 +268,7 @@ EOT
                      [:test, {:name => "test1_1"}],
                      [:test, {:name => "test1_2"}]]]) do |collector|
       collector.filter = Proc.new do |test|
-        not /\Atest1/.match(test.method_name).nil?
+        !/\Atest1/.match(test.method_name).nil?
       end
     end
   end

data/test/test-color-scheme.rb

@@ -0,0 +1,55 @@
+class TestUnitColorScheme < Test::Unit::TestCase
+  def test_default
+    assert_equal({
+                   "success" => color("green", :bold => true),
+                   "failure" => color("red", :bold => true),
+                   "pending" => color("magenta", :bold => true),
+                   "omission" => color("blue", :bold => true),
+                   "notification" => color("cyan", :bold => true),
+                   "error" => color("yellow", :bold => true),
+                 },
+                 Test::Unit::ColorScheme.default.to_hash)
+  end
+
+  def test_register
+    inverted_scheme_spec = {
+      "success" => {:name => "red"},
+      "failure" => {:name => "green"},
+    }
+    Test::Unit::ColorScheme["inverted"] = inverted_scheme_spec
+    assert_equal({
+                   "success" => color("red"),
+                   "failure" => color("green"),
+                 },
+                 Test::Unit::ColorScheme["inverted"].to_hash)
+  end
+
+  def test_new_with_colors
+    scheme = Test::Unit::ColorScheme.new(:success => color("blue"),
+                                         "failure" => color("green",
+                                                            :underline => true))
+    assert_equal({
+                   "success" => color("blue"),
+                   "failure" => color("green", :underline => true),
+                 },
+                 scheme.to_hash)
+  end
+
+  def test_new_with_spec
+    scheme = Test::Unit::ColorScheme.new(:success => {
+                                           :name => "blue",
+                                           :bold => true
+                                         },
+                                         "failure" => {:name => "green"})
+    assert_equal({
+                   "success" => color("blue", :bold => true),
+                   "failure" => color("green"),
+                 },
+                 scheme.to_hash)
+  end
+
+  private
+  def color(name, options={})
+    Test::Unit::Color.new(name, options)
+  end
+end

data/test/{test_color.rb → test-color.rb}

@@ -20,6 +20,16 @@ class TestUnitColor < Test::Unit::TestCase
                            color("none", :underline => true))
   end
 
+  def test_equal
+    red = color("red")
+    red_bold = color("red", :bold => true)
+
+    assert_operator(red, :==, red)
+    assert_not_equal(red, nil)
+    assert_equal(red, color("red"))
+    assert_not_equal(red, red_bold)
+  end
+
   private
   def color(name, options={})
     Test::Unit::Color.new(name, options)

data/test/test-fixture.rb

@@ -0,0 +1,287 @@
+class TestUnitFixture < Test::Unit::TestCase
+  module EmptyModule
+  end
+
+  def test_setup_without_option
+    expected_setup_calls = [:setup,
+                            :custom_setup_method0,
+                            :custom_setup_method1,
+                            :custom_setup_method3]
+    test_case = assert_setup(expected_setup_calls, [])
+    assert_inherited_setup(expected_setup_calls, test_case)
+
+    assert_inherited_setup([:setup], nil)
+    assert_called_fixtures(expected_setup_calls, test_case)
+  end
+
+  def test_setup_with_before_option
+    expected_setup_calls = [:custom_setup_method3,
+                            :custom_setup_method0,
+                            :custom_setup_method1,
+                            :setup]
+    test_case = assert_setup(expected_setup_calls,
+                             [[{:before => :append}],
+                              [{:before => :append}],
+                              [{:before => :prepend}],
+                              [{:before => :prepend}]])
+    assert_inherited_setup(expected_setup_calls, test_case)
+
+    assert_inherited_setup([:setup], nil)
+    assert_called_fixtures(expected_setup_calls, test_case)
+  end
+
+  def test_setup_with_after_option
+    expected_setup_calls = [:setup,
+                            :custom_setup_method3,
+                            :custom_setup_method0,
+                            :custom_setup_method1]
+    test_case = assert_setup(expected_setup_calls,
+                             [[{:after => :append}],
+                              [{:after => :append}],
+                              [{:after => :prepend}],
+                              [{:after => :prepend}]])
+    assert_inherited_setup(expected_setup_calls, test_case)
+
+    assert_inherited_setup([:setup], nil)
+    assert_called_fixtures(expected_setup_calls, test_case)
+  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_setup_with_option_to_inherited
+    expected_setup_calls = [:setup]
+    test_case = assert_setup(expected_setup_calls, nil)
+    assert_inherited_setup([:setup,
+                            :custom_setup_method0,
+                            :custom_setup_method1,
+                            :custom_setup_method3],
+                           test_case,
+                           [])
+
+    assert_inherited_setup([:setup], nil)
+    assert_called_fixtures(expected_setup_calls, test_case)
+  end
+
+  def test_teardown_without_option
+    expected_teardown_calls = [:custom_teardown_method3,
+                               :custom_teardown_method1,
+                               :custom_teardown_method0,
+                               :teardown]
+    test_case = assert_teardown(expected_teardown_calls, [])
+    assert_inherited_teardown(expected_teardown_calls, test_case)
+
+    assert_inherited_teardown([:teardown], nil)
+    assert_called_fixtures(expected_teardown_calls, test_case)
+  end
+
+  def test_teardown_with_before_option
+    expected_teardown_calls = [:custom_teardown_method3,
+                               :custom_teardown_method0,
+                               :custom_teardown_method1,
+                               :teardown]
+    test_case = assert_teardown(expected_teardown_calls,
+                                [[{:before => :append}],
+                                 [{:before => :append}],
+                                 [{:before => :prepend}],
+                                 [{:before => :prepend}]])
+    assert_inherited_teardown(expected_teardown_calls, test_case)
+
+    assert_inherited_teardown([:teardown], nil)
+    assert_called_fixtures(expected_teardown_calls, test_case)
+  end
+
+  def test_teardown_with_after_option
+    expected_teardown_calls = [:teardown,
+                               :custom_teardown_method3,
+                               :custom_teardown_method0,
+                               :custom_teardown_method1]
+    test_case = assert_teardown(expected_teardown_calls,
+                                [[{:after => :append}],
+                                 [{:after => :append}],
+                                 [{:after => :prepend}],
+                                 [{:after => :prepend}]])
+    assert_inherited_teardown(expected_teardown_calls, test_case)
+
+    assert_inherited_teardown([:teardown], nil)
+    assert_called_fixtures(expected_teardown_calls, test_case)
+  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
+
+  def test_teardown_with_option_to_inherited
+    expected_teardown_calls = [:teardown]
+    test_case = assert_teardown(expected_teardown_calls, nil)
+    assert_inherited_teardown([:custom_teardown_method3,
+                               :custom_teardown_method1,
+                               :custom_teardown_method0,
+                               :teardown],
+                              test_case, [])
+
+    assert_inherited_teardown([:teardown], nil)
+    assert_called_fixtures(expected_teardown_calls, test_case)
+  end
+
+  private
+  def assert_called_fixtures(expected, test_case)
+    test = test_case.new("test_nothing")
+    test.run(Test::Unit::TestResult.new) {}
+    assert_equal(expected, test.called_ids)
+  end
+
+  def assert_setup_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 setup
+        called(:setup)
+      end
+
+      setup(*(options[0] || [])) if options
+      def custom_setup_method0
+        called(:custom_setup_method0)
+      end
+
+      def custom_setup_method1
+        called(:custom_setup_method1)
+      end
+      setup(*[:custom_setup_method1, *(options[1] || [])]) if options
+
+      setup(*(options[2] || [])) if options
+      def custom_setup_method2
+        called(:custom_setup_method2)
+      end
+      unregister_setup(:custom_setup_method2) if options
+
+      setup(*(options[3] || [])) if options
+      def custom_setup_method3
+        called(:custom_setup_method3)
+      end
+
+      def test_nothing
+      end
+
+      yield(self, :after) if block_given?
+    end
+
+    assert_called_fixtures(expected, test_case)
+    test_case
+  end
+
+  def assert_setup(expected, options)
+    _test_case = assert_setup_customizable(expected, nil, options)
+    assert_setup_customizable(expected, nil, options) do |test_case, tag|
+      test_case.send(:include, EmptyModule) if tag == :before
+    end
+    _test_case
+  end
+
+  def assert_inherited_setup(expected, parent, options=nil)
+    _test_case = assert_setup_customizable(expected, parent, options)
+    assert_setup_customizable(expected, parent, options) do |test_case, tag|
+      test_case.send(:include, EmptyModule) if tag == :before
+    end
+    _test_case
+  end
+
+  def assert_teardown_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 teardown
+        called(:teardown)
+      end
+
+      teardown(*(options[0] || [])) if options
+      def custom_teardown_method0
+        called(:custom_teardown_method0)
+      end
+
+      def custom_teardown_method1
+        called(:custom_teardown_method1)
+      end
+      teardown(*[:custom_teardown_method1, *(options[1] || [])]) if options
+
+      teardown(*(options[2] || [])) if options
+      def custom_teardown_method2
+        called(:custom_teardown_method2)
+      end
+      unregister_teardown(:custom_teardown_method2) if options
+
+      teardown(*(options[3] || [])) if options
+      def custom_teardown_method3
+        called(:custom_teardown_method3)
+      end
+
+      def test_nothing
+      end
+
+      yield(self, :after) if block_given?
+    end
+
+    assert_called_fixtures(expected, test_case)
+    test_case
+  end
+
+  def assert_teardown(expected, options)
+    assert_teardown_customizable(expected, nil, options)
+    assert_teardown_customizable(expected, nil, options) do |test_case, tag|
+      test_case.send(:include, EmptyModule) if tag == :before
+    end
+  end
+
+  def assert_inherited_teardown(expected, parent, options=nil)
+    assert_teardown_customizable(expected, parent, options)
+    assert_teardown_customizable(expected, parent, options) do |test_case, tag|
+      test_case.send(:include, EmptyModule) if tag == :before
+    end
+  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