itms_automation 1.4 → 1.5

data/lib/itms_automation/database_steps_helper.rb

@@ -1,6 +1,7 @@
-require 'active_record'
+# require "active_record"
 
-def create_database_connection config
+def create_database_connection(config)
+  start = Time.now
   begin
     if config.class === "String"
       config = JSON.parse config
@@ -17,81 +18,108 @@ def create_database_connection config
     @connection = ActiveRecord::Base.establish_connection(config)
     ActiveRecord::Base.connection.active?
 
-    if !@connection.connected?
+    if @connection.connected?
+      print_log("passed", start, __method__, config)
+    else
+      print_log("failed", start, __method__, config)
       raise "Error: Can't connect to database"
     end
   rescue JSON::ParserError
-    raise "Create database connection error: Please check your connection configuration"
+    print_log("failed", start, __method__, config)
+    raise "Error: Please check your connection configuration"
   rescue Exception => e
-    raise "Create database connection error: #{e.message}"
+    print_log("failed", start, __method__, config)
+    raise "Error: #{e.message}"
   end
 end
 
 def close_database_connection
+  start = Time.now
   begin
     @connection.disconnect!
+    print_log("passed", start, __method__)
   rescue Exception => e
-    raise "Close database connection error: #{e.message}"
+    print_log("failed", start, __method__)
+    raise "Error: #{e.message}"
   end
 end
 
-def execute_query query
+def execute_query(query)
+  start = Time.now
   begin
     if @connection.connected?
       @result = @connection.connection.exec_query(query).to_a
+      print_log("passed", start, __method__, query)
     else
+      print_log("failed", start, __method__, query)
       raise "Error: Create connection to database first!"
     end
   rescue Exception => e
-    raise "Execute query error: #{e.message}"
+    print_log("failed", start, __method__, query)
+    raise "Error: #{e.message}"
   end
 end
 
 def print_sql_result
+  start = Time.now
   if @result.present?
-    p "SQL result:"
-    p @result.to_json
+    puts "SQL result:"
+    puts @result.to_json
   else
-    p "WARNING: No result from SQL statement"
+    puts "WARNING: No result from SQL statement"
   end
 end
 
-def verify_sql_result_contain expected_string
+def verify_sql_result_contain(expected_string)
+  start = Time.now
   begin
     @expected = JSON.parse(expected_string)
     is_contain = false
     if @expected.kind_of?(Array) && @expected.length > @result.length
-      raise "Expected: #{@expected}\nGot: #{@result}\nQuery result not includes your expected"
+      print_log("failed", start, __method__, expected_string)
+      raise "Error: Expected: #{@expected}\nGot: #{@result}\nQuery result not includes your expected"
     end
     @result.each do |row|
       is_contain = do_assertion_json(@expected, row)
       break if !@expected.kind_of?(Array) && is_contain == true
     end
-    unless is_contain
-      raise "Expected: #{@expected}\nGot: #{@result}\nQuery result not includes your expected"
+    if is_contain
+      print_log("passed", start, __method__, expected_string)
+    else
+      print_log("failed", start, __method__, expected_string)
+      raise "Error: Expected: #{@expected}\nGot: #{@result}\nQuery result not includes your expected"
     end
   rescue JSON::ParserError
-    raise "Verify SQL result contain error: Please check your expected"
+    print_log("failed", start, __method__, expected_string)
+    raise "Error: Please check your expected"
   rescue Exception => e
-    raise "Verify SQL result contain error: #{e.message}"
+    print_log("failed", start, __method__, expected_string)
+    raise "Error: #{e.message}"
   end
 end
 
-def verify_sql_result_equal expected_string
+def verify_sql_result_equal(expected_string)
+  start = Time.now
   begin
     @expected = JSON.parse(expected_string)
     if !@expected.kind_of?(Array) || @expected.length != @result.length
-      raise "Expected: #{@expected}\nGot: #{@result}\nQuery result not equal with your expected"
+      print_log("failed", start, __method__, expected_string)
+      raise "Error: Expected: #{@expected}\nGot: #{@result}\nQuery result not equal with your expected"
     end
     @result.each_with_index do |row, index|
       is_contain = row.to_s == @expected[index].to_s
-      unless is_contain
-        raise "Expected: #{@expected}\nGot: #{@result}\nQuery result not equal with your expected"
+      if is_contain
+        print_log("passed", start, __method__, expected_string)
+      else
+        print_log("failed", start, __method__, expected_string)
+        raise "Error: Expected: #{@expected}\nGot: #{@result}\nQuery result not equal with your expected"
       end
     end
   rescue JSON::ParserError
-    raise "Verify SQL result equal error: Please check your expected"
+    print_log("failed", start, __method__, expected_string)
+    raise "Error: Please check your expected"
   rescue Exception => e
-    raise "Verify SQL result equal error: #{e.message}"
+    print_log("failed", start, __method__, expected_string)
+    raise "Error: #{e.message}"
   end
 end

data/lib/itms_automation/version.rb

@@ -1,3 +1,3 @@
 module ItmsAutomation
-  VERSION = "1.4"
+  VERSION = "1.5"
 end

data/lib/itms_automation/web_steps_helper.rb

@@ -1,217 +1,284 @@
-require 'net/https'
-require 'rspec'
+require "net/https"
+require "rspec"
 
 def execute_openbrowser(url_site)
+  start = Time.now
   begin
     if url_site == ""
-      raise "❌  Error: Null web page URL."
+      print_log("failed", start, __method__, url_site)
+      raise "Error: Null web page URL."
     end
     visit(url_site)
+    print_log("passed", start, __method__, url_site)
   rescue StandardError => e
-    raise "❌  Error: #{e.message}"
+    print_log("failed", start, __method__, url_site)
+    raise "Error: #{e.message}"
   end
 end
 
 def execute_click(element)
+  start = Time.now
   foundElement = find_object(element)
   if foundElement != nil
     begin
       foundElement.click
+      print_log("passed", start, __method__, element)
     rescue StandardError => e
-      raise "❌  Error: #{e.message}"
+      print_log("failed", start, __method__, element)
+      raise "Error: #{e.message}"
     end
   else
-    raise "❌  Error >> Not found object: #{element}"
+    print_log("failed", start, __method__, element)
+    raise "Error: Not found object #{element}"
   end
 end
 
 def execute_click_offset(element, x, y)
+  start = Time.now
   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.move_to(foundElement.native, x.to_i, y.to_i)
       page.driver.browser.mouse.click()
+      print_log("passed", start, __method__, element, x, y)
     rescue Exception => e
-      raise "❌  Error: #{e.message}"
+      print_log("failed", start, __method__, element, x, y)
+      raise "Error: #{e.message}"
     end
   else
-    raise "❌  Error: Not found object: #{element}"
+    print_log("failed", start, __method__, element, x, y)
+    raise "Error: Not found object: #{element}"
   end
 end
 
 def double_click(element)
+  start = Time.now
   foundElement = find_object(element)
   if foundElement != nil
     begin
       foundElement.double_click
+      print_log("passed", start, __method__, element)
     rescue StandardError => e
-      raise "❌  Error: #{e}"
+      print_log("failed", start, __method__, element)
+      raise "Error: #{e.message}"
     end
   else
-    raise "❌  Error: Not found object: #{element}"
+    print_log("failed", start, __method__, element)
+    raise "Error: Not found object: #{element}"
   end
 end
 
 def execute_settext(element, text)
+  start = Time.now
   foundElement = find_object(element)
   if foundElement != nil
     begin
       foundElement.set(text)
+      print_log("passed", start, __method__, element, text)
     rescue StandardError => e
-      raise "❌  Error: #{e}"
+      print_log("failed", start, __method__, element, text)
+      raise "Error: #{e.message}"
     end
   else
-    raise "❌  Error: Not found object: #{element}"
+    print_log("failed", start, __method__, element, text)
+    raise "Error: Not found object: #{element}"
   end
 end
 
 def maximize_browser
+  start = Time.now
   begin
     page.driver.browser.manage.window.maximize
+    print_log("passed", start, __method__)
   rescue StandardError => e
-    raise "❌  Error: #{e}"
+    print_log("failed", start, __method__)
+    raise "Error: #{e.message}"
   end
 end
 
 def switch_to_window_by_title(window_title)
+  start = Time.now
   $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
+      print_log("passed", start, __method__, window_title)
       break
     end
   }
   if @window_found == false
-    raise "Window having title \"#{window_title}\" not found"
+    print_log("failed", start, __method__, window_title)
+    raise "Error: Window having title \"#{window_title}\" not found"
   end
 end
 
 def scroll_to_end_page
+  start = Time.now
   begin
-    page.driver.execute_script('window.scrollTo(0,Math.max(document.documentElement.scrollHeight,document.body.scrollHeight,document.documentElement.clientHeight));')
+    page.driver.execute_script("window.scrollTo(0,Math.max(document.documentElement.scrollHeight,document.body.scrollHeight,document.documentElement.clientHeight));")
+    print_log("passed", start, __method__)
   rescue StandardError => e
-    raise "❌  Error: #{e}"
+    print_log("failed", start, __method__)
+    raise "Error: #{e.message}"
   end
 end
 
 def scroll_to_top_page
+  start = Time.now
   begin
-    page.driver.execute_script('window.scrollTo(Math.max(document.documentElement.scrollHeight,document.body.scrollHeight,document.documentElement.clientHeight),0);')
+    page.driver.execute_script("window.scrollTo(Math.max(document.documentElement.scrollHeight,document.body.scrollHeight,document.documentElement.clientHeight),0);")
+    print_log("passed", start, __method__)
   rescue StandardError => e
-    raise "❌  Error: #{e}"
+    print_log("failed", start, __method__)
+    raise "Error: #{e.message}"
   end
 end
 
 def verify_title(expected_title)
+  start = Time.now
   begin
     page_title = page.title
-    puts "Actual Page Title : #{page_title}, Expected Page Title : #{expected_title}"
     expect(page_title).to eq expected_title
+    print_log("passed", start, __method__, expected_title)
+    puts "Actual Page Title : #{page_title}, Expected Page Title : #{expected_title}"
   rescue StandardError => e
-    raise "❌  Error: #{e}"
+    print_log("failed", start, __method__, expected_title)
+    raise "Error: #{e.message}"
   end
 end
 
 def verify_alert_text(text)
+  start = Time.now
   begin
     alert = page.driver.browser.switch_to.alert.text
-    puts "Actual Page alert text : #{alert}, Expected value : #{text}"
     expect(alert).to eq text
+    print_log("passed", start, __method__, text)
+    puts "Actual Page alert text : #{alert}, Expected value : #{text}"
   rescue StandardError => e
-    raise "❌  Error: #{e}"
+    print_log("failed", start, __method__, text)
+    raise "Error: #{e.message}"
   end
 end
 
 def accept_alert
+  start = Time.now
   begin
     page.driver.browser.switch_to.alert.accept
+    print_log("passed", start, __method__)
   rescue Exception => e
-    raise "❌  ERROR: #{e}"
+    print_log("failed", start, __method__)
+    raise "Error: #{e.message}"
   end
 end
 
 def back
+  start = Time.now
   begin
-    page.execute_script('window.history.back()')
+    page.execute_script("window.history.back()")
+    print_log("passed", start, __method__)
   rescue Exception => e
-    raise "❌  ERROR: #{e}"
+    print_log("failed", start, __method__)
+    raise "Error: #{e.message}"
   end
 end
 
 def refresh
+  start = Time.now
   begin
-    page.execute_script('window.location.reload()')
+    page.execute_script("window.location.reload()")
+    print_log("passed", start, __method__)
   rescue Exception => e
-    raise "❌  ERROR: #{e}"
+    print_log("failed", start, __method__)
+    raise "Error: #{e.message}"
   end
 end
 
 def clear_text(element)
+  start = Time.now
   foundElement = find_object(element)
   if foundElement != nil?
     begin
       foundElement.native.clear
+      print_log("passed", start, __method__, element)
     rescue Exception => e
-      raise "❌  ERROR: #{e}"
+      print_log("failed", start, __method__, element)
+      raise "Error: #{e.message}"
     end
   else
-    raise "❌  Error: Not found object: #{element}"
+    print_log("failed", start, __method__, element)
+    raise "Error: Not found object: #{element}"
   end
 end
 
 def execute_javascript(script)
+  start = Time.now
   begin
     page.execute_script(script)
+    print_log("passed", start, __method__, script)
   rescue Exception => e
-    puts "❌  Error: Not found object: #{element}"
+    print_log("failed", start, __method__, script)
+    raise "Error: Not found object: #{element}"
   end
 end
 
 def execute_select(element, option)
+  start = Time.now
   foundElement = find_object(element)
   if foundElement != nil
     begin
-      foundElement.find('option', text: option).select_option
+      foundElement.find("option", text: option).select_option
+      print_log("passed", start, __method__, element, option)
     rescue Exception => e
-      raise "❌  ERROR: #{e}"
+      print_log("failed", start, __method__, element, option)
+      raise "Error: #{e.message}"
     end
   else
-    raise "❌  Error: Not found object: #{element}"
+    print_log("failed", start, __method__, element, option)
+    raise "Error: Not found object: #{element}"
   end
 end
 
 def execute_mouse_over(element)
+  start = Time.now
   foundElement = find_object(element)
   if foundElement != nil
     begin
       page.driver.browser.action.move_to(foundElement.native, element).click.perform
+      print_log("passed", start, __method__, element)
       sleep(1)
     rescue StandardError => e
-      raise "❌  Error: #{e}"
+      print_log("failed", start, __method__, element)
+      raise "Error: #{e.message}"
     end
   else
-    raise "❌  Error: Not found object: #{element}"
+    print_log("failed", start, __method__, element)
+    raise "Error: Not found object: #{element}"
   end
 end
 
 def remove_element_attribute(element, attr)
+  start = Time.now
   foundElement = find_object(element)
   if foundElement != nil
     begin
       page.driver.browser.execute_script("arguments[0].removeAttribute('#{attr}');", foundElement.native)
+      print_log("passed", start, __method__, element, attr)
       sleep(1)
     rescue StandardError => e
-      raise "❌  Error: #{e}"
+      print_log("failed", start, __method__, element, attr)
+      raise "Error: #{e.message}"
     end
   else
-    raise "❌  Error: Not found object: #{element}"
+    print_log("failed", start, __method__, element, attr)
+    raise "Error: Not found object: #{element}"
   end
 end
 
 # Set state
 def execute_setstate(element, state)
+  start = Time.now
   foundElement = find_object(element)
   if foundElement != nil
     if state
@@ -219,164 +286,189 @@ def execute_setstate(element, state)
     else
       foundElement.unselect_option
     end
+    print_log("passed", start, __method__, element, state)
   else
-    raise "❌  Error: Not found object: #{element}"
+    print_log("failed", start, __method__, element, state)
+    raise "Error: Not found object: #{element}"
   end
 end
 
 def close_windows
+  start = Time.now
   begin
     page.execute_script "window.close();"
+    print_log("passed", start, __method__)
   rescue StandardError => e
-    raise "❌  Error: #{e}"
+    print_log("failed", start, __method__)
+    raise "Error: #{e.message}"
   end
 end
 
 def resize_window_screen(x, y)
+  start = Time.now
   begin
     page.driver.browser.manage.window.resize_to(x, y)
-    puts page.driver.browser.manage.window.size
+    print_log("passed", start, __method__, x, y)
   rescue StandardError => e
-    raise "❌  Error: #{e}"
+    print_log("failed", start, __method__, x, y)
+    raise "Error: #{e.message}"
   end
 end
 
 def switch_to_iframe(element)
-  begin
-    foundElement = find_object(element)
-    page.driver.switch_to_frame(foundElement)
-  rescue Exception => e
-    raise "❌  Error: #{e}"
+  start = Time.now
+  foundElement = find_object(element)
+  if foundElement != nil
+    begin
+      page.driver.switch_to_frame(foundElement)
+      print_log("passed", start, __method__, element)
+    rescue Exception => e
+      print_log("failed", start, __method__, element)
+      raise "Error: #{e.message}"
+    end
+  else
+    print_log("failed", start, __method__, element)
+    raise "Error: Not found object #{element}"
   end
 end
 
 def switch_out_frame
+  start = Time.now
   begin
     browser = page.driver.browser
     browser.switch_to.default_content
+    print_log("passed", start, __method__)
   rescue Exception => e
-    raise "❌  Error: #{e}"
+    print_log("failed", start, __method__)
+    raise "Error: #{e.message}"
   end
 end
 
 def get_computed_style(element, style)
+  start = Time.now
   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}"
+    print_log("failed", start, __method__, element, style)
+    raise "Error: Not found object: #{element}"
   end
-  puts "\nActual object style value is: #{computedStyle}"
+  print_log("passed", start, __method__, element, style)
+  puts "Actual 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)
+  start = Time.now
   foundElement = find_object(element)
   if foundElement != nil
     begin
       result = foundElement.text()
+      print_log("passed", start, __method__, element, style)
       puts "Text of #{element}: #{result}"
     rescue StandardError => e
-      raise "❌  Error: #{e}"
+      print_log("failed", start, __method__, element)
+      raise "Error: #{e.message}"
     end
   else
-    raise "❌  Error: Not found object: #{element}"
+    print_log("failed", start, __method__, element)
+    raise "Error: Not found object: #{element}"
   end
 end
 
-def get_element_attribute(element,value)
+def get_element_attribute(element, value)
+  start = Time.now
   foundElement = find_object(element)
   if foundElement != nil
     begin
       result = foundElement.value()
+      print_log("passed", start, __method__, element, value)
       puts "Attribute of #{element}: #{result}"
     rescue StandardError => e
-      raise "❌  Error: #{e}"
+      print_log("failed", start, __method__, element, value)
+      raise "Error: #{e.message}"
     end
   else
-    raise "❌  Error: Not found object: #{element}"
+    print_log("failed", start, __method__, element, value)
+    raise "Error: Not found object: #{element}"
   end
 end
 
-def verify_element_text(element,value)
+def verify_element_text(element, value)
+  start = Time.now
   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
+      print_log("passed", start, __method__, element, value)
     rescue Exception => e
-      raise "❌  ERROR: #{e} "
+      print_log("failed", start, __method__, element, value)
+      raise "Error: #{e.message}"
     end
   else
-    raise "❌  Error: Not found object: #{element}"
+    print_log("failed", start, __method__, element, value)
+    raise "Error: Not found object: #{element}"
   end
 end
 
-def verify_element_not_has_text(element,value)
+def verify_element_not_has_text(element, value)
+  start = Time.now
   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
+      print_log("passed", start, __method__, element, value)
     rescue Exception => e
-      raise "❌  ERROR: #{e}"
+      print_log("failed", start, __method__, element, value)
+      raise "Error: #{e.message}"
     end
-
   else
-    raise "❌  Error: Not found object: #{element}"
+    print_log("failed", start, __method__, element, value)
+    raise "Error: Not found object: #{element}"
   end
 end
 
-def verify_element_value(element,value)
+def verify_element_value(element, value)
+  start = Time.now
   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
+      print_log("passed", start, __method__, element, value)
     rescue Exception => e
-      raise "❌  ERROR: #{e}"
+      print_log("failed", start, __method__, element, value)
+      raise "Error: #{e.message}"
     end
   else
-    raise "❌  Error: Not found object: #{element}"
+    print_log("failed", start, __method__, element, value)
+    raise "Error: Not found object: #{element}"
   end
 end
 
-def verify_element_not_has_value(element,value)
+def verify_element_not_has_value(element, value)
+  start = Time.now
   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
+      print_log("passed", start, __method__, element, value)
     rescue Exception => e
-      raise "❌  ERROR: #{e}"
+      print_log("failed", start, __method__, element, value)
+      raise "Error: #{e.message}"
     end
   else
-    raise "❌  Error: Not found object: #{element}"
+    print_log("failed", start, __method__, element, value)
+    raise "Error: Not found object: #{element}"
   end
 end
 
-def execute_checkproperty(element, property, negate, value, isSpecialChar=false)
+def execute_checkproperty(element, property, negate, value, isSpecialChar = false)
+  start = Time.now
   validate_option_by(property)
   Capybara.configure do |config|
     config.ignore_hidden_elements = false
@@ -389,24 +481,21 @@ def execute_checkproperty(element, property, negate, value, isSpecialChar=false)
     # 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'
+      if property.upcase == "VALUE"
         actual_value = foundElement.value()
-
-      elsif property.upcase == 'TEXT'
+      elsif property.upcase == "TEXT"
         actual_value = foundElement.text()
-
       else
         actual_value = foundElement["#{property}"]
       end
 
       if actual_value == nil
-        actual_value = ''
+        actual_value = ""
       end
     else
-      put_log "❌  Error: Not found object: #{element}"
+      print_log("failed", start, __method__, element, property, negate, value, isSpecialChar)
+      raise "Error: Not found object: #{element}"
     end
 
     Capybara.configure do |config|
@@ -417,585 +506,80 @@ def execute_checkproperty(element, property, negate, value, isSpecialChar=false)
     #   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
+    begin
+      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
+      print_log("passed", start, __method__, element, property, negate, value, isSpecialChar)
+    rescue Exception => e
+      print_log("failed", start, __method__, element, property, negate, value, isSpecialChar)
+      raise "Error: #{e.message}"
     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)
+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)
+def get_object_and_store_to_file(object, file_name)
   $text = execute_gettext(object)
-  open($test_data_dir+file_name, 'a+') do |f|
+  open($test_data_dir + file_name, "a+") do |f|
     f << $text + "\n"
   end
 end
 
 def drag_and_drop_by_offset(element, x, y)
+  start = Time.now
   foundElement = find_object(element)
   if foundElement != nil
     begin
       page.driver.browser.action.drag_and_drop_by(foundElement, x, y).perform
+      print_log("passed", start, __method__, element, x, y)
     rescue Exception => e
-      raise "❌  ERROR: #{e}"
+      print_log("failed", start, __method__, element, x, y)
+      raise "Error: #{e.message}"
     end
   else
-    raise "❌  Error: Not found object: #{element}"
+    print_log("failed", start, __method__, element, x, y)
+    raise "Error: Not found object: #{element}"
   end
 end
 
 def drag_and_drop_to_object(from_element, element)
+  start = Time.now
   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)
+    print_log("passed", start, __method__, from_element, element)
   end
 end
 
 def execute_sendkeys(element, key)
+  start = Time.now
   validate_supported_keys(key)
   foundElement = find_object(element)
   if foundElement != nil
     begin
       foundElement.native.send_keys(key)
+      print_log("passed", start, __method__, element, key)
     rescue Exception => e
-      raise "❌  ERROR: #{e}"
+      print_log("failed", start, __method__, element, key)
+      raise "Error: #{e.message}"
     end
   else
-    raise "❌  Error: Not found object: #{element}"
+    print_log("failed", start, __method__, element, key)
+    raise "Error: Not found object: #{element}"
   end
 end
 
-def movemouseandclick var, element
+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