ci_reporter 2.0.0.alpha2 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9d4fd920bd59773352edb9dd239cb99ffe419406
-  data.tar.gz: 227712fdcd966fa2b57d5a32133e5e0587a89e03
+  metadata.gz: fe5f8b66682882d6a356567fcf2b9683fe5f529a
+  data.tar.gz: 7831002dd54de23d55414b03bfad33061d2c3359
 SHA512:
-  metadata.gz: 094edf36eb8b168fb606a2a2ad73ea9bf3e49a078934462ff95d2b07a27f49038291789b162807fe8395f49d237887edd0926f983a1848b100e0d150ff9e2266
-  data.tar.gz: bdde115c27717e95030df44d1accd7d79b38ba8230895faa0d13409cb4b721444efc79615241dd599e7e0ad25ada12777cad0247783d43428954a1d1298e2dd1
+  metadata.gz: b41cf605637d2974bb44f18698b80e682d863bae095751b4ac50f1349df7ea363a6346e4ff06e88e6ce1884c641f8277c8dac4a23240baec930157f27c791a98
+  data.tar.gz: 8bc3f23ee5b19300109a141a086fa64da41b0a0c647991c91b68a56adb16edb4114f8a3a8c9b46312ddb677548563e6fe378c044bb6de119553561ea477a6390

data/History.txt

@@ -1,3 +1,13 @@
+== 2.0.0 (2014-07-24)
+
+=== Changed
+
+- Gem has been refactored into multiple framework-specific gems.
+
+=== Removed
+
+- All methods of use except the `ci:setup:*` Rake tasks.
+
 == 1.9.2 (04/06/14)
 
 - GH #119: add timestamp attribute (Shawn Zhu)

data/README.md

@@ -30,10 +30,21 @@ Each supported testing framework is provided by a separate gem:
 [ci-spin]: https://github.com/ci-reporter/ci_reporter_spinach
 [ci-tu]: https://github.com/ci-reporter/ci_reporter_test_unit
 
+### Upgrading from CI::Reporter 1.x
+
+CI::Reporter 1.x supported all the different test frameworks in a
+single gem. This was convienient, but caused issues as test frameworks
+released new, sometimes incompatibile, versions. CI::Reporter 2.x has
+been split into multiple gems, allowing each gem to specify the test
+framework versions it supports.
+
+To upgrade to 2.x, remove `ci_reporter` from your Gemfile and replace
+it with one or more of the framework-specific gems above.
+
 ## Jenkins setup
 
-1. Tick the box labelled "Publish JUnit test result report" in the job
-configuration
+1. Add the "Publish JUnit test result report" post-build step
+in the job configuration.
 
 2. Enter "test/reports/*.xml,spec/reports/*.xml" in the "Test report
 XMLs" field (adjust this to suit which tests you are running)

data/ci_reporter.gemspec

@@ -24,5 +24,5 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rdoc", "~> 4.0"
-  spec.add_development_dependency "rspec", "~> 2.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
 end

data/lib/ci/reporter/output_capture.rb

@@ -0,0 +1,31 @@
+require 'delegate'
+require 'stringio'
+
+module CI
+  module Reporter
+    # Captures $stdout or $stderr in order report it in the XML file.
+    class OutputCapture
+      # Creates an OutputCapture and immediately starts capturing.
+      def self.wrap(io, &assign)
+        new(io, &assign).tap {|oc| oc.start}
+      end
+
+      def initialize(io, &assign)
+        @original_io = io
+        @captured_io = StringIO.new
+        @assign_block = assign
+      end
+
+      # Start capturing IO.
+      def start
+        @assign_block.call(@captured_io)
+      end
+
+      # Finalize the capture and reset to the original IO object.
+      def finish
+        @assign_block.call(@original_io)
+        @captured_io.string
+      end
+    end
+  end
+end

data/lib/ci/reporter/test_suite.rb

@@ -1,50 +1,32 @@
-require 'delegate'
-require 'stringio'
 require 'time'
+require 'builder'
+require 'ci/reporter/output_capture'
 
 module CI
   module Reporter
-    # Emulates/delegates IO to $stdout or $stderr in order to capture output to report in the XML file.
-    module OutputCapture
-      class Delegate < DelegateClass(IO)
-        include OutputCapture
-        def initialize(io, &assign)
-          super(io)
-          capture(io, &assign)
-        end
+    module StructureXmlHelpers
+      # Struct#to_h is not available in Ruby 1.9
+      def attr_hash
+        Hash[self.members.zip(self.values)]
       end
 
-      def self.wrap(io, &assign)
-        Delegate.new(io, &assign)
+      # Removes empty attributes and truncates long attributes.
+      def cleaned_attributes
+        attr_array = attr_hash
+          .reject {|k,v| v.to_s.empty? }
+          .map    {|k,v| [k, truncate_at_newline(v)] }
+        Hash[attr_array]
       end
 
-      # Start capturing IO, using the given block to assign self to the proper IO global.
-      def capture(io, &assign)
-        @delegate_io = io
-        @captured_io = StringIO.new
-        @assign_block = assign
-        @assign_block.call @captured_io
-      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
+      def truncate_at_newline(txt)
+        txt.to_s.sub(/\n.*/m, '...')
       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, :timestamp)
+      include StructureXmlHelpers
+
       attr_accessor :testcases
       attr_accessor :stdout, :stderr
       def initialize(name)
@@ -66,39 +48,30 @@ module CI
         self.tests = testcases.size
         self.time = Time.now - @start
         self.timestamp = @start.iso8601
-        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.failures = testcases.map(&:failure_count).reduce(&:+)
+        self.errors = testcases.map(&:error_count).reduce(&:+)
+        self.skipped = testcases.count(&:skipped?)
         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 = Builder::XmlMarkup.new(indent: 2)
         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
+        builder.testsuite(cleaned_attributes) do
           @testcases.each do |tc|
             tc.to_xml(builder)
           end
-          builder.tag! "system-out" do
-            builder.text!(self.stdout || '' )
+          unless self.stdout.to_s.empty?
+            builder.tag! "system-out" do
+              builder.text!(self.stdout)
+            end
           end
-          builder.tag! "system-err" do
-            builder.text!(self.stderr || '' )
+          unless self.stderr.to_s.empty?
+            builder.tag! "system-err" do
+              builder.text!(self.stderr)
+            end
           end
         end
       end
@@ -106,6 +79,8 @@ module CI
 
     # Structure used to represent an individual test case.  Used to time the test and store the result.
     class TestCase < Struct.new(:name, :time, :assertions)
+      include StructureXmlHelpers
+
       attr_accessor :failures
       attr_accessor :skipped
 
@@ -126,12 +101,20 @@ module CI
 
       # Returns non-nil if the test failed.
       def failure?
-        !failures.empty? && failures.detect {|f| f.failure? }
+        failures.any?(&:failure?)
       end
 
       # Returns non-nil if the test had an error.
       def error?
-        !failures.empty? && failures.detect {|f| f.error? }
+        failures.any?(&:error?)
+      end
+
+      def failure_count
+        failures.count(&:failure?)
+      end
+
+      def error_count
+        failures.count(&:error?)
       end
 
       def skipped?
@@ -140,16 +123,14 @@ module CI
 
       # 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
+        builder.testcase(cleaned_attributes) do
           if skipped?
             builder.skipped
           else
             failures.each do |failure|
               tag = failure.error? ? :error : :failure
 
-              builder.tag!(tag, :type => builder.trunc!(failure.name), :message => builder.trunc!(failure.message)) do
+              builder.tag!(tag, type: truncate_at_newline(failure.name), message: truncate_at_newline(failure.message)) do
                 builder.text!(failure.message + " (#{failure.name})\n")
                 builder.text!(failure.location)
               end

data/lib/ci/reporter/version.rb

@@ -1,5 +1,5 @@
 module CI
   module Reporter
-    VERSION = "2.0.0.alpha2"
+    VERSION = "2.0.0"
   end
 end

data/spec/ci/reporter/output_capture_spec.rb

@@ -2,59 +2,67 @@ require File.dirname(__FILE__) + "/../../spec_helper.rb"
 require 'rexml/document'
 
 describe "Output capture" do
-  before(:each) do
-    @suite = CI::Reporter::TestSuite.new "test"
-  end
+  subject(:suite) { CI::Reporter::TestSuite.new "test" }
 
-  it "should save stdout and stderr messages written during the test run" do
-    @suite.start
+  it "saves 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"
+    suite.finish
+    expect(suite.stdout).to eql "Hello\n"
+    expect(suite.stderr).to eql "Hi"
   end
 
-  it "should include system-out and system-err elements in the xml output" do
-    @suite.start
+  it "includes system-out and system-err elements in the xml output" do
+    suite.start
     puts "Hello"
     $stderr.print "Hi"
-    @suite.finish
+    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.texts.first.to_s.strip.should == "Hello"
-    root.elements.to_a('//system-err').first.texts.first.to_s.strip.should == "Hi"
+    root = REXML::Document.new(suite.to_xml).root
+    expect(root.elements.to_a('//system-out').length).to eql 1
+    expect(root.elements.to_a('//system-err').length).to eql 1
+    expect(root.elements.to_a('//system-out').first.texts.first.to_s.strip).to eql "Hello"
+    expect(root.elements.to_a('//system-err').first.texts.first.to_s.strip).to eql "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
+  it "does not include system-out or system-err elements if nothing was output" do
+    suite.start
+    suite.finish
+
+    root = REXML::Document.new(suite.to_xml).root
+    expect(root.elements.to_a('//system-out').length).to eql 0
+    expect(root.elements.to_a('//system-err').length).to eql 0
   end
 
-  it "should capture only during run of owner test suite" do
+  it "captures only during run of owner test suite" do
     $stdout.print "A"
     $stderr.print "A"
-    @suite.start
+    suite.start
     $stdout.print "B"
     $stderr.print "B"
-    @suite.finish
+    suite.finish
     $stdout.print "C"
     $stderr.print "C"
-    @suite.stdout.should == "B"
-    @suite.stderr.should == "B"
+    expect(suite.stdout).to eql "B"
+    expect(suite.stderr).to eql "B"
   end
 
-  it "should not barf when commands are executed with back-ticks" do
-    @suite.start
-    `echo "B"`
-    @suite.finish
-  end
+  describe CI::Reporter::OutputCapture do
+    subject(:capture) { CI::Reporter::OutputCapture.new($stdout) {|x| $stdout = x } }
 
+    it "returns the IO to the original value after finish" do
+      original = $stdout
+      capture.start
+      expect($stdout.object_id).to_not eql original.object_id
+      capture.finish
+      expect($stdout.object_id).to eql original.object_id
+    end
+
+    it "does not barf when commands are executed with back-ticks" do
+      capture.start
+      `echo "B"`
+      capture.finish
+    end
+  end
 end

data/spec/ci/reporter/report_manager_spec.rb

@@ -1,75 +1,77 @@
 require File.dirname(__FILE__) + "/../../spec_helper.rb"
 
-describe "The ReportManager" do
-  before(:each) do
-    @reports_dir = REPORTS_DIR
-    ENV.delete 'MAX_FILENAME_SIZE'
-  end
+module CI::Reporter
+  describe ReportManager do
+    before(:each) do
+      @reports_dir = REPORTS_DIR
+      ENV.delete 'MAX_FILENAME_SIZE'
+    end
 
-  after(:each) do
-    FileUtils.rm_rf @reports_dir
-    ENV["CI_REPORTS"] = nil
-  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 "creates the report directory according to the given prefix" do
+      CI::Reporter::ReportManager.new("spec")
+      expect(File.directory?(@reports_dir)).to 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 "creates 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")
+      expect(File.directory?(@reports_dir)).to 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 = double("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
+    it "writes reports based on name and xml content of a test suite" do
+      reporter = CI::Reporter::ReportManager.new("spec")
+      suite = double("test suite")
+      expect(suite).to receive(:name).and_return("some test suite name")
+      expect(suite).to receive(:to_xml).and_return("<xml></xml>")
+      reporter.write_report(suite)
+      filename = "#{REPORTS_DIR}/SPEC-some-test-suite-name.xml"
+      expect(File.exist?(filename)).to be true
+      expect(File.read(filename)).to eql "<xml></xml>"
+    end
 
-  it "should shorten extremely long report filenames" do
-    reporter = CI::Reporter::ReportManager.new("spec")
-    suite = double("test suite")
-    very_long_name = "some test suite name that goes on and on and on and on and on and on and does not look like it will end any time soon and just when you think it is almost over it just continues to go on and on and on and on and on until it is almost over but wait there is more and then el fin"
-    suite.should_receive(:name).and_return(very_long_name)
-    suite.should_receive(:to_xml).and_return("<xml></xml>")
-    reporter.write_report(suite)
-    filename = "#{REPORTS_DIR}/SPEC-#{very_long_name}"[0..CI::Reporter::ReportManager::MAX_FILENAME_SIZE].gsub(/\s/, '-') + ".xml"
-    filename.length.should be <= 255
-    File.exist?(filename).should be true
-    File.open(filename) {|f| f.read.should == "<xml></xml>"}
-  end
+    it "shortens extremely long report filenames" do
+      reporter = CI::Reporter::ReportManager.new("spec")
+      suite = double("test suite")
+      very_long_name = "some test suite name that goes on and on and on and on and on and on and does not look like it will end any time soon and just when you think it is almost over it just continues to go on and on and on and on and on until it is almost over but wait there is more and then el fin"
+      expect(suite).to receive(:name).and_return(very_long_name)
+      expect(suite).to receive(:to_xml).and_return("<xml></xml>")
+      reporter.write_report(suite)
+      filename = "#{REPORTS_DIR}/SPEC-#{very_long_name}"[0..CI::Reporter::ReportManager::MAX_FILENAME_SIZE].gsub(/\s/, '-') + ".xml"
+      expect(filename.length).to be <= 255
+      expect(File.exist?(filename)).to be true
+      expect(File.read(filename)).to eql "<xml></xml>"
+    end
 
-  it "should shorten extremely long report filenames to custom length" do
-    reporter = CI::Reporter::ReportManager.new("spec")
-    suite = double("test suite")
-    very_long_name = "some test suite name that goes on and on and on and on and on and on and does not look like it will end any time soon and just when you think it is almost over it just continues to go on and on and on and on and on until it is almost over but wait there is more and then el fin"
-    suite.should_receive(:name).and_return(very_long_name)
-    suite.should_receive(:to_xml).and_return("<xml></xml>")
-    ENV['MAX_FILENAME_SIZE'] = '170'
-    reporter.write_report(suite)
-    filename = "#{REPORTS_DIR}/SPEC-#{very_long_name}"[0..170].gsub(/\s/, '-') + ".xml"
-    filename.length.should be <= 188
-    File.exist?(filename).should be true
-    File.open(filename) {|f| f.read.should == "<xml></xml>"}
-  end
+    it "shortens extremely long report filenames to custom length" do
+      reporter = CI::Reporter::ReportManager.new("spec")
+      suite = double("test suite")
+      very_long_name = "some test suite name that goes on and on and on and on and on and on and does not look like it will end any time soon and just when you think it is almost over it just continues to go on and on and on and on and on until it is almost over but wait there is more and then el fin"
+      expect(suite).to receive(:name).and_return(very_long_name)
+      expect(suite).to receive(:to_xml).and_return("<xml></xml>")
+      ENV['MAX_FILENAME_SIZE'] = '170'
+      reporter.write_report(suite)
+      filename = "#{REPORTS_DIR}/SPEC-#{very_long_name}"[0..170].gsub(/\s/, '-') + ".xml"
+      expect(filename.length).to be <= 188
+      expect(File.exist?(filename)).to be true
+      expect(File.read(filename)).to eql "<xml></xml>"
+    end
 
-  it "sidesteps existing files by adding an incrementing number" do
-    filename = "#{REPORTS_DIR}/SPEC-colliding-test-suite-name.xml"
-    FileUtils.mkdir_p(File.dirname(filename))
-    FileUtils.touch filename
-    reporter = CI::Reporter::ReportManager.new("spec")
-    suite = double("test suite")
-    suite.should_receive(:name).and_return("colliding test suite name")
-    suite.should_receive(:to_xml).and_return("<xml></xml>")
-    reporter.write_report(suite)
-    File.exist?(filename.sub('.xml', '.0.xml')).should be true
+    it "sidesteps existing files by adding an incrementing number" do
+      filename = "#{REPORTS_DIR}/SPEC-colliding-test-suite-name.xml"
+      FileUtils.mkdir_p(File.dirname(filename))
+      FileUtils.touch filename
+      reporter = CI::Reporter::ReportManager.new("spec")
+      suite = double("test suite")
+      expect(suite).to receive(:name).and_return("colliding test suite name")
+      expect(suite).to receive(:to_xml).and_return("<xml></xml>")
+      reporter.write_report(suite)
+      expect(File.exist?(filename.sub('.xml', '.0.xml'))).to be true
+    end
   end
 end

data/spec/ci/reporter/test_suite_spec.rb

@@ -1,157 +1,152 @@
 require File.dirname(__FILE__) + "/../../spec_helper.rb"
 require 'rexml/document'
 
-describe "A TestSuite" do
-  before(:each) do
-    @suite = CI::Reporter::TestSuite.new("example suite")
-  end
-
-  it "should collect timings when start and finish are invoked in sequence" do
-    @suite.start
-    @suite.finish
-    @suite.time.should >= 0
-  end
-
-  it "should aggregate tests" do
-    @suite.start
-    @suite.testcases << CI::Reporter::TestCase.new("example test")
-    @suite.finish
-    @suite.tests.should == 1
-  end
+module CI::Reporter
+  describe TestSuite do
+    subject(:suite) { CI::Reporter::TestSuite.new("example suite") }
+
+    let(:exception) do
+      begin
+        raise StandardError, "an exception occurred"
+      rescue => e
+        e
+      end
+    end
 
-  it "should stringify the name for cases when the object passed in is not a string" do
-    name = Object.new
-    def name.to_s; "object name"; end
-    CI::Reporter::TestSuite.new(name).name.should == "object name"
-  end
+    let(:failure) do
+      double("failure",
+             :failure? => true,
+             :error? => false,
+             :name => "failure",
+             :message => "There was a failure",
+             :location => exception.backtrace.join("\n"))
+    end
 
-  it "should indicate number of failures and errors" do
-    failure = double("failure")
-    failure.stub(:failure?).and_return true
-    failure.stub(:error?).and_return false
-
-    error = double("error")
-    error.stub(:failure?).and_return false
-    error.stub(:error?).and_return true
-
-    @suite.start
-    @suite.testcases << CI::Reporter::TestCase.new("example test")
-    @suite.testcases << CI::Reporter::TestCase.new("failure test")
-    @suite.testcases.last.failures << failure
-    @suite.testcases << CI::Reporter::TestCase.new("error test")
-    @suite.testcases.last.failures << error
-    @suite.finish
-    @suite.tests.should == 3
-    @suite.failures.should == 1
-    @suite.errors.should == 1
-  end
-end
+    let(:error) do
+       double("error",
+              :failure? => false,
+              :error? => true,
+              :name => "error",
+              :message => "There was a error",
+              :location => exception.backtrace.join("\n"))
+    end
 
-describe "TestSuite xml" do
-  before(:each) do
-    ENV['CI_CAPTURE'] = nil
-    @suite = CI::Reporter::TestSuite.new("example suite")
-    @suite.assertions = 11
-    begin
-      raise StandardError, "an exception occurred"
-    rescue => e
-      @exception = e
+    it "collects timings when start and finish are invoked in sequence" do
+      suite.start
+      suite.finish
+      expect(suite.time).to be >= 0
     end
-  end
 
-  it "should render successfully with CI_CAPTURE off" do
-    ENV['CI_CAPTURE'] = 'off'
-    @suite.start
-    @suite.testcases << CI::Reporter::TestCase.new("example test")
-    @suite.finish
-    xml = @suite.to_xml
-  end
+    it "aggregates tests" do
+      suite.start
+      suite.testcases << CI::Reporter::TestCase.new("example test")
+      suite.finish
+      expect(suite.tests).to eql 1
+    end
 
-  it "should contain Ant/JUnit-formatted description of entire suite" do
-    failure = double("failure")
-    failure.stub(:failure?).and_return true
-    failure.stub(:error?).and_return false
-    failure.stub(:name).and_return "failure"
-    failure.stub(:message).and_return "There was a failure"
-    failure.stub(:location).and_return @exception.backtrace.join("\n")
-
-    error = double("error")
-    error.stub(:failure?).and_return false
-    error.stub(:error?).and_return true
-    error.stub(:name).and_return "error"
-    error.stub(:message).and_return "There was a error"
-    error.stub(:location).and_return @exception.backtrace.join("\n")
-
-    @suite.start
-    @suite.testcases << CI::Reporter::TestCase.new("example test")
-    @suite.testcases << CI::Reporter::TestCase.new("skipped test").tap {|tc| tc.skipped = true }
-    @suite.testcases << CI::Reporter::TestCase.new("failure test")
-    @suite.testcases.last.failures << failure
-    @suite.testcases << CI::Reporter::TestCase.new("error test")
-    @suite.testcases.last.failures << error
-    @suite.finish
-
-    xml = @suite.to_xml
-    doc = REXML::Document.new(xml)
-    testsuite = doc.root.elements.to_a("/testsuite")
-    testsuite.length.should == 1
-    testsuite = testsuite.first
-    testsuite.attributes["name"].should == "example suite"
-    testsuite.attributes["assertions"].should == "11"
-    testsuite.attributes["timestamp"].should match(/(\d{4})-(\d{2})-(\d{2})T(\d{2})\:(\d{2})\:(\d{2})[+-](\d{2})\:(\d{2})/)
-
-    testcases = testsuite.elements.to_a("testcase")
-    testcases.length.should == 4
-  end
+    it "stringifies the name for cases when the object passed in is not a string" do
+      name = Object.new
+      def name.to_s; "object name"; end
+      expect(CI::Reporter::TestSuite.new(name).name).to eql "object name"
+    end
 
-  it "should contain full exception type and message in location element" do
-    failure = double("failure")
-    failure.stub(:failure?).and_return true
-    failure.stub(:error?).and_return false
-    failure.stub(:name).and_return "failure"
-    failure.stub(:message).and_return "There was a failure"
-    failure.stub(:location).and_return @exception.backtrace.join("\n")
-
-    @suite.start
-    @suite.testcases << CI::Reporter::TestCase.new("example test")
-    @suite.testcases << CI::Reporter::TestCase.new("failure test")
-    @suite.testcases.last.failures << failure
-    @suite.finish
-
-    xml = @suite.to_xml
-    doc = REXML::Document.new(xml)
-    elem = doc.root.elements.to_a("/testsuite/testcase[@name='failure test']/failure").first
-    location = elem.texts.join
-    location.should =~ Regexp.new(failure.message)
-    location.should =~ Regexp.new(failure.name)
-  end
+    it "indicates number of failures and errors" do
+      suite.start
+      suite.testcases << CI::Reporter::TestCase.new("example test")
+      suite.testcases << CI::Reporter::TestCase.new("failure test")
+      suite.testcases.last.failures << failure
+      suite.testcases << CI::Reporter::TestCase.new("error test")
+      suite.testcases.last.failures << error
+      suite.finish
+      expect(suite.tests).to eql 3
+      expect(suite.failures).to eql 1
+      expect(suite.errors).to eql 1
+    end
 
-  it "should filter attributes properly for invalid characters" do
-    failure = double("failure")
-    failure.stub(:failure?).and_return true
-    failure.stub(:error?).and_return false
-    failure.stub(:name).and_return "failure"
-    failure.stub(:message).and_return "There was a <failure>\nReason: blah"
-    failure.stub(:location).and_return @exception.backtrace.join("\n")
-
-    @suite.start
-    @suite.testcases << CI::Reporter::TestCase.new("failure test")
-    @suite.testcases.last.failures << failure
-    @suite.finish
-
-    xml = @suite.to_xml
-    xml.should =~ %r/message="There was a &lt;failure&gt;\.\.\."/
+    context "xml" do
+      let(:suite) { CI::Reporter::TestSuite.new("example suite") }
+
+      before(:each) do
+        ENV['CI_CAPTURE'] = nil
+        suite.assertions = 11
+      end
+
+      after(:each) do
+        ENV['CI_CAPTURE'] = nil
+      end
+
+      it "renders successfully with CI_CAPTURE off" do
+        ENV['CI_CAPTURE'] = 'off'
+        suite.start
+        suite.testcases << CI::Reporter::TestCase.new("example test")
+        suite.finish
+        xml = suite.to_xml
+      end
+
+      it "contains Ant/JUnit-formatted description of entire suite" do
+        suite.start
+        suite.testcases << CI::Reporter::TestCase.new("example test")
+        suite.testcases << CI::Reporter::TestCase.new("skipped test").tap {|tc| tc.skipped = true }
+        suite.testcases << CI::Reporter::TestCase.new("failure test")
+        suite.testcases.last.failures << failure
+        suite.testcases << CI::Reporter::TestCase.new("error test")
+        suite.testcases.last.failures << error
+        suite.finish
+
+        xml = suite.to_xml
+        doc = REXML::Document.new(xml)
+        testsuite = doc.root.elements.to_a("/testsuite")
+        expect(testsuite.length).to eql 1
+        testsuite = testsuite.first
+        expect(testsuite.attributes["name"]).to eql "example suite"
+        expect(testsuite.attributes["assertions"]).to eql "11"
+        expect(testsuite.attributes["timestamp"]).to match(/(\d{4})-(\d{2})-(\d{2})T(\d{2})\:(\d{2})\:(\d{2})[+-](\d{2})\:(\d{2})/)
+
+        testcases = testsuite.elements.to_a("testcase")
+        expect(testcases.length).to eql 4
+      end
+
+      it "contains full exception type and message in location element" do
+        suite.start
+        suite.testcases << CI::Reporter::TestCase.new("example test")
+        suite.testcases << CI::Reporter::TestCase.new("failure test")
+        suite.testcases.last.failures << failure
+        suite.finish
+
+        xml = suite.to_xml
+        doc = REXML::Document.new(xml)
+        elem = doc.root.elements.to_a("/testsuite/testcase[@name='failure test']/failure").first
+        location = elem.texts.join
+        expect(location).to match Regexp.new(failure.message)
+        expect(location).to match Regexp.new(failure.name)
+      end
+
+      it "filters attributes properly for invalid characters" do
+        failure = double("failure",
+                         :failure? => true,
+                         :error? => false,
+                         :name => "failure",
+                         :message => "There was a <failure>\nReason: blah",
+                         :location => exception.backtrace.join("\n"))
+
+        suite.start
+        suite.testcases << CI::Reporter::TestCase.new("failure test")
+        suite.testcases.last.failures << failure
+        suite.finish
+
+        xml = suite.to_xml
+        expect(xml).to match %r/message="There was a &lt;failure&gt;\.\.\."/
+      end
+    end
   end
-end
 
-describe "A TestCase" do
-  before(:each) do
-    @tc = CI::Reporter::TestCase.new("example test")
-  end
+  describe TestCase do
+    subject(:tc) { TestCase.new("example test") }
 
-  it "should collect timings when start and finish are invoked in sequence" do
-    @tc.start
-    @tc.finish
-    @tc.time.should >= 0
+    it "collects timings when start and finish are invoked in sequence" do
+      tc.start
+      tc.finish
+      expect(tc.time).to be >= 0
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ci_reporter
 version: !ruby/object:Gem::Version
-  version: 2.0.0.alpha2
+  version: 2.0.0
 platform: ruby
 authors:
 - Nick Sieger
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-30 00:00:00.000000000 Z
+date: 2014-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: builder
@@ -59,14 +59,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
 description: CI::Reporter is an add-on to Ruby testing frameworks that allows you
   to generate XML reports of your test runs. The resulting files can be read by a
   continuous integration system that understands Ant's JUnit report format.
@@ -91,6 +91,7 @@ files:
 - ci_reporter.gemspec
 - gemfiles/.gitignore
 - lib/ci/reporter/core.rb
+- lib/ci/reporter/output_capture.rb
 - lib/ci/reporter/rake/utils.rb
 - lib/ci/reporter/report_manager.rb
 - lib/ci/reporter/test_suite.rb
@@ -114,9 +115,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.2.2