reportTestUnit 1.0.0

data/README

@@ -0,0 +1,112 @@
+== ReportTestUnit
+
+Version 1.0.0 - 2007-09-14
+
+
+ReportTestUnit is an add on to the Test::Unit package. It leverage's the full support 
+of Test:Unit to write out html based reports of each test case. ReportTestUnit is 
+designed to work with cruisecontrol.rb - but not limited to it.
+
+
+=== Installation
+
+Installed as a gem:
+	gem install reportTestUnit-x.y.z.gem (where x.y.z is the revision number)
+or directly from rubyforge.net
+	gem install reportTestUnit
+
+=== Dependencies
+
+ReportTestUnit is built on top of Test::Unit which is part of the core package of ruby 1.8
+
+
+=== Usage
+
+ReportTestUnit subclasses the Test::Unit package, as such it is used similarly to 
+Test::Unit (Please see the Test::Unit rdoc for information on how to use Test::Unit).
+
+A test suite might look like the following:
+
+ ts_test.rb
+
+ require 'reportUnitTest'
+ require 'test_cases/tc_test1.rb'
+
+ class TS_MyTests
+    def self.suite
+      suite = Test::Unit::TestSuite.new
+      suite << TestTc_test.suite
+     return suite
+    end
+  end
+ Report::TestUnit::UI::Report::TestRunner.run(TS_MyTests, 3) # 3 is verbose
+
+And a test case might look like:
+
+ test_cases/tc_test1.rb
+
+ require 'test/unit'
+
+ # test class is written exactly the same as for Test::Unit only its subclasses Report::TestUnit::TestCase
+ # instead of Test::Unit::TestCase (Report::TestUnit::TestCase is a subclass of Test::Unit:TestCase
+
+ class TestTc_test < Report::TestUnit::TestCase
+   def setup
+     # override default settings if needed
+   end
+
+   def teardown
+     # override default settings if needed
+   end
+
+   def test_get_user_id
+     assert_equal(100, 99+1) # (test cases written exactly the same as for Test::Unit
+   end
+ end
+
+The html report will be dropped in a directory specified by the ENV var UNIT_TEST_REPORT_DIR under this directory an index.html file will be created along with a classes directory populated with html files for each test_case class.
+To integrate with CruiseControl.rb add the following line to your rakefile: 
+ENV['UNIT_TEST_REPORT_DIR']="#{ENV['CC_BUILD_ARTIFACTS']}/unitTestReport"
+
+
+=== Acknowledgements
+
+As this package is built on Test::Unit all the credit must go to those guys for 
+providing excellent opertunities to plug in extra functionality.
+
+=== License
+
+
+
+This program is free software; you can redistribute it and/or
+
+modify it under the terms of the GNU General Public License
+
+as published by the Free Software Foundation; either version 2
+
+of the License, or (at your option) any later version.
+
+
+
+This program is distributed in the hope that it will be useful,
+
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+
+GNU General Public License for more details.
+
+
+
+You should have received a copy of the GNU General Public License
+
+along with this program; if not, write to the Free Software
+
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+
+
+
+  
+
+

data/lib/report/testunit/error.rb

@@ -0,0 +1,21 @@
+require 'test/unit/util/backtracefilter'
+
+module Report
+  module TestUnit
+    class Error < Test::Unit::Error
+      
+      def initialize(test_name, exception)
+        super(test_name, exception)
+      end
+
+      # Returns the first line of the backtrace
+      # (the line that caises the exception)
+      def location_disp
+        location=filter_backtrace(@exception.backtrace)
+        location_display = location[0].sub(/\A(.+:\d+).*/, ' [\\1]')
+        "#{location_display}"
+      end
+    end
+  end
+end
+

data/lib/report/testunit/failure.rb

@@ -0,0 +1,22 @@
+module Report
+  module TestUnit
+    # Encapsulates a test failure. Created by Test::Unit::TestCase
+    # when an assertion fails.
+    class Failure < Test::Unit::Failure
+      def initialize(test_name, location, message)
+        super(test_name, location, message)
+      end
+      # Returns the first line of the backtrace
+      # (the line that caises the exception)
+      def location_disp
+        if "#{location.class}" == "NilClass"
+          "No backtrace"
+        else
+          location_display = location[0].sub(/\A(.+:\d+).*/, ' [\\1]')
+          "#{location_display}"
+        end
+      end
+    end
+  end
+end
+

data/lib/report/testunit/success.rb

@@ -0,0 +1,53 @@
+#--
+#
+# Author:: Nathaniel Talbott.
+# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
+# License:: Ruby license.
+
+require 'test/unit/util/backtracefilter'
+
+module Report
+  module TestUnit
+
+    # Encapsulates a success in a test. Created by
+    # Report::TestUnit::TestCase when no exceptions were thrown
+    # during the processing of a test.
+    class Success
+
+      attr_reader(:test_name, :exception)
+
+      SINGLE_CHARACTER = 'S'
+
+      # Creates a new Success with the given test_name and
+      def initialize(test_name)
+        @test_name = test_name
+      end
+
+      # Returns a single character representation of the status (S).
+      def single_character_display
+        SINGLE_CHARACTER
+      end
+
+      # Returns the message "Successfully passed".
+      def message
+        "Successfully passed"
+      end
+
+      # Returns a brief message "test_name: Success"
+      def short_display
+        "#@test_name: SUCCESS"
+      end
+
+      # Returns a verbose version a success text "Success:
+      # test_name: Successfully passed"
+      def long_display
+        "SUCCESS:\n#@test_name: #{message}"
+      end
+
+      # Overridden to return long_display.
+      def to_s
+        long_display
+      end
+    end
+  end
+end

data/lib/report/testunit/testcase.rb

@@ -0,0 +1,70 @@
+module Report
+  module TestUnit
+
+    # This is a direct subclass of Test::Unit::TestCase, so everthing 
+    # you can do with Test::Unit::TestCase you can do here along with 
+    # getting notified of a successfully passed test. 
+    # Please see the rdoc for Test::Unit::TestCase for more information.
+    class TestCase < Test::Unit::TestCase
+      include Test::Unit::Assertions
+      include Test::Unit::Util::BacktraceFilter
+            
+      def initialize(test_method_name)
+        super(test_method_name)
+      end
+      
+      # Runs the individual test method represented by this instance of the
+      # fixture, collecting statistics, failures and errors in result.
+      def run(result)
+        yield(STARTED, name)
+        @_result = result
+        test_success=true
+        begin
+          setup
+          __send__(@method_name)
+        rescue Test::Unit::AssertionFailedError => e
+          test_success=false
+          add_failure(e.message, e.backtrace)
+        rescue Exception
+          test_success=false
+          raise if PASSTHROUGH_EXCEPTIONS.include? $!.class
+          add_error($!)
+        ensure
+          begin
+            teardown
+          rescue Test::Unit::AssertionFailedError => e
+            add_failure(e.message, e.backtrace)
+          rescue Exception
+            raise if PASSTHROUGH_EXCEPTIONS.include? $!.class
+            add_error($!)
+          end
+        end
+        if test_success
+          add_success()
+        else
+           test_success=true
+        end
+        result.add_run
+        yield(FINISHED, name)
+      end
+      def add_success()
+        @_result.add_success(Success.new(name))
+      end
+      private :add_success
+      
+      def add_error(exception)
+        @test_passed = false
+        @_result.add_error(Report::TestUnit::Error.new(name, exception))
+      end
+      private :add_error
+
+      def add_failure(message, all_locations=caller())
+        @test_passed = false
+        @_result.add_failure(Report::TestUnit::Failure.new(name, filter_backtrace(all_locations), message))
+      end
+      private :add_failure
+
+    end
+  end
+end
+

data/lib/report/testunit/testresult.rb

@@ -0,0 +1,27 @@
+require 'test/unit/util/observable'
+require 'test/unit/testresult'
+module Report
+  module TestUnit
+
+    # Collects Report::TestUnit::Failure, Report::TestUnit::Error
+    # and Report::TestUnit::Success so that they can be displayed
+    # to the user. To this end, observers can be added to it,
+    # allowing the dynamic updating of, say, a UI.
+    class TestResult < Test::Unit::TestResult
+     
+      SUCCESS = "SUCCESS"
+      # Constructs a new, empty TestResult.
+      def initialize
+        super
+        @success = Array.new
+      end
+
+      # Records a Report::TestUnit::Success.
+      def add_success(success)
+        @success << success
+        notify_listeners(SUCCESS, success)
+      end
+    end
+  end
+end
+

data/lib/report/testunit/ui/report/testrunner.rb

@@ -0,0 +1,358 @@
+require 'test/unit/ui/testrunnermediator'
+require 'test/unit/ui/testrunnerutilities'
+
+module Report
+  module TestUnit
+    module UI
+      module Report
+
+        # Runs a Test::Unit::TestSuite on the console.
+        class TestRunner
+          extend Test::Unit::UI::TestRunnerUtilities
+          # because we're using a different namespace - re-declare these here
+          SILENT = 0
+          PROGRESS_ONLY = 1
+          NORMAL = 2
+          VERBOSE = 3
+
+          # 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
+          # failures, and the final result. io specifies
+          # where runner output should go to; defaults to
+          # STDOUT.
+          # The html report will be dropped in a directory 
+          # specified by the ENV var UNIT_TEST_REPORT_DIR
+          # under this directory an index.html file will be
+          # created along with a classes directory populated
+          # with html files for each test_case class.
+          def initialize(suite, output_level=NORMAL, io=STDOUT)
+            @coverage_report_dir_stub=ENV['UNIT_TEST_REPORT_DIR'] || "/tmp"
+            if (suite.respond_to?(:suite))
+              @suite = suite.suite
+            else
+              @suite = suite
+            end
+            @output_level = output_level
+            @io = io
+            @reportio=File.open("#{@coverage_report_dir_stub}/index.html", "w")
+            @already_outputted = false
+            @faults = []
+            @classHash=Hash.new
+          end
+
+          def setup_html_page
+            html_text = <<-EOT
+              <HTML>
+              <HEAD>
+              <TITLE>Unit test results</TITLE>
+                      <STYLE TYPE="text/css">
+                      <!--
+                              @page { size: 8.5in 11in; margin: 0.79in }
+                              P { margin-bottom: 0.08in }
+                              TD P { margin-bottom: 0in }
+                      -->
+                      </STYLE>
+              </HEAD>
+              <BODY LANG="en-GB" DIR="LTR">
+              <P><BR><h2>Unit test results for date #{Time.now}</h2><BR></P>
+              <TABLE WIDTH=100% BORDER=1 BORDERCOLOR="#000000" CELLPADDING=4 CELLSPACING=0>
+                      <COL WIDTH=80*>
+                      <COL WIDTH=78*>
+                      <COL WIDTH=49*>
+                      <COL WIDTH=48*>
+              <TR VALIGN=TOP>
+              <TD WIDTH=60%>
+                  <P ALIGN=CENTER>CLASS NAME</P>
+              </TD>
+              <TD WIDTH=10%>
+                  <P ALIGN=CENTER>Tests</P>
+              </TD>
+              <TD WIDTH=10%>
+                   <P ALIGN=CENTER>Errors</P>
+              </TD>
+              <TD WIDTH=10%>
+                   <P ALIGN=CENTER>Failures</P>
+              </TD>
+              <TD WIDTH=10%>
+                   <P ALIGN=CENTER>Success</P>
+              </TD>
+              </TR>
+            EOT
+            output_report(@reportio, html_text)
+          end
+          
+          def setup_class_page(class_name)
+            if @classHash[class_name]["fh"] == nil
+              if !(Dir.entries(@coverage_report_dir_stub).include?("classes"))
+                Dir.mkdir("#{@coverage_report_dir_stub}/classes")
+              end
+              @classHash[class_name]["fh"]=File.open("#{@coverage_report_dir_stub}/classes/#{class_name}.html", "w")
+            end
+            html_text = <<-EOT
+              <HTML>
+              <HEAD>
+              <TITLE>Unit test results</TITLE>
+                      <STYLE TYPE="text/css">
+                      <!--
+                              @page { size: 8.5in 11in; margin: 0.79in }
+                              P { margin-bottom: 0.08in }
+                              TD P { margin-bottom: 0in }
+                      -->
+                      </STYLE>
+              </HEAD>
+              <BODY LANG="en-GB" DIR="LTR">
+              <P><BR><h2>Unit test results for date #{Time.now}</h2><BR></P>
+              <P><h3>Class: #{class_name}</h3></P>
+              <TABLE WIDTH=100% BORDER=1 BORDERCOLOR="#000000" CELLPADDING=4 CELLSPACING=0>
+                      <COL WIDTH=80*>
+                      <COL WIDTH=78*>
+                      <COL WIDTH=49*>
+                      <COL WIDTH=48*>
+              <TR VALIGN=TOP>
+              <TD WIDTH=21%>
+                  <P ALIGN=CENTER>METHOD NAME</P>
+              </TD>
+              <TD WIDTH=5%>
+                   <P ALIGN=CENTER>STATUS</P>
+              </TD>
+              <TD WIDTH=23%>
+                   <P ALIGN=CENTER>FAULT LOCATION</P>
+              </TD>
+              <TD WIDTH=51%>
+                   <P ALIGN=CENTER>FAULT MESSAGE</P>
+              </TD>
+              </TR>
+            EOT
+            output_report(@classHash[class_name]["fh"], html_text)
+          end
+          
+          def close_class_page(class_name)
+            html_text = <<-EOT
+              </TABLE>
+              <P STYLE="margin-bottom: 0in"><BR>
+              </P>
+              </BODY>
+              </HTML>
+            EOT
+            output_report(@classHash[class_name]["fh"], html_text)
+          end
+
+          def finish_html
+            html_text = <<-EOT
+              <P STYLE="margin-bottom: 0in"><BR>
+              </P>
+              </BODY>
+              </HTML>
+            EOT
+            output_report(@reportio, html_text)
+          end
+
+          # Begins the test run.
+          def start
+            setup_mediator
+            attach_to_mediator
+            return start_mediator
+          end
+
+          private
+          def setup_mediator
+            @mediator = create_mediator(@suite)
+            suite_name = @suite.to_s
+            if ( @suite.kind_of?(Module) )
+              suite_name = @suite.name
+            end
+            output("Loaded suite #{suite_name}")
+          end
+          
+          def create_mediator(suite)
+            return UI::TestRunnerMediator.new(suite)
+          end
+          
+          def attach_to_mediator
+            @mediator.add_listener(TestResult::FAULT, &method(:add_fault))
+            @mediator.add_listener(TestResult::SUCCESS, &method(:add_success))
+            @mediator.add_listener(UI::TestRunnerMediator::STARTED, &method(:started))
+            @mediator.add_listener(UI::TestRunnerMediator::FINISHED, &method(:finished))
+            @mediator.add_listener(TestCase::STARTED, &method(:test_started))
+            @mediator.add_listener(TestCase::FINISHED, &method(:test_finished))
+          end
+
+
+          def add_success(result)
+            format_table(result.test_name, "Success", ".", ".")
+          end
+   
+          def start_mediator
+            return @mediator.run_suite
+          end
+
+          def format_table(name, status, location, message)
+            names=name.split("\(")
+            method_name=names[0]
+            class_name=names[1].chop
+            case status
+            when "Success"
+              colour="#000000"
+            when "Failure"
+              colour="#ff3366"
+            when "Error"
+              colour="#ff3366"
+            end
+            html_text = <<-EOT
+              <TR VALIGN=TOP>
+              <TD WIDTH=21%>
+                   <P><FONT SIZE=2 COLOR=\"#{colour}\">#{method_name}</FONT></P>
+              </TD>
+              <TD WIDTH=5%>
+                  <P><FONT COLOR=\"#{colour}\">#{status}</FONT></P>
+              </TD>
+              <TD WIDTH=23%>
+                  <P><FONT SIZE=2 COLOR=\"#{colour}\">#{location}</FONT></P>
+              </TD>
+              <TD WIDTH=41%>
+                  <P><FONT SIZE=2 COLOR=\"#{colour}\">#{message}</FONT></P>
+              </TD>
+              </TR>
+            EOT
+            increment_stats(name, status, html_text)
+          end
+          
+          def output_summary(fh, class_name, total, error, failures, success)
+            if (failures > 0 || error > 0)
+              colour="#ff3366"
+            else
+              colour="#000000"
+            end
+            html_text = <<-EOT
+              <TR VALIGN=TOP>
+              <TD WIDTH=60%>
+                  <P><FONT SIZE=2 COLOR=\"#{colour}\">#{class_name}</FONT></P>
+              </TD>
+              <TD WIDTH=10%>
+                   <P><FONT SIZE=2 COLOR=\"#{colour}\">#{total}</FONT></P>
+              </TD>
+              <TD WIDTH=10%>
+                  <P><FONT SIZE=2 COLOR=\"#{colour}\">#{error}</FONT></P>
+              </TD>
+              <TD WIDTH=10%>
+                  <P><FONT SIZE=2 COLOR=\"#{colour}\">#{failures}</FONT></P>
+              </TD>
+              <TD WIDTH=10%>
+                  <P><FONT SIZE=2 COLOR=\"#{colour}\">#{success}</FONT></P>
+              </TD>
+              </TR>
+            EOT
+            output_report(fh, html_text)
+          end
+          
+          def initialize_hash(class_name)
+            @classHash[class_name]={"total"   => 0,
+                                    "success" => 0,
+                                    "failure" => 0,
+                                    "error"   => 0,
+                                    "message" => [],
+                                    "fh"     => nil
+            }
+          end
+          def increment_stats(name, status, text)
+            names=name.split("\(")
+            method_name=names[0]
+            class_name=names[1].chop
+            if @classHash[class_name] == nil
+              # first time meeting this class
+              initialize_hash(class_name)
+            end
+            @classHash[class_name]["total"]+=1
+            case status
+            when "Success"
+              @classHash[class_name]["success"]+=1
+              @classHash[class_name]["message"].push(text)
+            when "Error"
+              @classHash[class_name]["error"]+=1
+              @classHash[class_name]["message"].push(text)
+            when "Failure"
+              @classHash[class_name]["failure"]+=1
+              @classHash[class_name]["message"].push(text)
+            else
+              output("invalid status #{status} for #{class_name}, #{method_name}")
+            end
+          end
+          
+          def add_fault(fault)
+            @faults << fault
+            if fault.single_character_display == "F"
+              format_table(fault.test_name, "Failure", fault.location_disp, fault.message)
+            elsif fault.single_character_display == "E"
+              format_table(fault.test_name, "Error", fault.location_disp, fault.message.gsub(/([<>])/, '_'))
+            end
+            output_single("name = #{fault.test_name}\nscd = #{fault.single_character_display}\nmessage = #{fault.message}\nlong_display = #{fault.long_display}\nshort_display = #{fault.short_display}\n", PROGRESS_ONLY)
+            @already_outputted = true
+          end
+          
+          def started(result)
+            @result = result
+            output("Started")
+          end
+          
+          def finished(elapsed_time)
+            nl
+            output("Finished in #{elapsed_time} seconds.")
+            @faults.each_with_index do |fault, index|
+              nl
+              output("%3d) %s" % [index + 1, fault.long_display])
+            end
+            nl
+            output(@result)
+            setup_html_page
+            @classHash.each do |class_name, attributes|
+              output_summary(@reportio, "<A HREF=\"./classes/#{class_name}.html\">#{class_name}</A>", attributes["total"], attributes["error"], attributes["failure"], attributes["success"])
+              setup_class_page(class_name)
+              attributes["message"].each do |record|
+                output_report(attributes["fh"], record)
+              end
+              close_class_page(class_name)
+            end
+            output_report(@reportio, "</TABLE>")
+            output_report(@reportio, "<p>#{@result}<\p>")
+            output_report(@reportio, "<p>Total time taken for all tests is #{elapsed_time}<\p>")
+            finish_html
+          end
+          
+          def test_started(name)
+            output_single(name + ": ", VERBOSE)
+          end
+          
+          def test_finished(name)
+            output_single(name + "finished.", PROGRESS_ONLY) unless (@already_outputted)
+            nl(VERBOSE)
+            @already_outputted = false
+          end
+          
+          def nl(level=NORMAL)
+            output("", level)
+          end
+
+          def output_report(fh, something)
+            fh.puts(something)
+            fh.flush
+          end
+          
+          def output(something, level=NORMAL)
+            @io.puts(something) if (output?(level))
+            @io.flush
+          end
+          
+          def output_single(something, level=NORMAL)
+            @io.write(something) if (output?(level))
+            @io.flush
+          end
+          
+          def output?(level)
+            level <= @output_level
+          end
+        end
+      end
+    end
+  end
+end

data/lib/report/testunit/ui/testrunnermediator.rb

@@ -0,0 +1,53 @@
+require 'test/unit'
+require 'test/unit/util/observable'
+require 'test/unit/testresult'
+
+module Report
+  module TestUnit
+    module UI
+      # Subclass of Test::Unit::UI::TestRunnerMediator
+      # to override the run_suite to add an extra listener for a
+      # SUCCESS result
+      class TestRunnerMediator < Test::Unit::UI::TestRunnerMediator
+        def initialize(suite)
+          super(suite)        
+        end
+        
+        def run_suite
+          Test::Unit.run = true
+          begin_time = Time.now
+          notify_listeners(UI::TestRunnerMediator::RESET, @suite.size)
+          result = create_result
+          notify_listeners(UI::TestRunnerMediator::STARTED, result)
+          result_listener = result.add_listener(TestResult::CHANGED) do |updated_result|
+            notify_listeners(TestResult::CHANGED, updated_result)
+          end
+
+          fault_listener = result.add_listener(TestResult::FAULT) do |fault|
+            notify_listeners(TestResult::FAULT, fault)
+          end
+
+          success_listener = result.add_listener(TestResult::SUCCESS) do |success|
+            notify_listeners(TestResult::SUCCESS, success)
+          end
+
+
+          @suite.run(result) do |channel, value|
+            notify_listeners(channel, value)
+          end
+
+          result.remove_listener(TestResult::FAULT, fault_listener)
+          result.remove_listener(TestResult::CHANGED, result_listener)
+          end_time = Time.now
+          elapsed_time = end_time - begin_time
+          notify_listeners(UI::TestRunnerMediator::FINISHED, elapsed_time) #"Finished in #{elapsed_time} seconds.")
+          return result
+        end
+        def create_result
+          return TestResult.new
+        end
+      end
+    end
+  end
+end
+

data/lib/reportTestUnit.rb

@@ -0,0 +1,10 @@
+require 'test/unit'
+require 'report/testunit/ui/report/testrunner'
+require 'report/testunit/testcase'
+require 'report/testunit/ui/testrunnermediator'
+require 'report/testunit/testresult'
+require 'report/testunit/success'
+require 'report/testunit/failure'
+require 'report/testunit/error'
+
+

data/test/report/testunit/tc_error.rb

@@ -0,0 +1,27 @@
+# tc_error.rb
+# September 18, 2007
+#
+
+
+class TestTc_error < Test::Unit::TestCase
+ 
+  def a
+    raise "boom"
+  end
+ 
+  def b
+    a()
+  end
+
+  def test_location_disp
+    errorTest=Report::TestUnit::Error.new("TestError", Exception.new("testError"))
+    assert_equal("No backtrace", errorTest.location_disp())
+    begin
+      b()
+    rescue => detail
+      errorTest=Report::TestUnit::Error.new("TestError", detail)
+    end
+    assert_match(/.*\/testunit\/tc_error.rb:9\]/, errorTest.location_disp())
+  end
+
+end

data/test/report/testunit/tc_failure.rb

@@ -0,0 +1,28 @@
+# tc_error.rb
+# September 18, 2007
+#
+
+
+class TestTc_failure < Test::Unit::TestCase
+ 
+  def a
+    raise "boom"
+  end
+ 
+  def b
+    a()
+  end
+
+  def test_location_disp
+    e=Exception.new("testFailure")
+    failureTest=Report::TestUnit::Failure.new("TestFailure", e.backtrace(), "testFailure")
+    assert_equal("No backtrace", failureTest.location_disp())
+    begin
+      b()
+    rescue => detail
+      errorTest=Report::TestUnit::Failure.new("TestFailure", detail.backtrace(), detail.message())
+    end
+    assert_match(/.*\/testunit\/tc_failure.rb:9\]/, errorTest.location_disp())
+  end
+
+end

data/test/report/testunit/tc_success.rb

@@ -0,0 +1,33 @@
+# tc_success.rb
+# September 18, 2007
+#
+
+
+class TestTc_success < Test::Unit::TestCase
+  def setup
+    @testSuccess=Report::TestUnit::Success.new("testSuccess")
+  end
+
+  def teardown
+    @testSuccess=nil
+  end
+
+  def test_constant
+    assert_equal("S", Report::TestUnit::Success::SINGLE_CHARACTER)
+    assert_equal("S", @testSuccess.single_character_display())
+  end
+  
+  def test_message
+    assert_equal("Successfully passed", @testSuccess.message())
+  end
+  
+  def test_short_display
+    assert_equal("testSuccess: SUCCESS", @testSuccess.short_display())
+  end
+  
+  def test_long_display
+    assert_equal("SUCCESS:\ntestSuccess: Successfully passed", @testSuccess.long_display())
+    assert_equal("SUCCESS:\ntestSuccess: Successfully passed", @testSuccess.to_s())
+  end
+  
+end

data/test/report/testunit/tc_testcase.rb

@@ -0,0 +1,164 @@
+# tc_testcase.rb
+# September 18, 2007
+#
+
+
+class TestTc_testcase < Test::Unit::TestCase
+
+  def test_success
+    rd, wr = IO.pipe
+    TESTCASES::TestRunner.run(TESTCASES::TS_MyTestSuite1, 3, wr)
+    wr.close
+    result = rd.read
+    rd.close
+    assert_equal("test_success1(TESTCASES::TestTc_testCase1), Success, ., .\n", result)
+  end
+  
+  def test_failure
+    rd, wr = IO.pipe
+    TESTCASES::TestRunner.run(TESTCASES::TS_MyTestSuite2, 3, wr)
+    wr.close
+    result = rd.read
+    rd.close
+    assert_equal("test_failure2(TESTCASES::TestTc_testCase2), Failure\n", result)
+  end
+
+  def test_error
+    rd, wr = IO.pipe
+    TESTCASES::TestRunner.run(TESTCASES::TS_MyTestSuite3, 3, wr)
+    wr.close
+    result = rd.read
+    rd.close
+    assert_equal("test_error3(TESTCASES::TestTc_testCase3), Error\n", result)
+  end   
+  
+end
+
+module TESTCASES
+  class TestTc_testCase1 < Report::TestUnit::TestCase
+    def test_success1
+      assert_equal(1, 1)
+    end
+
+  end
+
+  class TS_MyTestSuite1
+     def self.suite
+       suite = Test::Unit::TestSuite.new
+       suite << TestTc_testCase1.suite
+       return suite
+     end
+   end
+   
+  class TestTc_testCase2 < Report::TestUnit::TestCase
+    def test_failure2
+      assert_equal(1, 2)
+    end
+
+  end
+
+  class TS_MyTestSuite2
+     def self.suite
+       suite = Test::Unit::TestSuite.new
+       suite << TestTc_testCase2.suite
+       return suite
+     end
+   end
+   
+  class TestTc_testCase3 < Report::TestUnit::TestCase
+    def test_error3
+      assert_equal(1)
+    end
+
+  end
+
+  class TS_MyTestSuite3
+     def self.suite
+       suite = Test::Unit::TestSuite.new
+       suite << TestTc_testCase3.suite
+       return suite
+     end
+   end
+
+   
+  class TestRunner
+    extend Test::Unit::UI::TestRunnerUtilities
+    def self.run(suite, output_level=NORMAL, io=STDOUT)
+      return new(suite, output_level, io).start
+    end
+
+    SILENT = 0
+    PROGRESS_ONLY = 1
+    NORMAL = 2
+    VERBOSE = 3
+
+    def initialize(suite, output_level=NORMAL, io=STDOUT)
+      if (suite.respond_to?(:suite))
+        @suite = suite.suite
+      else
+        @suite = suite
+      end
+      @already_outputted = false
+      @faults = []
+      @io=io
+    end
+    
+    def start
+      setup_mediator
+      attach_to_mediator
+      return start_mediator
+    end
+
+    private
+    def setup_mediator
+      @mediator = create_mediator(@suite)
+      suite_name = @suite.to_s
+      if ( @suite.kind_of?(Module) )
+        suite_name = @suite.name
+      end
+    end
+
+    def create_mediator(suite)
+      return Report::TestUnit::UI::TestRunnerMediator.new(suite)
+    end
+
+    def attach_to_mediator
+      @mediator.add_listener(Report::TestUnit::TestResult::FAULT, &method(:add_fault))
+      @mediator.add_listener(Report::TestUnit::TestResult::SUCCESS, &method(:add_success))
+      @mediator.add_listener(Report::TestUnit::UI::TestRunnerMediator::STARTED, &method(:started))
+      @mediator.add_listener(Report::TestUnit::UI::TestRunnerMediator::FINISHED, &method(:finished))
+      @mediator.add_listener(Report::TestUnit::TestCase::STARTED, &method(:test_started))
+      @mediator.add_listener(Report::TestUnit::TestCase::FINISHED, &method(:test_finished))
+    end
+
+    def add_success(result)
+      @io.puts "#{result.test_name}, Success, ., ."
+    end
+
+    def start_mediator
+      return @mediator.run_suite
+    end
+    
+    def add_fault(fault)
+      if fault.single_character_display == "F"
+        @io.puts "#{fault.test_name}, Failure"
+      elsif fault.single_character_display == "E"
+        @io.puts "#{fault.test_name}, Error"
+      end
+    end
+
+    def started(result)
+      @result = result
+    end
+
+    def finished(elapsed_time)
+    end
+
+    def test_started(name)
+    end
+
+    def test_finished(name)
+      @already_outputted = false
+    end
+   end
+end

data/test/report/testunit/tc_testresult.rb

@@ -0,0 +1,16 @@
+# tc_testresukt.rb
+# September 18, 2007
+#
+
+
+class TestTc_testresult < Test::Unit::TestCase
+  
+  def test_constant
+    assert_equal("SUCCESS", Report::TestUnit::TestResult::SUCCESS) 
+  end
+  def test_add_success()
+    testResult=Report::TestUnit::TestResult.new()
+    assert_nothing_raised {testResult.add_success(Report::TestUnit::Success.new("testReport"))}
+  end
+  
+end

data/test/report/testunit/ui/report/tc_testrunner.rb

@@ -0,0 +1,55 @@
+# tc_testrunner.rb
+# September 19, 2007
+#
+
+
+class TestTc_testrunner < Test::Unit::TestCase
+
+  def test_constants
+    assert_equal(0, Report::TestUnit::UI::Report::TestRunner::SILENT)
+    assert_equal(1, Report::TestUnit::UI::Report::TestRunner::PROGRESS_ONLY)
+    assert_equal(2, Report::TestUnit::UI::Report::TestRunner::NORMAL)
+    assert_equal(3, Report::TestUnit::UI::Report::TestRunner::VERBOSE)
+  end
+  
+  def test_rest
+    Report::TestUnit::UI::Report::TestRunner.run(TESTCASES::TS_MyTestSuite4, 3)
+    assert_equal(true, FileTest::exists?("#{ENV['UNIT_TEST_REPORT_DIR']}/index.html"))
+    index=File.open("#{ENV['UNIT_TEST_REPORT_DIR']}/index.html", "r")
+    indexdata=index.read()
+    assert_equal(0, indexdata =~ /.*TESTCASES\:\:TestTc_testCase4\.html.*>3<.*>1<.*>1<.*>1<.*>3 tests\, 2 assertions\, 1 failures\, 1 errors<.*/m)
+    
+    assert_equal(true, FileTest::exists?("#{ENV['UNIT_TEST_REPORT_DIR']}/classes/TESTCASES::TestTc_testCase4.html"))
+    index=File.open("#{ENV['UNIT_TEST_REPORT_DIR']}/classes/TESTCASES::TestTc_testCase4.html", "r")
+    indexdata=index.read()
+    assert_equal(0, indexdata =~ /.*>test_error4<.*>Error<.*>test_failure4<.*>Failure<.*>test_success4<.*>Success<.*/m)
+  end
+  
+  
+end
+
+
+module TESTCASES
+  class TestTc_testCase4 < Report::TestUnit::TestCase
+    def test_success4
+      assert_equal(1, 1)
+    end
+    
+    def test_error4
+      assert_equal(1)
+    end
+
+    def test_failure4
+      assert_equal(1,2)
+    end
+  end
+
+  class TS_MyTestSuite4
+    def self.suite
+      suite = Test::Unit::TestSuite.new
+      suite << TestTc_testCase4.suite
+      return suite
+    end
+  end
+end 
+  

data/test/report/testunit/ui/tc_test.rb

@@ -0,0 +1,31 @@
+# tc_test.rb
+# September 19, 2007
+#
+
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/unit'
+
+class TestTc_test < Test::Unit::TestCase
+#  def setup
+#  end
+#
+#  def teardown
+#  end
+
+  def test_fail
+    assert(false, 'Assertion was false.')
+  end
+   
+  def test_foo
+    # assert_equal("foo", bar)
+
+    # assert, assert_block, assert_equal, assert_in_delta, assert_instance_of,
+    # assert_kind_of, assert_match, assert_nil, assert_no_match, assert_not_equal,
+    # assert_not_nil, assert_not_same, assert_nothing_raised, assert_nothing_thrown,
+    # assert_operator, assert_raise, assert_raises, assert_respond_to, assert_same,
+    # assert_send, assert_throws
+
+    flunk "TODO: Write test"
+  end
+end

data/test/report/ts_reportTestUnit.rb

@@ -0,0 +1,34 @@
+# ts_reportTestUnit.rb
+# September 18, 2007
+#
+
+require 'rubygems'
+require 'reportTestUnit'
+require 'test/unit/ui/console/testrunner'
+
+require 'testunit/tc_testcase'
+require 'testunit/tc_success'
+require 'testunit/tc_failure'
+require 'testunit/tc_error'
+require 'testunit/tc_testresult'
+require 'testunit/ui/report/tc_testrunner'
+
+
+ENV['UNIT_TEST_REPORT_DIR']="/tmp"
+
+
+class TS_MyTests
+   def self.suite
+     suite = Test::Unit::TestSuite.new("testcases")
+     suite << TestTc_testcase.suite
+     suite << TestTc_testrunner.suite
+     suite << TestTc_testresult.suite
+     suite << TestTc_success.suite
+     suite << TestTc_failure.suite
+     suite << TestTc_error.suite
+     return suite
+   end
+ end
+
+Test::Unit::UI::Console::TestRunner.run(TS_MyTests, 3)
+

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: reportTestUnit
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+date: 2007-09-19 00:00:00 +01:00
+summary: An Extension to the Test::Unit platform to produce html reports
+require_paths: 
+- lib
+email: erobson@tssg.org
+homepage: http://tssgrb.rubyforge.org/
+rubyforge_project: 
+description: 
+autorequire: reportTestUnit
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Eric Robson
+files: 
+- lib/report
+- lib/reportTestUnit.rb
+- lib/report/testunit
+- lib/report/testunit/error.rb
+- lib/report/testunit/failure.rb
+- lib/report/testunit/success.rb
+- lib/report/testunit/testcase.rb
+- lib/report/testunit/testresult.rb
+- lib/report/testunit/ui
+- lib/report/testunit/ui/report
+- lib/report/testunit/ui/testrunnermediator.rb
+- lib/report/testunit/ui/report/testrunner.rb
+- test/report
+- test/report/testunit
+- test/report/ts_reportTestUnit.rb
+- test/report/testunit/tc_error.rb
+- test/report/testunit/tc_failure.rb
+- test/report/testunit/tc_success.rb
+- test/report/testunit/tc_testcase.rb
+- test/report/testunit/tc_testresult.rb
+- test/report/testunit/ui
+- test/report/testunit/ui/report
+- test/report/testunit/ui/tc_test.rb
+- test/report/testunit/ui/report/tc_testrunner.rb
+- README
+test_files: 
+- test/report/ts_reportTestUnit.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+