automation_object 0.0.4 → 0.5.0

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

@@ -0,0 +1,118 @@
+require_relative '../helpers/selenium_element_helper'
+
+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
+
+        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
+        end
+
+        # Scroll the element into view
+        # @return [void]
+        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?
+
+          element_center = self.element_center
+          window_height = self.inner_window_height
+          scroll_position = @driver.scroll_position
+
+          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
+
+          @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
+
+          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
+
+        # Perform a click action on the element
+        # @return [void]
+        def click
+          self.scroll_into_view if @driver.is_browser?
+          @subject.click
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/driver/base.rb

@@ -0,0 +1,11 @@
+module AutomationObject
+  module Driver
+    class Base
+      attr_accessor :adapter
+
+      def initialize(adapter_object, *args)
+        self.adapter = adapter_object
+      end
+    end
+  end
+end

data/lib/automation_object/driver/driver.rb

@@ -1,280 +1,104 @@
-#Thread Safe Execution Purposes
+require_relative 'base'
+require_relative 'element'
+
 module AutomationObject
   module Driver
-    class Driver
-      @@anonymous_skip_classes = [TrueClass, FalseClass, String, Numeric, Array, Hash]
-      attr_accessor :mutex_object
-
-      attr_accessor :is_browser, :is_mobile, :supports_contexts
-
-      @@throttle_methods = {
-          'navigate' => 2,
-          'close' => 2,
-          'manage' => 1
-      }
-
-      @@minimum_speed = 0 #0.01 #Speed it up to see where faults may lay
-
-      @@implicit_wait_timeout = 30
-      @@script_timeout = 500
-      @@page_load_timeout = 500
-
-      def self.throttle_methods
-        @@throttle_methods
-      end
-
-      def self.throttle_methods=(value)
-        @@throttle_methods = value
-      end
-
-      def self.minimum_speed
-        @@minimum_speed
-      end
-
-      def self.minimum_speed=(value)
-        @@minimum_speed = value
-      end
-
-      def initialize(driver_object)
-        @driver_object = driver_object
-        self.mutex_object = Mutex.new
-
-        return if self.is_mobile?
+    Point     = Struct.new(:x, :y)
+    Dimension = Struct.new(:width, :height)
 
-        self.mutex_object.synchronize do
-          @driver_object.manage.timeouts.implicit_wait = @@implicit_wait_timeout
-          @driver_object.manage.timeouts.script_timeout = @@script_timeout
-          @driver_object.manage.timeouts.page_load = @@page_load_timeout
-        end
+    #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)
       end
 
-      def respond_to?(method_symbol, include_private = false)
-        self.mutex_object.synchronize do
-          return true if super
-          return @driver_object.respond_to?(method_symbol, include_private)
-        end
-      end
-
-      def method_missing(method_symbol, *arguments, &block)
-        anonymous_object = nil
-        start_time = Time.new.to_f
-
-        self.mutex_object.synchronize do
-          #For Appium because it's under driver method
-          if @driver_object.respond_to?(:driver) and not @driver_object.respond_to?(method_symbol)
-            driver_return = @driver_object.driver.send(method_symbol, *arguments, &block)
-          else
-            driver_return = @driver_object.send(method_symbol, *arguments, &block)
-          end
-
-          self.throttle_speed(method_symbol, start_time)
-
-          total_time_taken = (Time.new.to_f-start_time)
-          AutomationObject::Logger::add_driver_message(total_time_taken, caller_locations, method_symbol, *arguments, &block)
-
-          @@anonymous_skip_classes.each { |skip_class|
-            if driver_return.is_a?(skip_class)
-              return driver_return
-            end
-          }
-
-          anonymous_object = AutomationObject::Driver::Anonymous.new(self, driver_return)
-        end
-
-        return anonymous_object
+      # Set timeout wait
+      # @param timeout [Integer] the timeout in seconds
+      # @return [void]
+      def set_wait(timeout = nil)
+        self.adapter.set_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)
-        start_time = Time.new.to_f
-
-        self.mutex_object.synchronize do
-          if @driver_object.respond_to?(:exists) #Appium
-            exists = @driver_object.exists { @driver_object.find_element(selector_type, selector_path) }
-          else
-            begin
-              @driver_object.manage.timeouts.implicit_wait = 0
-              element_objects = @driver_object.find_elements(selector_type, selector_path)
-              @driver_object.manage.timeouts.implicit_wait = @@implicit_wait_timeout
-              if element_objects.length == 0
-                exists = false
-              else
-                exists = true
-              end
-            rescue
-              exists = false
-            end
-          end
-
-          self.throttle_speed(:exists?, start_time)
-
-          total_time_taken = (Time.new.to_f-start_time)
-          AutomationObject::Logger::add_driver_message(total_time_taken, caller_locations, :exists?, [selector_type, selector_path])
-
-          return exists
-        end
+        self.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)
-        start_time = Time.new.to_f
-
-        self.mutex_object.synchronize do
-          element_object = @driver_object.find_element(selector_type, selector_path)
-
-          self.throttle_speed(:find_element, start_time)
-
-          total_time_taken = (Time.new.to_f-start_time)
-          AutomationObject::Logger::add_driver_message(total_time_taken, caller_locations, :find_element, [selector_type, selector_path])
-
-          return AutomationObject::Driver::Element.new(self, element_object)
-        end
+        self.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)
-        start_time = Time.new.to_f
-
-        self.mutex_object.synchronize do
-          element_objects = @driver_object.find_elements(selector_type, selector_path)
-
-          parsed_element_objects = Array.new
-          element_objects.each { |element_object|
-            parsed_element_objects.push(AutomationObject::Driver::Element.new(self, element_object))
-          }
-
-          self.throttle_speed(:find_elements, start_time)
-
-          total_time_taken = (Time.new.to_f-start_time)
-          AutomationObject::Logger::add_driver_message(total_time_taken, caller_locations, :find_elements, [selector_type, selector_path])
-
-          return parsed_element_objects
-        end
-      end
-
-      def throttle_speed(method_symbol, start_time)
-        method_string = method_symbol.to_s
-
-        throttle_time_minimum = @@minimum_speed
-        if @@throttle_methods.is_a?(Hash)
-          if @@throttle_methods.has_key?(method_string)
-            throttle_time_minimum = @@throttle_methods[method_string].to_f
-          end
-        end
-
-        time_difference = Time.new.to_f - start_time
-
-        if time_difference < throttle_time_minimum
-          sleep((throttle_time_minimum-time_difference))
-        end
-      end
-
-      def screenshot(path)
-        start_time = Time.new.to_f
-
-        if self.driver_object.respond_to?(:screenshot)
-          driver_return = self.driver_object.screenshot(path)
-        else
-          driver_return = self.driver_object.save_screenshot(path)
-        end
-
-        self.throttle_speed(:find_elements, start_time)
-
-        total_time_taken = (Time.new.to_f-start_time)
-        AutomationObject::Logger::add_driver_message(total_time_taken, caller_locations, :screenshot, [path])
-
-        return driver_return
+        self.adapter.find_elements(selector_type, selector_path)
       end
 
+      #Accept prompt either in browser or mobile
       def accept_prompt
-        start_time = Time.new.to_f
-
-        if self.driver_object.respond_to?(:alert_accept)
-          self.driver_object.alert_accept
-        else
-          alert = self.driver_object.switch_to.alert
-          alert.accept
-        end
-
-        self.throttle_speed(:accept_prompt, start_time)
-        return nil
+        self.adapter.accept_prompt
       end
 
+      #Dismiss the prompt
       def dismiss_prompt
-        start_time = Time.new.to_f
-
-        begin
-          @driver_object.alert_dismiss
-        rescue NoMethodError
-          alert = @driver_object.switch_to.alert
-          alert.dismiss
-          @driver_object.switch_to.default_content
-        end
-
-        self.throttle_speed(:dismiss_prompt, start_time)
-        return nil
-      end
-
-      def is_mobile?
-        if self.is_mobile == nil
-          self.is_mobile = self.supports_contexts?
-        end
-
-        return self.is_mobile
+        self.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?
-        unless self.is_browser == nil
-          return self.is_browser
-        end
-
-        #If Selenium the yeah we are using a browser
-        if self.supports_window_handles?
-          self.is_browser = true
-          return self.is_browser
-        end
+        self.adapter.is_browser?
+      end
 
-        #Now we need to check Appium's contexts to see if WEBVIEW is in available_contexts
-        available_contexts = nil
-        self.mutex_object.synchronize do
-          available_contexts = @driver_object.available_contexts
-        end
-        self.supports_contexts = true
+      #Window Handles
+      # @return [Array<String>] array of window handle ids
+      def window_handles
+        self.adapter.window_handles
+      end
 
-        available_contexts.each { |context|
-          if context.match(/^WEBVIEW_\d+$/)
-            self.is_browser = true
-            return self.is_browser
-          end
-        }
+      #Current window handle
+      # @return [String] handle id
+      def window_handle
+        self.adapter.window_handle
+      end
 
-        self.is_browser = false
-        return self.is_browser
+      #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)
       end
 
-      #Selenium's use of window_handles
-      def supports_window_handles?
-        begin
-          self.mutex_object.synchronize do
-            @driver_object.window_handles
-          end
-          return true
-        rescue NoMethodError, Selenium::WebDriver::Error::UnknownError
-          return false
-        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
 
-      #Appium's use of window_handles
-      def supports_contexts?
-        return self.supports_contexts if self.supports_contexts != nil
+      # Wait till the document is complete
+      # @return [void]
+      def document_complete_wait
+        self.adapter.document_complete_wait
+      end
 
-        self.mutex_object.synchronize do
-          begin
-            @driver_object.available_contexts
-            self.supports_contexts = true
-          rescue NoMethodError
-            self.supports_contexts = false
-          end
-        end
+      # @param script [String] JS to run
+      # @return [Object, nil]
+      def execute_script(script)
+        self.adapter.execute_script(script)
+      end
 
-        return self.supports_contexts
+      # Destroy the driver
+      def quit
+        self.adapter.quit
       end
     end
   end