itms_automation 1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f5369eaf7be36672e2fccdf1ba400a8cb807b4a09c043c741b04d16fdec9c4a5
+  data.tar.gz: 0f16ce745b0b433fe0171510da26d56a199cd867b03bd55fa2d824e5223a958d
+SHA512:
+  metadata.gz: 752628884608cdff4e59ad467be586f28d6b1f29d6fb867c9cd5cff444362c7666cc15b309382a1e4f517f311674c6b8b60c4d66f52025ad4214b47d2530ba72
+  data.tar.gz: cbe8237a0a30a988671aa44f44b780178286c70559294ee2922a0d9d9e7a3724ab24f9549ae490f22cafff036157aa70c18247aa9577448445f820ac82ca6cdd

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "itms_automation"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/documentation_generator.rb

@@ -0,0 +1,119 @@
+module DocumentationGenerator
+
+  module CommentExtractor
+    def parse_and_format_comment(comment)
+      comment.gsub!(/.*coding:.*UTF-8.*/, '')
+      comment.strip!
+      comment_lines = comment.split("\n").take_while { |line| line =~ /^\s*#/ }
+      comment_lines && comment_lines.join("\n").gsub(/^\s*# ?/, '')
+    end
+  end
+
+  class StepDefinition
+
+    extend CommentExtractor
+
+    def initialize(definition, comment = nil)
+      @definition = definition
+      @comment = comment
+    end
+
+    def self.try_and_parse(code)
+      definition = code[/^\s*((When|Then|Given|AfterStep).*)do/, 1]
+      return unless definition
+      comment = parse_and_format_comment(code)
+      return if comment =~ /\bnodoc\b/
+      new(definition.strip, comment)
+    end
+
+    def format
+      <<-TEXT
+* **#{format_definition}**
+
+#{@comment.gsub(/^/, '  ')}
+      TEXT
+    end
+
+    def format_definition
+      if @definition =~ /AfterStep/
+        @definition[/@\w*/]
+      else
+        capture_groups = %w[([^\"]*) ([^"]*) (.*) (.*?) [^"]+ ([^\"]+) ([^']*) ([^/]*) (.+) (.*[^:])]
+        capture_groups.map! &Regexp.method(:escape)
+
+        @definition.
+          gsub('/^', '').
+          gsub('$/', '').
+          gsub(' ?', ' ').
+          gsub('(?:|I )', 'I ').
+          gsub('?:', '').
+          gsub(Regexp.new(capture_groups.join '|'), '...').
+          gsub(/\\\//, '/')
+      end
+    end
+  end
+
+  class StepDefinitionFile
+
+    FILE_COMMENT_END = 'FILE_COMMENT_END'
+
+    include CommentExtractor
+
+    def initialize(filename)
+      @filename = filename
+      @code = File.read(filename)
+      @steps = []
+      extract_comment
+      add_steps
+    end
+
+    def extract_comment
+      if @code.include?(FILE_COMMENT_END)
+        file_comment = @code.split(FILE_COMMENT_END).first
+        @comment = parse_and_format_comment(file_comment)
+      end
+    end
+
+    def add_steps
+      @code.split("\n\n").each do |block|
+        step = StepDefinition.try_and_parse(block)
+        if step
+          @steps << step
+        end
+      end
+    end
+
+    def format
+      <<-TEXT
+### #{format_filename}
+
+#{@comment}
+
+#{format_steps}
+      TEXT
+    end
+
+    def format_filename
+      @filename.split('/').last
+    end
+
+    def format_steps
+      @steps.collect { |step| step.format }.join("\n\n")
+    end
+  end
+
+  class StepDefinitionsDirectory
+    def initialize(directory)
+      @step_definition_files = []
+      Dir["#{directory}/*.rb"].to_a.sort.each do |filename|
+        next if filename =~ /all_steps/
+        @step_definition_files << StepDefinitionFile.new(filename)
+      end
+    end
+
+    def format
+      @step_definition_files.collect { |step_definition_file| step_definition_file.format }.join("\n\n")
+    end
+  end
+
+end

data/bin/generate.rb

@@ -0,0 +1,53 @@
+
+def itms_automation_scaffold
+  if File.exists?(@features_dir)
+    puts 'There is already cucumber directory. Please move existing cucumber directory to carry on '
+    exit 1
+  end
+  msg("Question") do
+    puts "I'm about to create a subdirectory called features."
+    puts "features will contain all your project tests."
+    puts "Please hit return to confirm that's what you want."
+  end
+  exit 2 unless STDIN.gets.chomp == ''
+
+  FileUtils.cp_r(@source_dir, @features_dir)
+
+  msg('Info') do
+    puts "iTMS Automation is creating 'cucumber' framework. Please have a look which files are being created\n"
+  end
+  msg('Gemfile') do
+    puts "iTMS Automation created Gemfile containing all required Gems\n"
+  end
+  msg('cucumber.yml') do
+    puts "iTMS Automation created cucumber.yml file with profiles of all needed configurations\n"
+  end
+  msg('config/chrome_headless_options.yaml') do
+    puts "iTMS Automation created chrome_headless_options.yml file with profiles of all needed configurations\n"
+  end
+  msg('config/firefox_headless_options.yaml') do
+    puts "iTMS Automation created firefox_headless_options.yml file with profiles of all needed configurations\n"
+  end
+  msg('config/chrome_options.yaml') do
+    puts "iTMS Automation created chrome_options.yml file with profiles of all needed configurations\n"
+  end
+  msg('config/firefox_options.yaml') do
+    puts "iTMS Automation created firefox_options.yml file with profiles of all needed configurations\n"
+  end
+  msg('config/ie_options.yaml') do
+    puts "iTMS Automation created ie_options.yml file with profiles of all needed configurations\n"
+  end
+  msg('config/remote_options.yaml') do
+    puts "iTMS Automation created remote_options.yml file with profiles of all needed configurations\n"
+  end
+  msg('config/safari_options.yaml') do
+    puts "iTMS Automation created safari_options.yml file with profiles of all needed configurations\n"
+  end
+  msg('README.md') do
+    puts "iTMS Automation created README.md file with template usage\n"
+  end
+  msg('Info') do
+    puts "All Config files created. \n"
+  end
+
+end

data/bin/helper.rb

@@ -0,0 +1,38 @@
+require 'tempfile'
+require 'json'
+require "rubygems"
+
+def msg(title, &block)
+  puts "\n" + '-' * 10 + title + '-' * 10
+  yield
+  puts '-' * 10 + '-------' + '-' * 10 + "\n"
+  sleep 1
+end
+
+def print_help
+  puts <<EOF
+  Author: iTMS
+
+  Usage: itms_automation <command-name> [parameters] [options]
+
+  <command-name> can be one of
+    help
+    gen
+    version
+    ls
+
+    Commands:
+      help : prints more detailed help information.
+
+      gen  : creates a features dir. This is usually used once when
+             setting up itms_automation to ensure that the features folder contains
+             the right step definitions and environment to run with cucumber.
+
+      version : prints the gem version
+
+      ls: list all steps name of itms_automation framework
+
+  <Options>
+      -v, --verbose  Turns on verbose logging
+EOF
+end

data/bin/itms_automation

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+require_relative 'helper.rb'
+require_relative 'generate.rb'
+require_relative 'documentation_generator.rb'
+require 'itms_automation/version'
+
+@features_dir = File.join(FileUtils.pwd, "project")
+@source_dir = File.join(File.dirname(__FILE__), '..', 'project')
+
+search_string = ARGV.shift
+case search_string
+  when /version/
+    puts ItmsAutomation::VERSION
+  when /gen/
+    itms_automation_scaffold
+  when /ls/
+    ORDERED_KINDS = %w[Given When Then]
+    heading = 'All itms_automation steps'
+
+# collect
+    steps_glob = File.expand_path('../../lib/itms_automation/*_steps.rb', __FILE__)
+    step_names = `cat #{steps_glob}`.split($/).select { |line| line =~ /^\s*(Given|When|Then)/ }
+
+# Output
+    puts "\e[4;34m\n# #{heading}\e[0m" # blue underline
+    puts step_names
+  else
+    print_help
+end
+
+
+

data/bin/setup

@@ -0,0 +1,8 @@
+#!/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.rb

@@ -0,0 +1,3 @@
+require 'cucumber_priority'
+require "itms_automation/version"
+Dir[File.dirname(__FILE__) + '/itms_automation/*.rb'].each { |file| require file }

data/lib/itms_automation/all_steps.rb

@@ -0,0 +1,8 @@
+# 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/auto_util.rb

@@ -0,0 +1,133 @@
+#-----------------------------------------------------
+# 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 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

data/lib/itms_automation/version.rb

@@ -0,0 +1,3 @@
+module ItmsAutomation
+  VERSION = "1.0"
+end

data/lib/itms_automation/web_steps_helper.rb

@@ -0,0 +1,994 @@
+require 'net/https'
+require 'rspec'
+
+def execute_openbrowser(url_site)
+  begin
+    if url_site == ""
+      raise "❌  Error: Null web page URL."
+    end
+    visit(url_site)
+  rescue StandardError => e
+    raise "❌  Error: #{e}"
+  end
+end
+
+def execute_click(element)
+  foundElement = find_object(element)
+  if foundElement != nil
+    begin
+      foundElement.click
+    rescue StandardError => e
+      raise "❌  Error: #{e}"
+    end
+  else
+    raise "❌  Error >> Not found object: #{element}"
+  end
+end
+
+def execute_click_offset(element, x, y)
+  foundElement = find_object(element)
+  if foundElement != nil
+    begin
+      page.driver.browser.mouse.move_to(foundElement.native,x.to_i,y.to_i)
+      page.driver.browser.mouse.click()
+    rescue Exception => e
+      raise "❌  Error: #{e}"
+    end
+  else
+    raise "❌  Error: Not found object: #{element}"
+  end
+end
+
+def double_click(element)
+  foundElement = find_object(element)
+  if foundElement != nil
+    begin
+      foundElement.double_click
+    rescue StandardError => e
+      raise "❌  Error: #{e}"
+    end
+  else
+    raise "❌  Error: Not found object: #{element}"
+  end
+end
+
+def execute_settext(element, text)
+  foundElement = find_object(element)
+  if foundElement != nil
+    begin
+      foundElement.set(text)
+    rescue StandardError => e
+      raise "❌  Error: #{e}"
+    end
+  else
+    raise "❌  Error: Not found object: #{element}"
+  end
+end
+
+def maximize_browser
+  begin
+    page.driver.browser.manage.window.maximize
+  rescue StandardError => e
+    raise "❌  Error: #{e}"
+  end
+end
+
+def switch_to_window_by_title(window_title)
+  $previous_window = page.driver.browser.window_handle
+  @window_found = false
+  page.driver.browser.window_handles.each { |handle|
+    page.driver.browser.switch_to.window handle
+    if page.title == window_title
+      @window_found = true
+      break
+    end
+  }
+  if @window_found == false
+    raise "Window having title \"#{window_title}\" not found"
+  end
+end
+
+def scroll_to_end_page
+  begin
+    page.driver.execute_script('window.scrollTo(0,Math.max(document.documentElement.scrollHeight,document.body.scrollHeight,document.documentElement.clientHeight));')
+  rescue StandardError => e
+    raise "❌  Error: #{e}"
+  end
+end
+
+def scroll_to_top_page
+  begin
+    page.driver.execute_script('window.scrollTo(Math.max(document.documentElement.scrollHeight,document.body.scrollHeight,document.documentElement.clientHeight),0);')
+  rescue StandardError => e
+    raise "❌  Error: #{e}"
+  end
+end
+
+def verify_title(expected_title)
+  begin
+    page_title = page.title
+    puts "Actual Page Title : #{page_title}, Expected Page Title : #{expected_title}"
+    expect(page_title).to eq expected_title
+  rescue StandardError => e
+    raise "❌  Error: #{e}"
+  end
+end
+
+def verify_alert_text(text)
+  begin
+    alert = page.driver.browser.switch_to.alert.text
+    puts "Actual Page alert text : #{alert}, Expected value : #{text}"
+    expect(alert).to eq text
+  rescue StandardError => e
+    raise "❌  Error: #{e}"
+  end
+end
+
+def accept_alert
+  begin
+    page.driver.browser.switch_to.alert.accept
+  rescue Exception => e
+    raise "❌  ERROR: #{e}"
+  end
+end
+
+def back
+  begin
+    page.execute_script('window.history.back()')
+  rescue Exception => e
+    raise "❌  ERROR: #{e}"
+  end
+end
+
+def refresh
+  begin
+    page.execute_script('window.location.reload()')
+  rescue Exception => e
+    raise "❌  ERROR: #{e}"
+  end
+end
+
+def clear_text(element)
+  foundElement = find_object(element)
+  if foundElement != nil?
+    begin
+      foundElement.native.clear
+    rescue Exception => e
+      raise "❌  ERROR: #{e}"
+    end
+  else
+    raise "❌  Error: Not found object: #{element}"
+  end
+end
+
+def execute_javascript(script)
+  begin
+    page.execute_script(script)
+  rescue Exception => e
+    puts "❌  Error: Not found object: #{element}"
+  end
+end
+
+def execute_select(element, text)
+  #select(text, :xpath => element)
+  foundElement = find_object(element)
+  if foundElement != nil
+    begin
+      option_value = page.evaluate_script("$(\"##{foundElement[:id]} option:contains('#{text}')\").val()")
+      page.execute_script("$('##{foundElement[:id]}').val('#{option_value}')")
+      page.execute_script("$('##{foundElement[:id]}').trigger('liszt:updated').trigger('change')")
+    rescue Exception => e
+      raise "❌  ERROR: #{e}"
+    end
+  else
+    raise "❌  Error: Not found object: #{element}"
+  end
+end
+
+def execute_mouse_over(element)
+  foundElement = find_object(element)
+  if foundElement != nil
+    begin
+      page.driver.browser.action.move_to(foundElement.native, element).click.perform
+      sleep(1)
+    rescue StandardError => e
+      raise "❌  Error: #{e}"
+    end
+  else
+    raise "❌  Error: Not found object: #{element}"
+  end
+end
+
+def remove_element_attribute(element, attr)
+  foundElement = find_object(element)
+  if foundElement != nil
+    begin
+      page.driver.browser.execute_script("arguments[0].removeAttribute('#{attr}');", foundElement.native)
+      sleep(1)
+    rescue StandardError => e
+      raise "❌  Error: #{e}"
+    end
+  else
+    raise "❌  Error: Not found object: #{element}"
+  end
+end
+
+# Set state
+def execute_setstate(element, state)
+  foundElement = find_object(element)
+  if foundElement != nil
+    if state
+      foundElement.select_option
+    else
+      foundElement.unselect_option
+    end
+  else
+    raise "❌  Error: Not found object: #{element}"
+  end
+end
+
+def close_windows
+  begin
+    page.execute_script "window.close();"
+  rescue StandardError => e
+    raise "❌  Error: #{e}"
+  end
+end
+
+def resize_window_screen(x, y)
+  begin
+    page.driver.browser.manage.window.resize_to(x, y)
+    puts page.driver.browser.manage.window.size
+  rescue StandardError => e
+    raise "❌  Error: #{e}"
+  end
+end
+
+def switch_to_frame(element)
+  begin
+    page.driver.browser.switch_to.frame element
+  rescue Exception => e
+    raise "❌  Error: #{e}"
+  end
+end
+
+def get_computed_style(element, style)
+  foundElement = get_object_value(element)
+  computedStyle = ""
+  if foundElement != nil
+    computedStyle = page.evaluate_script("window.getComputedStyle(document.querySelector('#{foundElement}')).#{style}")
+  else
+    raise "❌  Error: Not found object: #{element}"
+  end
+  puts "\nActual object style value is: #{computedStyle}"
+  computedStyle
+end
+
+def put_log str
+  p str if $print_log == true
+end
+
+def get_object_value(str_obj)
+  string_object = str_obj.gsub(/"/, "'")
+  hash_object = $OBJECT[string_object]
+  if hash_object == nil
+    raise ">>> OBJECT: #{str_obj} NAME MAYBE NOT FOUND!!!"
+  end
+  if hash_object.keys[0].to_s.upcase != "CSS_SELECTOR"
+    raise ">>> OBJECT: #{str_obj} should be formatted as Css Selector."
+  end
+  hash_object[hash_object.keys[0]]
+end
+
+def get_element_text(element)
+  foundElement = find_object(element)
+  if foundElement != nil
+    begin
+      result = foundElement.text()
+      puts "Text of #{element}: #{result}"
+    rescue StandardError => e
+      raise "❌  Error: #{e}"
+    end
+  else
+    raise "❌  Error: Not found object: #{element}"
+  end
+end
+
+def get_element_attribute(element,value)
+  foundElement = find_object(element)
+  if foundElement != nil
+    begin
+      result = foundElement.value()
+      puts "Attribute of #{element}: #{result}"
+    rescue StandardError => e
+      raise "❌  Error: #{e}"
+    end
+  else
+    raise "❌  Error: Not found object: #{element}"
+  end
+end
+
+def verify_element_text(element,value)
+  foundElement = find_object(element)
+  if foundElement != nil
+    begin
+      actual_value = foundElement.text()
+      put_log "Actual result is: '#{actual_value}' -- Expected result is: '#{value}'"
+      expect(actual_value).to eq value
+    rescue Exception => e
+      raise "❌  ERROR: #{e} "
+    end
+  else
+    raise "❌  Error: Not found object: #{element}"
+  end
+end
+
+def verify_element_not_has_text(element,value)
+  foundElement = find_object(element)
+  if foundElement != nil
+    begin
+      actual_value = foundElement.text()
+      put_log "Actual result is: '#{actual_value}' -- Expected result is: '#{value}'"
+      expect(actual_value).not_to eql value
+    rescue Exception => e
+      raise "❌  ERROR: #{e}"
+    end
+
+  else
+    raise "❌  Error: Not found object: #{element}"
+  end
+end
+
+def verify_element_value(element,value)
+  foundElement = find_object(element)
+  if foundElement != nil
+    begin
+      actual_value = foundElement.value()
+      put_log "Actual result is: '#{actual_value}' -- Expected result is: '#{value}'"
+      expect(actual_value).to eq value
+    rescue Exception => e
+      raise "❌  ERROR: #{e}"
+    end
+  else
+    raise "❌  Error: Not found object: #{element}"
+  end
+end
+
+def verify_element_not_has_value(element,value)
+  foundElement = find_object(element)
+  if foundElement != nil
+    begin
+      actual_value = foundElement.value()
+      put_log "Actual result is: '#{actual_value}' -- Expected result is: '#{value}'"
+      expect(actual_value).not_to eql value
+    rescue Exception => e
+      raise "❌  ERROR: #{e}"
+    end
+  else
+    raise "❌  Error: Not found object: #{element}"
+  end
+end
+
+def execute_checkproperty(element, property, negate, value, isSpecialChar=false)
+  validate_option_by(property)
+  Capybara.configure do |config|
+    config.ignore_hidden_elements = false
+  end
+  foundElement = find_object(element)
+
+  check = false
+  if foundElement == nil and value == ""
+    check = true
+    # check.should eq true
+    expect(check).to eq true
+  else
+    # put_log "\n\n\t>>> execute_checkproperty: finish to found element"
+    if foundElement != nil
+
+      if property.upcase == 'VALUE'
+        actual_value = foundElement.value()
+
+      elsif property.upcase == 'TEXT'
+        actual_value = foundElement.text()
+
+      else
+        actual_value = foundElement["#{property}"]
+      end
+
+      if actual_value == nil
+        actual_value = ''
+      end
+    else
+      put_log "❌  Error: Not found object: #{element}"
+    end
+
+    Capybara.configure do |config|
+      config.ignore_hidden_elements = true
+    end
+
+    # if IFD_Assertion.reg_compare(actual_value, value, isSpecialChar)
+    #   check = true
+    # end
+
+    put_log "\n#{property} :: Actual result is: '#{actual_value}' -- Expected result is: '#{value}'"
+
+    if negate == " not"
+      actual_value.should_not eq value
+      expect(actual_value).not_to eql value
+    elsif actual_value.should eq value
+      expect(actual_value).to eq value
+    end
+  end
+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 "❌ 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 "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}"
+  end
+
+  return foundElements
+end
+
+def get_objects_by_Class(strClass)
+  foundElements = nil
+  begin
+    foundElements = page.all("*[@class='#{strClass}']")
+  rescue StandardError => e
+     raise "❌  Error: #{e}"
+  end
+
+  return foundElements
+end
+
+def get_objects_by_Name(strName)
+  foundElements = nil
+  begin
+    foundElements = page.all("*[@name='#{strName}']")
+  rescue StandardError => e
+     raise "❌  Error: #{e}"
+  end
+
+  return foundElements
+end
+
+def get_objects_by_Tagname(strTagname)
+  foundElements = nil
+  begin
+    foundElements = page.all("#{strTagname}")
+  rescue StandardError => e
+     raise "❌  Error: #{e}"
+  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}"
+  end
+  foundElements
+end
+
+def get_objects_by_xpath_selector(strXpathSelector)
+  foundElements = nil
+  begin
+    foundElements = page.all(:xpath, strXpathSelector)
+  rescue StandardError => e
+    raise "❌  Error: #{e}"
+  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}"
+  end
+
+  return false;
+end
+
+def get_object_and_store_as_string(object,string)
+  text = execute_gettext(object)
+  txt = "'" + text + "'"
+  set_var(string, txt)
+end
+
+
+def get_object_and_store_to_file(object,file_name)
+  $text = execute_gettext(object)
+  open($test_data_dir+file_name, 'a+') do |f|
+    f << $text + "\n"
+  end
+end
+
+def drag_and_drop_by_offset(element, x, y)
+  foundElement = find_object(element)
+  if foundElement != nil
+    begin
+      page.driver.browser.action.drag_and_drop_by(foundElement, x, y).perform
+    rescue Exception => e
+      raise "❌  ERROR: #{e}"
+    end
+  else
+    raise "❌  Error: Not found object: #{element}"
+  end
+end
+
+def drag_and_drop_to_object(from_element, element)
+  found_from_element = find_object(from_element)
+  foundElement = find_object(element)
+  if foundElement != nil and found_from_element != nil
+    found_from_element.drag_to(foundElement)
+  end
+end
+
+def execute_sendkeys(element, key)
+  validate_supported_keys(key)
+  foundElement = find_object(element)
+  if foundElement != nil
+    begin
+      foundElement.native.send_keys(key)
+    rescue Exception => e
+      raise "❌  ERROR: #{e}"
+    end
+  else
+    raise "❌  Error: Not found object: #{element}"
+  end
+end
+
+def movemouseandclick var, element
+  Selenium::WebDriver::Support::Select.new(page.driver.browser.find_element(:id, "#{var}")).select_by(:text, "#{element}")
+  page.driver.browser.find_element(:id, "#{var}").click
+end