testa_appium_driver 0.1.0 → 0.1.4

data/lib/testa_appium_driver/common/locator.rb

@@ -12,7 +12,10 @@ module TestaAppiumDriver
     attr_accessor :driver
     attr_accessor :strategy
     attr_accessor :strategy_reason
+
+    # @type [Boolean] used to determine if last selector was one of siblings or children. Only in those selectors we can reliably use xpath array [instance] selector
     attr_accessor :last_selector_adjacent
+    attr_accessor :can_use_id_strategy
 
     attr_accessor :from_element
     attr_accessor :scroll_orientation
@@ -37,11 +40,11 @@ module TestaAppiumDriver
       @driver = driver
 
       params, selectors = extract_selectors_from_params(params)
-
       single = params[:single]
 
       @single = single
 
+      selectors[:id] = selectors[:name] unless selectors[:name].nil?
       if from_element.instance_of?(Selenium::WebDriver::Element)
         @xpath_selector = "//*" # to select current element
         @xpath_selector += hash_to_xpath(@driver.device, selectors, single)[1..-1]
@@ -54,11 +57,19 @@ module TestaAppiumDriver
       @default_find_strategy = params[:default_find_strategy]
       @default_scroll_strategy = params[:default_scroll_strategy]
 
+      @can_use_id_strategy = selectors.keys.count == 1 && !selectors[:id].nil?
+      if @can_use_id_strategy
+        if @driver.device == :android
+          @can_use_id_strategy = resolve_id(selectors[:id])
+        else
+          @can_use_id_strategy = selectors[:id]
+        end
+      end
+
 
       @strategy = params[:strategy]
       @strategy_reason = params[:strategy_reason]
 
-      # @type [Boolean] used to determine if last selector was one of siblings or children. Only in those selectors we can reliably use xpath array [instance] selector
       @last_selector_adjacent = false
 
       init(params, selectors, single)
@@ -68,6 +79,7 @@ module TestaAppiumDriver
     # method missing is used to fetch the element before executing additional commands like click, send_key, count
     def method_missing(method, *args, &block)
       execute.send(method, *args, &block)
+      @driver.invalidate_cache
     end
 
 
@@ -84,16 +96,23 @@ module TestaAppiumDriver
       if @xpath_selector == "//*/*[1]" && @from_element.instance_of?(Selenium::WebDriver::Element)
         return @from_element
       end
-      @driver.execute(@from_element, selector, @single, @strategy, @default_find_strategy, skip_cache)
+
+
+
+      strategy, selector = strategy_and_selector
+
+
+      @driver.execute(@from_element, selector, @single, strategy, @default_find_strategy, skip_cache)
     end
 
 
     # @param [Integer] timeout in seconds
     # @return [TestaAppiumDriver::Locator]
-    def wait_until_exists(timeout = @driver.get_timeouts["implicit"] / 1000)
+    def wait_until_exists(timeout = nil)
+      timeout = @driver.get_timeouts["implicit"] / 1000 if timeout.nil?
       start_time = Time.now.to_f
       until exists?
-        raise "wait until exists timeout exceeded" if start_time + timeout > Time.now.to_f
+        raise "wait until exists timeout exceeded" if start_time + timeout < Time.now.to_f
         sleep EXISTS_WAIT
       end
       self
@@ -102,10 +121,11 @@ module TestaAppiumDriver
 
     # @param [Integer] timeout in seconds
     # @return [TestaAppiumDriver::Locator]
-    def wait_while_exists(timeout = @driver.get_timeouts["implicit"] / 1000)
+    def wait_while_exists(timeout = nil)
+      timeout = @driver.get_timeouts["implicit"] / 1000 if timeout.nil?
       start_time = Time.now.to_f
       while exists?
-        raise "wait until exists timeout exceeded" if start_time + timeout > Time.now.to_f
+        raise "wait until exists timeout exceeded" if start_time + timeout < Time.now.to_f
         sleep EXISTS_WAIT
       end
       self
@@ -128,15 +148,34 @@ module TestaAppiumDriver
       found
     end
 
+    # @return [TestaAppiumDriver::Locator]
+    def first
+      self[0]
+    end
+
+    # @return [TestaAppiumDriver::Locator]
+    def second
+      self[1]
+    end
+
+    # @return [TestaAppiumDriver::Locator]
+    def third
+      self[2]
+    end
+
+    # @return [TestaAppiumDriver::Locator]
+    def last
+      self[-1]
+    end
 
     def [](instance)
       raise "Cannot add index selector to non-Array" if @single
-
-      if (@strategy.nil? && !@last_selector_adjacent) || @strategy == FIND_STRATEGY_UIAUTOMATOR
+      if ((@strategy.nil? && !@last_selector_adjacent) || @strategy == FIND_STRATEGY_UIAUTOMATOR) && instance >= 0
         locator = self.dup
         locator.strategy = FIND_STRATEGY_UIAUTOMATOR
         locator.ui_selector = "#{@ui_selector}.instance(#{instance})"
         locator.single = true
+        locator.can_use_id_strategy = false
         locator
       else
         from_element = self.execute[instance]
@@ -175,7 +214,8 @@ module TestaAppiumDriver
           uiautomator: defined?(self.ui_selector) ? ui_selector : nil,
           xpath: @xpath_selector,
           scrollable: @scrollable_locator.nil? ? nil : @scrollable_locator.to_s,
-          scroll_orientation: @scroll_orientation
+          scroll_orientation: @scroll_orientation,
+          resolved: strategy_and_selector
       }
     end
 
@@ -235,6 +275,7 @@ module TestaAppiumDriver
       locator.strategy = FIND_STRATEGY_XPATH
       locator.strategy_reason = "parent"
       locator.xpath_selector += "/.."
+      locator.can_use_id_strategy = false
       locator
     end
 
@@ -250,6 +291,7 @@ module TestaAppiumDriver
       locator.xpath_selector += "/*"
       locator.single = false
       locator.last_selector_adjacent = true
+      locator.can_use_id_strategy = false
       locator
     end
 
@@ -265,6 +307,7 @@ module TestaAppiumDriver
       locator.strategy_reason = "child"
       locator.xpath_selector += "/*[1]"
       locator.single = true
+      locator.can_use_id_strategy = false
       locator
     end
 
@@ -281,6 +324,7 @@ module TestaAppiumDriver
       locator.xpath_selector += "/../*[not(@index=\"#{index}\")]"
       locator.single = false
       locator.last_selector_adjacent = true
+      locator.can_use_id_strategy = false
       locator
     end
 
@@ -296,6 +340,7 @@ module TestaAppiumDriver
       locator.xpath_selector += "/../*[position() < #{index + 1}]" # position() starts from 1
       locator.single = false
       locator.last_selector_adjacent = true
+      locator.can_use_id_strategy = false
       locator
     end
 
@@ -313,6 +358,7 @@ module TestaAppiumDriver
       return nil if i == 0
       locator.xpath_selector += "/../*[@index=\"#{i - 1}\"]"
       locator.last_selector_adjacent = true
+      locator.can_use_id_strategy = false
       locator
     end
 
@@ -329,6 +375,7 @@ module TestaAppiumDriver
       locator.xpath_selector += "/../*[position() > #{index + 1}]" # position() starts from 1
       locator.single = false
       locator.last_selector_adjacent = true
+      locator.can_use_id_strategy = false
       locator
     end
 
@@ -346,6 +393,7 @@ module TestaAppiumDriver
       return nil if i == 0
       locator.xpath_selector += "/../*[@index=\"#{i + 1}\"]"
       locator.last_selector_adjacent = true
+      locator.can_use_id_strategy = false
       locator
     end
 

data/lib/testa_appium_driver/common/scroll_actions/w3c_scroll_actions.rb

@@ -3,7 +3,7 @@ module TestaAppiumDriver
 
     private
     # @return [Array]
-    def w3c_each(skip_scroll_to_start, &block)
+    def w3c_each(direction, &block)
       elements = []
       begin
         @driver.disable_wait_for_idle
@@ -13,7 +13,14 @@ module TestaAppiumDriver
         iterations = 0
 
 
-        scroll_to_start unless skip_scroll_to_start
+        if direction.nil?
+          scroll_to_start
+          if @scrollable.scroll_orientation == :vertical
+            direction = :down
+          else
+            direction = :right
+          end
+        end
 
         until is_end_of_scroll?
           matches = @locator.execute(skip_cache: true)
@@ -27,6 +34,7 @@ module TestaAppiumDriver
           end
           iterations += 1
           break if !@max_scrolls.nil? && iterations == @max_scrolls
+          self.send("page_#{direction}")
         end
       rescue => e
         raise e
@@ -37,13 +45,13 @@ module TestaAppiumDriver
       elements
     end
 
-    def w3c_align(with)
+    def w3c_align(with, scroll_to_find)
       @driver.disable_wait_for_idle
       default_deadzone!
 
 
 
-      @locator.scroll_to unless @raise # called with !
+      @locator.scroll_to if scroll_to_find
 
       element = @locator.execute
       @driver.disable_implicit_wait

data/lib/testa_appium_driver/common/scroll_actions.rb

@@ -3,19 +3,24 @@ require_relative 'scroll_actions/w3c_scroll_actions'
 
 
 module TestaAppiumDriver
-  #noinspection RubyResolve,RubyTooManyInstanceVariablesInspection
-  class ScrollActions
 
+  # Class for handling scroll actions
+  class ScrollActions
+    # @param [TestaAppiumDriver::Locator, nil] scrollable container that will be used to determine the bounds for scrolling
+    # @param [Hash] params
+    #   acceptable params
+    #     - locator - element that should be found with scrolling actions
+    #     - deadzone - [Hash] that stores top, bottom, left and right deadzone values. If deadzone[:top] is 200 then 200px from top of the scrollable container will not be used for scrolling
+    #     - max_scrolls - [Integer] maximum number of scrolls before exception is thrown
+    #     - default_scroll_strategy - defines which scroll strategy will be used if a scroll action is valid for multiple strategies
     def initialize(scrollable, params = {})
       @scrollable = scrollable
       @locator = params[:locator]
       @deadzone = params[:deadzone]
-      @direction = params[:direction]
       @max_scrolls = params[:max_scrolls]
       @default_scroll_strategy = params[:default_scroll_strategy]
       @driver = @locator.driver
 
-      @raise = params[:raise]
 
       if @scrollable.nil?
         # if we dont have a scrollable element or if we do have it, but it is not compatible with uiautomator
@@ -26,7 +31,7 @@ module TestaAppiumDriver
       @strategy = nil
       if @scrollable.strategy == FIND_STRATEGY_XPATH || # uiautomator cannot resolve scrollable from a xpath locator
           !@deadzone.nil? ||
-          !@scrollable.from_element.instance_of?(TestaAppiumDriver::Driver)  # uiautomator cannot resolve nested scrollable
+          !@scrollable.from_element.instance_of?(TestaAppiumDriver::Driver) # uiautomator cannot resolve nested scrollable
         @strategy = SCROLL_STRATEGY_W3C
       end
 
@@ -35,16 +40,33 @@ module TestaAppiumDriver
     end
 
 
-    def align(with)
-      w3c_align(with)
+    def align(with, scroll_to_find)
+      w3c_align(with, scroll_to_find)
       @locator
     end
 
     # @return [Array]
-    def each(skip_scroll_to_start,  &block)
-      w3c_each(skip_scroll_to_start,  &block)
+    def each(&block)
+      w3c_each(nil, &block)
+    end
+
+    def each_down(&block)
+      w3c_each(:down, &block)
+    end
+
+    def each_up(&block)
+      w3c_each(:up, &block)
+    end
+
+    def each_right(&block)
+      w3c_each(:right, &block)
     end
 
+    def each_left(&block)
+      w3c_each(:left, &block)
+    end
+
+
     def resolve_strategy
       if @strategy.nil?
         @default_scroll_strategy
@@ -63,39 +85,19 @@ module TestaAppiumDriver
     end
 
     def scroll_down_to
-      if resolve_strategy == SCROLL_STRATEGY_W3C
-        # we have direction enabled, uiautomator does not support direction specific element search
-        w3c_scroll_to(:down)
-      elsif resolve_strategy == SCROLL_STRATEGY_UIAUTOMATOR
-        raise "scroll_down_to is not supported for uiautomator scroll strategy. Use scroll_to without deadzone"
-      end
+      w3c_scroll_to(:down)
     end
 
     def scroll_up_to
-      if resolve_strategy == SCROLL_STRATEGY_W3C
-        # we have direction enabled, uiautomator does not support direction specific element search
-        w3c_scroll_to(:up)
-      elsif resolve_strategy == SCROLL_STRATEGY_UIAUTOMATOR
-        raise "scroll_up_to is not supported for uiautomator scroll strategy. Use scroll_to without deadzone"
-      end
+      w3c_scroll_to(:up)
     end
 
     def scroll_right_to
-      if resolve_strategy == SCROLL_STRATEGY_W3C
-        # we have direction enabled, uiautomator does not support direction specific element search
-        w3c_scroll_to(:right)
-      elsif resolve_strategy == SCROLL_STRATEGY_UIAUTOMATOR
-        raise "scroll_right_to is not supported for uiautomator scroll strategy. Use scroll_to without deadzone"
-      end
+      w3c_scroll_to(:right)
     end
 
     def scroll_left_to
-      if resolve_strategy == SCROLL_STRATEGY_W3C
-        # we have direction enabled, uiautomator does not support direction specific element search
-        w3c_scroll_to(:left)
-      elsif resolve_strategy == SCROLL_STRATEGY_UIAUTOMATOR
-        raise "scroll_left_to is not supported for uiautomator scroll strategy. Use scroll_to without deadzone"
-      end
+      w3c_scroll_to(:left)
     end
 
     def page_next
@@ -202,6 +204,7 @@ module TestaAppiumDriver
 
 
     private
+
     def is_end_of_scroll?
       old_elements = @previous_elements
       @previous_elements = @scrollable.first_and_last_leaf

data/lib/testa_appium_driver/common/selenium_element.rb

@@ -0,0 +1,19 @@
+module Selenium
+  module WebDriver
+    class Element
+      # sets the testa appium driver instance for the current phone
+      def self.set_driver(driver, udid)
+        udid = "unknown" if udid.nil?
+        @@drivers ||= {}
+        @@drivers[udid] = driver
+      end
+
+      # @return [TestaAppiumDriver::Driver] testa appium driver instance for the current phone
+      def get_driver
+        udid = @bridge.capabilities.instance_variable_get(:@capabilities)["udid"]
+        udid = "unknown" if udid.nil?
+        @@drivers[udid]
+      end
+    end
+  end
+end

data/lib/testa_appium_driver/driver.rb

@@ -1,24 +1,35 @@
 # frozen_string_literal: true
 
+require 'em/pure_ruby'
+require 'appium_lib_core'
+
 require_relative 'common/bounds'
 require_relative 'common/exceptions/strategy_mix_exception'
 require_relative 'common/helpers'
 require_relative 'common/locator'
 require_relative 'common/scroll_actions'
+require_relative 'common/selenium_element'
 
 module TestaAppiumDriver
   class Driver
+    include Helpers
+
+    # @return [::Appium::Core::Base::Driver] the ruby_lib_core appium driver
     attr_accessor :driver
+
+    # @return [String] iOS or Android
     attr_reader :device
+
+    # @return [String] driver automation name (uiautomator2 or xcuitest)
     attr_reader :automation_name
 
     # custom options
-    # - default_strategy: default strategy to be used for finding elements. Available strategies :uiautomator or :xpath
+    # - default_find_strategy: default strategy to be used for finding elements. Available strategies :uiautomator or :xpath
+    # - default_scroll_strategy: default strategy to be used for scrolling. Available strategies: :uiautomator(android only), :w3c
     def initialize(opts = {})
       @testa_opts = opts[:testa_appium_driver] || {}
 
 
-
       core = Appium::Core.for(opts)
       extend_for(core.device, core.automation_name)
       @device = core.device
@@ -27,15 +38,15 @@ module TestaAppiumDriver
       handle_testa_opts
 
       @driver = core.start_driver
-      invalidate_cache!
-
+      invalidate_cache
 
 
-      extend_element_with_driver(opts[:caps][:udid])
+      Selenium::WebDriver::Element.set_driver(self, opts[:caps][:udid])
     end
 
 
-    def invalidate_cache!
+    # invalidates current find_element cache
+    def invalidate_cache
       @cache = {
           strategy: nil,
           selector: nil,
@@ -45,28 +56,16 @@ module TestaAppiumDriver
       }
     end
 
-    #noinspection RubyClassVariableUsageInspection
-    def extend_element_with_driver(udid)
-      Selenium::WebDriver::Element.define_singleton_method(:set_driver) do |driver|
-        udid = "unknown" if udid.nil?
-        @@drivers ||={}
-        @@drivers[udid] = driver
-      end
 
-      Selenium::WebDriver::Element.set_driver(self)
-      Selenium::WebDriver::Element.define_method(:get_driver) do
-        udid = self.instance_variable_get(:@bridge).instance_variable_get(:@capabilities).instance_variable_get(:@capabilities)["udid"]
-        udid = "unknown" if udid.nil?
-        @@drivers[udid]
-      end
-    end
 
 
-    #noinspection RubyScope
+    # Executes the find_element with the resolved locator strategy and selector. Find_element might be skipped if cache is hit.
+    # Cache stores last executed find_element with given selector, strategy and from_element. If given values are the same within
+    # last 5 seconds element is retrieved from cache.
     # @param [TestaAppiumDriver::Locator, TestaAppiumDriver::Driver] from_element element from which start the search
-    # @param [String] selector resolved string of a [TestaAppiumDriver::Locator] selector xpath for xpath strategy, java UiSelectors for uiautomator
+    # @param [String] selector resolved string of a [TestaAppiumDriver::Locator] selector xpath for xpath strategy, java UiSelectors for uiautomator or id for ID strategy
     # @param [Boolean] single fetch single or multiple results
-    # @param [Symbol, nil] strategy [TestaAppiumDriver:FIND_STRATEGY_UIAUTOMATOR] or [FIND_STRATEGY_XPATH]
+    # @param [Symbol, nil] strategy [TestaAppiumDriver::FIND_STRATEGY_UIAUTOMATOR], [TestaAppiumDriver::FIND_STRATEGY_XPATH] or [TestaAppiumDriver::FIND_STRATEGY_ID]
     # @param [Symbol] default_strategy if strategy is not enforced, default can be used
     # @param [Boolean] skip_cache to skip checking and storing cache
     # @return [Selenium::WebDriver::Element, Array] element is returned if single is true, array otherwise
@@ -75,13 +74,14 @@ module TestaAppiumDriver
       # if user wants to wait for element to exist, he can use wait_until_present
       disable_wait_for_idle
 
+
       # if not restricted to a strategy, use the default one
       strategy = default_strategy if strategy.nil?
 
       # resolve from_element unique id, so that we can cache it properly
-      from_element_id = from_element.kind_of?(TestaAppiumDriver::Locator) ? from_element.selector : nil
+      from_element_id = from_element.kind_of?(TestaAppiumDriver::Locator) ? from_element.strategy_and_selector[1] : nil
 
-      puts "Executing #{from_element_id ? "from #{from_element.strategy}: #{from_element.selector} => " : ""}#{strategy}: #{selector}"
+      puts "Executing #{from_element_id ? "from #{from_element.strategy}: #{from_element.strategy_and_selector} => " : ""}#{strategy}: #{selector}"
       begin
         if @cache[:selector] != selector || # cache miss, selector is different
             @cache[:time] + 5 <= Time.now || # cache miss, older than 5 seconds
@@ -89,23 +89,13 @@ module TestaAppiumDriver
             @cache[:from_element_id] != from_element_id || # cache miss, search is started from different element
             skip_cache # cache is skipped
 
-          if strategy == FIND_STRATEGY_UIAUTOMATOR
-            if single
-              execute_result = from_element.find_element(uiautomator: selector)
-            else
-              execute_result = from_element.find_elements(uiautomator: selector)
-            end
-
-          elsif strategy == FIND_STRATEGY_XPATH
-            if single
-              execute_result = from_element.find_element(xpath: selector)
-            else
-              execute_result = from_element.find_elements(xpath: selector)
-            end
+          if single
+            execute_result = from_element.find_element("#{strategy}": selector)
           else
-            raise "Unknown find_element strategy"
+            execute_result = from_element.find_elements("#{strategy}": selector)
           end
 
+
           unless skip_cache
             @cache[:selector] = selector
             @cache[:strategy] = strategy
@@ -129,21 +119,26 @@ module TestaAppiumDriver
 
 
     # method missing is used to forward methods to the actual appium driver
+    # after the method is executed, find element cache is invalidated
     def method_missing(method, *args, &block)
       @driver.send(method, *args, &block)
+      invalidate_cache
     end
 
+    # disables implicit wait
     def disable_implicit_wait
       @implicit_wait_ms = @driver.get_timeouts["implicit"]
       @driver.manage.timeouts.implicit_wait = 0
     end
 
+    # enables implicit wait, can be called only after disabling implicit wait
     def enable_implicit_wait
       raise "Implicit wait is not disabled" if @implicit_wait_ms.nil?
       # get_timeouts always returns in milliseconds, but we should set in seconds
       @driver.manage.timeouts.implicit_wait = @implicit_wait_ms / 1000
     end
 
+    # disables wait for idle, only executed for android devices
     def disable_wait_for_idle
       if @device == :android
         @wait_for_idle_timeout = @driver.settings.get["waitForIdleTimeout"]
@@ -151,6 +146,7 @@ module TestaAppiumDriver
       end
     end
 
+    # enables wait for idle, only executed for android devices
     def enable_wait_for_idle
       if @device == :android
         raise "Wait for idle is not disabled" if @wait_for_idle_timeout.nil?
@@ -158,12 +154,15 @@ module TestaAppiumDriver
       end
     end
 
+
+    # @@return [String] current package under test
     def current_package
       @driver.current_package
     end
 
-    def window_size(*args)
-      @driver.window_size(*args)
+
+    def window_size
+      @driver.window_size
     end
 
     def back
@@ -188,6 +187,7 @@ module TestaAppiumDriver
     end
 
 
+    # @return [Array<Selenium::WebDriver::Element] array of 2 elements, the first element without children and the last element without children in the current page
     def first_and_last_leaf(from_element = @driver)
       disable_wait_for_idle
       disable_implicit_wait