itms_automation 2.2 → 2.5.7

data/bin/setup

@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-IFS=$'\n\t'
-set -vx
-
-bundle install
-
-# Do any other automated setup that you need to do here

data/lib/itms_automation/all_steps.rb

@@ -1,8 +0,0 @@
-# coding: UTF-8
-
-Dir[File.join(File.dirname(__FILE__), '*_steps.rb')].each do |f|
-  name = File.basename(f, '.rb')
-  unless name == 'all_steps'
-    require "itms_automation/#{name}"
-  end
-end

data/lib/itms_automation/assertion_helper.rb

@@ -1,29 +0,0 @@
-def do_assertion_json expected_obj, actual_obj
-  if expected_obj.kind_of? Array
-    is_contain = true
-    expected_obj.each_with_index do |expected, index|
-      is_contain = do_assertion_json(expected, actual_obj)
-      @expected.shift if is_contain == true
-      return is_contain if is_contain == false || index == expected_obj.length - 1
-    end
-  elsif expected_obj.kind_of? Hash
-    is_contain = true
-    expected_obj_keys = expected_obj.keys
-    expected_obj_keys.each_with_index do |key, index|
-      if actual_obj[key].nil?
-        raise "[%s] expected [%s] but actual value was nil." % [key, expected_obj[key].to_s]
-      else
-        is_contain = expected_obj[key] == actual_obj[key]
-        return is_contain if is_contain == false || index == expected_obj_keys.length - 1
-      end
-    end
-  elsif [Integer, String, Float].include? expected_obj.class
-    return assert_string_equal(expected_obj, actual_obj)
-  else
-    raise "Verify sql result error: Not support expected type #{expected_obj.class} yet"
-  end
-end
-
-def assert_string_equal expected, actual
-  actual.to_s == expected.to_s
-end

data/lib/itms_automation/auto_util.rb

@@ -1,699 +0,0 @@
-#-----------------------------------------------------
-# support define and bind variable dynamically
-#-----------------------------------------------------
-$dyn_vars = nil
-
-# set value to a variable
-def set_var(var_name, var_value)
-  if $dyn_vars == nil
-    $dyn_vars = binding
-  end
-
-  strEval = var_name + "=" + var_value
-  eval strEval, $dyn_vars
-end
-
-def get_var(var_name)
-  $dyn_vars.local_variable_get(var_name)
-end
-
-def check_dynamic_value(value)
-  if !value.is_a? Fixnum
-    if value.include? "params="
-      resolve_params value
-    else
-      bind_with_dyn_vars value
-    end
-  else
-    value
-  end
-end
-
-# bind string with $dyn_vars context
-def bind_with_dyn_vars(str)
-  if $dyn_vars == nil
-    $dyn_vars = binding
-  end
-
-  strEval = '"' + str + '"'
-  return eval strEval, $dyn_vars
-end
-
-# evaluate operation/statement with $dyn_vars context
-def eval_with_dyn_vars(operation)
-  if $dyn_vars == nil
-    $dyn_vars = binding
-  end
-
-  eval operation, $dyn_vars
-end
-
-def bind_with_dyn_json_vars(json, bind_json)
-  if json.kind_of? Hash
-    json.each_pair do |k, v|
-      if v.kind_of? String
-        bind_json[bind_with_dyn_vars(k)] = bind_with_dyn_json_vars(v, bind_json)
-      elsif v.kind_of? Hash
-        temp = Hash.new
-        v.each_pair do |k1, v1|
-          temp[bind_with_dyn_vars(k1)] = bind_with_dyn_json_vars(v1, temp)
-        end
-        bind_json[bind_with_dyn_vars(k)] = temp
-      elsif v.kind_of? Array
-        temp1 = Array.new
-        v.each { |item|
-          temp2 = Hash.new
-          bind_with_dyn_json_vars(item, temp2)
-          temp1 << temp2
-        }
-        bind_json[bind_with_dyn_vars(k)] = temp1
-      end
-    end
-  elsif json.kind_of? Array
-    temp1 = Array.new
-    json.each { |item|
-      temp2 = Hash.new
-      bind_with_dyn_json_vars(item, temp2)
-      temp1 << temp2
-    }
-    return temp1
-  else
-    return bind_with_dyn_vars(json)
-  end
-end
-
-def var_collect(string_var)
-  if string_var =~ /^.*{year}.*$/
-    string_var = replace_year(string_var)
-  end
-
-  if string_var =~ /^.*{month}.*$/
-    string_var = replace_month(string_var)
-  end
-
-  if string_var =~ /^.*{day}.*$/
-    string_var = replace_day(string_var)
-  end
-
-  if string_var =~ /^.*{store_value}.*$/
-    string_var = $context_value
-  end
-
-  return string_var
-end
-
-def replace_year(str)
-  t = Time.now()
-  return str.gsub("{year}", t.year.to_s)
-end
-
-def replace_month(str)
-  t = Time.now()
-  _month = t.month
-  if _month < 10
-    return str.gsub("{month}", "0#{_month.to_s}")
-  else
-    return str.gsub("{month}", "#{_month.to_s}")
-  end
-  return str
-end
-
-def replace_day(str)
-  t = Time.now()
-  _day = t.day
-  if _day < 10
-    return str.gsub("{day}", "0#{_day.to_s}")
-  else
-    return str.gsub("{day}", "#{_day.to_s}")
-  end
-  return str
-end
-
-def print_variable(variable)
-  puts "VALUE OF #{variable}: #{eval_with_dyn_vars(variable)}"
-end
-
-def duration(start)
-  current = Time.now.to_f
-  convert_time = Time.at(current - start.to_f).utc.strftime('%Mm%s.%Ls')
-  return convert_time
-end
-
-def print_log(status, start, method, *args)
-  icon = status === "passed" ? "✅" : "❌"
-  str = ""
-  args = *args
-  args_length = args.length - 1
-  args.each_with_index do |a, i|
-    if i < args_length
-      str += "\"#{a}\", "
-    else
-      str += "\"#{a}\""
-    end
-  end
-
-  puts "#{icon} Step: #{method}(#{str}) (#{duration(start)})"
-end
-
-def get_object_value(str_obj)
-  string_object = str_obj.gsub(/"/, "'")
-  hash_object = $OBJECT[string_object]
-  if hash_object == nil
-    raise "❌  Error: #{str_obj} NAME MAYBE NOT FOUND!!!"
-  end
-  if hash_object.keys[0].to_s.upcase != "CSS_SELECTOR"
-    raise "❌  Error: #{str_obj} should be formatted as Css Selector."
-  end
-  hash_object[hash_object.keys[0]]
-end
-
-def put_log str
-  start = Time.now
-  p str if $print_log == true
-end
-
-def check_valid_option_by?(option_by)
-  %w(text value).include? option_by
-end
-
-def validate_option_by(option_by)
-  raise "Please select valid option, invalid option - #{option_by}" unless check_valid_option_by? option_by
-end
-
-def check_valid_keys?(key)
-  %w(:cancel :help :backspace :tab :clear :return :enter :shift :control :alt :pause :escape :space :page_up :page_down :end :home :left :up :right :down :insert :delete :semicolon :equals).include? key
-end
-
-def validate_supported_keys(key)
-  raise "Please select valid keys, invalid key - #{key}" unless check_valid_option_by? key
-end
-
-def find_object string_object
-  startTime = Time.new.to_i
-  string_object = string_object.gsub(/"/, "'")
-  locator_matching = /(.*?)(\{.*?\})/.match(string_object)
-  dyn_pros = {}
-  if locator_matching != nil
-    string_object = locator_matching[1]
-    eval(locator_matching[2].gsub(/['][\s,\t]*?:[\s,\t]*?[']?/, "'=>'")).each { |k, v|
-      dyn_pros[k.to_s.upcase] = v
-    }
-  end
-  hash_object = $OBJECT[string_object]
-  if hash_object == nil
-    raise "❌  find_object error: >>> Object: #{string_object} is not found in Object Repository."
-  end
-  upcase_attrb = {}
-  if hash_object != nil
-    hash_object.each {|k,v|
-      k = k.to_s.upcase
-      if k =~ /ph_/i
-        if dyn_pros[k] != nil
-          if v =~ /<ph_value>/i
-            upcase_attrb[k[3..k.size-1]] = v.gsub(/<ph_value>/i, dyn_pros[k])
-          else
-            upcase_attrb[k[3..k.size-1]] = dyn_pros[k]
-          end
-          dyn_pros.delete(k)
-        end
-      else
-        upcase_attrb[k.to_s.upcase] = v
-      end
-    }
-  end
-  ph_attrs = {}
-  dyn_pros.each{|k,v|
-    if k =~ /ph_/i
-      ph_attrs[k] = v
-    else
-      upcase_attrb[k.to_s.upcase] = v
-    end
-  }
-  if upcase_attrb.size > 0
-    strId = ""
-    strClass = ""
-    strName = ""
-    strTagname = ""
-    strCssSelector = ""
-    strXpathSelector = ""
-    strText = ""
-    strRelated = ""
-    strRelatedType = ""
-
-    index = nil
-    minWidth = -1
-    maxWidth = -1
-    minHeight = -1
-    maxHeight = -1
-
-    ano_pros = {}
-
-    upcase_attrb.each{|key, value|
-      upcase_key = key.to_s.upcase
-      case upcase_key
-      when "XPATH_SELECTOR"
-        strXpathSelector = value
-      when "CSS_SELECTOR"
-        strCssSelector = value
-      when "ID"
-        strId = value
-      when "CLASS"
-        strClass = value
-      when "NAME"
-        strName = value
-      when "TAGNAME"
-        strTagname = value
-      when "TEXT"
-        strText = value
-      when "INDEX"
-        index = value
-      else
-        raise "❌  find_object error: >>> Wrong format type: #{key.to_s} of object: #{string_object}. Available supported format are: XPATH_SELECTOR | CSS_SELECTOR | ID | NAME | CLASS | TEXT | TAGNAME | INDEX"
-      end
-    }
-    continue_run = true;
-    ref_object = nil;
-
-    if strRelated != nil and strRelated.length > 0
-      ref_object = find_object(strRelated)
-      if (ref_object == nil)
-        continue_run = false
-      end
-    end
-
-    if continue_run == true
-      begin
-        if strCssSelector != nil and strCssSelector.length > 0
-          foundElements = get_objects_by_css_selector(strCssSelector)
-        elsif strXpathSelector != nil and strXpathSelector.length > 0
-          foundElements = get_objects_by_xpath_selector(strXpathSelector)
-        else
-          strGenerateXpathSel = generate_xpath_selector(strId, strClass, strName, strTagname)
-          if strGenerateXpathSel.length > 0
-            foundElements = get_objects_by_xpath_selector(strGenerateXpathSel)
-          else
-            if (check_string_letters_only(strId))
-              foundElements = get_objects_by_Id(strId)
-            elsif (check_string_letters_only(strName))
-              foundElements = get_objects_by_Name(strName)
-            elsif (check_string_letters_only(strClass))
-              foundElements = get_objects_by_Class(strClass)
-            elsif (check_string_letters_only(strTagname))
-              foundElements = get_objects_by_Tagname(strTagname)
-            end
-          end
-        end
-        if foundElements == nil or foundElements.length == 0
-          currentTime = Time.new.to_i
-        else
-          break
-        end
-        test = currentTime - startTime
-        puts "\n Finding the object #{string_object}... TIME-OUT:: #{test} < #{$wait_time}"
-        sleep(0.5)
-      end while (currentTime - startTime) < $wait_time
-
-      if foundElements != nil or foundElements.length != 0
-        if index != nil and index.to_i >= 0
-          matched_index = 0;
-          return_element = nil
-          foundElements.each{|cur_element|
-            passCheck = find_object_check_object(cur_element, ref_object, strRelatedType, strId, strClass, strName, strTagname, strText, minWidth, maxWidth, minHeight, maxHeight, ano_pros)
-            if passCheck
-              if matched_index == index.to_i
-                return_element = cur_element
-                break
-              else
-                matched_index = matched_index + 1
-              end
-            end
-          }
-          return return_element
-        else
-          return_element = nil
-          foundElements.each{|cur_element|
-            passCheck = find_object_check_object(cur_element, ref_object, strRelatedType, strId, strClass, strName, strTagname, strText, minWidth, maxWidth, minHeight, maxHeight, ano_pros)
-            if passCheck
-              return_element = cur_element
-              break
-            end
-          }
-          return return_element
-        end # if index != nil and index.to_i >= 0
-      end #if foundElements != nil or foundElements.length != 0
-    end #if continue = true
-  end
-  return nil
-end
-
-def generate_xpath_selector(strId, strClass, strName, strTagname)
-  strGenerateXpathSel = ""
-  if strId != nil and strId.length > 0 and (strId =~ /^#/) == nil
-    strGenerateXpathSel = "[@id='#{strId}']"
-  end
-  if strClass != nil and strClass.length > 0 and (strClass =~ /^#/) == nil
-    strGenerateXpathSel = "#{strGenerateXpathSel}[@class='#{strClass}']"
-  end
-  if strName != nil and strName.length > 0 and (strName =~ /^#/) == nil
-    strGenerateXpathSel = "#{strGenerateXpathSel}[@name='#{strName}']"
-  end
-
-  if strGenerateXpathSel.length > 0
-    if strTagname != nil and strTagname.length > 0
-      strGenerateXpathSel = "//#{strTagname}#{strGenerateXpathSel}"
-    else
-      strGenerateXpathSel = "//*#{strGenerateXpathSel}"
-    end
-  end
-
-  return strGenerateXpathSel
-end
-
-def check_string_letters_only(strToCheck)
-  if strToCheck != nil and strToCheck.length > 0 and strToCheck =~ /^[a-zA-Z]+$/
-    return true
-  end
-  return false
-end
-
-def get_objects_by_Id(strId)
-  foundElements = nil
-  begin
-    foundElements = page.all("*[@id='#{strId}']")
-  rescue StandardError => e
-     raise "Error: #{e.message}"
-  end
-
-  return foundElements
-end
-
-def get_objects_by_Class(strClass)
-  foundElements = nil
-  begin
-    foundElements = page.all("*[@class='#{strClass}']")
-  rescue StandardError => e
-    raise "Error: #{e.message}"
-  end
-
-  return foundElements
-end
-
-def get_objects_by_Name(strName)
-  foundElements = nil
-  begin
-    foundElements = page.all("*[@name='#{strName}']")
-  rescue StandardError => e
-    raise "Error: #{e.message}"
-  end
-
-  return foundElements
-end
-
-def get_objects_by_Tagname(strTagname)
-  foundElements = nil
-  begin
-    foundElements = page.all("#{strTagname}")
-  rescue StandardError => e
-    raise "Error: #{e.message}"
-  end
-
-  return foundElements
-end
-
-def get_objects_by_css_selector(strCssSelector)
-  foundElements = nil
-  begin
-    foundElements = page.all(:css, strCssSelector)
-  rescue StandardError => e
-    raise "Error: #{e.message}"
-  end
-  foundElements
-end
-
-def get_objects_by_xpath_selector(strXpathSelector)
-  foundElements = nil
-  begin
-    foundElements = page.all(:xpath, strXpathSelector)
-  rescue StandardError => e
-    raise "Error: #{e.message}"
-  end
-  foundElements
-end
-
-def find_object_check_object(cur_element, ref_object, ref_object_type, strId, strClass, strName, strTagname, strText, minWidth, maxWidth, minHeight, maxHeight, ano_pros)
-  passCheck = true
-  if cur_element != nil
-    # Check ref_object
-    if (ref_object != nil)
-      if find_object_check_ref_object(ref_object, ref_object_type, cur_element) == false
-        passCheck = false
-      end
-    end
-
-    # Check ID
-    if strId != nil and strId.length > 0
-      if strId =~ /^#/
-        strId = strId[1..-1]
-      end
-      if find_object_check_Id(cur_element, strId) == false
-        passCheck = false
-      end
-    end
-
-    # Check Class
-    if passCheck and strClass != nil and strClass.length > 0
-      if strClass =~ /^#/
-        strClass = strClass[1..-1]
-      end
-      if find_object_check_Class(cur_element, strClass) == false
-        passCheck = false
-      end
-    end
-
-    # Check Name
-    if passCheck and strName != nil and strName.length > 0
-      if strName =~ /^#/
-        strName = strName[1..-1]
-      end
-      if find_object_check_Name(cur_element, strName) == false
-        passCheck = false
-      end
-    end
-
-    # Check Tag name
-    if passCheck and strTagname != nil and strTagname.length > 0
-      if find_object_check_Tagname(cur_element, strTagname) == false
-        passCheck = false
-      end
-    end
-
-    # Check Text
-    if passCheck and strText != nil and strText.length > 0
-      if (strText =~ /^#/)
-        strText = strText[1..-1]
-      end
-
-      if find_object_check_Text(cur_element, strText) == false
-        passCheck = false
-      end
-    end
-
-    # Check minWidth
-    if passCheck and minWidth > 0
-      if !find_object_check_minWidth(cur_element, minWidth)
-        passCheck = false
-      end
-    end
-
-    # Check maxWidth
-    if passCheck and maxWidth > 0
-      if !find_object_check_maxWidth(cur_element, maxWidth)
-        passCheck = false
-      end
-    end
-
-    # Check minHeight
-    if passCheck and minHeight > 0
-      if !find_object_check_minHeight(cur_element, minHeight)
-        passCheck = false
-      end
-    end
-
-    # Check maxHeight
-    if passCheck and maxHeight > 0
-      if !find_object_check_maxHeight(cur_element, maxHeight)
-        passCheck = false
-      end
-    end
-
-    # Check another properties
-    if passCheck and ano_pros.length > 0
-      ano_pros.each{|property, value|
-        if value =~ /^#/
-          value = value[1..-1]
-        end
-        if !find_object_check_property(cur_element, property, value)
-          passCheck = false
-          break
-        end
-      }
-    end
-
-    return passCheck
-  end
-
-  return false
-end
-
-def find_object_check_Id(element, strId)
-  actual_Id = element[:id]
-  if actual_Id != nil and actual_Id.length > 0
-    actual_Id = actual_Id.strip
-    if reg_compare(actual_Id, strId)
-      return true
-    end
-  end
-
-  return false
-end
-
-def find_object_check_Class(element, strClass)
-  actual_Class = element[:class]
-  if actual_Class != nil and actual_Class.length > 0
-    actual_Class = actual_Class.strip
-    if reg_compare(actual_Class, strClass)
-      return true
-    end
-  end
-
-  return false
-end
-
-def find_object_check_Name(element, strName)
-  actual_Name = element[:name]
-  if actual_Name != nil and actual_Name.length > 0
-    actual_Name = actual_Name.strip
-    if reg_compare(actual_Name, strName)
-      return true
-    end
-  end
-
-  return false
-end
-
-def find_object_check_Tagname(element, strTagname)
-  actual_Tagname = element.tag_name()
-  if actual_Tagname != nil and actual_Tagname.length > 0
-    actual_Tagname = actual_Tagname.strip
-    if reg_compare(actual_Tagname, strTagname)
-      return true
-    end
-  end
-
-  return false
-end
-
-def find_object_check_Xpath(element, strXpath)
-
-end
-
-def find_object_check_Text(element, strText)
-  actual_Text = element.text()
-  if actual_Text != nil and actual_Text.length > 0
-    actual_Text = actual_Text.strip
-    if reg_compare(actual_Text, strText)
-      return true
-    end
-  end
-
-  return false
-end
-
-def find_object_check_minWidth(element, minWidth)
-  width = element[:width]
-  if (width >= minWidth)
-    return true
-  end
-
-  return false
-end
-
-def find_object_check_maxWidth(element, maxWidth)
-  width = element[:width]
-  if (width <= maxWidth)
-    return true
-  end
-
-  return false
-end
-
-def find_object_check_minHeight(element, minHeight)
-  height = element[:height]
-  if (height <= minHeight)
-    return true
-  end
-
-  return false
-end
-
-def find_object_check_maxHeight(element, maxHeight)
-  height = element[:height]
-  if (height <= maxHeight)
-    return true
-  end
-
-  return false
-end
-
-def find_object_check_ref_object(ref_object, ref_type, target_element)
-  begin
-    ref = ref_object.native
-    target = target_element.native
-    if(ref_type == "up" or ref_type == "down")
-      ref_x1 = ref.location.x - 10
-      ref_x2 = ref.location.x + ref.size.width + 10
-      target_x1 = target.location.x
-      target_x2 = target_x1 + target.size.width
-    elsif(ref_type == "left" or ref_type == "right")
-      ref_y1 = ref.location.y - 10
-      ref_y2 = ref.location.y + ref_object.native.size.height + 10
-      target_y1 = target.location.y
-      target_y2 = target_y1 + target.size.height
-    elsif(ref_type == "child" or ref_type == "parent")
-      ref_W = ref.location.x + ref.size.width
-      ref_H = ref.location.y + ref.size.height
-      target_W = target.location.x + target.size.width
-      target_H = target.location.y + target.size.height
-    end
-
-    if(ref_type == "up" and
-      target_x1 > ref_x1 and target_x2 < ref_x2 and # has same column or X Position
-      target.location.y < ref.location.y) # at row or Y position, target is upper
-      return true
-    elsif(ref_type == "down" and
-      target_x1 > ref_x1 and target_x2 < ref_x2 and # has same column or X Position
-      target.location.y > ref.location.y) # at row or Y position, target is at down
-      return true
-    elsif(ref_type == "left" and
-      target.location.x < ref.location.x and # at column or X Position, target is at left
-      target_y1 > ref_y1 and target_y2 < ref_y2) # at row or Y position, target is same as ref object
-      return true
-    elsif(ref_type == "right" and
-      target.location.x > ref.location.x and # at column or X Position, target is at right
-      target_y1 > ref_y1 and target_y2 < ref_y2) # at row or Y position, target is same as ref object
-      return true
-    elsif(ref_type == "child" and
-      (target_W < ref_W) and (target_H < ref_H) and
-      (target.location.x > ref.location.x) and (target.location.y > ref.location.y))
-      return true
-    elsif(ref_type == "parent" and
-      (target_W > ref_W) and (target_H > ref_H) and
-      (target.location.x < ref.location.x) and (target.location.y < ref.location.y))
-      return true
-    end
-  rescue StandardError => e
-    puts "Error: #{e.message}"
-  end
-
-  return false;
-end