ci_reporter 2.0.0.alpha2 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 9d4fd920bd59773352edb9dd239cb99ffe419406
-  data.tar.gz: 227712fdcd966fa2b57d5a32133e5e0587a89e03
+SHA256:
+  metadata.gz: a528a2fafebcc8be684a8ca7dc12acef432ac82dec567d5b1176bdfdb5377ffb
+  data.tar.gz: 97d80b1b12e409a0d9ad4d5a9592800a30492b41050787c43a16d86128687167
 SHA512:
-  metadata.gz: 094edf36eb8b168fb606a2a2ad73ea9bf3e49a078934462ff95d2b07a27f49038291789b162807fe8395f49d237887edd0926f983a1848b100e0d150ff9e2266
-  data.tar.gz: bdde115c27717e95030df44d1accd7d79b38ba8230895faa0d13409cb4b721444efc79615241dd599e7e0ad25ada12777cad0247783d43428954a1d1298e2dd1
+  metadata.gz: af641871ec70d11f86d1afa32590d848a8e3118bb5fd494f07005f8f97421242f365c74197e6cee1b606b4c817622539b5b9d4df4e65449c4c8f745d8c49dafc
+  data.tar.gz: e9cbaff5e0ec53a727791a81645282653ac8d29ed68e0970bc454d5c84b05bf170adb4b1ce5f1a8cd2f895b0adfaba9b07ae9a72c34b5115aae12a7189ce8907

data/.github/workflows/ci.yaml

@@ -0,0 +1,27 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  test:
+    name: test
+    strategy:
+      matrix:
+        ruby: ['2.6', '2.7', '3.0', '3.1', '3.2', head, jruby, jruby-head]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - name: Tests
+        run: bundle exec rake
+      - name: Gem build
+        run: bundle exec rake build

data/.github/workflows/release.yaml

@@ -0,0 +1,41 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v[0-9]+.[0-9]+.[0-9]+"
+
+jobs:
+  release:
+    name: release
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.2'
+          bundler-cache: true
+
+      - name: Log into Rubygems
+        run: |
+          mkdir -p ~/.local/share/gem
+          echo ":rubygems_api_key: ${{ secrets.RUBYGEMS_API_KEY }}" > ~/.local/share/gem/credentials
+          chmod 600 ~/.local/share/gem/credentials
+
+      - name: Release
+        run: |
+          set -e
+          PKG="$(echo *.gemspec | sed 's/.gemspec//')"
+          VERSION="${GITHUB_REF#refs/tags/v}"
+          bundle exec rake build
+          GEM="pkg/$PKG-$VERSION.gem"
+          if [ -f "$GEM" ]; then
+            gem push $GEM
+            echo "Release $VERSION done."
+          else
+            echo "Build did not create a $VERSION release gem."
+            echo "Please check the version in the gemspec and try again."
+            cat *.gemspec | grep '\.version'
+            exit 1
+          fi

data/History.txt

@@ -1,3 +1,28 @@
+== 2.1.0 (2023/02/09)
+
+=== Changed
+
+- Testing on Ruby 2.6 - HEAD, JRuby 9.x latest, JRuby HEAD
+- CI changed to GitHub Actions
+- Tracking branch changed to `main`
+- GH #160: Add monotonic time (Michal Cichra)
+- GH #148: fix deprecation issues (Akira Matsuda)
+- GH #149: fix for RSpec 3.1.2 (Akira Matsuda)
+
+=== Removed
+
+- Testing on versions of Ruby < 2.6
+
+== 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

@@ -5,8 +5,7 @@ system that understands Ant's JUnit report XML format, thus allowing
 your CI system to track test/spec successes and failures.
 
 [![Gem Version](https://badge.fury.io/rb/ci_reporter.svg)](http://badge.fury.io/rb/ci_reporter)
-[![Build Status](https://travis-ci.org/ci-reporter/ci_reporter.svg?branch=master)](https://travis-ci.org/ci-reporter/ci_reporter)
-[![Dependency Status](https://gemnasium.com/ci-reporter/ci_reporter.svg)](https://gemnasium.com/ci-reporter/ci_reporter)
+[![Build Status](https://github.com/ci-reporter/ci_reporter/actions/workflows/ci.yaml/badge.svg)](https://github.com/ci-reporter/ci_reporter/actions/workflows/ci.yaml)
 [![Code Climate](https://codeclimate.com/github/ci-reporter/ci_reporter.png)](https://codeclimate.com/github/ci-reporter/ci_reporter)
 
 ## Usage
@@ -30,12 +29,23 @@ 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 convenient, 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
+2. Enter "test/reports/\*.xml,spec/reports/\*.xml" in the "Test report
 XMLs" field (adjust this to suit which tests you are running)
 
 Report files are written, by default, to the
@@ -58,7 +68,7 @@ will be invoked:
 ```ruby
 if ENV['GENERATE_REPORTS'] == 'true'
   require 'ci/reporter/rake/rspec'
-  task :rspec => 'ci:setup:rspec'
+  task :spec => 'ci:setup:rspec'
 end
 ```
 
@@ -66,7 +76,7 @@ You can either inject this variable in your CI or simply call `rake`
 with the environment variable set:
 
 ```
-GENERATE_REPORTS=true rake rspec
+GENERATE_REPORTS=true rake spec
 ```
 
 ### With CI-specific Rake tasks
@@ -75,7 +85,7 @@ Instead of modifying your existing Rake tasks, create new ones:
 
 ```ruby
 namespace :ci do
-  task :all => ['ci:setup:rspec', 'rspec']
+  task :all => ['ci:setup:rspec', 'spec']
 end
 ```
 

data/Rakefile

@@ -2,7 +2,6 @@ require "bundler/gem_tasks"
 require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:rspec) do |t|
-  t.pattern = FileList['spec']
   t.rspec_opts = "--color"
 end
 

data/ci_reporter.gemspec

@@ -21,8 +21,9 @@ Gem::Specification.new do |spec|
   spec.extra_rdoc_files = ["History.txt", "LICENSE.txt", "README.md"]
 
   spec.add_dependency "builder", ">= 2.1.2"
+  spec.add_dependency "rexml"
 
   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/monotonic_time.rb

@@ -0,0 +1,22 @@
+module CI
+  module Reporter
+    module MonotonicTime
+      module_function
+
+      if defined?(Process::CLOCK_MONOTONIC)
+        def time_in_nanoseconds
+          Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
+        end
+      else
+        def time_in_nanoseconds
+          t = Time.now
+          t.to_i * 10 ** 9 + t.nsec
+        end
+      end
+
+      def time_in_seconds
+        time_in_nanoseconds / 10 ** 9.0
+      end
+    end
+  end
+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/report_manager.rb

@@ -31,7 +31,7 @@ module CI #:nodoc:
       # with N < 100000, to prevent endless sidestep loops
       MAX_SIDESTEPS     = 100000
       MAX_FILENAME_SIZE = 240
-      #
+
       def filename_for(suite)
         basename = "#{@basename}-#{suite.name.gsub(/[^a-zA-Z0-9]+/, '-')}"
         suffix = "xml"
@@ -48,7 +48,7 @@ module CI #:nodoc:
         # 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
+        while File.exist?(filename) && i < MAX_SIDESTEPS
           filename = [basename, i, suffix].join(".")
           i += 1
         end

data/lib/ci/reporter/test_suite.rb

@@ -1,60 +1,46 @@
-require 'delegate'
-require 'stringio'
 require 'time'
+require 'builder'
+require 'ci/reporter/output_capture'
+require 'ci/reporter/monotonic_time'
 
 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)
         super(name.to_s) # RSpec passes a "description" object instead of a string
         @testcases = []
+        @capture_out = nil
+        @capture_err = nil
       end
 
       # Starts timing the test suite.
       def start
-        @start = Time.now
+        @start_time = Time.now
+        @start = MonotonicTime.time_in_seconds
         unless ENV['CI_CAPTURE'] == "off"
           @capture_out = OutputCapture.wrap($stdout) {|io| $stdout = io }
           @capture_err = OutputCapture.wrap($stderr) {|io| $stderr = io }
@@ -64,41 +50,32 @@ module CI
       # Finishes timing the test suite.
       def finish
         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.time = MonotonicTime.time_in_seconds - @start
+        self.timestamp = @start_time.iso8601
+        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 +83,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
 
@@ -116,22 +95,30 @@ module CI
 
       # Starts timing the test.
       def start
-        @start = Time.now
+        @start = MonotonicTime.time_in_seconds
       end
 
       # Finishes timing the test.
       def finish
-        self.time = Time.now - @start
+        self.time = MonotonicTime.time_in_seconds - @start
       end
 
       # 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 +127,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.1.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.1.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: 2023-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: builder
@@ -25,6 +25,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.1.2
+- !ruby/object:Gem::Dependency
+  name: rexml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -59,14 +73,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.
@@ -80,17 +94,19 @@ extra_rdoc_files:
 - LICENSE.txt
 - README.md
 files:
+- ".github/workflows/ci.yaml"
+- ".github/workflows/release.yaml"
 - ".gitignore"
 - ".rspec"
-- ".travis.yml"
 - Gemfile
 - History.txt
 - LICENSE.txt
 - README.md
 - Rakefile
 - ci_reporter.gemspec
-- gemfiles/.gitignore
 - lib/ci/reporter/core.rb
+- lib/ci/reporter/monotonic_time.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,12 +130,11 @@ 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
+rubygems_version: 3.4.1
 signing_key: 
 specification_version: 4
 summary: Connects Ruby test frameworks to CI systems via JUnit reports.

data/.travis.yml

@@ -1,5 +0,0 @@
-rvm:
-  - 1.9.3
-  - 2.0
-  - 2.1
-  - jruby

data/gemfiles/.gitignore

@@ -1 +0,0 @@
-Gemfile.*.lock