appom 1.4.0 → 2.0.0

data/lib/appom/element_finder.rb

@@ -1,174 +1,178 @@
-module Appom
-  module ElementFinder
-    # Find an element
-    def _find(*find_args)
-      args, text, visible = deduce_element_args(find_args)
-      wait = Wait.new(timeout: Appom.max_wait_time)
-
-      wait.until do
-        elements = page.find_elements(*args)
-        elements.each do |element|
-          if !visible.nil? && !text.nil?
-            if element.displayed? && element.text == text
-              return element
-            end
-          elsif !visible.nil?
-            if element.displayed?
-              return element
-            end
-          elsif !text.nil?
-            if element.text == text
-              return element
-            end
-          # Just return first element
-          else
-            return element
-          end
-        end
-        raise StandardError, "Can not found element with args = #{find_args}"
-      end
-    end
+# frozen_string_literal: true
 
-    # Find elements
-    def _all(*find_args)
-      args, text, visible = deduce_element_args(find_args)
-      elements = page.find_elements(*args)
-      els = []
+# Element finding functionality for Appom automation framework
+# Handles element location with various strategies and options
+module Appom::ElementFinder
+  include Appom::Logging
+
+  def self.included(klass)
+    # Include cache-aware finder if caching is enabled
+
+    klass.include(ElementCache::CacheAwareFinder) if Appom.cache_config[:enabled]
+  rescue StandardError
+    # Continue without caching if it fails to load
+  end
+
+  # Find an element
+  def _find(*find_args)
+    args, text, visible = deduce_element_args(find_args)
+    wait = Appom::Wait.new(timeout: Appom.max_wait_time)
+
+    log_debug('Finding element', { args: args, text: text, visible: visible })
+    start_time = Time.now
 
+    wait.until do
+      elements = page.find_elements(*args)
       elements.each do |element|
         if !visible.nil? && !text.nil?
           if element.displayed? && element.text == text
-            els.push(element)
+            duration = ((Time.now - start_time) * 1000).round(2)
+            log_element_action('FOUND', "element with #{args.join(', ')}", duration)
+            return element
           end
         elsif !visible.nil?
           if element.displayed?
-            els.push(element)
+            duration = ((Time.now - start_time) * 1000).round(2)
+            log_element_action('FOUND', "element with #{args.join(', ')}", duration)
+            return element
           end
         elsif !text.nil?
           if element.text == text
-            els.push(element)
+            duration = ((Time.now - start_time) * 1000).round(2)
+            log_element_action('FOUND', "element with #{args.join(', ')}", duration)
+            return element
           end
+        # Just return first element
         else
-          els.push(element)
+          duration = ((Time.now - start_time) * 1000).round(2)
+          log_element_action('FOUND', "element with #{args.join(', ')}", duration)
+          return element
         end
       end
-      return els
+      raise Appom::ElementNotFoundError.new(find_args.join(', '), Appom.max_wait_time)
     end
+  rescue Appom::WaitError
+    log_error('Element not found', { args: find_args, timeout: Appom.max_wait_time })
+    raise Appom::ElementNotFoundError.new(find_args.join(', '), Appom.max_wait_time)
+  end
 
-    # Check page has or has not element with find_args
-    # If page has element return TRUE else return FALSE
-    def _check_has_element(*find_args)
-      args, text, visible = deduce_element_args(find_args)
-      elements = page.find_elements(*args)
+  # Find elements
+  def _all(*find_args)
+    args, text, visible = deduce_element_args(find_args)
+    elements = page.find_elements(*args)
+    els = []
 
-      if visible.nil? && text.nil? 
-        return elements.empty? ? false : true
+    elements.each do |element|
+      if !visible.nil? && !text.nil?
+        els.push(element) if element.displayed? && element.text == text
+      elsif !visible.nil?
+        els.push(element) if element.displayed?
+      elsif !text.nil?
+        els.push(element) if element.text == text
       else
-        is_found = false
-        elements.each do |element|
-          if !visible.nil? && !text.nil?
-            if element.displayed? && element.text == text
-              is_found = true
-            end
-          elsif !visible.nil?
-            if element.displayed?
-              is_found = true
-            end
-          elsif !text.nil?
-            if element.text == text
-              is_found = true
-            end
-          end
-        end
-        return is_found
+        els.push(element)
       end
     end
+    els
+  end
 
-    ##
-    # Use wait to get elements
-    # Before timeout we will try to find elements until response return array is not empty
-    #
-    def wait_until_get_not_empty(*find_args)
-      wait = Wait.new(timeout: Appom.max_wait_time)
-      wait.until do
-        result = page.find_elements(*find_args)
-        # If response is empty we will return false to make it not pass Wait condition
-        if result.empty?
-          raise StandardError, "Can not found any elements with args = #{find_args}"
-        end
-        # Return result
-        return result
+  # Check page has or has not element with find_args
+  # If page has element return TRUE else return FALSE
+  def _check_has_element(*find_args)
+    args, text, visible = deduce_element_args(find_args)
+    elements = page.find_elements(*args)
+
+    return !elements.empty? if visible.nil? && text.nil?
+
+    is_found = false
+    elements.each do |element|
+      if !visible.nil? && !text.nil?
+        is_found = true if element.displayed? && element.text == text
+      elsif !visible.nil?
+        is_found = true if element.displayed?
+      elsif !text.nil?
+        is_found = true if element.text == text
       end
     end
+    is_found
+  end
 
-    # Function is used to check
-    # Note: Function WILL NOT RETURN ELEMENT
-    def wait_until(type, *find_args)
-      wait = Wait.new(timeout: Appom.max_wait_time)
-      wait.until do
-        case type
-        # Function only return true if element enabled or raise an error if time out
-        when 'element enable'
-          _find(*find_args).enabled?
-        # Function only return true if element disabled or raise an error if time out
-        when 'element disable'
-          result = _find(*find_args)
-          if result.enabled?
-            raise StandardError, "Still found an element enable with args = #{find_args}"
-          end
-          return true
-        # Function only return true if we can find at least one element (array is not empty) or raise error
-        when 'at least one element exists'
-          result = _all(*find_args)
-          if result.empty?
-            raise StandardError, "Could not find any elements with args = #{find_args}"
-          end
-          return true
-
-        # Function only return true if we can't find at least one element (array is empty) or raise error
-        when 'no element exists'
-          result = _all(*find_args)
-          if !result.empty?
-            if result.size > 1
-              raise StandardError, "Still found #{result.size} elements with args = #{find_args}"
-            else
-              raise StandardError, "Still found #{result.size} element with args = #{find_args}"
-            end
-          end
-          return true
+  ##
+  # Use wait to get elements
+  # Before timeout we will try to find elements until response return array is not empty
+  #
+  def wait_until_get_not_empty(*find_args)
+    wait = Appom::Wait.new(timeout: Appom.max_wait_time)
+    wait.until do
+      result = page.find_elements(*find_args)
+      # If response is empty we will return false to make it not pass Wait condition
+      raise Appom::ElementNotFoundError.new(find_args.join(', '), Appom.max_wait_time) if result.empty?
+
+      # Return result
+      return result
+    end
+  end
+
+  # Function is used to check
+  # Note: Function WILL NOT RETURN ELEMENT
+  def wait_until(type, *find_args)
+    wait = Appom::Wait.new(timeout: Appom.max_wait_time)
+    wait.until do
+      case type
+      # Function only return true if element enabled or raise an error if time out
+      when 'element enable'
+        _find(*find_args).enabled?
+      # Function only return true if element disabled or raise an error if time out
+      when 'element disable'
+        result = _find(*find_args)
+        raise StandardError, "Still found an element enable with args = #{find_args}" if result.enabled?
+
+        return true
+      # Function only return true if we can find at least one element (array is not empty) or raise error
+      when 'at least one element exists'
+        result = _all(*find_args)
+        raise Appom::ElementNotFoundError.new(find_args.join(', '), Appom.max_wait_time) if result.empty?
+
+        return true
+
+      # Function only return true if we can't find at least one element (array is empty) or raise error
+      when 'no element exists'
+        result = _all(*find_args)
+        unless result.empty?
+          message = "Still found #{result.size} element#{'s' if result.size > 1}"
+          raise Appom::ElementError.new(message, { elements_found: result.size, selector: find_args.join(', ') })
         end
+        return true
       end
     end
+  end
 
-    private
+  private
 
-    def deduce_element_args(args)
-      # Flatten argument array first if we are in case array inside array
-      args = args.flatten
+  def deduce_element_args(args)
+    # Flatten argument array first if we are in case array inside array
+    args = args.flatten
 
-      if args.empty?
-        raise(ArgumentError, 'You should provide search arguments in element creation')
-      end
+    raise Appom::InvalidElementError if args.empty?
 
-      # Get last key and check if it contain 'text' key
-      text = nil
-      visible = nil
+    # Get last key and check if it contain 'text' key
+    text = nil
+    visible = nil
 
-      args.each do |arg|
-        if arg.is_a?(Hash)
-          # Extract text value
-          if arg.key?(:text)
-            text = arg[:text]
-            args.delete(arg)
-          end
-          # Extract visible value
-          if arg.key?(:visible)
-            visible = arg[:visible]
-            args.delete(arg)
-          end
-        end
+    args.each do |arg|
+      next unless arg.is_a?(Hash)
+
+      # Extract text value
+      if arg.key?(:text)
+        text = arg[:text]
+        args.delete(arg)
+      end
+      # Extract visible value
+      if arg.key?(:visible)
+        visible = arg[:visible]
+        args.delete(arg)
       end
-      [args, text, visible]
     end
+    [args, text, visible]
   end
-end
+end