Ifd_Automation 2.8.2 → 2.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79bab1248d7f5d0a920e0f5c6dd7140b0435ae944e5a58f0855594a0db554a8f
-  data.tar.gz: 05b42b97b11906af46735ff15c1b44e6242aff4770f90794f00251c536216fcb
+  metadata.gz: ead647aae45a7dabb8912d9a7be482be5460da9cf7d2274daa47bfa3b55f4c85
+  data.tar.gz: 5735834456929b033aa6ddfc677e85c02f9aa3fad5a35ee000cc45fe5abf7e14
 SHA512:
-  metadata.gz: 0506005ae122bb0b7a75c21b7654e410d7bde7af442708b40694c4168043e4da51a9ea299d3605b59e51558603a3cb733a6675f887988185d10d7aef2684bb94
-  data.tar.gz: 728d540e016a22977d5b3e9addbec00aba4b2f31dabf22f68199f3b160bd1e11d9d203294d982d67866153a72b3f9cfa5358dd42d7ed4c3756267eb8a594fd0b
+  metadata.gz: d336664be9b300d03336f4f1d5e15df44f6d92d00adb7b749559ea85e4e6e09c8b2799dba66b1f8fec7ffb318e2f97e685eb3c095ff5ec0c69aa66baa94a3f86
+  data.tar.gz: 16bcdf590ac0676206de8f09f6314bdea030a979b3259e25386887667c568e5e1cc7b6dc8c1184f332cf1ffca4243870d3c3205271beba7a264d006cf78eb5ba

data/bin/generate.rb

@@ -25,12 +25,6 @@ def ifd_automation_scaffold
   msg('README.md') do
     puts "INFOdation Automation created README.md file with template usage\n"
   end
-  msg('Dockerfile') do
-    puts "INFOdation Automation created Dockerfile\n"
-  end
-  msg('docker-compose.yml') do
-    puts "INFOdation Automation created Dockerfile\n"
-  end
   msg('Info') do
     puts "All Config files created. \n"
   end

data/lib/Ifd_Automation.rb

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

data/{project/features/step_definitions/IFD_Libraries → lib/Ifd_Automation}/database_steps.rb

@@ -41,4 +41,4 @@ end
 
 When /^I store the result of SQL script as "(.*?)"$/ do |var_name|
   IFD_DBConnection.store_sql_result_into_string(var_name)
-end
+end

data/lib/Ifd_Automation/version.rb

@@ -1,3 +1,3 @@
 module IfdAutomation
-  VERSION = "2.8.2"
+  VERSION = "2.9"
 end

data/lib/Ifd_Automation/web_steps.rb

@@ -0,0 +1,109 @@
+# require 'cucumber_priority'
+# require 'spreewald_support/tolerance_for_selenium_sync_issues'
+# require 'spreewald_support/step_fallback'
+# require_relative '../helper/web_steps_helper'
+
+# Given /I am on the "(.*?)" page/ do |url|
+#   patiently do
+#     execute_openbrowser(url)
+#   end
+# end.overridable
+
+# When /I wait for (\d+) seconds/ do |second|
+#   sleep(second.to_i)
+# end.overridable
+
+# And /I click on "(.*?)"/ do |object|
+#   patiently do
+#     execute_click(object)
+#   end
+# end.overridable
+
+# Then /I double click on "(.*?)"/ do |element|
+#   patiently do
+#     double_click(element)
+#   end
+# end.overridable
+
+# And /I set text on "(.*?)" with "(.*?)"/ do |object, text|
+#   patiently do
+#     execute_settext(object, text)
+#   end
+# end.overridable
+
+# And /I select option on "(.*?)" with "(.*?)"/ do |object, text|
+#   patiently do
+#     execute_select(object, text)
+#   end
+# end.overridable
+
+# Then /I maximize browser window/ do
+#   maximize_browser
+# end.overridable
+
+# Then /I capture a screenshot as "(.*)"/ do |name|
+#   file_path = $test_data_dir + name.downcase
+#   page.save_screenshot(file_path)
+# end.overridable
+
+# Then /I switch to window having title "(.*?)"/ do |window_title|
+#   switch_to_window_by_title window_title
+# end.overridable
+
+# Then /I scroll to (top|end) of page/ do |to|
+#   scroll_page(to)
+# end.overridable
+
+# Then /I check property "(.*?)" with "(.*?)" has( | not)? value "(.*?)"/ do |object, property, negate, value|
+#   value = Utils.bind_with_dyn_vars value
+#   patiently do
+#     execute_checkproperty(object, property, negate, value)
+#   end
+# end.overridable
+
+# Then /I should see text alert "(.*?)"/ do |actual_value|
+#   verify_alert_text(actual_value)
+# end.overridable
+
+# Given /I move mouse to element "(.*)" and click/ do |object|
+#   patiently do
+#     execute_mousehoverandclick(object)
+#   end
+# end.overridable
+
+# And /I remove attribute "(.*)" on object "(.*)"/ do |attr, object|
+#   patiently do
+#     remove_element_attribute object, attr
+#   end
+# end.overridable
+
+# And /I set state on "(.*?)" with "(.*?)"/ do |object, state|
+#   patiently do
+#     execute_setstate(object, state)
+#   end
+# end.overridable
+
+# And /browser window is re-sized to width "(.*)" and height "(.*)"/ do |x,y|
+#   resize_window_screen(x,y)
+# end.overridable
+
+# And /I verify object "(.*)" with "(.*)" has value "(.*)"/ do |object,style,expected_value|
+#   actual_value = get_computed_style(object,style)
+#   patiently do
+#     IFD_Assertion.assert_string_equal(expected_value,actual_value)
+#   end
+# end.overridable
+
+# Then /I should( not)? see page title "(.*)"/ do |present, title|
+#   check_title(title, present.empty?)
+# end.overridable
+
+# And /I move mouse to element "(.*)" and choose item "(.*)" then click/ do |var, element|
+#   patiently do
+#     movemouseandclick(var, element)
+#   end
+# end.overridable
+
+# And /I hold element "(.*)" and move from location x "(.*)" to y "(.*)"$/ do |el, x, y|
+#   drag_drop el, x, y
+# end.overridable

data/lib/helper/ssh_helper.rb

@@ -36,4 +36,4 @@ class IFD_Ssh
     $context_value = Utils.bind_with_dyn_vars(@output)
     Utils.set_var(name, '$context_value')
   end
-end
+end

data/lib/helper/step_fallback.rb

@@ -0,0 +1,13 @@
+# coding: UTF-8
+
+module StepFallback
+  def step(*args)
+    if defined?(super)
+      super
+    else
+      When(*args)
+    end
+  end
+end
+
+World(StepFallback)

data/lib/helper/tolerance_for_selenium_sync_issues.rb

@@ -0,0 +1,72 @@
+module ToleranceForSeleniumSyncIssues
+  RETRY_ERRORS = %w[
+    Capybara::ElementNotFound
+    Spec::Expectations::ExpectationNotMetError
+    RSpec::Expectations::ExpectationNotMetError
+    Minitest::Assertion
+    Capybara::Poltergeist::ClickFailed
+    Capybara::ExpectationNotMet
+    Selenium::WebDriver::Error::StaleElementReferenceError
+    Selenium::WebDriver::Error::NoAlertPresentError
+    Selenium::WebDriver::Error::ElementNotVisibleError
+    Selenium::WebDriver::Error::NoSuchFrameError
+    Selenium::WebDriver::Error::NoAlertPresentError
+    Selenium::WebDriver::Error::JavascriptError
+    Selenium::WebDriver::Error::UnknownError
+    Selenium::WebDriver::Error::NoSuchAlertError
+  ]
+
+  class CapybaraWrapper
+    def self.default_max_wait_time
+      if Capybara.respond_to?(:default_max_wait_time)
+        Capybara.default_max_wait_time
+      else
+        Capybara.default_wait_time
+      end
+    end
+
+    def self.default_max_wait_time=(value)
+      if Capybara.respond_to?(:default_max_wait_time=)
+        Capybara.default_max_wait_time = value
+      else
+        Capybara.default_wait_time = value
+      end
+    end
+  end
+
+  class Patiently
+    WAIT_PERIOD = 0.05
+
+    def patiently(seconds, &block)
+      started = Time.now
+      tries = 0
+      begin
+        tries += 1
+        block.call
+      rescue Exception => e
+        raise e unless retryable_error?(e)
+        raise e if (Time.now - started > seconds && tries >= 2)
+        sleep(WAIT_PERIOD)
+        raise Capybara::FrozenInTime, "time appears to be frozen, Capybara does not work with libraries which freeze time, consider using time travelling instead" if Time.now == started
+        retry
+      end
+    end
+
+    private
+
+    def retryable_error?(e)
+      RETRY_ERRORS.include?(e.class.name)
+    end
+  end
+
+
+  def patiently(seconds = CapybaraWrapper.default_max_wait_time, &block)
+    if page.driver.wait?
+      Patiently.new.patiently(seconds, &block)
+    else
+      block.call
+    end
+  end
+end
+
+World(ToleranceForSeleniumSyncIssues)

data/lib/helper/web_steps_helper.rb

@@ -1,436 +1,616 @@
 require 'net/https'
-# Open Browser with config-able maximize browser option
-  def execute_openbrowser(url_site)
-    begin
-      if $_CFWEB['Maximize Browser'] == true
-        page.driver.browser.manage.window.maximize
-      end
-    rescue StandardError => myStandardError
-      raise "\n>>> Error: #{myStandardError}"
+require 'rspec'
+def execute_openbrowser(url_site)
+  begin
+    if $_CFWEB['Maximize Browser'] == true
+      page.driver.browser.manage.window.maximize
     end
+  rescue StandardError => e
+    raise "\n>>> Error: #{e}"
+    exit
+  end
 
-    if url_site == ""
-      raise "\n>>> Error: Null web page URL."
-    else
-      visit(url_site)
-    end
+  if url_site == ""
+    raise "\n>>> Error: Null web page URL."
+    exit
+  else
+    visit(url_site)
   end
+end
 
-  def execute_click(element)
-    foundElement = find_object(element)
-    if foundElement != nil
-      page.driver.execute_script('window.focus();')
-      startTime = Time.new.to_i
-      begin
-        sleep(0.5)
-        currentTime = Time.new.to_i
-      end while (foundElement.native.enabled? == false and (currentTime - startTime) < $_CFWEB['Wait Time'])
-      page.driver.browser.execute_script("arguments[0].scrollIntoView(true);", foundElement.native)
-      page.driver.browser.action.move_to(foundElement.native, element).click.perform
-      # page.driver.browser.action.click(foundElement.native)
-      # foundElement.native.send_keys(:return)
-    else
-      raise "\nError >> Not found object: #{element}"
+def execute_click(element)
+  foundElement = find_object(element)
+  if foundElement != nil
+    begin
+      foundElement.click
+    rescue StandardError => e
+      raise "\n>>> Error: #{e}"
+      exit
     end
+  else
+    raise "\nError >> Not found object: #{element}"
+    exit
   end
+end
 
-  def double_click(element)
-    foundElement = find_object(element)
-    if foundElement != nil
-      begin
-        page.driver.browser.action.double_click(foundElement.native)
-      rescue StandardError => myStandardError
-        raise "\n>>> Error: #{myStandardError}"
-      end
-    else
-      raise "\nError >> Not found object: #{element}"
+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 "\n>>> Error: #{e}"
       exit
     end
+  else
+    raise "\nError >> Not found object: #{element}"
+    exit
   end
+end
 
-  def execute_settext(element, text)
-    foundElement = find_object(element)
-    if foundElement != nil
-      begin
-        foundElement.set(text)
-      rescue StandardError => myStandardError
-        raise "\n>>> Error: #{myStandardError}"
-      end
-    else
-      raise "\nError >> Not found object: #{element}"
+def double_click(element)
+  foundElement = find_object(element)
+  if foundElement != nil
+    begin
+      foundElement.double_click
+    rescue StandardError => e
+      raise "\n>>> Error: #{e}"
       exit
     end
+  else
+    raise "\nError >> Not found object: #{element}"
+    exit
   end
+end
 
-  def maximize_browser
-    page.driver.browser.manage.window.maximize
+def execute_settext(element, text)
+  foundElement = find_object(element)
+  if foundElement != nil
+    begin
+      foundElement.set(text)
+    rescue StandardError => e
+      raise "\n>>> Error: #{e}"
+    end
+  else
+    raise "\nError >> Not found object: #{element}"
+    exit
   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
-    }
-    raise "Window having title \"#{window_title}\" not found" if not window_found
+def maximize_browser
+  begin
+    page.driver.browser.manage.window.maximize
+  rescue StandardError => e
+    raise "\n>>> Error: #{e}"
+    exit
   end
+end
 
-  def scroll_page(to)
-    if to == 'end'
-      page.driver.execute_script('window.scrollTo(0,Math.max(document.documentElement.scrollHeight,document.body.scrollHeight,document.documentElement.clientHeight));')
-    elsif to == 'top'
-      page.driver.execute_script('window.scrollTo(Math.max(document.documentElement.scrollHeight,document.body.scrollHeight,document.documentElement.clientHeight),0);')
-    else
-      raise "Exception : Invalid Direction (only scroll \"top\" or \"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"
+    exit
+  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 "\n>>> Error: #{e}"
+    exit
   end
+end
 
-# Method to verify title
-# param 1 : String : expected title
-# param 2 : Boolean : test case [true or flase]
-  def check_title(title, test_case)
+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 "\n>>> Error: #{e}"
+    exit
+  end
+end
+
+def verify_title(expected_title)
+  begin
     page_title = page.title
-    if test_case
-      if page_title != "#{title}"
-        raise "Page Title Not Matched, Actual Page Title : #{page_title}, Expected Page Title : #{title}"
-      end
-    else
-      if page_title == "#{title}"
-        raise "Page Title Matched, Actual Page Title: #{page_title}"
-      end
-    end
+    puts "Actual Page Title : #{page_title}, Expected Page Title : #{expected_title}"
+    expect(page_title).to eq expected_title
+  rescue StandardError => e
+    raise "\n>>> Error: #{e}"
+    exit
   end
+end
 
-  def check_alert_text(text)
+def verify_alert_text(text)
+  begin
     alert = page.driver.browser.switch_to.alert.text
-    if alert != text
-      raise "Text on alert pop up not matched, Actual Text : #{alert}, Expected Text : #{text}"
+    puts "Actual Page alert text : #{alert}, Expected value : #{text}"
+    expect(alert).to eq text
+  rescue StandardError => e
+    raise "\n>>> Error: #{e}"
+    exit
+  end
+end
+
+def accept_alert
+  begin
+    page.driver.browser.switch_to.alert.accept
+  rescue Exception => e
+    raise "\n>>> ERROR: #{e}"
+    exit
+  end
+end
+
+def back
+  begin
+    page.execute_script('window.history.back()')
+  rescue Exception => e
+    raise "\n>>> ERROR: #{e}"
+    exit
+  end
+end
+
+def refresh
+  begin
+    page.execute_script('window.location.reload()')
+  rescue Exception => e
+    raise "\n>>> ERROR: #{e}"
+    exit
+  end
+end
+
+def clear_text(element)
+  foundElement = find_object(element)
+  if foundElement != nil?
+    begin
+      foundElement.native.clear
+    rescue Exception => e
+      raise "\n>>> ERROR: #{e}"
+      exit
     end
+  else
+    raise "\nError >> Not found object: #{element}"
+    exit
   end
+end
 
-  def execute_select(element, text)
-    #select(text, :xpath => element)
-    foundElement = find_object(element)
+def execute_javascript(script)
+  begin
+    page.execute_script(script)
+  rescue Exception => e
+    raise "\nError >> Not found object: #{element}"
+    exit
+  end
+end
 
-    if foundElement != nil
+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')")
-    else
-      put_log "\nError >> Not found object: #{element}"
+    rescue Exception => e
+      raise "\n>>> ERROR: #{e}"
       exit
     end
+  else
+    raise "\nError >> Not found object: #{element}"
+    exit
   end
+end
 
-  def execute_mousehoverandclick(element)
-    foundElement = find_object(element)
-    if foundElement != nil
+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)
-    else
-      put_log "\nError >> Not found object: #{element}"
+    rescue StandardError => e
+      raise "\n>>> Error: #{e}"
+      exit
     end
+  else
+    raise "\nError >> Not found object: #{element}"
+    exit
   end
+end
 
-  def remove_element_attribute(element, attr)
-    foundElement = find_object(element)
-    if foundElement != nil
+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)
-    else
-      put_log "\nError >> Not found object: #{element}"
+      sleep(1)
+    rescue StandardError => e
+      raise "\n>>> Error: #{e}"
+      exit
     end
+  else
+    raise "\nError >> Not found object: #{element}"
+    exit
   end
+end
 
 # Set state
-  def execute_setstate(element, state)
-    foundElement = find_object(element)
-    if foundElement != nil
-      if state.upcase == "TRUE"
-        foundElement.select_option
-      else
-        foundElement.unselect_option
-      end
+def execute_setstate(element, state)
+  foundElement = find_object(element)
+  if foundElement != nil
+    if state
+      foundElement.select_option
     else
-      put_log "\nError >> Not found object: #{element}"
-      exit
+      foundElement.unselect_option
     end
+  else
+    raise "\nError >> Not found object: #{element}"
+    exit
   end
+end
+
+def close_windows
+  begin
+    page.execute_script "window.close();"
+  rescue StandardError => e
+    raise "\n>>> Error: #{e}"
+    exit
+  end
+end
 
-  def resize_window_screen(x, y)
+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 "\n>>> Error: #{e}"
+    exit
   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
-      puts "\nError >> Not found object: #{element}"
-    end
-    puts "\nActual object style value is: #{computedStyle}"
-    computedStyle
+def switch_to_frame(element)
+  begin
+    page.driver.browser.switch_to.frame 'element'
+  rescue Exception => e
+    raise "\n>>> Error: #{e}"
+    exit
   end
+end
 
-  require 'rspec'
+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 "\nError >> Not found object: #{element}"
+    exit
+  end
+  puts "\nActual object style value is: #{computedStyle}"
+  computedStyle
+end
 
-  def put_log str
-    p str if $_CFWEB['Print Log'] == true
+def put_log str
+  p str if $_CFWEB['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!!!"
+    exit
   end
+  if hash_object.keys[0].to_s.upcase != "CSS_SELECTOR"
+    raise ">>> OBJECT: #{str_obj} should be formatted as Css Selector."
+    exit
+  end
+  hash_object[hash_object.keys[0]]
+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."
+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 "\n>>> Error: #{e}"
+      exit
     end
-    hash_object[hash_object.keys[0]]
+  else
+    raise "\nError >> Not found object: #{element}"
+    exit
   end
+end
 
-  def execute_checkproperty(element, property, negate, value, isSpecialChar=false)
-    Capybara.configure do |config|
-      config.ignore_hidden_elements = false
+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 "\n>>> Error: #{e}"
+      exit
     end
-    foundElement = find_object(element)
+  else
+    raise "\nError >> Not found object: #{element}"
+    exit
+  end
+end
 
-    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()
+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 "\n>>> ERROR: #{e} "
+      exit
+    end
+  else
+    raise "\nError >> Not found object: #{element}"
+    exit
+  end
+end
 
-        elsif property.upcase == 'TEXT'
-          actual_value = foundElement.text()
+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 "\n>>> ERROR: #{e}"
+      exit
+    end
 
-        elsif property.upcase == 'SPECIAL CHAR'
-          actual_value = foundElement.text()
-          isSpecialChar = true
+  else
+    raise "\nError >> Not found object: #{element}"
+    exit
+  end
+end
 
-        elsif property.upcase == 'TAGNAME'
-          actual_value = foundElement.tag_name()
+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 "\n>>> ERROR: #{e}"
+      exit
+    end
+  else
+    raise "\nError >> Not found object: #{element}"
+    exit
+  end
+end
 
-        elsif property.upcase == 'STYLE'
-          actual_value = foundElement[:style]
+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 "\n>>> ERROR: #{e}"
+      exit
+    end
+  else
+    raise "\nError >> Not found object: #{element}"
+    exit
+  end
+end
 
-        elsif property.upcase == 'DISABLED'
-          actual_value = foundElement[:disabled]
+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
 
-        elsif property.upcase == 'WIDTH'
-          actual_value = foundElement[:width]
+      if property.upcase == 'VALUE'
+        actual_value = foundElement.value()
 
-        elsif property.upcase == 'HEIGHT'
-          actual_value = foundElement[:height]
+      elsif property.upcase == 'TEXT'
+        actual_value = foundElement.text()
 
-        elsif property.upcase == 'ID'
-          actual_value = foundElement[:id]
+      else
+        actual_value = foundElement["#{property}"]
+      end
 
-        elsif property.upcase == 'NAME'
-          actual_value = foundElement[:name]
+      if actual_value == nil
+        actual_value = ''
+      end
+    else
+      put_log "\nError >> Not found object: #{element}"
+    end
 
-        elsif property.upcase == 'CLASS'
-          actual_value = foundElement[:class]
+    Capybara.configure do |config|
+      config.ignore_hidden_elements = true
+    end
 
-        elsif property.upcase == 'HREF'
-          actual_value = foundElement[:href]
+    # if IFD_Assertion.reg_compare(actual_value, value, isSpecialChar)
+    #   check = true
+    # end
 
-        elsif property.upcase == 'TITLE'
-          actual_value = foundElement[:title]
+    put_log "\n#{property} :: Actual result is: '#{actual_value}' -- Expected result is: '#{value}'"
 
-        elsif property.upcase == 'TYPE'
-          actual_value = foundElement[:type]
+    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
 
-        elsif property.upcase == 'CHECKED'
-          actual_value = "true" if foundElement.checked? == true
-          actual_value = "false" if foundElement.checked? == false
-        else
-          actual_value = foundElement["#{property}"]
-        end
+def check_valid_option_by?(option_by)
+  %w(text value).include? option_by
+end
 
-        if actual_value == nil
-          actual_value = ''
-        end
-      else
-        put_log "\nError >> Not found object: #{element}"
-      end
+def validate_option_by(option_by)
+  raise "Please select valid option, invalid option - #{option_by}" unless check_valid_option_by? option_by
+end
 
-      Capybara.configure do |config|
-        config.ignore_hidden_elements = true
-      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
 
-      # if IFD_Assertion.reg_compare(actual_value, value, isSpecialChar)
-      #   check = true
-      # end
+def validate_supported_keys(key)
+  raise "Please select valid keys, invalid key - #{key}" unless check_valid_option_by? key
+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
+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
 
-  def execute_gettext(element)
-    foundElement = find_object(element)
-    if foundElement != nil
-      tagname = foundElement.tag_name()
+  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
 
-      if tagname.upcase == 'SELECT'
-      else
-        actual_text = foundElement.text()
-        if (actual_text == nil or actual_text.length == 0) and (tagname.upcase == 'INPUT' or tagname.upcase == 'TEXTAREA')
-          actual_text = foundElement.value()
+          dyn_pros.delete(k)
         end
+      else
+        upcase_attrb[k.to_s.upcase] = v
       end
 
-      put_log "\nText is '" + actual_text + "' of object '" + element + "'"
-      $context_value = actual_text
+    }
+  end
+  ph_attrs = {}
+  dyn_pros.each { |k, v|
+    if k =~ /ph_/i
+      ph_attrs[k] = v
     else
-      put_log "\nError >> Not found object: #{element}"
-      exit
+      upcase_attrb[k.to_s.upcase] = v
     end
-  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
+  if upcase_attrb.size > 0
+    strCssSelector = ""
+    strXpathSelector = ""
 
-    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
+    upcase_attrb.each { |key, value|
+      upcase_key = key.to_s.upcase
+      case upcase_key
+      when "XPATH_SELECTOR"
+        strXpathSelector = value
+      when "CSS_SELECTOR"
+        strCssSelector = value
       else
-        upcase_attrb[k.to_s.upcase] = v
+        raise "ERROR: >>> Wrong format type: #{key.to_s} of object: #{string_object}. Available supported format are: XPATH_SELECTOR and CSS_SELECTOR"
       end
     }
 
-    if upcase_attrb.size > 0
-      strCssSelector = ""
-      strXpathSelector = ""
-
-
-      upcase_attrb.each { |key, value|
-        upcase_key = key.to_s.upcase
-        case upcase_key
-          when "XPATH_SELECTOR"
-            strXpathSelector = value
-          when "CSS_SELECTOR"
-            strCssSelector = value
-          else
-            raise "ERROR: >>> Wrong format type: #{key.to_s} of object: #{string_object}. Available supported format are: XPATH_SELECTOR and CSS_SELECTOR"
-        end
-      }
-
-      begin
-        if strCssSelector != nil and strCssSelector.length > 0
-          foundElements = get_objects_by_css_selector(strCssSelector)
-        else
-          foundElements = get_objects_by_xpath_selector(strXpathSelector)
-        end
-        if foundElements == nil or foundElements.length == 0
-          currentTime = Time.new.to_i
-        else
-          put_log "\nBREAK!!!"
+    begin
+      if strCssSelector != nil and strCssSelector.length > 0
+        foundElements = get_objects_by_css_selector(strCssSelector)
+      else
+        foundElements = get_objects_by_xpath_selector(strXpathSelector)
+      end
+      if foundElements == nil or foundElements.length == 0
+        currentTime = Time.new.to_i
+      else
+        # put_log "\nBREAK!!!"
+        break
+      end
+      test = currentTime - startTime
+      # put_log "\n#TIMEOUNT:#{test} < #{$_CFWEB['Wait Time']}"
+      sleep(0.5)
+    end while (currentTime - startTime) < $_CFWEB['Wait Time']
+
+    if foundElements != nil or foundElements.length != 0
+      return_element = nil
+      foundElements.each { |cur_element|
+        passCheck = find_object_check_object(cur_element)
+        if passCheck
+          return_element = cur_element
           break
         end
-        test = currentTime - startTime
-        put_log "\n#TIMEOUNT:#{test} < #{$_CFWEB['Wait Time']}"
-        sleep(0.5)
-      end while (currentTime - startTime) < $_CFWEB['Wait Time']
-
-      if foundElements != nil or foundElements.length != 0
-        return_element = nil
-        foundElements.each { |cur_element|
-          passCheck = find_object_check_object(cur_element)
-          if passCheck
-            return_element = cur_element
-            break
-          end
-        }
-        return return_element
-      end
+      }
+      return return_element
     end
-
-    nil
   end
 
-  def get_objects_by_css_selector(strCssSelector)
-    foundElements = nil
-    begin
-      foundElements = page.all(:css, strCssSelector)
-    rescue StandardError => myStandardError
-      raise "\n>>> Error: #{myStandardError}"
-    end
+  nil
+end
 
-    foundElements
+def get_objects_by_css_selector(strCssSelector)
+  foundElements = nil
+  begin
+    foundElements = page.all(:css, strCssSelector)
+  rescue StandardError => e
+    raise "\n>>> Error: #{e}"
   end
+  foundElements
+end
 
-  def get_objects_by_xpath_selector(strXpathSelector)
-    foundElements = nil
-    begin
-      foundElements = page.all(:xpath, strXpathSelector)
-    rescue StandardError => myStandardError
-      put_log "\n>>> Error: #{myStandardError}"
-    end
-    foundElements
+def get_objects_by_xpath_selector(strXpathSelector)
+  foundElements = nil
+  begin
+    foundElements = page.all(:xpath, strXpathSelector)
+  rescue StandardError => e
+    raise "\n>>> Error: #{e}"
+    exit
   end
+  foundElements
+end
 
-  def find_object_check_object(cur_element)
-    passCheck = true
-    if cur_element != nil
-      return passCheck
-    end
-    false
+def find_object_check_object(cur_element)
+  passCheck = true
+  if cur_element != nil
+    return passCheck
   end
+  false
+end
 
 def get_object_and_store_as_string(object,string)
   text = execute_gettext(object)
@@ -446,9 +626,43 @@ def get_object_and_store_to_file(object,file_name)
   end
 end
 
-def drag_drop el, x, y
-  foundElement = page.driver.browser.find_element(css: "#{el}")
-  page.driver.browser.action.drag_and_drop_by(foundElement, x, y).perform
+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 "\n>>> ERROR: #{e}"
+      exit
+    end
+  else
+    raise "\nError >> Not found object: #{element}"
+    exit
+  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 "\n>>> ERROR: #{e}"
+      exit
+    end
+  else
+    raise "\nError >> Not found object: #{element}"
+    exit
+  end
 end
 
 def movemouseandclick var, element