res 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 127358ee22371eb6201add12abb4a4aec0534ef7
+  data.tar.gz: 7e4bdc7f8c10691fe03569bf3a8762cde6aaada9
+SHA512:
+  metadata.gz: 934947a0fb56156732515d456b454819146b83ce8e3b7346a2bba55faafe47b54b716093a22aaf2201a3dda3f5fdf1cd7010ad812fab92c30e16a70dc55d89e4
+  data.tar.gz: 0507cb3031cb9301ebc6281d4b45ce9316ad3877b1a4ea53d69351bbaf121abf3674691d5f6d039e8299e9f55bce40799d9baf74038476b77d314c8870063fe3

data/README.md

@@ -0,0 +1,96 @@
+# Res
+
+Res is a collection of formatting tools for making test 
+result reporting easier and more consistent. The concept is that 
+rather than writing formatters over and over again for different testing
+tools and result repositories, we standardise on one format for test
+results (an Intermediate Representation) and write a single formatter
+and submitter for each runner and repository.
+
+Example: Reporting a testing tool output to testrail
+
+    Formatter      --------->    Intermediate     -------->   Reporter
+    or Parser                   Representation               (TestRail)
+
+## Frontends
+
+There are three different types of front end:
+
+1. Formatters -- libraries that can be loaded into a test runner to generate IR output
+2. Parsers -- scripts that parse result files into IR after a test runner has completed
+3. Native -- custom test runners that use IR as their native format
+
+IR is a json formatted file that captures a hierarchical definition of 
+a test suite alongside results and metadata.
+
+## Formatters and Parsers
+You can dump a Res IR results file using a cucumber formatter or parse xunit output into res format. 
+
+## Cucumber
+
+    cucumber -f pretty -f Res::Formatters::RubyCucumber -o './cucumber.res'
+Note: This cucumber formatter works for cucumber version < 2.0 
+
+## Junit
+
+    ./bin/res.rb --junit '/path/to/xunit_result.xml'
+Note: The Res output of the xunit parser is saved in the current directory
+
+## Reporters
+
+There are a number of backend reporters, for taking IR and producing a report from
+it, or submitting the IR results to a test repository or test management
+tool.
+
+If you have a Res IR file, you can submit using a reporter: 
+
+    ./bin/res.rb --res '/path/to/file.res' --submit REPORTER [... options]
+
+### Hive
+
+Hive CI uses a Res reporter for result submission, the api arguments look like this:
+
+    Res.submit_results( 
+      :reporter => :hive, 
+      :ir       => 'path/to/file.res', 
+      :url      => 'http://hive.local', 
+      :job_id   => 10723 
+    )
+
+### TestRail
+
+    ./bin/res.rb --res '/path/to/file.res' --submit testrail --config-file '/path/to/.test_rail.yaml'
+
+Our TestRail reporter currently be used to sync a suite with TestRail, and
+to submit test results against a test run. You will need to create a
+config file in your project in order for our reporter to know where to sync
+the tests and put the results.
+    
+Your config file should be called .test_rail.yaml, and should look like this:
+
+    namespace: 'NameSpace'
+    user:      'user@example.com'
+    password:  'passw0rd'
+    project:   'MyProjectName'
+    suite:     'MySuite'
+    run_name:  'RunName' or run_id:    '1234'
+
+### Testmine 
+
+The Testmine reporter is very similar to the TestRail reporter, but doesn't 
+require you to sync your test definitions before you submit a run.
+
+You need to create a project file in the root of your test code, the file 
+should be called .testmine.yaml, and should look like this:
+
+    testmine_url: 'mytestmineinstance.bbc.co.uk'
+    authentication: 'authenticationkey'
+    project:   'MyProjectName'
+    component: 'Android acceptance'
+    suite:     'MySuiteName'
+
+## License
+
+*Res* is available to everyone under the terms of the MIT open source licence. Take a look at the LICENSE file in the code.
+
+Copyright (c) 2015 BBC

data/lib/res.rb

@@ -0,0 +1,45 @@
+require 'res/ir'
+
+# Res API
+module Res
+
+  # Report Res IR to a test repository or similar
+  def self.submit_results(args)
+    reporter_class = Res.reporter_class(args[:reporter])
+    reporter = reporter_class.new( args )
+    
+    ir = Res::IR.load(args[:ir])
+    
+    reporter.submit_results( ir, args )
+  end
+
+  def self.reporter_class(type)
+    case type
+    when :test_rail
+      require 'res/reporters/test_rail'
+      Res::Reporters::TestRail
+    when :hive
+      require 'res/reporters/hive'
+      Res::Reporters::Hive
+    when :testmine
+      require 'res/reporters/testmine'
+      Res::Reporters::Testmine
+    end
+  end
+
+  def self.parse_results(args)
+    parser_class = Res.parser_class(args[:parser])
+    parser_class.new(args[:file])
+  end
+
+  def self.parser_class(type)
+    case type
+    when :junit
+      require 'res/parsers/junit'
+      Res::Parsers::Junit
+    else
+      raise "#{type} parser not Implemented"
+    end
+  end
+
+end

data/lib/res/config.rb

@@ -0,0 +1,59 @@
+require 'yaml'
+
+
+module Res
+  class Config
+    attr_accessor :struct, :required, :optional, :prepend
+        
+    def initialize(items, args = {})
+      @required = *items
+      @optional = args[:optional] || []
+      @prepend = args[:pre_env] || ''
+      items = required + optional
+      @struct = Struct.new(*items).new
+    end
+    
+    # Load in config -- this can come from three places:
+    # 1. Arguments passed to the initializer
+    # 2. From environment variables
+    # 3. From a config file
+    def process( args = {} )
+      
+      config_from_file = {}
+      if args[:config_file]
+        config_from_file = load_from_config(args[:config_file])
+        args.delete(:config_file)
+      end
+      
+      missing = []
+      struct.members.each do |item|
+        struct[item] = args[item] || ENV[(prepend + item.to_s).upcase] || config_from_file[item] || nil
+        missing << item if (struct[item].nil? && required.include?(item))
+      end
+      raise "Missing configuration: " + missing.join( ", ") if missing.any?
+    end
+
+    def load_from_config(config_file)
+      config = {}
+      if File.exists?(config_file)
+        config = Res::Config.symbolize_keys(YAML::load(File.open(config_file)))
+      else
+        raise "Couldn't find config file '#{config_file}'"
+      end
+      config
+    end
+    
+    def self.symbolize_keys(hash)
+      symbolized_hash = {}
+      hash.each do |key, value|
+        symbolized_hash[key.to_sym] = value
+      end
+      symbolized_hash
+    end
+    
+    def method_missing(m, *args, &block)
+      struct.send(m,*args, &block)
+    end
+
+  end
+end

data/lib/res/formatters/ruby_cucumber.rb

@@ -0,0 +1,284 @@
+# Formatter for ruby cucumber
+
+require 'fileutils'
+require 'res/ir'
+require 'cucumber/formatter/io'
+
+module Res
+  module Formatters
+    class RubyCucumber
+      include FileUtils
+      include ::Cucumber::Formatter::Io
+
+      def initialize(runtime, path_or_io, options)
+        cucumber_version = %x(cucumber --version)
+        @cucumber_version = cucumber_version.gsub("\n","") 
+        
+        @runtime = runtime
+        @io = ensure_io(path_or_io, "reporter")
+        @options = options
+        @exceptions = []
+        @indent = 0
+        @prefixes = options[:prefixes] || {}
+        @delayed_messages = []
+        @_start_time = Time.now
+      end
+
+      def before_features(features)
+        @_features = []
+      end
+
+      # Once everything has run -- whack it in a ResultIR object and
+      # dump it as json
+      def after_features(features)
+        results = @_features
+        ir = ::Res::IR.new( :started     => @_start_time,
+                            :finished    => Time.now(),
+                            :results     => results,
+                            :type        => 'Cucumber' )
+        @io.puts ir.json
+      end
+
+      def before_feature(feature)
+        @_feature = {}
+        @_context = {}
+        @_feature[:started] = Time.now()
+        begin
+          if @cucumber_version.to_f < 1.3.to_f
+            uri = feature.file.to_s
+          else  
+           uri = feature.location.to_s
+          end
+          
+          hash = RubyCucumber.split_uri( uri )
+          @_feature[:file] = hash[:file]
+          @_feature[:line] = hash[:line]
+          @_feature[:urn]  = hash[:urn]
+        rescue
+          @_feature[:uri] = 'unknown'
+        end
+        @_features << @_feature
+        @_context = @_feature
+      end
+
+      def comment_line(comment_line)
+        @_context[:comments] = [] if !@_context[:comments]
+        @_context[:comments] << comment_line 
+      end
+
+      def after_tags(tags)
+      end
+
+      def tag_name(tag_name)
+        @_context[:tags] = [] if !@_context[:tag]
+        # Strip @ from tags
+        @_context[:tags] << tag_name[1..-1]
+      end
+
+      # { :type => 'Feature',
+      #   :name => 'Feature name',
+      #   :description => "As a blah\nAs a blah\n" }
+      def feature_name(keyword, name)
+        @_feature[:type] = "Cucumber::" + keyword.gsub(/\s+/, "")
+
+        lines = name.split("\n")
+        lines = lines.collect { |l| l.strip }
+
+        @_feature[:name] = lines.shift
+        @_feature[:description] = lines.join("\n")
+      end
+
+      def after_feature(feature)
+        @_feature[:finished] = Time.now()
+      end
+
+      def before_feature_element(feature_element)
+
+        @_feature_element = {}
+        @_context = {}
+        @_feature_element[:started] = Time.now
+        begin
+          if @cucumber_version.to_f < 1.3.to_f
+            uri = feature_element.file_colon_line
+          else  
+            uri = feature_element.location.to_s
+          end
+          hash = RubyCucumber.split_uri( uri )
+          @_feature_element[:file] = hash[:file]
+          @_feature_element[:line] = hash[:line]
+          @_feature_element[:urn] = hash[:urn]
+        rescue => e
+          @_feature_element[:error] = e.message
+          @_feature_element[:file] = 'unknown'
+        end
+
+        @_feature[:children] = [] if ! @_feature[:children]
+
+        @_feature[:children] << @_feature_element
+        @_context = @_feature_element
+      end
+
+      # After a scenario
+      def after_feature_element(feature_element)
+        @_context = {}
+
+        if feature_element.respond_to? :status
+          @_feature_element[:status] = feature_element.status
+        end
+        @_feature_element[:finished] = Time.now
+      end
+
+      def before_background(background)
+        #@_context[:background] = background
+      end
+
+      def after_background(background)
+      end
+
+      def background_name(keyword, name, file_colon_line, source_indent)
+      end
+
+        #    def before_examples_array(examples_array)
+        #      @indent = 4
+        #      @io.puts
+        #      @visiting_first_example_name = true
+        #    end
+        #
+
+      def examples_name(keyword, name)
+        #      @io.puts unless @visiting_first_example_name
+        #      @visiting_first_example_name = false
+        #      names = name.strip.empty? ? [name.strip] : name.split("\n")
+        #      @io.puts("    #{keyword}: #{names[0]}")
+        #      names[1..-1].each {|s| @io.puts "      #{s}" } unless names.empty?
+        #      @io.flush
+        #      @indent = 6
+        #      @scenario_indent = 6
+      end
+        #
+
+      def scenario_name(keyword, name, file_colon_line, source_indent)
+        @_context[:type] = "Cucumber::" + keyword.gsub(/\s+/, "")
+        @_context[:name] = name || ''
+      end
+
+      def before_step(step)
+        @_step = {}
+
+        # Background steps can appear totally divorced from scenerios (feature
+        # elements). Need to make sure we're not including them as children
+        # to scenario that don't exist
+        return if @_feature_element && @_feature_element[:finished]
+
+        @_feature_element = {} if !@_feature_element
+        @_feature_element[:children] = [] if !@_feature_element[:children]
+        @_feature_element[:children] << @_step
+        @_context = @_step
+      end
+
+    #  def before_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background, file_colon_line)
+    #    @hide_this_step = false
+    #    if exception
+    #      if @exceptions.include?(exception)
+    #        @hide_this_step = true
+    #        return
+    #      end
+    #      @exceptions << exception
+    #    end
+    #    if status != :failed && @in_background ^ background
+    #      @hide_this_step = true
+    #      return
+    #    end
+    #    @status = status
+    #  end
+
+      # Argument list changed after cucumber 1.4, hence the *args
+      def step_name(keyword, step_match, status, source_indent, background, *args)
+
+        file_colon_line = args[0] if args[0]
+
+        @_step[:type] = "Cucumber::Step"
+        name = keyword + step_match.format_args(lambda{|param| %{#{param}}}) 
+        @_step[:name] = name
+        @_step[:status] = status
+        #@_step[:background] = background
+        @_step[:type] = "Cucumber::Step"
+
+      end
+
+        #    def doc_string(string)
+        #      return if @options[:no_multiline] || @hide_this_step
+        #      s = %{"""\n#{string}\n"""}.indent(@indent)
+        #      s = s.split("\n").map{|l| l =~ /^\s+$/ ? '' : l}.join("\n")
+        #      @io.puts(format_string(s, @current_step.status))
+        #      @io.flush
+        #    end
+        #
+        
+      def exception(exception, status)
+        @_context[:message] = exception.to_s
+      end
+
+      def before_multiline_arg(multiline_arg)
+        #      return if @options[:no_multiline] || @hide_this_step
+        #      @table = multiline_arg
+      end
+
+      def after_multiline_arg(multiline_arg)
+        @_context[:args] = multiline_arg.to_s.gsub(/\e\[(\d+)m/, '')
+        @_table = nil
+      end
+
+      # Before a scenario outline is encountered
+      def before_outline_table(outline_table)
+        # Scenario outlines appear as children like normal scenarios,
+        # but really we just want to construct normal-looking children
+        # from them
+        @_outlines = @_feature_element[:children]
+        @_table = []
+      end
+
+      def after_outline_table(outline_table)
+        headings = @_table.shift
+        description = @_outlines.collect{ |o| o[:name] }.join("\n") + "\n" + headings[:name]
+        @_feature_element[:children] = @_table
+        @_feature_element[:description] = description
+      end
+
+      def before_table_row(table_row)
+        @_current_table_row = { :type => 'Cucumber::ScenarioOutline::Example' }
+        @_table = [] if !@_table
+      end
+
+      def after_table_row(table_row)
+        if table_row.class == Cucumber::Ast::OutlineTable::ExampleRow
+          @_current_table_row[:name] = table_row.name
+          if table_row.exception
+            @_current_table_row[:message] = table_row.exception.to_s
+          end
+          if table_row.scenario_outline
+            @_current_table_row[:status] = table_row.status
+          end
+          @_current_table_row[:line] = table_row.line
+          @_current_table_row[:urn] = @_feature_element[:file] + ":" + table_row.line.to_s
+          @_table << @_current_table_row
+        end
+      end
+
+      def after_table_cell(cell)
+      end
+
+      def table_cell_value(value, status)
+        @_current_table_row[:children] = [] if !@_current_table_row[:children]
+        @_current_table_row[:children] << { :type => "Cucumber::ScenarioOutline::Parameter",
+                                            :name => value, :status => status }
+      end
+
+      def self.split_uri(uri)
+        strings = uri.rpartition(/:/)
+        { :file => strings[0], :line => strings[2].to_i, :urn => uri }
+      end
+
+    end
+  end
+end

data/lib/res/ir.rb

@@ -0,0 +1,81 @@
+require 'json'
+
+module Res
+  class IR
+    attr_accessor :hash, :results, :type, :start_time, :end_time, :world
+    attr_accessor :project, :suite, :target, :hive_job_id
+ 
+    def self.load(file)
+      f = File.open file
+      hash = JSON.load(f, nil, :symbolize_names => true )
+      Res::IR.new( hash )
+    end  
+   
+    # Expects hash of:
+    # :results => {  }
+    # :type => test_runner
+    # :start_time => Time the tests started
+    # :end_time => Time they completed
+    def initialize( options = {} )
+      @results     = options[:results]     or raise "No results data"
+      @type        = options[:type]        or raise "No type provided (e.g. 'Cucumber')"
+      @started     = options[:started]     or raise "Need to provide a start time"
+      @finished    = options[:finished]    or raise "Need to provide an end time"
+    end
+
+    # Dump as json
+    def json
+      hash = {
+        :started     => @started,
+        :finished    => @finished,
+        :results     => @results,
+        :type        => @type }
+      
+      # Merge in the world information if it's available
+      hash[:world] = world if world
+      hash[:hive_job_id] = hive_job_id if hive_job_id
+      
+      JSON.pretty_generate( hash )
+    end
+
+    # Pluck out the actual test nodes from the contexts
+    def tests
+      IR.find_tests(results).flatten
+    end
+
+    def count(status)
+      tests.count { |t| t[:status].to_sym == status.to_sym  }
+    end
+
+    # Returns a simple array of test information
+    # [ { :name => 'test1', :urn => 'file/tests.t:32', :status => 'passed', :time => 12.04 },
+    #   { :name => 'test2', :urn => 'file/tests.t:36', :status => 'failed', :time =>  } ]
+    def flat_format
+      self.tests.collect do |t|
+        { :name   => t[:name],
+          :urn    => t[:urn],
+          :status => t[:status] }
+      end
+    end
+    
+    private
+    
+    # Recursive function for retrieving test nodes
+    def self.find_tests(nodes)
+      tests = []
+      nodes.each do |n|
+        if IR.is_a_test?(n)
+          tests << n
+        elsif n[:children]
+          tests << IR.find_tests(n[:children])
+        end
+      end
+      tests
+    end
+    
+    def self.is_a_test?(node)
+      !node[:status].nil?
+    end
+    
+  end
+end

data/lib/res/mappings.rb

@@ -0,0 +1,23 @@
+module Res
+  class Mappings
+
+    attr_accessor :context, :case, :type
+
+    def initialize(type)
+      @type = type
+      set_type
+    end
+
+    def set_type
+      case @type
+      when "Junit"
+        @context = ["JUnit::testsuite", "JUnit::testsuites"]
+        @case = ["JUnit::testcase"]      
+      when "Cucumber"
+        @context = ["Cucumber::Feature", "Cucumber::ScenarioOutline"]
+        @case = ["Cucumber::Scenario"]
+      end
+    end
+
+  end
+end

data/lib/res/parsers/junit.rb

@@ -0,0 +1,65 @@
+require 'ox'
+require 'json'
+require 'res/ir'
+
+module Res
+  module Parsers
+    class Junit
+      attr_accessor :io
+     
+      def initialize(junit_xml)
+        file = File.open(junit_xml, "rb") 
+        begin
+          junit = Ox.parse(file.read)
+        rescue Ox::ParseError => e
+         raise "Invalid xunit XML format. Error: #{e}"
+        end
+        file.close
+        result = Array.new
+        result = attach_suite(junit)
+        ir = ::Res::IR.new( :type        => 'Junit', 
+                            :started     => "",
+                            :finished    => Time.now(),
+                            :results     => result
+                            )
+        @io = File.open("./junit.res", "w")
+        @io.puts ir.json
+        @io.close
+      end
+
+      def attach_cases(node)
+        testcase = Hash.new
+        testcase["type"] = "JUnit::" + node.value
+        testcase["name"] = node.attributes[:name]
+        testcase["classname"] = node.attributes[:classname] if testcase["classname"] != nil
+        testcase["duration"] = node.attributes[:time]
+        testcase["status"] = "passed"
+        if node.nodes[0] != nil
+          testcase["status"] = "failed" if node.nodes[0].value == "failure" or node.nodes[0].value == "error"
+          testcase["status"] = "notrun" if node.nodes[0].value == "skipped"
+        end
+        testcase
+      end
+
+      def attach_suite(component)
+        suite = Array.new
+        index = 0
+        component.nodes.each do |node|
+          if node.value == "testcase"
+            suite[index] = Hash.new
+            suite[index] = attach_cases(node)
+          else 
+            suite[index] = Hash.new
+            suite[index]["type"] = "JUnit::" + node.value
+            suite[index]["name"] = node.attributes[:name]
+            suite[index]["classname"] = node.attributes[:classname] if suite[index]["classname"] != nil
+            suite[index]["children"] = attach_suite(node)
+          end # if 
+        index += 1
+        end # each
+        suite
+      end # def attach_suite
+    end # class JUnit 
+  end # class Parsers
+end # class Res
+

data/lib/res/reporters/hive.rb

@@ -0,0 +1,42 @@
+require 'hive/messages'
+require 'json'
+
+module Res
+  module Reporters
+    class Hive
+
+      def initialize( args = {} )
+
+        if args[:url]
+          ::Hive::Messages.configure do |config|
+            config.base_path       = args[:url]
+            config.pem_file        = args[:cert]
+            config.ssl_verify_mode = args[:ssl_verify_mode]
+          end
+        end
+
+      end
+
+      def submit_results(ir, args)
+        
+        # Still include count summaries for backward compatability
+        params = { :failed_count => ir.count(:failed), 
+                   :passed_count => ir.count(:passed), 
+                   :errored_count => ir.count(:errored), 
+                   :running_count => ir.count(:running),
+                   :result_details => ir.flat_format.to_json }
+        
+        hive_job = ::Hive::Messages::Job.new(:job_id => args[:job_id])
+        begin
+          update_response = hive_job.update_results(params)
+          #log "Hive results update response: #{update_response}"
+        rescue
+          #log "Hive::Messages couldn't hit the hive, retrying once more"
+          update_response = hive_job.update_results(params)
+          #log "Hive results update response: #{update_response}"
+        end
+      end
+
+    end
+  end
+end

data/lib/res/reporters/test_rail.rb

@@ -0,0 +1,150 @@
+require 'test_rail'
+require 'res/ir'
+require 'res/mappings'
+require 'res/config'
+
+module Res
+  module Reporters
+    class TestRail
+      
+      attr_accessor :ir, :case_status, :config, :project, :suite
+      def initialize(args)
+        @url = args[:url]
+        @config = Res::Config.new([:user, :password, :namespace, :project, :suite], :optional => [:run_id, :run_name], :pre_env => 'test_rail')
+        config.process(args)
+
+        @case_status = {}
+        @io = File.new("./.test_rail_reporter.log","w+") 
+      
+        test_rail_project = config.project
+        @suite_name = config.suite 
+  
+       begin
+          @project = tr.find_project(:name => test_rail_project)
+        rescue
+          @io.puts "Project: #{test_rail_project} could not be found" 
+          @io.puts "  Please create a project first to contain test suite #{@suite_name}"
+          @io.close
+          return "Project #{test_rail_project} could not be found" 
+        end
+      end # initialize
+
+      # Creates a new suite within testrail
+      def sync_tests(args)
+        @ir = args[:ir]
+        @mappings = Res::Mappings.new(@ir.type)
+
+        suite = @project.find_or_create_suite(:name => @suite_name, :id => @project.id)
+        @io.puts "Syncing Suite"
+
+        i = 0
+          while i < @ir.results.count         
+            section = suite.find_or_create_section(:project_id => @project.id, :suite_id => suite.id, :name => @ir.results[i][:name])   
+            create_suite(@ir.results[i], @project.id, suite, section)
+            i += 1
+          end # while
+        @synced = true
+        @io.puts "> Sync Successful"
+      end
+
+      # Submits run against suite
+      # Either creates a new run using run_name or use existing run_id 
+      def submit_results(args = {})
+        sync_tests(args) if !@synced
+        suite = @project.find_suite(:name => @suite_name)
+
+        run_name = @config.run_name || args[:run_name] || nil
+        run_id = @config.run_id || args[:run_id] || nil
+
+        if !run_name.nil? 
+          run_name = @config.run_name 
+          @io.puts "> Created new run with name #{run_name}"
+          run_id = @tr.add_run( :project_id => @project.id, :name => run_name, :description => args[:run_description], :suite_id => suite.id ).id
+          @io.puts "> Created new run: #{run_id}"
+        
+        elsif !run_id.nil? 
+          run_id = @config.run_id 
+            begin
+              run = @tr.get_run(:run_id => @config.run_id) 
+              @io.puts "> Found run with id #{run_id}"
+            rescue
+              @io.puts "> Couldn't find run with id #{run_id}"
+              @io.close
+              return "Couldn't find run with id #{run_id}"           
+            end
+
+        else
+          @io.puts "> run_name and run_id are either nil or not specified"
+          @io.close
+          return "run_name and run_id are either nil or not specified"          
+
+        end
+
+        i = 0
+        if @case_status.empty?
+          while i < @ir.results.count
+            begin
+              section = suite.find_section(:name => @ir.results[i][:name])
+            rescue 
+              @io.puts "> Couldn't find section with name #{@ir.results[i][:name]}" 
+              puts "Couldn't find section with name #{@ir.results[i][:name]}"
+            end
+            case_details(@ir.results[i], section)
+            i += 1
+          end # while
+        end # ifa
+        add_case_status(run_id)
+        @io.puts "> Added the test case status"
+        @io.puts "> Submit Successful"
+        @io.close
+        return "Submitted to Test Rail"
+      end
+
+      def tr
+        @tr = ::TestRail::API.new( :user   => @config.user,
+                                :password  => @config.password,
+                                :namespace => @config.namespace) 
+      end
+
+      # Add status to each testcase
+      def add_case_status(run_id)
+        @case_status.each { |case_id, status|
+          @tr.add_result_for_case(:run_id => run_id, :case_id => case_id, :status => status)
+        }
+      end
+
+      # Add section or cases within parent section
+      def create_suite(ir, project_id, suite, parent)
+        ir[:children].each do |child|
+          if @mappings.context.include?(child[:type])
+            section = parent.find_or_create_section(:project_id => project_id, :suite_id => suite.id, :name => child[:name])   
+            create_suite(child, project_id, suite, section) if child[:children].count > 0
+
+          elsif @mappings.case.include?(child[:type])
+            parent = suite if parent.nil?   
+            tcase = parent.find_or_create_test_case(:title => child[:name])
+            @case_status[:"#{tcase.id}"] = child[:status]
+
+          else
+            # To be added. Ex: steps 
+          end # if
+        end # each
+      end # create_suite
+
+      def case_details(ir, section)
+        ir[:children].each do |child|
+          if @mappings.context.include?(child[:type])
+              section = section.find_section(:name => child[:name])   
+              case_details(child, section)
+
+          elsif @mappings.case.include?(child[:type])  
+              tcase = section.find_test_case(:title => child[:name])  if !section.nil?
+              @case_status[:"#{tcase.id}"] = child[:status] if !tcase.nil?
+
+          end
+        end
+      end
+
+    end # TestRail
+ end # Reporters
+end # Res

data/lib/res/reporters/testmine.rb

@@ -0,0 +1,48 @@
+require 'res/config'
+
+module Res
+  module Reporters
+    class Testmine
+
+      attr_accessor :url, :config
+
+      def initialize(args)
+        @url = args[:url]
+        @config = Res::Config.new([:project, :component, :suite, :version, :url, :target],
+                                  :optional => [:hive_job_id],
+                                  :pre_env  => 'TESTMINE_')
+        config.process(args)
+      end
+
+      def submit_results(ir, args)
+        # Set missing project information
+        ir.project     = config.project
+        ir.suite       = config.suite
+        ir.target      = config.target
+        ir.hive_job_id = config.hive_job_id 
+        
+        # Load world information into json hash
+        ir.world = {
+          :project   => @config.project,
+          :component => @config.component,
+          :version   => @config.version,
+        }
+
+        # Submit to testmine
+        uri = URI.parse(config.url)
+        net = Net::HTTP.new(uri.host, uri.port)
+        request = Net::HTTP::Post.new("/api/v1/submit")
+        request.set_form_data({"data" => ir.to_json})
+        net.read_timeout = 60
+        net.open_timeout = 10
+        
+        response = net.start do |http|
+          http.request(request)
+        end
+        
+        response.read_body
+      end
+
+    end
+  end
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: res
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- BBC
+- David Buckhurst
+- Asim Khan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: test_rail-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: ox
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+description: Formatters, parsers, and submitters for test results
+email:
+- david.buckhurst@bbc.co.uk
+- asim.khan.ext@bbc.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/res.rb
+- lib/res/config.rb
+- lib/res/formatters/ruby_cucumber.rb
+- lib/res/ir.rb
+- lib/res/mappings.rb
+- lib/res/parsers/junit.rb
+- lib/res/reporters/hive.rb
+- lib/res/reporters/test_rail.rb
+- lib/res/reporters/testmine.rb
+homepage: https://github.com/bbc/res
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Test Result report libraries
+test_files: []