automation_object 0.5.0 → 0.5.1

data/lib/automation_object/driver/appium_adapter/element.rb

@@ -1,80 +1,17 @@
-require_relative '../helpers/selenium_element_helper'
+# frozen_string_literal: true
+require_relative '../common_selenium/element'
 
 module AutomationObject
   module Driver
     module AppiumAdapter
-      #Element proxy for Appium
-      #Conform Appium element interface to what's expected of the Driver Port
-      class Element < AutomationObject::Proxies::Proxy
-        include AutomationObject::Driver::SeleniumElementHelper
+      # Element proxy for Appium
+      # Conform Appium element interface to what's expected of the Driver Port
+      class Element < AutomationObject::Proxy::Proxy
+        include AutomationObject::Driver::CommonSelenium::Element
 
-        def initialize(args)
-          @driver = args.fetch :driver
-          @subject = args.fetch :element
-        end
-
-        # Set or Get attribute
-        # @param key [String] key of element
-        # @param value [String, nil] set value or leave blank
-        # @return [String, nil]
-        def attribute(key, value = nil)
-          @subject.attribute(key, value)
-        end
-
-        # @return [String] id of element
-        def id
-          @subject.id
-        end
-
-        # @return [String] href of element
-        def href
-          @subject.attribute('href')
-        end
-
-        # Text of element
-        # @return [String, nil]
-        def text
-          @subject.text
-        end
-
-        # Type into an element
-        # @return [void]
-        def send_keys(string)
-          @subject.send_keys(string)
-        end
-
-        # Clear the element field
-        # @return [void]
-        def clear
-          @subject.clear
-        end
-
-        # @return [Boolean]
-        def visible?
-          @subject.displayed?
-        end
-
-        # @return [Boolean]
-        def invisible?
-          !@subject.displayed?
-        end
-
-        # Get the location
-        # @return [Point]
-        def location
-          @subject.location
-        end
-
-        # Get the size of an element
-        # @return [Dimension]
-        def size
-          @subject.size
-        end
-
-        # Perform a submit action on an element
-        # @return [void]
-        def submit
-          @subject.submit
+        def initialize(driver, element)
+          @driver = driver
+          @subject = element
         end
 
         # Scroll the element into view
@@ -82,37 +19,33 @@ module AutomationObject
         def scroll_into_view
           @subject.location_once_scrolled_into_view
 
-          #Only scroll better if this is a browser and not an app
-          return unless @driver.is_browser?
+          # Only scroll better if this is a browser and not an app
+          return unless @driver.browser?
+
+          center = element_center
+          @driver.execute_script("window.scroll(#{center[:x]},#{ideal_y_position});")
+          # Just in case in close to the top or bottom bounds of the window
+          element_location = @subject.location_once_scrolled_into_view
+
+          return unless (element_location[:y]).negative?
 
-          element_center = self.element_center
-          window_height = self.inner_window_height
           scroll_position = @driver.scroll_position
+          scroll_y_position = scroll_position[:y] + element_location[:y]
+          @driver.execute_script("window.scroll(#{element_location[:x]},#{scroll_y_position});")
+        end
 
-          if element_center[:y] < (window_height/2)
-            ideal_y_position = (scroll_position[:y] + element_center[:y] - (window_height.to_f / 2.0)).abs
-          else
-            ideal_y_position = (scroll_position[:y] - element_center[:y] + (window_height.to_f / 2.0)).abs
-          end
+        private
 
-          @driver.execute_script("window.scroll(#{element_center[:x]},#{ideal_y_position});")
-          #Just in case in close to the top or bottom bounds of the window
-          element_location = @subject.location_once_scrolled_into_view
+        def ideal_y_position
+          center = element_center
+          window_height = inner_window_height
+          scroll_position = @driver.scroll_position
 
-          if element_location[:y] < 0
-            scroll_position = @driver.scroll_position
-            scroll_y_position = scroll_position[:y] + element_location[:y]
-            @driver.execute_script("window.scroll(#{element_location[:x]},#{scroll_y_position});")
-          end
-        end
+          return (scroll_position[:y] + center[:y] - (window_height.to_f / 2.0)).abs if center[:y] < (window_height / 2)
 
-        # Perform a click action on the element
-        # @return [void]
-        def click
-          self.scroll_into_view if @driver.is_browser?
-          @subject.click
+          (scroll_position[:y] - center[:y] + (window_height.to_f / 2.0)).abs
         end
       end
     end
   end
-end
+end

data/lib/automation_object/driver/base.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
 module AutomationObject
   module Driver
+    # Base class for driver and element adapter interface
     class Base
       attr_accessor :adapter
 
-      def initialize(adapter_object, *args)
+      def initialize(adapter_object, *_args)
         self.adapter = adapter_object
       end
     end
   end
-end
+end

data/lib/automation_object/driver/common_selenium/driver.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+require_relative '../driver'
+
+module AutomationObject
+  module Driver
+    module CommonSelenium
+      # Common Selenium/AppiumMethods
+      module Driver
+        # Suspend timeout for block running
+        def suspend_timeout
+          original_timeout = @subject.manage.timeouts.implicit_wait
+          @subject.manage.timeouts.implicit_wait = 0
+
+          yield
+
+          @subject.manage.timeouts.implicit_wait = original_timeout
+        end
+
+        # @return [Point] x,y scroll position
+        def scroll_position
+          position = Point.new
+
+          position.x = @subject.execute_script('var doc = document.documentElement; return (window.pageXOffset || doc.scrollLeft) - (doc.clientLeft || 0);').to_f
+          position.y = @subject.execute_script('var doc = document.documentElement; return (window.pageYOffset || doc.scrollTop) - (doc.clientTop || 0);').to_f
+
+          position
+        end
+
+        # @return [Float] inner window height
+        def inner_window_height
+          @subject.execute_script('return window.innerHeight;').to_f
+        end
+
+        # @param script [String] JS to run
+        # @return [Object, nil]
+        def execute_script(script)
+          @subject.execute_script(script)
+        end
+
+        # Go back
+        # @return [void]
+        def back
+          @subject.navigate.back
+        end
+
+        # Go forward
+        # @return [void]
+        def forward
+          @subject.navigate.forward
+        end
+
+        # Refresh window
+        # @return [void]
+        def refresh
+          @subject.navigate.refresh
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/driver/common_selenium/element.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+require_relative '../driver'
+require_relative 'element_geometry'
+
+module AutomationObject
+  module Driver
+    module CommonSelenium
+      # Helper module for Selenium based elements
+      module Element
+        include ElementGeometry
+
+        # @return [Boolean] element visible
+        def visible?
+          @subject.displayed?
+        end
+
+        # @return [Boolean] element invisible
+        def invisible?
+          @subject.displayed? ? false : true
+        end
+
+        # @return [String, nil] id of element
+        def id
+          @subject.attribute('id')
+        end
+
+        # @return [String, nil] href of element
+        def href
+          @subject.attribute('href')
+        end
+
+        # Text of element
+        # @return [String, nil]
+        def text
+          @subject.text
+        end
+
+        # @return [String, nil] content of element
+        def content
+          @subject.attribute('content')
+        end
+
+        # @param key [String] attribute key to get or set
+        # @param value [Object] optional value to set the key as
+        # @return [Object] value of attribute
+        def attribute(key, value = false)
+          if value
+            script = "return arguments[0].#{key} = '#{value}'"
+            @driver.execute_script(script, @subject)
+          end
+
+          @subject.attribute(key)
+        end
+
+        # Type into an element
+        # @return [void]
+        def send_keys(string)
+          @subject.send_keys(string)
+        end
+
+        # Clear the element field
+        # @return [void]
+        def clear
+          @subject.clear
+        end
+
+        # Perform a submit action on an element
+        # @return [void]
+        def submit
+          @subject.submit
+        end
+
+        # Perform a click action on the element
+        # @return [void]
+        def click
+          scroll_into_view if @driver.browser?
+          @subject.click
+        end
+
+        # Hover over element
+        def hover
+          scroll_into_view
+          @driver.action.move_to(@subject).perform
+        end
+
+        # Helper method to switch to this element's iframe
+        def switch_to_iframe
+          @driver.switch_to.frame(iframe_switch_value)
+        end
+
+        protected
+
+        # Helper method for getting the value to switch to
+        # If value doesn't exist then create one
+        # @return [String] iframe value to switch to
+        def iframe_switch_value
+          iframe_switch_value = attribute('id')
+          iframe_switch_value = attribute('name') if iframe_switch_value.length.zero?
+
+          iframe_switch_value = attribute('name', SecureRandom.hex(16)) unless iframe_switch_value
+
+          iframe_switch_value
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/driver/common_selenium/element_geometry.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+require_relative '../driver'
+
+module AutomationObject
+  module Driver
+    module CommonSelenium
+      # Helper module for Selenium based elements
+      module ElementGeometry
+        # @return [Numeric] x position of element
+        def x
+          @subject.location.x
+        end
+
+        # @return [Numeric] y position of element
+        def y
+          @subject.location.y
+        end
+
+        # @return [Numeric] width of element
+        def width
+          @subject.size.width
+        end
+
+        # @return [Numeric] height of element
+        def height
+          @subject.size.height
+        end
+
+        # Get the location
+        # @return [Point]
+        def location
+          @subject.location
+        end
+
+        # Get the size of an element
+        # @return [Dimension]
+        def size
+          @subject.size
+        end
+
+        # @return [Hash] :x, :y coordinates
+        def element_center
+          element_location = @subject.location
+          element_size = @subject.size
+
+          center = Point.new
+          center.x = (element_location.x.to_f + element_size.width.to_f / 2).to_f
+          center.y = (element_location.y.to_f + element_size.height.to_f / 2).to_f
+
+          center
+        end
+
+        # @return [BoxCoordinates] :x1, :x2, :y1, :y2 coordinates of a box
+        def box_coordinates
+          element_location = @subject.location
+          element_size = @subject.size
+
+          box_coordinates = BoxCoordinates.new
+          box_coordinates.x1 = element_location.x.to_f
+          box_coordinates.y1 = element_location.y.to_f
+          box_coordinates.x2 = element_location.x.to_f + element_size.width.to_f
+          box_coordinates.y2 = element_location.y.to_f + element_size.height.to_f
+
+          box_coordinates
+        end
+
+        # @param second_element_object [Object] element to compare to
+        # @param collision_tolerance [Numeric] pixel tolerance of collisions
+        # @return [Boolean] element collides with other
+        def collides_with_element?(second_element_object, collision_tolerance = 0)
+          box_one = box_coordinates
+          box_two = second_element_object.box_coordinates
+
+          if box_one.x2 > box_two.x1 && box_one.x1 < box_two.x2 && box_one.y2 > box_two.y1 && box_one.y1 < box_two.y2
+            if box_one.x2 > (box_two.x1 + collision_tolerance) && (box_one.x1 + collision_tolerance) < box_two.x2 &&
+               box_one.y2 > (box_two.y1 + collision_tolerance) && (box_one.y1 + collision_tolerance) < box_two.y2
+              return true
+            end
+          end
+
+          false
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/driver/driver.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require_relative 'base'
 require_relative 'element'
 
@@ -5,101 +6,130 @@ module AutomationObject
   module Driver
     Point     = Struct.new(:x, :y)
     Dimension = Struct.new(:width, :height)
+    BoxCoordinates = Struct.new(:x1, :y1, :x2, :y2)
 
-    #Driver adapter interface
-    #Adapters should meet this interface standard
+    # Driver adapter interface
+    # Adapters should meet this interface standard
     class Driver < Base
       # Navigates current window to a given url
       # @param url [String] navigate to the following url
       # @return [void]
       def get(url)
-        self.adapter.get(url)
+        adapter.get(url)
+      end
+
+      # Get the title of the document
+      # @return [String]
+      def title
+        adapter.title
+      end
+
+      # Refreshes current window
+      # @return [void]
+      def refresh
+        adapter.refresh
+      end
+
+      # Go forward
+      # @return [void]
+      def forward
+        adapter.forward
+      end
+
+      # Go back
+      # @return [void]
+      def back
+        adapter.back
       end
 
       # Set timeout wait
       # @param timeout [Integer] the timeout in seconds
       # @return [void]
-      def set_wait(timeout = nil)
-        self.adapter.set_wait(timeout)
+      def wait(timeout = nil)
+        adapter.wait(timeout)
       end
 
       # @param selector_type [Symbol] selector type (:css, :xpath, etc...)
       # @param selector_path [String] path to element
       # @return [Boolean] exists or not
       def exists?(selector_type, selector_path)
-        self.adapter.exists?(selector_type, selector_path)
+        adapter.exists?(selector_type, selector_path)
       end
 
       # @param selector_type [Symbol] selector type, :css, :xpath, etc...
       # @param selector_path [String] path to element
       # @return [AutomationObject::Driver::Element] element
       def find_element(selector_type, selector_path)
-        self.adapter.find_element(selector_type, selector_path)
+        adapter.find_element(selector_type, selector_path)
       end
 
       # @param selector_type [Symbol] selector type, :css, :xpath, etc...
       # @param selector_path [String] path to element
       # @return [Array<AutomationObject::Driver::Element>] elements
       def find_elements(selector_type, selector_path)
-        self.adapter.find_elements(selector_type, selector_path)
+        adapter.find_elements(selector_type, selector_path)
       end
 
-      #Accept prompt either in browser or mobile
+      # Accept prompt either in browser or mobile
       def accept_prompt
-        self.adapter.accept_prompt
+        adapter.accept_prompt
       end
 
-      #Dismiss the prompt
+      # Dismiss the prompt
       def dismiss_prompt
-        self.adapter.dismiss_prompt
+        adapter.dismiss_prompt
       end
 
       # Check if browser, more useful for Appium but can be generic here
       # @return [Boolean] whether or not browser is being used
-      def is_browser?
-        self.adapter.is_browser?
+      def browser?
+        adapter.browser?
       end
 
-      #Window Handles
+      # Window Handles
       # @return [Array<String>] array of window handle ids
       def window_handles
-        self.adapter.window_handles
+        adapter.window_handles
       end
 
-      #Current window handle
+      # Current window handle
       # @return [String] handle id
       def window_handle
-        self.adapter.window_handle
+        adapter.window_handle
       end
 
-      #Set current window handle to, will switch windows
+      # Set current window handle to, will switch windows
       # @param handle_value [String] window handle value
       def window_handle=(handle_value)
-        self.adapter.window_handle(handle_value)
+        adapter.window_handle(handle_value)
       end
 
       # Run script in browser to check if document in JS is complete
       # @return [Boolean] document is complete
       def document_complete?
-        self.adapter.document_complete?
-      end
-
-      # Wait till the document is complete
-      # @return [void]
-      def document_complete_wait
-        self.adapter.document_complete_wait
+        adapter.document_complete?
       end
 
       # @param script [String] JS to run
       # @return [Object, nil]
       def execute_script(script)
-        self.adapter.execute_script(script)
+        adapter.execute_script(script)
+      end
+
+      # @return [Point] x,y scroll position
+      def scroll_position
+        adapter.scroll_position
+      end
+
+      # @return [Float] inner window height
+      def inner_window_height
+        adapter.inner_window_height
       end
 
       # Destroy the driver
       def quit
-        self.adapter.quit
+        adapter.quit
       end
     end
   end
-end
+end