schubert-ci_reporter 1.6.1

data/lib/ci/reporter/test_suite.rb

@@ -0,0 +1,151 @@
+# (c) Copyright 2006-2007 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, :classname, :tests, :time, :failures, :errors, :assertions)
+      attr_accessor :testcases
+      attr_accessor :stdout, :stderr
+      def initialize(name)
+        suite_name = name.to_s.gsub(/#/, "%23")
+        super(suite_name) # RSpec passes a "description" object instead of a string
+        if potential_classname = suite_name.split(" ").first
+          self.classname = potential_classname if defined?(potential_classname) == "constant"
+        end
+        @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.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.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
+          require 'rubygems'
+          gem 'builder'
+        rescue LoadError
+        end
+
+        require 'builder'
+        # :escape_attrs is obsolete in a newer version, but should do no harm
+        Builder::XmlMarkup.new(:indent => 2, :escape_attrs => true)
+      end
+
+      # Creates an xml string containing the test suite results.
+      def to_xml
+        builder = create_builder
+        # more recent version of Builder doesn't need the escaping
+        def builder.trunc!(txt)
+          txt.sub(/\n.*/m, '...')
+        end
+        builder.instruct!
+        attrs = {}
+        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.cdata! self.stdout
+          end
+          builder.tag! "system-err" do
+            builder.cdata! 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, :assertions)
+      attr_accessor :failures
+
+      def initialize(*args)
+        super
+        @failures = []
+      end
+
+      # Starts timing the test.
+      def start
+        @start = Time.now
+      end
+
+      # Finishes timing the test.
+      def finish
+        self.time = Time.now - @start
+      end
+
+      # Returns non-nil if the test failed.
+      def failure?
+        !failures.empty? && failures.detect {|f| f.failure? }
+      end
+
+      # Returns non-nil if the test had an error.
+      def error?
+        !failures.empty? && failures.detect {|f| f.error? }
+      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) unless v.nil? || v.to_s.empty?}
+        builder.testcase(attrs) do
+          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

data/lib/ci/reporter/test_unit.rb

@@ -0,0 +1,124 @@
+# (c) Copyright 2006-2007 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'
+
+module CI
+  module Reporter
+    # Factory for constructing either a CI::Reporter::TestUnitFailure or CI::Reporter::TestUnitError depending on the result
+    # of the test.
+    class Failure
+      def self.new(fault)
+        fault.kind_of?(Test::Unit::Failure) ? TestUnitFailure.new(fault) : 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 failure?() false end
+      def error?() true end
+      def name() @fault.exception.class.name end
+      def message() @fault.exception.message end
+      def location() @fault.exception.backtrace.join("\n") end
+    end
+
+    # 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 failure?() true end
+      def error?() false end
+      def name() Test::Unit::AssertionFailedError.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)
+        super(suite)
+        @report_manager = report_mgr || ReportManager.new("test")
+        add_listener(Test::Unit::UI::TestRunnerMediator::STARTED, &method(:started))
+        add_listener(Test::Unit::TestCase::STARTED, &method(:test_started))
+        add_listener(Test::Unit::TestCase::FINISHED, &method(:test_finished))
+        add_listener(Test::Unit::TestResult::FAULT, &method(:fault))
+        add_listener(Test::Unit::UI::TestRunnerMediator::FINISHED, &method(:finished))
+      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)
+        test_name, suite_name = extract_names(name)
+        unless @current_suite && @current_suite.name == suite_name
+          finish_suite
+          start_suite(suite_name)
+        end
+        start_test(test_name)
+      end
+
+      def test_finished(name)
+        finish_test
+      end
+
+      def fault(fault)
+        tc = @current_suite.testcases.last
+        tc.failures << Failure.new(fault)
+      end
+
+      def finished(elapsed_time)
+        finish_suite
+      end
+
+      private
+      def extract_names(name)
+        match = name.match(/(.*)\(([^)]*)\)/)
+        if match
+          [match[1], match[2]]
+        else
+          @unknown_count += 1
+          [name, "unknown-#{@unknown_count}"]
+        end
+      end
+
+      def start_suite(suite_name)
+        @current_suite = TestSuite.new(suite_name)
+        @current_suite.start
+      end
+
+      def finish_suite
+        if @current_suite
+          @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
+
+      def start_test(test_name)
+        tc = TestCase.new(test_name)
+        tc.start
+        @current_suite.testcases << tc
+      end
+
+      def finish_test
+        tc = @current_suite.testcases.last
+        tc.finish
+        tc.assertions = @suite_result.assertion_count - @result_assertion_count
+        @result_assertion_count = @suite_result.assertion_count
+      end
+    end
+  end
+end

data/lib/ci/reporter/version.rb

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

data/spec/ci/reporter/output_capture_spec.rb

@@ -0,0 +1,57 @@
+# (c) Copyright 2006-2007 Nick Sieger <nicksieger@gmail.com>
+# See the file LICENSE.txt included with the distribution for
+# software license details.
+
+require File.dirname(__FILE__) + "/../../spec_helper.rb"
+require 'rexml/document'
+
+describe "Output capture" do
+  before(:each) do
+    @suite = CI::Reporter::TestSuite.new "test"
+  end
+
+  it "should save stdout and stderr messages written during the test run" do
+    @suite.start
+    puts "Hello"
+    $stderr.print "Hi"
+    @suite.finish
+    @suite.stdout.should == "Hello\n"
+    @suite.stderr.should == "Hi"
+  end
+
+  it "should include system-out and system-err elements in the xml output" do
+    @suite.start
+    puts "Hello"
+    $stderr.print "Hi"
+    @suite.finish
+
+    root = REXML::Document.new(@suite.to_xml).root
+    root.elements.to_a('//system-out').length.should == 1
+    root.elements.to_a('//system-err').length.should == 1
+    root.elements.to_a('//system-out').first.cdatas.first.to_s.should == "Hello\n"
+    root.elements.to_a('//system-err').first.cdatas.first.to_s.should == "Hi"
+  end
+
+  it "should return $stdout and $stderr to original value after finish" do
+    out, err = $stdout, $stderr
+    @suite.start
+    $stdout.object_id.should_not == out.object_id
+    $stderr.object_id.should_not == err.object_id
+    @suite.finish
+    $stdout.object_id.should == out.object_id
+    $stderr.object_id.should == err.object_id
+  end
+  
+  it "should capture only during run of owner test suite" do
+    $stdout.print "A"
+    $stderr.print "A"
+    @suite.start
+    $stdout.print "B"
+    $stderr.print "B"
+    @suite.finish
+    $stdout.print "C"
+    $stderr.print "C"
+    @suite.stdout.should == "B"
+    @suite.stderr.should == "B"
+  end
+end

data/spec/ci/reporter/rake/rake_tasks_spec.rb

@@ -0,0 +1,73 @@
+# (c) Copyright 2006-2007 Nick Sieger <nicksieger@gmail.com>
+# See the file LICENSE.txt included with the distribution for
+# software license details.
+
+require File.dirname(__FILE__) + "/../../../spec_helper.rb"
+require 'rake'
+
+def save_env(v)
+  ENV["PREV_#{v}"] = ENV[v]
+end
+def restore_env(v)
+  ENV[v] = ENV["PREV_#{v}"]
+  ENV.delete("PREV_#{v}")
+end
+
+describe "ci_reporter ci:setup:testunit task" do
+  before(:each) do
+    @rake = Rake::Application.new
+    Rake.application = @rake
+    load CI_REPORTER_LIB + '/ci/reporter/rake/test_unit.rb'
+    save_env "CI_REPORTS"
+    save_env "TESTOPTS"
+    ENV["CI_REPORTS"] = "some-bogus-nonexistent-directory-that-wont-fail-rm_rf"
+  end
+  after(:each) do
+    restore_env "TESTOPTS"
+    restore_env "CI_REPORTS"
+    Rake.application = nil
+  end
+
+  it "should set ENV['TESTOPTS'] to include test/unit setup file" do
+    @rake["ci:setup:testunit"].invoke
+    ENV["TESTOPTS"].should =~ /test_unit_loader/
+  end
+  
+  it "should append to ENV['TESTOPTS'] if it already contains a value" do
+    ENV["TESTOPTS"] = "somevalue".freeze
+    @rake["ci:setup:testunit"].invoke
+    ENV["TESTOPTS"].should =~ /somevalue.*test_unit_loader/
+  end
+end
+
+describe "ci_reporter ci:setup:rspec task" do
+  before(:each) do
+    @rake = Rake::Application.new
+    Rake.application = @rake
+    load CI_REPORTER_LIB + '/ci/reporter/rake/rspec.rb'
+    save_env "CI_REPORTS"
+    save_env "SPEC_OPTS"
+    ENV["CI_REPORTS"] = "some-bogus-nonexistent-directory-that-wont-fail-rm_rf"
+  end
+  after(:each) do
+    restore_env "SPEC_OPTS"
+    restore_env "CI_REPORTS"
+    Rake.application = nil
+  end
+  
+  it "should set ENV['SPEC_OPTS'] to include rspec formatter args" do
+    @rake["ci:setup:rspec"].invoke
+    ENV["SPEC_OPTS"].should =~ /--require.*rspec_loader.*--format.*CI::Reporter::RSpec/
+  end
+
+  it "should set ENV['SPEC_OPTS'] to include rspec doc formatter if task is ci:setup:rspecdoc" do
+    @rake["ci:setup:rspecdoc"].invoke
+    ENV["SPEC_OPTS"].should =~ /--require.*rspec_loader.*--format.*CI::Reporter::RSpecDoc/
+  end
+  
+  it "should append to ENV['SPEC_OPTS'] if it already contains a value" do
+    ENV["SPEC_OPTS"] = "somevalue".freeze
+    @rake["ci:setup:rspec"].invoke
+    ENV["SPEC_OPTS"].should =~ /somevalue.*--require.*rspec_loader.*--format.*CI::Reporter::RSpec/
+  end
+end

data/spec/ci/reporter/report_manager_spec.rb

@@ -0,0 +1,39 @@
+# (c) Copyright 2006-2007 Nick Sieger <nicksieger@gmail.com>
+# See the file LICENSE.txt included with the distribution for
+# software license details.
+
+require File.dirname(__FILE__) + "/../../spec_helper.rb"
+
+describe "The ReportManager" do
+  before(:each) do
+    @reports_dir = REPORTS_DIR
+  end
+
+  after(:each) do
+    FileUtils.rm_rf @reports_dir
+    ENV["CI_REPORTS"] = nil
+  end
+
+  it "should create the report directory according to the given prefix" do
+    CI::Reporter::ReportManager.new("spec")
+    File.directory?(@reports_dir).should be_true
+  end
+  
+  it "should create the report directory based on CI_REPORTS environment variable if set" do
+    @reports_dir = "#{Dir.getwd}/dummy"
+    ENV["CI_REPORTS"] = @reports_dir
+    CI::Reporter::ReportManager.new("spec")
+    File.directory?(@reports_dir).should be_true
+  end
+  
+  it "should write reports based on name and xml content of a test suite" do
+    reporter = CI::Reporter::ReportManager.new("spec")
+    suite = mock("test suite")
+    suite.should_receive(:name).and_return("some test suite name")
+    suite.should_receive(:to_xml).and_return("<xml></xml>")
+    reporter.write_report(suite)
+    filename = "#{REPORTS_DIR}/SPEC-some-test-suite-name.xml"
+    File.exist?(filename).should be_true
+    File.open(filename) {|f| f.read.should == "<xml></xml>"}
+  end
+end

data/spec/ci/reporter/rspec_spec.rb

@@ -0,0 +1,108 @@
+# (c) Copyright 2006-2008 Nick Sieger <nicksieger@gmail.com>
+# See the file LICENSE.txt included with the distribution for
+# software license details.
+
+require File.dirname(__FILE__) + "/../../spec_helper.rb"
+require 'stringio'
+
+describe "The RSpec reporter" do
+  before(:each) do
+    @error = mock("error")
+    @error.stub!(:expectation_not_met?).and_return(false)
+    @error.stub!(:pending_fixed?).and_return(false)
+    @report_mgr = mock("report manager")
+    @options = mock("options")
+    @args = [@options, StringIO.new("")]
+    @args.shift if Spec::VERSION::MAJOR == 1 && Spec::VERSION::MINOR < 1
+    @fmt = CI::Reporter::RSpec.new *@args
+    @fmt.report_manager = @report_mgr
+    @formatter = mock("formatter")
+    @fmt.formatter = @formatter
+  end
+
+  it "should use a progress bar formatter by default" do
+    fmt = CI::Reporter::RSpec.new *@args
+    fmt.formatter.should be_instance_of(Spec::Runner::Formatter::ProgressBarFormatter)
+  end
+
+  it "should use a specdoc formatter for RSpecDoc" do
+    fmt = CI::Reporter::RSpecDoc.new *@args
+    fmt.formatter.should be_instance_of(Spec::Runner::Formatter::SpecdocFormatter)
+  end
+
+  it "should create a test suite with one success, one failure, and one pending" do
+    @report_mgr.should_receive(:write_report).and_return do |suite|
+      suite.testcases.length.should == 3
+      suite.testcases[0].should_not be_failure
+      suite.testcases[0].should_not be_error
+      suite.testcases[1].should be_error
+      suite.testcases[2].name.should =~ /\(PENDING\)/
+    end
+
+    example_group = mock "example group"
+    example_group.stub!(:description).and_return "A context"
+
+    @formatter.should_receive(:start).with(3)
+    @formatter.should_receive(:example_group_started).with(example_group)
+    @formatter.should_receive(:example_started).exactly(3).times
+    @formatter.should_receive(:example_passed).once
+    @formatter.should_receive(:example_failed).once
+    @formatter.should_receive(:example_pending).once
+    @formatter.should_receive(:start_dump).once
+    @formatter.should_receive(:dump_failure).once
+    @formatter.should_receive(:dump_summary).once
+    @formatter.should_receive(:dump_pending).once
+    @formatter.should_receive(:close).once
+
+    @fmt.start(3)
+    @fmt.example_group_started(example_group)
+    @fmt.example_started("should pass")
+    @fmt.example_passed("should pass")
+    @fmt.example_started("should fail")
+    @fmt.example_failed("should fail", 1, @error)
+    @fmt.example_started("should be pending")
+    @fmt.example_pending("A context", "should be pending", "Not Yet Implemented")
+    @fmt.start_dump
+    @fmt.dump_failure(1, mock("failure"))
+    @fmt.dump_summary(0.1, 3, 1, 1)
+    @fmt.dump_pending
+    @fmt.close
+  end
+
+  it "should support RSpec 1.0.8 #add_behavior" do
+    @formatter.should_receive(:start)
+    @formatter.should_receive(:add_behaviour).with("A context")
+    @formatter.should_receive(:example_started).once
+    @formatter.should_receive(:example_passed).once
+    @formatter.should_receive(:dump_summary)
+    @report_mgr.should_receive(:write_report)
+
+    @fmt.start(2)
+    @fmt.add_behaviour("A context")
+    @fmt.example_started("should pass")
+    @fmt.example_passed("should pass")
+    @fmt.dump_summary(0.1, 1, 0, 0)
+  end
+
+  it "should use the example #description method when available" do
+    group = mock "example group"
+    group.stub!(:description).and_return "group description"
+    example = mock "example"
+    example.stub!(:description).and_return "should do something"
+
+    @formatter.should_receive(:start)
+    @formatter.should_receive(:example_group_started).with(group)
+    @formatter.should_receive(:example_started).with(example).once
+    @formatter.should_receive(:example_passed).once
+    @formatter.should_receive(:dump_summary)
+    @report_mgr.should_receive(:write_report).and_return do |suite|
+      suite.testcases.last.name.should == "should do something"
+    end
+
+    @fmt.start(2)
+    @fmt.example_group_started(group)
+    @fmt.example_started(example)
+    @fmt.example_passed(example)
+    @fmt.dump_summary(0.1, 1, 0, 0)
+  end
+end