finnlabs-ci_reporter 1.6.5

data/lib/ci/reporter/rspec.rb

@@ -0,0 +1,189 @@
+# 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'
+
+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?
+        @failure.expectation_not_met?
+      end
+
+      def error?
+        !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)
+        @example = example
+        @exception = @example.execution_result[:exception] || @example.execution_result[:exception_encountered]
+      end
+
+      def failure?
+        exception.is_a?(::RSpec::Expectations::ExpectationNotMetError)
+      end
+    end
+
+    # Custom +RSpec+ formatter used to hook into the spec runs and capture results.
+    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)
+        @formatter.start(spec_count)
+      end
+
+      # rspec 0.9
+      def add_behaviour(name)
+        @formatter.add_behaviour(name)
+        new_suite(name)
+      end
+
+      # 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_started(name_or_example)
+        @formatter.example_started(name_or_example)
+        spec = TestCase.new
+        @suite.testcases << spec
+        spec.start
+      end
+
+      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)
+        else
+          failure = RSpecFailure.new(rest[1]) # example_failed(name, counter, failure) in RSpec 1
+        end
+
+        spec = @suite.testcases.last
+        spec.finish
+        spec.name = description_for(name_or_example)
+        spec.failures << failure
+      end
+
+      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
+        @formatter.start_dump
+      end
+
+      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

data/lib/ci/reporter/test_suite.rb

@@ -0,0 +1,151 @@
+# 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, :skipped, :assertions)
+      attr_accessor :testcases
+      attr_accessor :stdout, :stderr
+      def initialize(name)
+        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.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
+        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.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, :assertions)
+      attr_accessor :failures
+      attr_accessor :skipped
+
+      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
+
+      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) unless v.nil? || v.to_s.empty?}
+        builder.testcase(attrs) do
+          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

data/lib/ci/reporter/test_unit.rb

@@ -0,0 +1,132 @@
+# 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'
+
+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)
+        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))
+        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
+
+    # 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
+
+    # 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.5"
+  end
+end

data/spec/ci/reporter/cucumber_spec.rb

@@ -0,0 +1,230 @@
+# Copyright (c) 2006-2010 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 'ci/reporter/cucumber'
+
+describe "The Cucumber reporter" do
+  describe CI::Reporter::CucumberFailure do
+    before(:each) do
+      @klass = mock("class")
+      @klass.stub!(:name).and_return("Exception name")
+
+      @exception = mock("exception")
+      @exception.stub!(:class).and_return(@klass)
+      @exception.stub!(:message).and_return("Exception message")
+      @exception.stub!(:backtrace).and_return(["First line", "Second line"])
+
+      @step = mock("step")
+      @step.stub!(:exception).and_return(@exception)
+
+      @cucumber_failure = CI::Reporter::CucumberFailure.new(@step)
+    end
+
+    it "should always return true for failure?" do
+      @cucumber_failure.should be_failure
+    end
+
+    it "should always return false for error?" do
+      @cucumber_failure.should_not be_error
+    end
+
+    it "should propagate the name as the underlying exception's class name" do
+      @step.should_receive(:exception)
+      @exception.should_receive(:class)
+      @klass.should_receive(:name)
+
+      @cucumber_failure.name.should == "Exception name"
+    end
+
+    it "should propagate the message as the underlying exception's message" do
+      @step.should_receive(:exception)
+      @exception.should_receive(:message)
+
+      @cucumber_failure.message.should == "Exception message"
+    end
+
+    it "should propagate and format the exception's backtrace" do
+      @step.should_receive(:exception)
+      @exception.should_receive(:backtrace)
+
+      @cucumber_failure.location.should == "First line\nSecond line"
+    end
+  end
+
+  describe CI::Reporter::Cucumber do
+    before(:each) do
+      @step_mother = mock("step_mother")
+      @io = mock("io")
+
+      @report_manager = mock("report_manager")
+      CI::Reporter::ReportManager.stub!(:new).and_return(@report_manager)
+    end
+
+    def new_instance
+      CI::Reporter::Cucumber.new(@step_mother, @io, {})
+    end
+
+    it "should create a new report manager to report on test success/failure" do
+      CI::Reporter::ReportManager.should_receive(:new)
+      new_instance
+    end
+
+    it "should record the feature name when a new feature is visited" do
+      cucumber = new_instance
+      cucumber.feature_name(nil, "Some feature name")
+      cucumber.name.should == "Some feature name"
+    end
+
+    it "should record only the first line of a feature name" do
+      cucumber = new_instance
+      cucumber.feature_name(nil, "Some feature name\nLonger description")
+      cucumber.name.should == "Some feature name"
+    end
+
+    context "applied to a feature" do
+      before(:each) do
+        @cucumber = new_instance
+        @cucumber.feature_name(nil, "Demo feature")
+
+        @test_suite = mock("test_suite", :start => nil, :finish => nil, :name= => nil)
+        CI::Reporter::TestSuite.stub!(:new).and_return(@test_suite)
+
+        @feature = mock("feature")
+
+        @report_manager.stub!(:write_report)
+      end
+
+      context "before" do
+        it "should create a new test suite" do
+          CI::Reporter::TestSuite.should_receive(:new).with(/Demo feature/)
+          @cucumber.before_feature(@feature)
+        end
+
+        it "should indicate that the test suite has started" do
+          @test_suite.should_receive(:start)
+          @cucumber.before_feature(@feature)
+        end
+      end
+
+      context "after" do
+        before :each do
+          @cucumber = new_instance
+          @cucumber.feature_name(nil, "Demo feature")
+
+          @test_suite = mock("test_suite", :start => nil, :finish => nil, :name= => nil)
+          CI::Reporter::TestSuite.stub!(:new).and_return(@test_suite)
+
+          @feature = mock("feature")
+
+          @report_manager.stub!(:write_report)
+
+          @cucumber.before_feature(@feature)
+        end
+
+        it "should indicate that the test suite has finished" do
+          @test_suite.should_receive(:finish)
+          @cucumber.after_feature(@feature)
+        end
+
+        it "should ask the report manager to write a report" do
+          @report_manager.should_receive(:write_report).with(@test_suite)
+          @cucumber.after_feature(@feature)
+        end
+      end
+    end
+
+    context "inside a scenario" do
+      before(:each) do
+        @testcases = []
+
+        @test_suite = mock("test_suite", :testcases => @testcases)
+
+        @cucumber = new_instance
+        @cucumber.stub!(:test_suite).and_return(@test_suite)
+
+        @test_case = mock("test_case", :start => nil, :finish => nil, :name => "Step Name")
+        CI::Reporter::TestCase.stub!(:new).and_return(@test_case)
+
+        @step = mock("step", :status => :passed)
+        @step.stub!(:name).and_return("Step Name")
+      end
+
+      context "before steps" do
+        it "should create a new test case" do
+          CI::Reporter::TestCase.should_receive(:new).with("Step Name")
+          @cucumber.scenario_name(nil, "Step Name")
+          @cucumber.before_steps(@step)
+        end
+
+        it "should indicate that the test case has started" do
+          @test_case.should_receive(:start)
+          @cucumber.before_steps(@step)
+        end
+      end
+
+      context "after steps" do
+        before :each do
+          @cucumber.before_steps(@step)
+        end
+
+        it "should indicate that the test case has finished" do
+          @test_case.should_receive(:finish)
+          @cucumber.after_steps(@step)
+        end
+
+        it "should add the test case to the suite's list of cases" do
+          @testcases.should be_empty
+          @cucumber.after_steps(@step)
+          @testcases.should_not be_empty
+          @testcases.first.should == @test_case
+        end
+
+        it "should alter the name of a test case that is pending to include '(PENDING)'" do
+          @step.stub!(:status).and_return(:pending)
+          @test_case.should_receive(:name=).with("Step Name (PENDING)")
+          @cucumber.after_steps(@step)
+        end
+
+        it "should alter the name of a test case that is undefined to include '(PENDING)'" do
+          @step.stub!(:status).and_return(:undefined)
+          @test_case.should_receive(:name=).with("Step Name (PENDING)")
+          @cucumber.after_steps(@step)
+        end
+
+        it "should alter the name of a test case that was skipped to include '(SKIPPED)'" do
+          @step.stub!(:status).and_return(:skipped)
+          @test_case.should_receive(:name=).with("Step Name (SKIPPED)")
+          @cucumber.after_steps(@step)
+        end
+      end
+
+      describe "that fails" do
+        before(:each) do
+          @step.stub!(:status).and_return(:failed)
+
+          @failures = []
+          @test_case.stub!(:failures).and_return(@failures)
+
+          @cucumber.before_steps(@step)
+
+          @cucumber_failure = mock("cucumber_failure")
+          CI::Reporter::CucumberFailure.stub!(:new).and_return(@cucumber_failure)
+        end
+
+        it "should create a new cucumber failure with that step" do
+          CI::Reporter::CucumberFailure.should_receive(:new).with(@step)
+          @cucumber.after_steps(@step)
+        end
+
+        it "should add the failure to the suite's list of failures" do
+          @failures.should be_empty
+          @cucumber.after_steps(@step)
+          @failures.should_not be_empty
+          @failures.first.should == @cucumber_failure
+        end
+      end
+    end
+  end
+end