trail_marker 0.1.1

data/lib/trail_marker/mark_tests.rb

@@ -0,0 +1,169 @@
+# Executes parsing and posting results to TestRail
+class MarkTests
+
+  EXIT_MSG = "\nYour test results have been marked on TestRails!\n"
+  DEFAULT_COMMENT = "Marked by Automation"
+
+  #
+  def initialize(argobj, config_filename)
+    @argument = argobj
+    cf = ConfigFile.new(config_filename)
+    cf.check_create_configfile
+    @user = @argument.get_arg_value('-u') == '' ? cf.username : @argument.get_arg_value('-u')
+    @token = @argument.get_arg_value('-pw') == '' ? cf.token : @argument.get_arg_value('-pw')
+    @url = @argument.get_arg_value('-url') == '' ? cf.testrail_url : @argument.get_arg_value('-url')
+    @default_comment = @argument.get_arg_value('-com') == '' ? cf.default_comment : @argument.get_arg_value('-com')
+    puts "VALUES: #{@user} #{@token}"
+  end
+
+  # If user name and password (or token) are passed in the command line arguments
+  # it would use those instead of the preset values.
+  #
+  def get_client
+    client = TestRail::APIClient.new(@url)
+    client.user = @user
+    client.password = @token
+    return client
+  end
+
+  # Initial setup - creates API client and API testrail objects
+  #
+  def setup
+    if @client.nil? || @api_testrail.nil?
+      @client = get_client
+      @api_testrail = ApiTestRail.new(@client)
+    end
+  end
+
+
+  # Determine if results are for a run or a plan.
+  # Calls method to mark results.
+  #
+  def markoff_all_results
+    mark_type = 'testrun'
+    runner = @argument.get_optional_arg(['-r', '-cr'])
+    if runner.nil? || runner == ""
+      mark_type = "testplan"
+      runner = @argument.get_optional_arg(['-t', '-ct'])
+    end
+    run_ids = []
+    project_id = @api_testrail.get_project_id(@argument.get_arg_value('-p'))
+    case mark_type
+      when "testrun"
+        run_name = @argument.get_optional_arg(['-r', '-cr'])
+        run_ids << @api_testrail.get_test_runplan_id(project_id, run_name)
+      when "testplan"
+        plan_name = @argument.get_optional_arg(['-t', '-ct'])
+        run_ids = @api_testrail.get_testplan_run_ids(project_id, plan_name)
+    end
+    markoff(run_ids, project_id)
+  end
+
+  # Parses the XML files and makes API calls to post results to TestRail
+  def markoff(run_ids, pid = nil)
+    project_id = pid.nil? ? @api_testrail.get_project_id(@argument.get_arg_value('-p')) : pid
+    is_dir = @argument.arg_exists?('-x')
+    is_file = @argument.arg_exists?('-f')
+    if is_dir || is_file
+      results_parser = nil
+      #results_file = nil
+      if is_dir
+        results_parser = ResultsParser.new(@argument.get_arg_value('-x'))
+        results_files = results_parser.getAllXMLFiles()
+      else
+        specific_file = @argument.get_arg_value('-f')
+        results_parser = ResultsParser.new(specific_file)
+        results_files = Array.new
+        results_files << specific_file
+      end
+
+      if results_files.size <= 0
+        puts "No XML Results found. Please check your directory"
+        exit(0)
+      end
+      results_files.each do |one_file|
+        case_results = results_parser.read_XML_file(one_file)
+        if ! case_results.nil? && case_results.kind_of?(Array)
+          case_results.each do |one_case|
+            testrun_ids = []
+            testrun_ids += run_ids
+            markoff_test_case(@api_testrail, one_case, testrun_ids)
+          end
+        else
+          puts "No Results found in : #{one_file} (Might be empty)"
+        end
+      end
+    end
+
+  end
+
+  def markoff_test_case(api_obj, result_hash, run_ids)
+    case_id = result_hash[:trail_case].gsub(/[Cc]/, "")
+    test_id = nil
+    run_id = nil
+    puts "=====> #{run_ids}"
+    if run_ids.size > 1
+      run_ids.each do |rid|
+        tempid = api_obj.get_testid(rid, case_id)
+        if ! tempid.nil?
+          test_id = tempid
+          run_id = rid
+          break
+        end
+      end
+    else
+      run_id = run_ids.pop()
+    end
+    passed = result_hash[:passed]
+    api_obj.markoff_test(case_id, run_id, passed, @default_comment)
+  end
+
+  def create_milestone
+    project_name = @argument.get_arg_value('-p')
+    milestone_name = @argument.get_arg_value('-m')
+    if ! milestone_name.nil?
+      @api_testrail.create_milestone(project_name, milestone_name)
+    end
+  end
+
+  # USER DOES NOT HAVE PERMISSION.
+  # Verify you have super user account or maybe
+  # not yet implemented in TestRail. GUI has no delete as well.
+  def delete_milestone
+    project_name = @argument.get_arg_value('-p')
+    milestone_name = @argument.get_arg_value('-dm')
+    if ! milestone_name.nil?
+      @api_testrail.delete_milestone(project_name, milestone_name)
+    end
+  end
+
+  def create_testrun
+    project_name = @argument.get_arg_value('-p')
+    milestone_name = @argument.get_optional_arg(['-m', '-cm'])
+    testrun_name = @argument.get_arg_value('-cr')
+    if ! testrun_name.nil?
+      @api_testrail.create_testrun(project_name, milestone_name, testrun_name)
+    end
+  end
+
+
+  def check_create
+    project_name = @argument.get_arg_value('-p')
+    if @argument.arg_exists?('-cm')
+      milestone_name = @argument.get_arg_value('-cm')
+      @api_testrail.create_milestone(project_name, milestone_name)
+    end
+    run_name = @argument.get_arg_value('-cr')
+    if @argument.arg_exists?('-cr')
+      milestone_name = @argument.get_optional_arg(['-m', '-cm'])
+      suite_name = @argument.get_arg_value('-s')
+      @api_testrail.create_testrun(project_name, milestone_name, run_name, suite_name)
+    end
+  end
+
+  def show_exit_msg
+    puts "\n#{EXIT_MSG}\n"
+  end
+
+
+end

data/lib/trail_marker/request.rb

@@ -0,0 +1,122 @@
+require_relative 'testrail'
+
+# Calls testrail API
+# History: 2/26/18 Removed retry for failed calls
+#          2/27/18 Combined post/get methods DRY
+#                  Change retry to skip only if TC not found.
+#
+class Request
+  RETRIES = 1
+
+  def initialize(client, debug_mode = false)
+    @client = client
+    @debug_mode = get_debug_value(debug_mode)
+    @debug_mode = true
+  end
+
+  # Retries an API call max number of times if an
+  # exception is raised. Sleeps 4, 8, 12 .... seconds
+  # for each retry.
+  #
+  def exec_api_call(rest_type, req, data = nil, exit_on_fail = false)
+    max_retry = RETRIES
+    get_hash = nil
+    attempts = 0
+    is_good = false
+    while !is_good && attempts < max_retry
+      attempts += 1
+      get_hash = call_api(req, rest_type, data)
+      is_good = get_hash[:status]
+      unless is_good
+        exit_script() if exit_on_fail
+        puts "Got Error making API call - #{req} "
+        if attempts < max_retry
+          puts "Retrying #{attempts}"
+          sleep(4 * attempts)
+        end
+      end
+    end
+    get_hash
+  end
+
+  # TODO: DRY with exec_get
+  def exec_post(req, data, exit_on_fail = false)
+    response_hash = exec_api_call('POST', req, data, exit_on_fail)
+    response_hash[:response]
+  end
+
+  def exec_get(req, exit_on_fail = false)
+    response_hash = exec_api_call('GET', req, nil, exit_on_fail)
+    check_authentication_fail(response_hash) unless response_hash[:status]
+    response_hash[:response]
+  end
+
+  # Executes a TestRail API call but catches any
+  # exception raised to prevent script from crashing.
+  # Used by exec_get to do retries.
+  #
+  def call_api(req, rtype, data=nil)
+    msg("#{rtype} REQ: #{req}")
+    res_hash = {:status => true, :response => ""}
+    begin
+      if rtype == 'POST'
+        get_response = @client.send_post(req, data)
+      else
+        get_response = @client.send_get(req)
+      end
+    rescue Exception => e
+      puts "Raised Exception: #{e.message}."
+      res_hash[:status] = false
+      res_hash[:response] = e.message
+    else
+      res_hash[:status] = true
+      res_hash[:response] = get_response
+    end
+    msg("RESPONSE: #{res_hash}")
+    return res_hash
+  end
+
+  private
+
+  def exit_script()
+    msg("Exiting script.")
+    exit(1)
+  end
+
+  def msg(msg_txt)
+    if @debug_mode
+      puts msg_txt
+    end
+  end
+
+  class APIError < StandardError
+  end
+
+  def get_debug_value(debug_val)
+    boolval = false
+    if !! debug_val == debug_val
+      boolval = debug_val
+    else
+      boolval = string_to_boolean(debug_val)
+    end
+    return boolval
+  end
+  
+  def string_to_boolean(strval)
+    retval = false
+    if strval.downcase == "true"
+      retval = true
+    end
+    return retval
+  end
+  
+  def check_authentication_fail(response_hash)
+    failed_str = "Authentication failed"
+    max_attempts_str = "maximum number of failed"
+    if response_hash[:response].include?(failed_str) || response_hash[:response].include?(max_attempts_str)
+      puts "Cannot authenticate User or password.\n"
+      exit(1)
+    end
+  end
+  
+end

data/lib/trail_marker/response.rb

@@ -0,0 +1,121 @@
+require 'json'
+
+# Holds the TestRail response to easily access fields and
+# give an easy user selector.
+# TODO: Clean this UP!
+class Response
+  
+  @response_type = nil
+  
+  def initialize(response)
+    @response_type = response.class.name
+    @json_data = ""
+    @raw_data = response
+  end
+  
+  def update(response)
+    initialize(response)
+  end
+  
+  def list_projects()
+    
+  end
+  
+  def get_value(key)
+    retval = nil
+    case @response_type
+    when "Array"
+      retval = parse_array(@raw_data, key)
+    when "Hash"
+      retval = parse_hash(@raw_data, key)
+    end
+    return retval
+  end
+  
+  def get_id(key, value)
+    retval = nil
+    case @response_type
+    when "Array"
+      retval = parse_array_kv(@raw_data, key, value, 'id')
+    when "Hash"
+      retval = @raw_data['id']
+    end
+    return retval
+  end
+  
+  # Returns ID of item selected via user key enter
+  #
+  def picker(key)
+    min_val = 1
+    max_val = 1
+    valarr = get_value(key)
+    puts "Options Available: "
+    valarr.each_with_index do |one_select, index|
+      dis_index = index + 1
+      puts "#{dis_index}) #{one_select}"
+      max_val = dis_index
+    end
+    
+    puts "q) TO QUIT"
+    print "Enter number of your selection: "
+   
+    user_choice = pick_filter(min_val, max_val, true)
+    puts "You SELECTED #{valarr[user_choice - 1]}"
+    puts ""
+    return valarr[user_choice - 1]
+  end
+  
+  private
+  
+  def parse_array_kv(rdata, k, v, key_return)
+    fnd = rdata.detect {|unhash| unhash[k] == v}
+    return fnd['id']
+  end
+  
+  def parse_array(rdata, key)
+    retarr = []
+    rdata.map do |h|
+      retarr.push(h[key])
+    end
+    return retarr
+  end
+  
+  def parse_hash(rdata, key)
+    retval = rdata[key]
+  end
+  
+  # TODO: Add user keyboard input checks.
+  #
+  def pick_filter(min, max, add_quit = true)
+    guide_msg = "Valid values are from #{min} to #{max}"
+    if add_quit
+      guide_msg += " or 'q' to quit"
+    end
+    retval = nil
+    entered_valid = false
+    atmps = 0
+    integer_pattern = /[0-9]+/
+    while ! entered_valid do
+      user_input = $stdin.gets.chomp.downcase
+      if (user_input == 'q' && add_quit) || (atmps > 7)
+        puts "Exiting!"
+        exit(0)
+      end
+      if user_input =~ integer_pattern
+        entered_value = user_input.to_i
+        if entered_value >= min && entered_value <= max
+          retval = entered_value
+          entered_valid = true
+        end
+      end
+      if ! entered_valid
+        puts guide_msg
+      end
+      atmps += 1
+    end
+    return retval
+  end  
+    
+  
+  
+end

data/lib/trail_marker/results_parser.rb

@@ -0,0 +1,241 @@
+require 'nokogiri'
+require 'json'
+
+# HISTORY: 1/7/2016    modified to handle just 1 file
+#          3/21/2016   Allows indexing of test case
+#                      e.g. (TestRail: [C11, C22], [C33, C44], 1) Last argument is an index (starts at 0)
+#                      to mark test case C33 and C44. Modified method parse_trail_tag to implement this.
+#
+# TODO: Parse Failure element CDATA to add to comment - will require changes in request.rb, etc.
+#
+class ResultsParser
+  
+  DEBUG_MODE = false 
+  
+  def initialize(results_path)
+    checkIfDirectoryExists(results_path)
+    @results_path = results_path
+    #xmls = getAllXMLFiles(results_path)
+    #readAllXMLFiles(xmls)
+  end
+  
+  def checkIfDirectoryExists(xml_loc) 
+    if ! File.directory?(xml_loc) && ! File.file?(xml_loc)
+      puts "ERROR: Cannot find the XML results directory or file:"
+      puts "       #{xml_loc}"
+      puts "       Please check the path of the directory where the results are located.\n\n"
+      exit(1)
+    end
+  end
+  
+  # Retrieves all .xml files in the directory passed as parameter
+  # also recurssively gets subdirectory files because it uses Dir.glob
+  # Return: array of file names with path where it is located.
+  def getAllXMLFiles() 
+    originalDir = Dir.pwd
+    Dir.chdir @results_path
+    filesArray = Array.new
+    debug_msg "#{@results_path}/**/*.xml"
+    Dir.glob("**/*.xml") do |f|
+      debug_msg "XML: #{f}"
+      filesArray << "#{@results_path}/" + f
+    end
+    Dir.chdir originalDir
+    return filesArray
+  end
+  
+  def readAllXMLFiles(xml_files)
+    xml_files.each do |xml_file|
+      read_XML_file(xml_file)
+    end
+  end
+  
+  # Reads XML file and uses nokogiri to parse
+  # 
+  def read_XML_file(xfile)
+    result_array = []
+    if File.file?(xfile)
+      puts "\n\nOPENING #{xfile}"
+      f = File.open(xfile)
+      doc = Nokogiri::XML(f)
+      if is_squish?(doc)
+        result_array = squish_parser(doc)
+      else
+        result_array = rspec_parser(doc)
+      end
+    else
+      puts "\nNot a file: #{xfile} - verify options (-x for directory, -f for a specific file)"
+    end
+    return result_array  
+  end
+  
+  # Parses the SquishReport XML results file
+  def squish_parser(nokigiri_doc)
+    result_arr = []
+    verifications = nokigiri_doc.xpath("//verification")
+    verifications.each do |verification|
+      #puts "ONEVER: #{verification}"
+      trail_cases = parse_trail_tag(verification["name"])
+      result = verification.xpath("result").first
+      is_passed = squish_check_passed(result)
+      debug_msg "\nVERIFICATION: #{verification["name"]} :: #{trail_cases}"
+      trail_cases = parse_trail_tag(verification["name"])
+      trail_cases.each do |trail_case|
+        result_arr.push({:trail_case => trail_case, :passed => is_passed})
+      end
+    end
+    debug_msg "Squish FINAL: #{result_arr}"
+    return result_arr
+  end
+  
+  # Parses the results of an RSPEC XML file.
+  # TODO: 
+  def rspec_parser(nokigiri_doc)
+    result_arr = []
+    testsuites = nokigiri_doc.xpath("//testsuites")
+    testsuites.each do |suites|
+      testsuite = suites.xpath("./testsuite")
+      testsuite.each do |suite|
+        debug_msg "\nSUITE: #{suite["name"]} "
+        testsuite_name = suite["name"]
+        testcases = suite.xpath("./testcase")
+        testcases.each do |tcase|
+          debug_msg "TESTCASE: #{tcase}"
+          is_passed = false
+          failure = tcase.xpath("./failure")
+          if ! failure.nil?
+            is_passed = true
+            if failure.size > 0
+              is_passed = false
+            end
+          end
+          debug_msg "    TC: #{tcase["name"]}"
+          testcase_name = tcase["name"]
+          trail_cases = parse_trail_tag(testcase_name)
+          trail_cases.each do |trail_case|
+            result_arr.push({:trail_case => trail_case, :passed => is_passed})
+          end
+        end
+      end
+      debug_msg "FINAL: #{result_arr}"
+      return result_arr
+    end
+  end
+  
+  # Parses the 'name' attribute of <testcase> and returns all 
+  # test cases found. Returns an array in case a single test can mark off multiple test cases.
+  # Ex. <testcase name="Login: should allow all valued users to successfully login (TestRail: C123, C888)
+  # Returns ['C123', 'C888']
+  def parse_trail_tag(name_line)
+    case_arr = []
+    ndex = get_index(name_line)
+    if ndex < 0
+      pattern = /\(TestRail:([Cc0-9\,\s]+)\)/
+      just_cases = pattern.match(name_line)
+      if ! just_cases.nil?
+        debug_msg "HowMany #{just_cases[1]}"
+        split_cases = just_cases[1].split(',')
+        split_cases.each do |onecase|
+          case_arr.push(onecase.strip)
+        end
+      end
+      debug_msg "ARR: #{case_arr}"
+    else
+      case_arr = get_indexed_cases(name_line, ndex)
+    end
+    return case_arr
+  end
+  
+  private
+  
+  # Called if the test cases are indexed as described in JIRA ticket ACI-206
+  #
+  def get_indexed_cases(name_line, nx)
+    cases = []
+    pattern = /\(TestRail:([Cc0-9\,\s\[\]\|]+)\:[0-9\s]+\)/
+    just_cases = pattern.match(name_line)
+    if ! just_cases.nil?
+      case_tags = just_cases[1]
+      debug_msg "PARSING: #{case_tags}"
+      if (case_tags =~ /^\s*[Cc0-9\,\s]+$/)
+        debug_msg "CASE COMMAS"
+        indexed_case = case_tags.split(',')[nx].strip
+        cases.push(indexed_case)
+      elsif (case_tags =~ /^\s*[Cc0-9\,\s\|]+$/)
+        debug_msg "CASE PIPES"
+        indexed_case = case_tags.split('|')[nx]
+        cases = strip_array(indexed_case.split(','))
+      elsif (case_tags =~ /^\s*[Cc0-9\,\s\[\]]+$/)
+        debug_msg "CASE BRACKETS"
+        subed_tags = sub_brackets(case_tags)
+        indexed_case = subed_tags.split('|')[nx]
+        cases = strip_array(indexed_case.split(','))
+        end
+      end
+      return cases
+    end
+  
+  # Replaces ],[ and ], and ,[ with '|'
+  def sub_brackets(nline)
+    local_line = nline
+    local_line.gsub!(/\]\s*\,\s*\[/, '|')
+    local_line.gsub!(/\]\s*\,/, '|')
+    local_line.gsub!(/\,\s*\[/, '|')
+    return local_line.tr('[]', '')
+  end
+  
+  # Parses for (TestRail: [C12, C13], [C21, C24], [C33]:2)
+  # Returns the index number if found or -1 if not found
+  def get_index(name_line)
+    index_found = -1
+    pattern = /\(TestRail:.*\:\s*([0-9]+)\s*\)/
+    just_cases = pattern.match(name_line)
+    if ! just_cases.nil?
+      index_found = just_cases[1].to_i
+    end
+    return index_found
+  end
+  
+  def is_squish?(nokigiri_doc)
+    retval = false
+    squish_report = nokigiri_doc.xpath("/SquishReport")
+    if ! squish_report.nil? 
+      if squish_report.size > 0
+        retval = true
+      end
+    end
+    return retval
+  end
+  
+  def squish_check_passed(result_doc)
+    retval = false
+    if ! result_doc.nil?
+      debug_msg "RESULT: #{result_doc}"
+      get_type = result_doc['type']
+      if get_type.downcase == "pass"
+        retval = true
+      end
+    end
+    debug_msg "PASED: #{retval}"
+    return retval
+  end
+  
+  # Removed all white spaces before/after each cell in
+  # an array. Returns array.
+  def strip_array(clothed_arr)
+    fully_stripped = []
+    clothed_arr.each do |onecase|
+      fully_stripped.push(onecase.strip)
+    end
+    return fully_stripped
+  end
+  
+  def debug_msg(msg)
+    if DEBUG_MODE
+      puts msg
+    end
+  end
+  
+end
+
+

data/lib/trail_marker/test.bak

@@ -0,0 +1,12 @@
+require_relative 'config_file'
+
+### MAIN
+#
+#
+
+confile = "trail_config.yml"
+currpath = File.dirname(__FILE__)
+
+full_filepath = "#{currpath}/#{confile}"
+cf = ConfigFile.new(full_filepath)
+cf.read_configfile