test-unit 2.2.0 → 2.3.0

data/lib/test/unit/testresult.rb

@@ -31,8 +31,10 @@ module Test
       include TestResultOmissionSupport
       include TestResultNotificationSupport
 
-      CHANGED = "CHANGED"
-      FAULT = "FAULT"
+      FINISHED = name + "::FINISHED"
+      CHANGED = name + "::CHANGED"
+      PASS_ASSERTION = name + "::PASS_ASSERTION"
+      FAULT = name + "::FAULT"
 
       attr_reader :run_count, :pass_count, :assertion_count, :faults
 
@@ -48,6 +50,7 @@ module Test
       # Records a test run.
       def add_run
         @run_count += 1
+        notify_listeners(FINISHED, self)
         notify_changed
       end
 
@@ -58,6 +61,7 @@ module Test
       # Records an individual assertion.
       def add_assertion
         @assertion_count += 1
+        notify_listeners(PASS_ASSERTION, self)
         notify_changed
       end
 

data/lib/test/unit/testsuite.rb

@@ -18,14 +18,16 @@ module Test
     # has a suite method as simply providing a way to get a
     # meaningful TestSuite instance.
     class TestSuite
-      attr_reader :name, :tests
+      attr_reader :name, :tests, :test_case, :start_time, :elapsed_time
 
       # Test suite that has higher priority is ran prior to
       # test suites that have lower priority.
       attr_accessor :priority
 
       STARTED = name + "::STARTED"
+      STARTED_OBJECT = name + "::STARTED::OBJECT"
       FINISHED = name + "::FINISHED"
+      FINISHED_OBJECT = name + "::FINISHED::OBJECT"
 
       # Creates a new TestSuite with the given name.
       def initialize(name="Unnamed TestSuite", test_case=nil)
@@ -34,19 +36,28 @@ module Test
         @test_case = test_case
         @n_tests = 0
         @priority = 0
+        @start_time = nil
+        @elapsed_time = nil
+        @passed = true
       end
 
       # Runs the tests and/or suites contained in this
       # TestSuite.
       def run(result, &progress_block)
+        @start_time = Time.now
         yield(STARTED, name)
+        yield(STARTED_OBJECT, self)
         run_startup(result)
         while test = @tests.shift
           @n_tests += test.size
           test.run(result, &progress_block)
+          @passed = false unless test.passed?
         end
         run_shutdown(result)
+      ensure
+        @elapsed_time = Time.now - @start_time
         yield(FINISHED, name)
+        yield(FINISHED_OBJECT, self)
       end
 
       # Adds the test to the suite.
@@ -85,6 +96,10 @@ module Test
         @tests == other.tests
       end
 
+      def passed?
+        @passed
+      end
+
       private
       def run_startup(result)
         return if @test_case.nil? or !@test_case.respond_to?(:startup)
@@ -110,6 +125,7 @@ module Test
           false
         else
           result.add_error(Error.new(@test_case.name, exception))
+          @passed = false
           true
         end
       end

data/lib/test/unit/testsuitecreator.rb

@@ -0,0 +1,79 @@
+#--
+#
+# Author:: Kouhei Sutou
+# Copyright::
+#   * Copyright (c) 2011 Kouhei Sutou <tt><kou@clear-code.com></tt>
+# License:: Ruby license.
+
+module Test
+  module Unit
+    class TestSuiteCreator # :nodoc:
+      def initialize(test_case)
+        @test_case = test_case
+      end
+
+      def create
+        suite = TestSuite.new(@test_case.name, @test_case)
+        collect_test_names.each do |test_name|
+          data_sets = @test_case.attributes(test_name)[:data]
+          if data_sets
+            data_sets.each do |data_set|
+              data_set = data_set.call if data_set.respond_to?(:call)
+              data_set.each do |label, data|
+                append_test(suite, test_name) do |test|
+                  test.assign_test_data(label, data)
+                end
+              end
+            end
+          else
+            append_test(suite, test_name)
+          end
+        end
+        append_test(suite, "default_test") if suite.empty?
+        suite
+      end
+
+      private
+      def append_test(suite, test_name)
+        test = @test_case.new(test_name)
+        yield(test) if block_given?
+        suite << test if test.valid?
+      end
+
+      def collect_test_names
+        method_names = @test_case.public_instance_methods(true).collect do |name|
+          name.to_s
+        end
+        test_names = method_names.find_all do |method_name|
+          method_name =~ /^test./ or @test_case.attributes(method_name)[:test]
+        end
+        send("sort_test_names_in_#{@test_case.test_order}_order", test_names)
+      end
+
+      def sort_test_names_in_alphabetic_order(test_names)
+        test_names.sort
+      end
+
+      def sort_test_names_in_random_order(test_names)
+        test_names.sort_by {rand(test_names.size)}
+      end
+
+      def sort_test_names_in_defined_order(test_names)
+        added_methods = @test_case.added_methods
+        test_names.sort do |test1, test2|
+          test1_defined_order = added_methods.index(test1)
+          test2_defined_order = added_methods.index(test2)
+          if test1_defined_order and test2_defined_order
+            test1_defined_order <=> test2_defined_order
+          elsif test1_defined_order
+            1
+          elsif test2_defined_order
+            -1
+          else
+            test1 <=> test2
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -56,13 +56,20 @@ module Test
           end
 
           def attach_to_mediator
-            @mediator.add_listener(TestResult::FAULT, &method(:add_fault))
-            @mediator.add_listener(TestRunnerMediator::STARTED, &method(:started))
-            @mediator.add_listener(TestRunnerMediator::FINISHED, &method(:finished))
-            @mediator.add_listener(TestCase::STARTED, &method(:test_started))
-            @mediator.add_listener(TestCase::FINISHED, &method(:test_finished))
-            @mediator.add_listener(TestSuite::STARTED, &method(:test_suite_started))
-            @mediator.add_listener(TestSuite::FINISHED, &method(:test_suite_finished))
+            @mediator.add_listener(TestResult::FAULT,
+                                   &method(:add_fault))
+            @mediator.add_listener(TestRunnerMediator::STARTED,
+                                   &method(:started))
+            @mediator.add_listener(TestRunnerMediator::FINISHED,
+                                   &method(:finished))
+            @mediator.add_listener(TestCase::STARTED_OBJECT,
+                                   &method(:test_started))
+            @mediator.add_listener(TestCase::FINISHED_OBJECT,
+                                   &method(:test_finished))
+            @mediator.add_listener(TestSuite::STARTED_OBJECT,
+                                   &method(:test_suite_started))
+            @mediator.add_listener(TestSuite::FINISHED_OBJECT,
+                                   &method(:test_suite_finished))
           end
 
           def add_fault(fault)
@@ -191,10 +198,10 @@ module Test
             fault.long_display
           end
 
-          def test_started(name)
+          def test_started(test)
             return unless output?(VERBOSE)
 
-            name = name.sub(/\(.+?\)\z/, '')
+            name = test.name.sub(/\(.+?\)\z/, '')
             right_space = 8 * 2
             left_space = @progress_row_max - right_space
             left_space = left_space - indent.size - name.size
@@ -203,7 +210,7 @@ module Test
             @test_start = Time.now
           end
 
-          def test_finished(name)
+          def test_finished(test)
             unless @already_outputted
               output_progress(".", color("pass"))
             end
@@ -214,24 +221,24 @@ module Test
             output(": (%f)" % (Time.now - @test_start), nil, VERBOSE)
           end
 
-          def test_suite_started(name)
+          def test_suite_started(suite)
             if @top_level
               @top_level = false
               return
             end
 
             output_single(indent, nil, VERBOSE)
-            if /\A[A-Z]/ =~ name
-              _color = color("case")
-            else
+            if suite.test_case.nil?
               _color = color("suite")
+            else
+              _color = color("case")
             end
-            output_single(name, _color, VERBOSE)
+            output_single(suite.name, _color, VERBOSE)
             output(": ", nil, VERBOSE)
             @indent += 2
           end
 
-          def test_suite_finished(name)
+          def test_suite_finished(suite)
             @indent -= 2
           end
 
@@ -458,7 +465,3 @@ module Test
     end
   end
 end
-
-if __FILE__ == $0
-  Test::Unit::UI::Console::TestRunner.start_command_line_test
-end

data/lib/test/unit/ui/testrunnermediator.rb

@@ -33,9 +33,15 @@ module Test
           Unit.run = true
 
           result = create_result
-          result_listener = result.add_listener(TestResult::CHANGED) do |*args|
+          finished_listener = result.add_listener(TestResult::FINISHED) do |*args|
+            notify_listeners(TestResult::FINISHED, *args)
+          end
+          changed_listener = result.add_listener(TestResult::CHANGED) do |*args|
             notify_listeners(TestResult::CHANGED, *args)
           end
+          pass_assertion_listener = result.add_listener(TestResult::PASS_ASSERTION) do |*args|
+            notify_listeners(TestResult::PASS_ASSERTION, *args)
+          end
           fault_listener = result.add_listener(TestResult::FAULT) do |*args|
             notify_listeners(TestResult::FAULT, *args)
           end
@@ -51,7 +57,10 @@ module Test
           ensure
             elapsed_time = Time.now - start_time
             result.remove_listener(TestResult::FAULT, fault_listener)
-            result.remove_listener(TestResult::CHANGED, result_listener)
+            result.remove_listener(TestResult::CHANGED, changed_listener)
+            result.remove_listener(TestResult::FINISHED, finished_listener)
+            result.remove_listener(TestResult::PASS_ASSERTION,
+                                   pass_assertion_listener)
             notify_listeners(FINISHED, elapsed_time)
           end
 

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

@@ -0,0 +1,224 @@
+#--
+#
+# Author:: Kouhei Sutou
+# Copyright::
+#   * Copyright (c) 2011 Kouhei Sutou <kou@clear-code.com>
+# License:: Ruby license.
+
+require 'erb'
+require 'time'
+require 'test/unit/ui/testrunner'
+require 'test/unit/ui/testrunnermediator'
+
+module Test
+  module Unit
+    module UI
+      module XML
+
+        # Runs a Test::Unit::TestSuite and outputs XML.
+        class TestRunner < UI::TestRunner
+          include ERB::Util
+
+          # Creates a new TestRunner for running the passed
+          # suite. :output option specifies where runner
+          # output should go to; defaults to STDOUT.
+          def initialize(suite, options={})
+            super
+            @output = @options[:output] || STDOUT
+            if @options[:output_file_descriptor]
+              @output = IO.new(@options[:output_file_descriptor], "w")
+            end
+            @already_outputted = false
+            @indent = 0
+            @top_level = true
+            @current_test = nil
+            @current_test_suite = nil
+            @already_outputted = false
+          end
+
+          private
+          def attach_to_mediator
+            @mediator.add_listener(TestResult::PASS_ASSERTION,
+                                   &method(:result_pass_assertion))
+            @mediator.add_listener(TestResult::FAULT,
+                                   &method(:result_fault))
+            @mediator.add_listener(TestRunnerMediator::STARTED,
+                                   &method(:started))
+            @mediator.add_listener(TestRunnerMediator::FINISHED,
+                                   &method(:finished))
+            @mediator.add_listener(TestCase::STARTED_OBJECT,
+                                   &method(:test_started))
+            @mediator.add_listener(TestCase::FINISHED_OBJECT,
+                                   &method(:test_finished))
+            @mediator.add_listener(TestSuite::STARTED_OBJECT,
+                                   &method(:test_suite_started))
+            @mediator.add_listener(TestSuite::FINISHED_OBJECT,
+                                   &method(:test_suite_finished))
+          end
+
+          def result_pass_assertion(result)
+            open_tag("pass-assertion") do
+              output_test(@current_test)
+            end
+          end
+
+          def result_fault(fault)
+            open_tag("test-result") do
+              open_tag("result") do
+                output_test_suite(@current_test_suite)
+                output_test(@current_test)
+                open_tag("backtrace") do
+                  fault.location.each do |entry|
+                    file, line, info = entry.split(/:/, 3)
+                    open_tag("entry") do
+                      add_content("file", file)
+                      add_content("line", line)
+                      add_content("info", info)
+                    end
+                  end
+                end
+                if fault.respond_to?(:expected)
+                  add_content("expected", fault.expected)
+                end
+                if fault.respond_to?(:actual)
+                  add_content("actual", fault.actual)
+                end
+                add_content("detail", fault.message)
+                add_content("status", fault.label.downcase)
+              end
+            end
+            @already_outputted = true if fault.critical?
+          end
+
+          def started(result)
+            @result = result
+            output_started
+          end
+
+          def output_started
+            open_tag("stream")
+          end
+
+          def finished(elapsed_time)
+            add_content("success", @result.passed?)
+            close_tag("stream")
+          end
+
+          def test_started(test)
+            @already_outputted = false
+            @current_test = test
+            open_tag("start-test") do
+              output_test(test)
+            end
+          end
+
+          def test_finished(test)
+            unless @already_outputted
+              open_tag("test-result") do
+                output_test(test)
+                open_tag("result") do
+                  output_test_suite(@current_test_suite)
+                  output_test(test)
+                  add_content("status", "success")
+                end
+              end
+            end
+
+            open_tag("complete-test") do
+              output_test(test)
+              add_content("success", test.passed?)
+            end
+            @current_test = nil
+          end
+
+          def test_suite_started(suite)
+            @current_test_suite = suite
+            if suite.test_case.nil?
+              open_tag("ready-test-suite") do
+                add_content("n-tests", suite.size)
+              end
+              open_tag("start-test-suite") do
+                output_test_suite(suite)
+              end
+            else
+              open_tag("ready-test-case") do
+                output_test_suite(suite)
+                add_content("n-tests", suite.size)
+              end
+              open_tag("start-test-case") do
+                output_test_suite(suite)
+              end
+            end
+          end
+
+          def test_suite_finished(suite)
+            if suite.test_case.nil?
+              open_tag("complete-test-suite") do
+                output_test_suite(suite)
+                add_content("success", suite.passed?)
+              end
+            else
+              open_tag("complete-test-case") do
+                output_test_suite(suite)
+                add_content("success", suite.passed?)
+              end
+            end
+            @current_test_suite = nil
+          end
+
+          def indent
+            " " * @indent
+          end
+
+          def open_tag(name)
+            @output.puts("#{indent}<#{name}>")
+            @indent += 2
+            if block_given?
+              yield
+              close_tag(name)
+            end
+          end
+
+          def add_content(name, content)
+            return if content.nil?
+            case content
+            when Time
+              content = content.iso8601
+            end
+            @output.puts("#{indent}<#{name}>#{h(content)}</#{name}>")
+          end
+
+          def close_tag(name)
+            @indent -= 2
+            @output.puts("#{indent}</#{name}>")
+          end
+
+          def output_test(test)
+            open_tag("test") do
+              add_content("name", test.method_name)
+              add_content("start-time", test.start_time)
+              add_content("elapsed", test.elapsed_time)
+            end
+          end
+
+          def output_test_suite(test_suite)
+            test_case = test_suite.test_case
+            if test_case.nil?
+              open_tag("test-suite") do
+                add_content("name", test_suite.name)
+                add_content("start-time", test_suite.start_time)
+                add_content("elapsed", test_suite.elapsed_time)
+              end
+            else
+              open_tag("test-case") do
+                add_content("name", test_suite.name)
+                add_content("start-time", test_suite.start_time)
+                add_content("elapsed", test_suite.elapsed_time)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end