testa_appium_driver 0.1.3 → 0.1.7

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

@@ -2,6 +2,7 @@ module TestaAppiumDriver
   #noinspection RubyTooManyMethodsInspection
   class Locator
 
+    # performs a long tap on the retrieved element
     # @param [Float] duration in seconds
     def long_tap(duration = LONG_TAP_DURATION)
       action_builder = @driver.action
@@ -15,173 +16,254 @@ module TestaAppiumDriver
       @driver.perform_actions [f1]
     end
 
-    # @return [Array] array of [Selenium::WebDriver::Element]
-    def each(deadzone: nil, skip_scroll_to_start: false, &block)
+
+    # scrolls to the start of the scrollable containers and scrolls to the end,
+    # everytime a locator element is found the given block is executed
+    # @return [Array<Selenium::WebDriver::Element>]
+    def each(top: nil, bottom: nil, right: nil, left: nil, direction: nil, &block)
+      deadzone = _process_deadzone(top, bottom, right, left)
       raise "Each can only be performed on multiple elements locator" if @single
       deadzone = @scrollable_locator.scroll_deadzone if deadzone.nil? && !@scrollable_locator.nil?
       sa = ScrollActions.new(@scrollable_locator,
                              locator: self,
                              deadzone: deadzone,
                              default_scroll_strategy: @default_scroll_strategy)
-      sa.each(skip_scroll_to_start, &block)
+      if direction.nil?
+        sa.each(&block)
+      else
+        sa.send("each_#{direction}", &block)
+      end
+    end
+
+    # scrolls down from the current page view (without prior scrolling to the top) and
+    # everytime a locator element is found the given block is executed
+    # @return [Array<Selenium::WebDriver::Element>]
+    def each_down(top: nil, bottom: nil, right: nil, left: nil, &block)
+      each(top: top, bottom: bottom, right: right, left: left, direction: :down, &block)
+    end
+
+    # scrolls up from the current page view (without prior scrolling to the bottom) and
+    # everytime a locator element is found the given block is executed
+    # @return [Array<Selenium::WebDriver::Element>]
+    def each_up(top: nil, bottom: nil, right: nil, left: nil, &block)
+      each(top: top, bottom: bottom, right: right, left: left, direction: :up, &block)
+    end
+
+    # scrolls right from the current page view (without prior scrolling to the left) and
+    # everytime a locator element is found the given block is executed
+    # @return [Array<Selenium::WebDriver::Element>]
+    def each_right(top: nil, bottom: nil, right: nil, left: nil, &block)
+      each(top: top, bottom: bottom, right: right, left: left, direction: :right, &block)
+    end
+
+    # scrolls left from the current page view (without prior scrolling to the right) and
+    # everytime a locator element is found the given block is executed
+    # @return [Array<Selenium::WebDriver::Element>]
+    def each_left(top: nil, bottom: nil, right: nil, left: nil, &block)
+      each(top: top, bottom: bottom, right: right, left: left, direction: :left, &block)
     end
 
 
     # Aligns element (by default) on top of the scrollable container, if the element does not exists it will scroll to find it
+    # The element is aligned if the the distance from the top/bottom/right/left of the scrollable container is less than [TestaAppiumDriver::SCROLL_ALIGNMENT_THRESHOLD]
+    # If the distance is greater than the threshold, it will attempt to realign it up to 2 more times.
+    # The retry mechanism allows alignment even for dynamic layouts when elements are hidden/show when scrolling to certain direction
     # @return [TestaAppiumDriver::Locator]
-    def align(with = :top, deadzone: nil, raise: false)
+    def align(with = :top, top: nil, bottom: nil, right: nil, left: nil, scroll_to_find: false)
       deadzone = @scrollable_locator.scroll_deadzone if deadzone.nil? && !@scrollable_locator.nil?
       sa = ScrollActions.new(@scrollable_locator,
                              locator: self,
                              deadzone: deadzone,
-                             default_scroll_strategy: @default_scroll_strategy,
-                             raise: raise)
-      sa.align(with)
+                             default_scroll_strategy: @default_scroll_strategy)
+      sa.align(with, scroll_to_find)
       self
     end
 
     # Aligns element on top of the scrollable container, if the element does not exists it will scroll to find it
+    # The element is aligned if the the distance from the top of the scrollable container is less than [TestaAppiumDriver::SCROLL_ALIGNMENT_THRESHOLD]
+    # If the distance is greater than the threshold, it will attempt to realign it up to 2 more times.
+    # The retry mechanism allows alignment even for dynamic layouts when elements are hidden/show when scrolling to certain direction
     # @return [TestaAppiumDriver::Locator]
-    def align_top(deadzone: nil)
-      align(:top, deadzone: deadzone)
+    def align_top(top: nil, bottom: nil, right: nil, left: nil)
+      align(:top, top: top, bottom: bottom, right: right, left: left)
     end
 
     # Aligns element on bottom of the scrollable container, if the element does not exists it will scroll to find it
+    # The element is aligned if the the distance from the bottom of the scrollable container is less than [TestaAppiumDriver::SCROLL_ALIGNMENT_THRESHOLD]
+    # If the distance is greater than the threshold, it will attempt to realign it up to 2 more times.
+    # The retry mechanism allows alignment even for dynamic layouts when elements are hidden/show when scrolling to certain direction
     # @return [TestaAppiumDriver::Locator]
-    def align_bottom(deadzone: nil)
-      align(:bottom, deadzone: deadzone)
+    def align_bottom(top: nil, bottom: nil, right: nil, left: nil)
+      align(:bottom, top: top, bottom: bottom, right: right, left: left)
     end
 
     # Aligns element on left of the scrollable container, if the element does not exists it will scroll to find it
+    # The element is aligned if the the distance from the left of the scrollable container is less than [TestaAppiumDriver::SCROLL_ALIGNMENT_THRESHOLD]
+    # If the distance is greater than the threshold, it will attempt to realign it up to 2 more times.
+    # The retry mechanism allows alignment even for dynamic layouts when elements are hidden/show when scrolling to certain direction
     # @return [TestaAppiumDriver::Locator]
-    def align_left(deadzone: nil)
-      align(:left, deadzone: deadzone)
+    def align_left(top: nil, bottom: nil, right: nil, left: nil)
+      align(:left, top: top, bottom: bottom, right: right, left: left)
     end
 
     # Aligns element on right of the scrollable container, if the element does not exists it will scroll to find it
+    # The element is aligned if the the distance from the right of the scrollable container is less than [TestaAppiumDriver::SCROLL_ALIGNMENT_THRESHOLD]
+    # If the distance is greater than the threshold, it will attempt to realign it up to 2 more times.
+    # The retry mechanism allows alignment even for dynamic layouts when elements are hidden/show when scrolling to certain direction
     # @return [TestaAppiumDriver::Locator]
-    def align_right(deadzone: nil)
-      align(:right, deadzone: deadzone)
+    def align_right(top: nil, bottom: nil, right: nil, left: nil)
+      align(:right, top: top, bottom: bottom, right: right, left: left)
     end
 
     # Aligns element (by default) on top of the scrollable container, if the element does not exists it raise an exception
+    # The element is aligned if the the distance from the top/bottom/right/left of the scrollable container is less than [TestaAppiumDriver::SCROLL_ALIGNMENT_THRESHOLD]
+    # If the distance is greater than the threshold, it will attempt to realign it up to 2 more times.
+    # The retry mechanism allows alignment even for dynamic layouts when elements are hidden/show when scrolling to certain direction
     # @return [TestaAppiumDriver::Locator]
-    def align!(with = :top, deadzone: nil)
-      align(with, deadzone: deadzone, raise: true)
+    def align!(with = :top, top: nil, bottom: nil, right: nil, left: nil)
+      align(with, top: top, bottom: bottom, right: right, left: left, scroll_to_find: true)
     end
 
     # Aligns element on top of the scrollable container, if the element does not exists it raise an exception
+    # The element is aligned if the the distance from the top of the scrollable container is less than [TestaAppiumDriver::SCROLL_ALIGNMENT_THRESHOLD]
+    # If the distance is greater than the threshold, it will attempt to realign it up to 2 more times.
+    # The retry mechanism allows alignment even for dynamic layouts when elements are hidden/show when scrolling to certain direction
     # @return [TestaAppiumDriver::Locator]
-    def align_top!(deadzone: nil)
-      align(:top, deadzone: deadzone, raise: true)
+    def align_top!(top: nil, bottom: nil, right: nil, left: nil)
+      align(:top, top: top, bottom: bottom, right: right, left: left, scroll_to_find: true)
     end
 
     # Aligns element on bottom of the scrollable container, if the element does not exists it raise an exception
+    # The element is aligned if the the distance from the bottom of the scrollable container is less than [TestaAppiumDriver::SCROLL_ALIGNMENT_THRESHOLD]
+    # If the distance is greater than the threshold, it will attempt to realign it up to 2 more times.
+    # The retry mechanism allows alignment even for dynamic layouts when elements are hidden/show when scrolling to certain direction
     # @return [TestaAppiumDriver::Locator]
-    def align_bottom!(deadzone: nil)
-      align(:bottom, deadzone: deadzone, raise: true)
+    def align_bottom!(top: nil, bottom: nil, right: nil, left: nil)
+      align(:bottom, top: top, bottom: bottom, right: right, left: left, scroll_to_find: true)
     end
 
     # Aligns element on left of the scrollable container, if the element does not exists it raise an exception
+    # The element is aligned if the the distance from the left of the scrollable container is less than [TestaAppiumDriver::SCROLL_ALIGNMENT_THRESHOLD]
+    # If the distance is greater than the threshold, it will attempt to realign it up to 2 more times.
+    # The retry mechanism allows alignment even for dynamic layouts when elements are hidden/show when scrolling to certain direction
     # @return [TestaAppiumDriver::Locator]
-    def align_left!(deadzone: nil)
-      align(:left, deadzone: deadzone, raise: true)
+    def align_left!(top: nil, bottom: nil, right: nil, left: nil)
+      align(:left, top: top, bottom: bottom, right: right, left: left, scroll_to_find: true)
     end
 
     # Aligns element on right of the scrollable container, if the element does not exists it raise an exception
+    # The element is aligned if the the distance from the right of the scrollable container is less than [TestaAppiumDriver::SCROLL_ALIGNMENT_THRESHOLD]
+    # If the distance is greater than the threshold, it will attempt to realign it up to 2 more times.
+    # The retry mechanism allows alignment even for dynamic layouts when elements are hidden/show when scrolling to certain direction
     # @return [TestaAppiumDriver::Locator]
-    def align_right!(deadzone: nil)
-      align(:right, deadzone: deadzone, raise: true)
+    def align_right!(top: nil, bottom: nil, right: nil, left: nil)
+      align(:right, top: top, bottom: bottom, right: right, left: left, scroll_to_find: true)
     end
 
 
     # First scrolls to the beginning of the scrollable container and then scrolls down until element is found or end is reached
     # @return [TestaAppiumDriver::Locator]
-    def scroll_to(deadzone: nil, max_scrolls: nil, direction: nil)
+    def scroll_to(top: nil, bottom: nil, right: nil, left: nil, max_scrolls: nil, direction: nil)
       if direction
-        _scroll_dir_to(deadzone, max_scrolls, direction)
+        _scroll_dir_to(_process_deadzone(top, bottom, right, left), max_scrolls, direction)
       else
-        _scroll_to(deadzone, max_scrolls)
+        _scroll_to(_process_deadzone(top, bottom, right, left), max_scrolls)
       end
     end
 
 
     # Scrolls down until element is found or end is reached
     # @return [TestaAppiumDriver::Locator]
-    def scroll_down_to(deadzone: nil, max_scrolls: nil)
-      _scroll_dir_to(deadzone, max_scrolls, :down)
+    def scroll_down_to(top: nil, bottom: nil, right: nil, left: nil, max_scrolls: nil)
+      _scroll_dir_to(_process_deadzone(top, bottom, right, left), max_scrolls, :down)
     end
 
     # Scrolls up until element is found or end is reached
     # @return [TestaAppiumDriver::Locator]
-    def scroll_up_to(deadzone: nil, max_scrolls: nil)
-      _scroll_dir_to(deadzone, max_scrolls, :up)
+    def scroll_up_to(top: nil, bottom: nil, right: nil, left: nil, max_scrolls: nil)
+      _scroll_dir_to(_process_deadzone(top, bottom, right, left), max_scrolls, :up)
     end
 
     # Scrolls right until element is found or end is reached
     # @return [TestaAppiumDriver::Locator]
-    def scroll_right_to(deadzone: nil, max_scrolls: nil)
-      _scroll_dir_to(deadzone, max_scrolls, :right)
+    def scroll_right_to(top: nil, bottom: nil, right: nil, left: nil, max_scrolls: nil)
+      _scroll_dir_to(_process_deadzone(top, bottom, right, left), max_scrolls, :right)
     end
 
 
     # Scrolls left until element is found or end is reached
     # @return [TestaAppiumDriver::Locator]
-    def scroll_left_to(deadzone: nil, max_scrolls: nil)
-      _scroll_dir_to(deadzone, max_scrolls, :left)
+    def scroll_left_to(top: nil, bottom: nil, right: nil, left: nil, max_scrolls: nil)
+      _scroll_dir_to(_process_deadzone(top, bottom, right, left), max_scrolls, :left)
     end
 
     # Scrolls to the start of the scrollable container (top on vertical container, left on horizontal)
     # @return [TestaAppiumDriver::Locator]
-    def scroll_to_start(deadzone: nil)
-      _scroll_to_start_or_end(:start, deadzone)
+    def scroll_to_start(top: nil, bottom: nil, right: nil, left: nil)
+      _scroll_to_start_or_end(:start, _process_deadzone(top, bottom, right, left))
     end
 
     # Scrolls to the end of the scrollable container (bottom on vertical container, right on horizontal)
     # @return [TestaAppiumDriver::Locator]
-    def scroll_to_end(deadzone: nil)
-      _scroll_to_start_or_end(:end, deadzone)
+    def scroll_to_end(top: nil, bottom: nil, right: nil, left: nil)
+      _scroll_to_start_or_end(:end, _process_deadzone(top, bottom, right, left))
     end
 
 
     # @return [TestaAppiumDriver::Locator]
-    def page_down(deadzone: nil)
-      _page(:down, deadzone)
+    def page_down(top: nil, bottom: nil, right: nil, left: nil)
+      _page(:down, _process_deadzone(top, bottom, right, left))
     end
 
     # @return [TestaAppiumDriver::Locator]
-    def page_up(deadzone: nil)
-      _page(:up, deadzone)
+    def page_up(top: nil, bottom: nil, right: nil, left: nil)
+      _page(:up, _process_deadzone(top, bottom, right, left))
     end
 
     # @return [TestaAppiumDriver::Locator]
-    def page_left(deadzone: nil)
-      _page(:left, deadzone)
+    def page_left(top: nil, bottom: nil, right: nil, left: nil)
+      _page(:left, _process_deadzone(top, bottom, right, left))
     end
 
     # @return [TestaAppiumDriver::Locator]
-    def page_right(deadzone: nil)
-      _page(:right, deadzone)
+    def page_right(top: nil, bottom: nil, right: nil, left: nil)
+      _page(:right, _process_deadzone(top, bottom, right, left))
     end
 
     # @return [TestaAppiumDriver::Locator]
-    def fling_down(deadzone: nil)
-      _fling(:down, deadzone)
+    def fling_down(top: nil, bottom: nil, right: nil, left: nil)
+      _fling(:down, _process_deadzone(top, bottom, right, left))
     end
 
     # @return [TestaAppiumDriver::Locator]
-    def fling_up(deadzone: nil)
-      _fling(:up, deadzone)
+    def fling_up(top: nil, bottom: nil, right: nil, left: nil)
+      _fling(:up, _process_deadzone(top, bottom, right, left))
     end
 
     # @return [TestaAppiumDriver::Locator]
-    def fling_left(deadzone: nil)
-      _fling(:left, deadzone)
+    def fling_left(top: nil, bottom: nil, right: nil, left: nil)
+      _fling(:left, _process_deadzone(top, bottom, right, left))
     end
 
     # @return [TestaAppiumDriver::Locator]
-    def fling_right(deadzone: nil)
-      _fling(:right, deadzone)
+    def fling_right(top: nil, bottom: nil, right: nil, left: nil)
+      _fling(:right, _process_deadzone(top, bottom, right, left))
+    end
+
+    def drag_up_by(amount)
+      drag_by(amount, direction: :top)
+    end
+
+    def drag_down_by(amount)
+      drag_by(amount, direction: :bottom)
+    end
+
+    def drag_left_by(amount)
+      drag_by(amount, direction: :left)
+    end
+
+    def drag_right_by(amount)
+      drag_by(amount, direction: :right)
     end
 
 
@@ -232,6 +314,18 @@ module TestaAppiumDriver
 
 
     private
+    def _process_deadzone(top, bottom, right, left)
+      deadzone = nil
+      if !top.nil? || !bottom.nil? || !right.nil? || !left.nil?
+        deadzone = {}
+        deadzone[:top] = top unless top.nil?
+        deadzone[:bottom] = bottom unless bottom.nil?
+        deadzone[:right] = right unless right.nil?
+        deadzone[:left] = left unless left.nil?
+      end
+      deadzone
+    end
+
     def _drag_to(x, y)
       sa = ScrollActions.new(@scrollable_locator,
                              locator: self,
@@ -239,6 +333,8 @@ module TestaAppiumDriver
       sa.drag_to(x, y)
       self
     end
+
+
     def _page(direction, deadzone)
       deadzone = @scrollable_locator.scroll_deadzone if deadzone.nil? && !@scrollable_locator.nil?
       sa = ScrollActions.new(@scrollable_locator,
@@ -266,7 +362,6 @@ module TestaAppiumDriver
       sa = ScrollActions.new(@scrollable_locator,
                              locator: self,
                              deadzone: deadzone,
-                             direction: :left,
                              default_scroll_strategy: @default_scroll_strategy)
       if type == :start
         sa.scroll_to_start
@@ -293,7 +388,6 @@ module TestaAppiumDriver
                              locator: self,
                              deadzone: deadzone,
                              max_scrolls: max_scrolls,
-                             direction: direction,
                              default_scroll_strategy: @default_scroll_strategy)
 
       sa.send("scroll_#{direction}_to")

data/lib/testa_appium_driver/common/locator.rb

@@ -17,6 +17,8 @@ module TestaAppiumDriver
     attr_accessor :last_selector_adjacent
     attr_accessor :can_use_id_strategy
 
+    attr_accessor :image_selector
+
     attr_accessor :from_element
     attr_accessor :scroll_orientation
     attr_accessor :scroll_deadzone
@@ -25,6 +27,8 @@ module TestaAppiumDriver
     attr_accessor :default_find_strategy
     attr_accessor :default_scroll_strategy
 
+    attr_accessor :index_for_multiple
+
 
     # locator parameters are:
     #   single: true or false
@@ -38,12 +42,22 @@ module TestaAppiumDriver
     def initialize(driver, from_element, params = {})
       # @type [TestaAppiumDriver::Driver]
       @driver = driver
+      @index_for_multiple = nil
+      @image_selector = nil
 
       params, selectors = extract_selectors_from_params(params)
       single = params[:single]
 
       @single = single
 
+      if selectors[:image].nil?
+        if from_element.instance_of?(TestaAppiumDriver::Locator) && !from_element.image_selector.nil?
+          raise "Cannot chain non-image selectors to image selectors"
+        end
+      else
+        handle_image_selector(selectors, params)
+      end
+
       selectors[:id] = selectors[:name] unless selectors[:name].nil?
       if from_element.instance_of?(Selenium::WebDriver::Element)
         @xpath_selector = "//*" # to select current element
@@ -57,7 +71,8 @@ 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?
+
+      @can_use_id_strategy = is_only_id_selector?(selectors)
       if @can_use_id_strategy
         if @driver.device == :android
           @can_use_id_strategy = resolve_id(selectors[:id])
@@ -76,32 +91,70 @@ module TestaAppiumDriver
     end
 
 
+
+
+    def is_only_id_selector?(selectors)
+      # since, name and id is the same thing for iOS,
+      if @driver.device == :android
+        selectors.keys.count == 1 && !selectors[:id].nil?
+      else
+        # if it iOS we assign the name to id
+        selectors.keys.count == 2 && !selectors[:id].nil? && selectors[:id] == selectors[:name]
+      end
+    end
+
+
     # 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)
+      r = execute.send(method, *args, &block)
+      @driver.invalidate_cache
+      r
     end
 
 
     # @param [Boolean] skip_cache if true it will skip cache check and store
     # @param [Selenium::WebDriver::Element] force_cache_element, for internal use where we have already the element, and want to execute custom locator methods on it
     # @return [Selenium::WebDriver::Element, Array]
-    def execute(skip_cache: false, force_cache_element: nil)
+    def execute(skip_cache: false, force_cache_element: nil, ignore_implicit_wait: false)
       return force_cache_element unless force_cache_element.nil?
       # if we are looking for current element, then return from_element
       # for example when we have driver.element.elements[1].click
       # elements[2] will be resolved with xpath because we are looking for multiple elements from element
       # and since we are looking for instance 2, [](instance) method will return new "empty locator"
       # we are executing click on that "empty locator" so we have to return the instance 2 of elements for the click
-      if @xpath_selector == "//*/*[1]" && @from_element.instance_of?(Selenium::WebDriver::Element)
+      if @xpath_selector == "//*[1]" && !@from_element.nil? && @image_selector.nil?
+        return @from_element if @from_element.instance_of?(Selenium::WebDriver::Element)
+        return @from_element.execute(skip_cache: skip_cache, force_cache_element: force_cache_element, ignore_implicit_wait: ignore_implicit_wait) if @from_element.instance_of?(TestaAppiumDriver::Locator)
         return @from_element
       end
 
 
 
-      strategy, selector = strategy_and_selector
 
 
-      @driver.execute(@from_element, selector, @single, strategy, @default_find_strategy, skip_cache)
+
+      r = @driver.execute(@from_element, @single, strategies_and_selectors, skip_cache, ignore_implicit_wait)
+      r = r[@index_for_multiple] if !@index_for_multiple.nil? && !@single
+      r
+    end
+
+    def when_exists(timeout = nil, &block)
+      timeout = @driver.get_timeouts["implicit"] / 1000 if timeout.nil?
+      found = false
+      begin
+        wait_until_exists(timeout)
+        found = true
+      rescue
+        #ignored
+      end
+      if found
+        if block_given? # block is given
+          block.call(self) # use call to execute the block
+        else # the value of block_argument becomes nil if you didn't give a block
+          # block was not given
+        end
+      end
+      self
     end
 
 
@@ -109,12 +162,8 @@ module TestaAppiumDriver
     # @return [TestaAppiumDriver::Locator]
     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
-        sleep EXISTS_WAIT
-      end
-      self
+      args = {timeout: timeout}
+      _wait(:until, args)
     end
 
 
@@ -122,28 +171,31 @@ module TestaAppiumDriver
     # @return [TestaAppiumDriver::Locator]
     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
-        sleep EXISTS_WAIT
-      end
-      self
+      args = {timeout: timeout}
+      _wait(:while, args)
+    end
+
+
+    def wait_while(timeout = nil, args = {})
+      args[:timeout] = timeout
+      _wait(:while, args)
+    end
+
+    def wait_until(timeout = nil, args = {})
+      args[:timeout] = timeout
+      _wait(:until, args)
     end
 
 
     # all timeouts are disabled before check, and enabled after check
     # @return [boolean] true if it exists in the page regardless if visible or not
     def exists?
-      @driver.disable_wait_for_idle
-      @driver.disable_implicit_wait
       found = true
       begin
-        execute(skip_cache: true)
+        execute(skip_cache: true, ignore_implicit_wait: true)
       rescue StandardError
         found = false
       end
-      @driver.enable_implicit_wait
-      @driver.enable_wait_for_idle
       found
     end
 
@@ -177,7 +229,8 @@ module TestaAppiumDriver
         locator.can_use_id_strategy = false
         locator
       else
-        from_element = self.execute[instance]
+        from_element = self.dup
+        from_element.index_for_multiple = instance
         params = {}.merge({single: true, scrollable_locator: @scrollable_locator})
         #params[:strategy] = FIND_STRATEGY_XPATH
         #params[:strategy_reason] = "retrieved instance of a array"
@@ -214,7 +267,8 @@ module TestaAppiumDriver
           xpath: @xpath_selector,
           scrollable: @scrollable_locator.nil? ? nil : @scrollable_locator.to_s,
           scroll_orientation: @scroll_orientation,
-          resolved: strategy_and_selector
+          resolved: strategies_and_selectors,
+          index_for_multiple: @index_for_multiple
       }
     end
 
@@ -399,6 +453,51 @@ module TestaAppiumDriver
 
     private
 
+    def _wait(type, args)
+      interval = EXISTS_WAIT
+      interval = args[:interval] unless args[:interval].nil?
+
+      message = "wait #{type} exists timeout exceeded"
+      message = args[:message] unless args[:message].nil?
+
+      if args[:timeout].nil?
+        timeout = @driver.get_timeouts["implicit"] / 1000
+      else
+        timeout = args[:timeout]
+      end
+
+      args.delete(:message)
+      args.delete(:interval)
+      args.delete(:timeout)
+
+
+
+      start_time = Time.now.to_f
+      if type ==  :while
+        while exists? && _attributes_match(args)
+          raise message if start_time + timeout < Time.now.to_f
+          sleep interval
+        end
+      else
+        until exists? && _attributes_match(args)
+          raise message if start_time + timeout < Time.now.to_f
+          sleep interval
+        end
+      end
+      self
+    end
+
+    def _attributes_match(attributes)
+      all_match = true
+      attributes.each do |key, value|
+        unless attribute(key) == value
+          all_match = false
+          break
+        end
+      end
+      all_match
+    end
+
     #noinspection RubyNilAnalysis
     def perform_driver_method(name, *args)
       elements = execute
@@ -413,6 +512,42 @@ module TestaAppiumDriver
       locator.single = false unless single # switching from single result to multiple
       locator.xpath_selector += hash_to_xpath(@driver.device, selectors, single)
     end
+
+
+    def handle_image_selector(selectors, params)
+      image_match_threshold = 0.4
+      image_match_threshold = params[:imageMatchThreshold] unless params[:imageMatchThreshold].nil?
+      image_match_threshold = params[:threshold] unless params[:threshold].nil?
+      fix_image_find_screenshot_dims = true
+      fix_image_find_screenshot_dims = params[:fixImageFindScreenshotDims] unless params[:fixImageFindScreenshotDims].nil?
+      fix_image_template_size = false
+      fix_image_template_size = params[:fixImageTemplateSize] unless params[:fixImageTemplateSize].nil?
+      fix_image_template_scale = false
+      fix_image_template_scale = params[:fixImageTemplateScale] unless params[:fixImageTemplateScale].nil?
+      default_image_template_scale = 1.0
+      default_image_template_scale = params[:defaultImageTemplateScale] unless params[:defaultImageTemplateScale].nil?
+      check_for_image_element_staleness = true
+      check_for_image_element_staleness = params[:checkForImageElementStaleness] unless params[:checkForImageElementStaleness].nil?
+      auto_update_image_element_position = false
+      auto_update_image_element_position = params[:autoUpdateImageElementPosition] unless params[:autoUpdateImageElementPosition].nil?
+      image_element_tap_strategy = "w3cActions"
+      image_element_tap_strategy = params[:imageElementTapStrategy] unless params[:imageElementTapStrategy].nil?
+      get_matched_image_result = false
+      get_matched_image_result = params[:getMatchedImageResult] unless params[:getMatchedImageResult].nil?
+
+      @image_selector = {
+        image: selectors[:image],
+        imageMatchThreshold: image_match_threshold,
+        fixImageFindScreenshotDims: fix_image_find_screenshot_dims,
+        fixImageTemplateSize: fix_image_template_size,
+        fixImageTemplateScale: fix_image_template_scale,
+        defaultImageTemplateScale: default_image_template_scale,
+        checkForImageElementStaleness: check_for_image_element_staleness,
+        autoUpdateImageElementPosition: auto_update_image_element_position,
+        imageElementTapStrategy: image_element_tap_strategy,
+        getMatchedImageResult: get_matched_image_result,
+      }
+    end
   end
 
 end