ci_reporter 1.0 → 1.6.5

data/lib/ci/reporter/rake/utils.rb

@@ -0,0 +1,14 @@
+# Copyright (c) 2006-2010 Nick Sieger <nicksieger@gmail.com>
+# See the file LICENSE.txt included with the distribution for
+# software license details.
+
+module CI
+  module Reporter
+    def self.maybe_quote_filename(fn)
+      if fn =~ /\s/
+        fn = %{"#{fn}"}
+      end
+      fn
+    end
+  end
+end

data/lib/ci/reporter/report_manager.rb

@@ -1,3 +1,7 @@
+# Copyright (c) 2006-2010 Nick Sieger <nicksieger@gmail.com>
+# See the file LICENSE.txt included with the distribution for
+# software license details.
+
 require 'fileutils'
 
 module CI #:nodoc:
@@ -10,10 +14,44 @@ module CI #:nodoc:
       end
       
       def write_report(suite)
-        File.open("#{@basename}-#{suite.name.gsub(/[^a-zA-Z0-9]+/, '-')}.xml", "w") do |f|
+        File.open(filename_for(suite), "w") do |f|
           f << suite.to_xml
         end
       end
+      
+    private
+    
+
+      # creates a uniqe filename per suite
+      # to prevent results from being overwritten
+      # if a result file is already written, it appends an index
+      # e.g.
+      #   SPEC-MailsController.xml
+      #   SPEC-MailsController.0.xml
+      #   SPEC-MailsController.1.xml
+      #   SPEC-MailsController...xml
+      #   SPEC-MailsController.N.xml
+      #
+      # with N < 100000, to prevent endless sidestep loops
+      MAX_SIDESTEPS = 100000
+      #
+      def filename_for(suite)
+        basename = "#{@basename}-#{suite.name.gsub(/[^a-zA-Z0-9]+/, '-')}"
+        suffix = "xml"
+        
+        # the initial filename, e.g. SPEC-MailsController.xml
+        filename = [basename, suffix].join(".")
+        
+        # if the initial filename is already in use
+        # do sidesteps, beginning with SPEC-MailsController.0.xml
+        i = 0
+        while File.exists?(filename) && i < MAX_SIDESTEPS
+          filename = [basename, i, suffix].join(".")
+          i += 1
+        end
+        
+        filename
+      end
     end
   end
-end
+end

data/lib/ci/reporter/rspec.rb

@@ -1,13 +1,38 @@
+# Copyright (c) 2006-2010 Nick Sieger <nicksieger@gmail.com>
+# See the file LICENSE.txt included with the distribution for
+# software license details.
+
 require 'ci/reporter/core'
-gem 'rspec'
-require 'spec'
 
 module CI
   module Reporter
+    module RSpecFormatters
+      begin
+        require 'rspec/core/formatters/base_formatter'
+        require 'rspec/core/formatters/progress_formatter'
+        require 'rspec/core/formatters/documentation_formatter'
+        BaseFormatter = ::RSpec::Core::Formatters::BaseFormatter
+        ProgressFormatter = ::RSpec::Core::Formatters::ProgressFormatter
+        DocFormatter = ::RSpec::Core::Formatters::DocumentationFormatter
+      rescue LoadError => first_error
+        begin
+          require 'spec/runner/formatter/progress_bar_formatter'
+          require 'spec/runner/formatter/specdoc_formatter'
+          BaseFormatter = ::Spec::Runner::Formatter::BaseFormatter
+          ProgressFormatter = ::Spec::Runner::Formatter::ProgressBarFormatter
+          DocFormatter = ::Spec::Runner::Formatter::SpecdocFormatter
+        rescue LoadError
+          raise first_error
+        end
+      end
+    end
+
     # Wrapper around a <code>RSpec</code> error or failure to be used by the test suite to interpret results.
     class RSpecFailure
+      attr_reader :exception
       def initialize(failure)
         @failure = failure
+        @exception = failure.exception
       end
 
       def failure?
@@ -15,71 +40,170 @@ module CI
       end
 
       def error?
-        !@failure.expectation_not_met?
+        !failure?
+      end
+
+      def name() exception.class.name end
+      def message() exception.message end
+      def location() (exception.backtrace || ["No backtrace available"]).join("\n") end
+    end
+
+    class RSpec2Failure < RSpecFailure
+      def initialize(example, formatter)
+        @formatter = formatter
+        @example = example
+        @exception = @example.execution_result[:exception] || @example.execution_result[:exception_encountered]
+      end
+
+      def failure?
+        exception.is_a?(::RSpec::Expectations::ExpectationNotMetError)
       end
 
-      def name() @failure.exception.class.name end
-      def message() @failure.exception.message end
-      def location() @failure.exception.backtrace.join("\n") end
+      def location() 
+        output = []
+        output.push "#{exception.class.name << ":"}" unless exception.class.name =~ /RSpec/
+        output.push @exception.message
+
+        @formatter.format_backtrace(@exception.backtrace, @example).each do |backtrace_info|
+          output.push "     #{backtrace_info}"
+        end
+        output.join "\n"
+      end
     end
 
     # Custom +RSpec+ formatter used to hook into the spec runs and capture results.
-    class RSpec < Spec::Runner::Formatter::ProgressBarFormatter
-      def initialize(output, dry_run=false, colour=false, report_mgr=nil)
-        super(output, dry_run, colour)
-        @report_manager = report_mgr || ReportManager.new("spec")
+    class RSpec < RSpecFormatters::BaseFormatter
+      attr_accessor :report_manager
+      attr_accessor :formatter
+      def initialize(*args)
+        super
+        @formatter ||= RSpecFormatters::ProgressFormatter.new(*args)
+        @report_manager = ReportManager.new("spec")
         @suite = nil
       end
 
       def start(spec_count)
-        super
+        @formatter.start(spec_count)
       end
 
-      def add_context(name, first)
-        super
-        write_report if @suite
-        @suite = TestSuite.new name
-        @suite.start
+      # rspec 0.9
+      def add_behaviour(name)
+        @formatter.add_behaviour(name)
+        new_suite(name)
       end
 
-      def spec_started(name)
-        super
-        spec = TestCase.new name
+      # Compatibility with rspec < 1.2.4
+      def add_example_group(example_group)
+        @formatter.add_example_group(example_group)
+        new_suite(description_for(example_group))
+      end
+
+      # rspec >= 1.2.4
+      def example_group_started(example_group)
+        @formatter.example_group_started(example_group)
+        new_suite(description_for(example_group))
+      end
+      
+      def example_group_finished(example_group)
+        @formatter.example_group_finished(example_group)
+      end
+
+      def example_started(name_or_example)
+        @formatter.example_started(name_or_example)
+        spec = TestCase.new
         @suite.testcases << spec
         spec.start
       end
 
-      def spec_failed(name, counter, failure)
-        super
+      def example_failed(name_or_example, *rest)
+        @formatter.example_failed(name_or_example, *rest)
+
+        # In case we fail in before(:all)
+        example_started(name_or_example) if @suite.testcases.empty?
+
+        if name_or_example.respond_to?(:execution_result) # RSpec 2
+          failure = RSpec2Failure.new(name_or_example, @formatter)
+        else
+          failure = RSpecFailure.new(rest[1]) # example_failed(name, counter, failure) in RSpec 1
+        end
+
         spec = @suite.testcases.last
         spec.finish
-        spec.failure = RSpecFailure.new(failure)
+        spec.name = description_for(name_or_example)
+        spec.failures << failure
       end
 
-      def spec_passed(name)
-        super
+      def example_passed(name_or_example)
+        @formatter.example_passed(name_or_example)
+        spec = @suite.testcases.last
+        spec.finish
+        spec.name = description_for(name_or_example)
+      end
+
+      def example_pending(*args)
+        @formatter.example_pending(*args)
+        name = description_for(args[0])
         spec = @suite.testcases.last
         spec.finish
+        spec.name = "#{name} (PENDING)"
+        spec.skipped = true
       end
 
       def start_dump
-        super
+        @formatter.start_dump
       end
 
-      def dump_failure(counter, failure)
-        super
+      def dump_failures(*args)
+        @formatter.dump_failures(*args)
       end
 
-      def dump_summary(duration, spec_count, failure_count)
-        super
+      def dump_failure(*args)
+        @formatter.dump_failure(*args)
+      end
+
+      def dump_summary(*args)
+        @formatter.dump_summary(*args)
         write_report
       end
 
+      def dump_pending
+        @formatter.dump_pending
+      end
+
+      def close
+        @formatter.close
+      end
+
       private
+      def description_for(name_or_example)
+        if name_or_example.respond_to?(:full_description)
+          name_or_example.full_description
+        elsif name_or_example.respond_to?(:metadata)
+          name_or_example.metadata[:example_group][:full_description]
+        elsif name_or_example.respond_to?(:description)
+          name_or_example.description
+        else
+          "UNKNOWN"
+        end
+      end
+
       def write_report
         @suite.finish
         @report_manager.write_report(@suite)
       end
+
+      def new_suite(name)
+        write_report if @suite
+        @suite = TestSuite.new name
+        @suite.start
+      end
+    end
+
+    class RSpecDoc < RSpec
+      def initialize(*args)
+        @formatter = RSpecFormatters::DocFormatter.new(*args)
+        super
+      end
     end
   end
-end
+end

data/lib/ci/reporter/test_suite.rb

@@ -1,39 +1,72 @@
+# Copyright (c) 2006-2010 Nick Sieger <nicksieger@gmail.com>
+# See the file LICENSE.txt included with the distribution for
+# software license details.
+
+require 'delegate'
+require 'stringio'
+
 module CI
   module Reporter
+    # Emulates/delegates IO to $stdout or $stderr in order to capture output to report in the XML file.
+    class OutputCapture < DelegateClass(IO)
+      # Start capturing IO, using the given block to assign self to the proper IO global.
+      def initialize(io, &assign)
+        super
+        @delegate_io = io
+        @captured_io = StringIO.new
+        @assign_block = assign
+        @assign_block.call self
+      end
+
+      # Finalize the capture and reset to the original IO object.
+      def finish
+        @assign_block.call @delegate_io
+        @captured_io.string
+      end
+
+      # setup tee methods
+      %w(<< print printf putc puts write).each do |m|
+        module_eval(<<-EOS, __FILE__, __LINE__)
+          def #{m}(*args, &block)
+            @delegate_io.send(:#{m}, *args, &block)
+            @captured_io.send(:#{m}, *args, &block)
+          end
+        EOS
+      end
+    end
+
     # Basic structure representing the running of a test suite.  Used to time tests and store results.
-    class TestSuite < Struct.new(:name, :tests, :time, :failures, :errors)
+    class TestSuite < Struct.new(:name, :tests, :time, :failures, :errors, :skipped, :assertions)
       attr_accessor :testcases
+      attr_accessor :stdout, :stderr
       def initialize(name)
-        super
+        super(name.to_s) # RSpec passes a "description" object instead of a string
         @testcases = []
       end
 
       # Starts timing the test suite.
       def start
         @start = Time.now
+        unless ENV['CI_CAPTURE'] == "off"
+          @capture_out = OutputCapture.new($stdout) {|io| $stdout = io }
+          @capture_err = OutputCapture.new($stderr) {|io| $stderr = io }
+        end
       end
 
       # Finishes timing the test suite.
       def finish
         self.tests = testcases.size
         self.time = Time.now - @start
-        self.failures = testcases.select {|tc| tc.failure? }.size
-        self.errors = testcases.select {|tc| tc.error? }.size
+        self.failures = testcases.inject(0) {|sum,tc| sum += tc.failures.select{|f| f.failure? }.size }
+        self.errors = testcases.inject(0) {|sum,tc| sum += tc.failures.select{|f| f.error? }.size }
+        self.skipped = testcases.inject(0) {|sum,tc| sum += (tc.skipped? ? 1 : 0) }
+        self.stdout = @capture_out.finish if @capture_out
+        self.stderr = @capture_err.finish if @capture_err
       end
 
       # Creates the xml builder instance used to create the report xml document.
       def create_builder
-        begin
-          gem 'builder'
-          require 'builder'
-        rescue
-          begin
-            gem 'activesupport'
-            require 'active_support'
-          rescue
-            raise LoadError, "XML Builder is required by CI::Reporter"
-          end
-        end unless defined?(Builder::XmlMarkup)
+        require 'builder'
         # :escape_attrs is obsolete in a newer version, but should do no harm
         Builder::XmlMarkup.new(:indent => 2, :escape_attrs => true)
       end
@@ -42,29 +75,35 @@ module CI
       def to_xml
         builder = create_builder
         # more recent version of Builder doesn't need the escaping
-        if Builder::XmlMarkup.private_instance_methods.include?("_attr_value")
-          def builder.trunc!(txt)
-            txt.sub(/\n.*/m, '...')
-          end
-        else
-          def builder.trunc!(txt)
-            _escape(txt.sub(/\n.*/m, '...'))
-          end
+        def builder.trunc!(txt)
+          txt.sub(/\n.*/m, '...')
         end
         builder.instruct!
         attrs = {}
-        each_pair {|k,v| attrs[k] = builder.trunc!(v.to_s) }
+        each_pair {|k,v| attrs[k] = builder.trunc!(v.to_s) unless v.nil? || v.to_s.empty? }
         builder.testsuite(attrs) do
           @testcases.each do |tc|
             tc.to_xml(builder)
           end
+          builder.tag! "system-out" do
+            builder.text! self.stdout
+          end
+          builder.tag! "system-err" do
+            builder.text! self.stderr
+          end
         end
       end
     end
 
     # Structure used to represent an individual test case.  Used to time the test and store the result.
-    class TestCase < Struct.new(:name, :time)
-      attr_accessor :failure
+    class TestCase < Struct.new(:name, :time, :assertions)
+      attr_accessor :failures
+      attr_accessor :skipped
+
+      def initialize(*args)
+        super
+        @failures = []
+      end
 
       # Starts timing the test.
       def start
@@ -78,26 +117,35 @@ module CI
 
       # Returns non-nil if the test failed.
       def failure?
-        failure && failure.failure?
+        !failures.empty? && failures.detect {|f| f.failure? }
       end
 
       # Returns non-nil if the test had an error.
       def error?
-        failure && failure.error?
+        !failures.empty? && failures.detect {|f| f.error? }
+      end
+
+      def skipped?
+        return skipped
       end
 
       # Writes xml representing the test result to the provided builder.
       def to_xml(builder)
         attrs = {}
-        each_pair {|k,v| attrs[k] = builder.trunc!(v.to_s) }
+        each_pair {|k,v| attrs[k] = builder.trunc!(v.to_s) unless v.nil? || v.to_s.empty?}
         builder.testcase(attrs) do
-          if failure
-            builder.failure(:type => builder.trunc!(failure.name), :message => builder.trunc!(failure.message)) do
-              builder.text!(failure.location)
+          if skipped
+            builder.skipped
+          else
+            failures.each do |failure|
+              builder.failure(:type => builder.trunc!(failure.name), :message => builder.trunc!(failure.message)) do
+                builder.text!(failure.message + " (#{failure.name})\n")
+                builder.text!(failure.location)
+              end
             end
           end
         end
       end
     end
   end
-end
+end

data/lib/ci/reporter/test_unit.rb

@@ -1,3 +1,7 @@
+# Copyright (c) 2006-2010 Nick Sieger <nicksieger@gmail.com>
+# See the file LICENSE.txt included with the distribution for
+# software license details.
+
 require 'ci/reporter/core'
 require 'test/unit'
 require 'test/unit/ui/console/testrunner'
@@ -8,15 +12,16 @@ module CI
     # of the test.
     class Failure
       def self.new(fault)
-        fault.kind_of?(Test::Unit::Failure) ? TestUnitFailure.new(fault) : TestUnitError.new(fault)
+        return TestUnitFailure.new(fault) if fault.kind_of?(Test::Unit::Failure)
+        return TestUnitSkipped.new(fault) if Test::Unit.constants.include?("Omission") && (fault.kind_of?(Test::Unit::Omission) || fault.kind_of?(Test::Unit::Pending))
+        return TestUnitNotification.new(fault) if Test::Unit.constants.include?("Notification") && fault.kind_of?(Test::Unit::Notification)
+        TestUnitError.new(fault)
       end
     end
 
     # Wrapper around a <code>Test::Unit</code> error to be used by the test suite to interpret results.
     class TestUnitError
-      def initialize(fault)
-        @fault = fault
-      end
+      def initialize(fault) @fault = fault end
       def failure?() false end
       def error?() true end
       def name() @fault.exception.class.name end
@@ -26,9 +31,7 @@ module CI
 
     # Wrapper around a <code>Test::Unit</code> failure to be used by the test suite to interpret results.
     class TestUnitFailure
-      def initialize(fault)
-        @fault = fault
-      end
+      def initialize(fault) @fault = fault end
       def failure?() true end
       def error?() false end
       def name() Test::Unit::AssertionFailedError.name end
@@ -36,6 +39,26 @@ module CI
       def location() @fault.location.join("\n") end
     end
 
+    # Wrapper around a <code>Test::Unit</code> 2.0 omission.
+    class TestUnitSkipped
+      def initialize(fault) @fault = fault end
+      def failure?() false end
+      def error?() false end
+      def name() Test::Unit::Omission.name end
+      def message() @fault.message end
+      def location() @fault.location.join("\n") end
+    end
+
+    # Wrapper around a <code>Test::Unit</code> 2.0 notification.
+    class TestUnitNotification
+      def initialize(fault) @fault = fault end
+      def failure?() false end
+      def error?() false end
+      def name() Test::Unit::Notification.name end
+      def message() @fault.message end
+      def location() @fault.location.join("\n") end
+    end
+
     # Replacement Mediator that adds listeners to capture the results of the <code>Test::Unit</code> runs.
     class TestUnit < Test::Unit::UI::TestRunnerMediator
       def initialize(suite, report_mgr = nil)
@@ -49,8 +72,11 @@ module CI
       end
 
       def started(result)
+        @suite_result = result
+        @last_assertion_count = 0
         @current_suite = nil
         @unknown_count = 0
+        @result_assertion_count = 0
       end
 
       def test_started(name)
@@ -67,7 +93,8 @@ module CI
       end
 
       def fault(fault)
-        finish_test(fault)
+        tc = @current_suite.testcases.last
+        tc.failures << Failure.new(fault)
       end
 
       def finished(elapsed_time)
@@ -92,7 +119,9 @@ module CI
 
       def finish_suite
         if @current_suite
-          @current_suite.finish 
+          @current_suite.finish
+          @current_suite.assertions = @suite_result.assertion_count - @last_assertion_count
+          @last_assertion_count = @suite_result.assertion_count
           @report_manager.write_report(@current_suite)
         end
       end
@@ -103,11 +132,12 @@ module CI
         @current_suite.testcases << tc
       end
 
-      def finish_test(failure = nil)
+      def finish_test
         tc = @current_suite.testcases.last
         tc.finish
-        tc.failure = Failure.new(failure) if failure
+        tc.assertions = @suite_result.assertion_count - @result_assertion_count
+        @result_assertion_count = @suite_result.assertion_count
       end
     end
   end
-end
+end

data/lib/ci/reporter/version.rb

@@ -0,0 +1,5 @@
+module CI
+  module Reporter
+    VERSION = "1.6.5"
+  end
+end