testa_appium_driver 0.1.21 → 0.1.24

data/lib/testa_appium_driver/common/helpers.rb

@@ -0,0 +1,272 @@
+module ::TestaAppiumDriver
+  module Helpers
+
+    # supported selectors
+    # id: "com.my.package:id/myId"
+    # id: "myId" => will be converted to "com.my.package:id/myId"
+    # id: /my/ will find all elements with ids that contain my
+    # desc: "element description"
+    # desc: /ription/ will find all elements that contains ription
+    # class: "android.widget.Button"
+    # class: /Button/ will find all elements with classes that contain Button
+    # text: "Hello world"
+    # text: /ello/ will find all elements with text that contain ello
+    # package: "com.my.package"
+    # package: /my/ will find all elements with package that contains my
+    # long_clickable: true or false
+    # checkable: true or false
+    # checked: true or false
+    # clickable: true or false
+    # enabled: true or false
+    # focusable: true or false
+    # focused: true or false
+    # index: child index inside of a parent element, index starts from 0
+    # selected: true or false
+    # scrollable: true or false
+    # @param [Hash] hash selectors for finding elements
+    # @param [Boolean] single should the command return first instance or all of matched elements
+    # @return [String] hash selectors converted to uiautomator command
+    def hash_to_uiautomator(hash, single = true)
+      command = "new UiSelector()"
+
+      id = resolve_id(hash[:id])
+      command = "#{ command }.resourceId(\"#{ %(#{ id }) }\")" if id && id.kind_of?(String)
+      command = "#{ command }.resourceIdMatches(\".*#{ %(#{ id.source }) }.*\")" if id && id.kind_of?(Regexp)
+      command = "#{ command }.description(\"#{ %(#{ hash[:desc] }) }\")" if hash[:desc] && hash[:desc].kind_of?(String)
+      command = "#{ command }.descriptionMatches(\".*#{ %(#{ hash[:desc].source }) }.*\")" if hash[:desc] && hash[:desc].kind_of?(Regexp)
+      command = "#{ command }.className(\"#{ %(#{ hash[:class] }) }\")" if hash[:class] && hash[:class].kind_of?(String)
+      command = "#{ command }.classNameMatches(\".*#{ %(#{ hash[:class].source }) }.*\")" if hash[:class] && hash[:class].kind_of?(Regexp)
+      command = "#{ command }.text(\"#{ %(#{ hash[:text] }) }\")" if hash[:text] && hash[:text].kind_of?(String)
+      command = "#{ command }.textMatches(\".*#{ %(#{ hash[:text].source }) }.*\")" if hash[:text] && hash[:text].kind_of?(Regexp)
+      command = "#{ command }.packageName(\"#{ %(#{ hash[:package] }) }\")" if hash[:package] && hash[:package].kind_of?(String)
+      command = "#{ command }.packageNameMatches(\".*#{ %(#{ hash[:package].source }) }.*\")" if hash[:package] && hash[:package].kind_of?(Regexp)
+
+      command = "#{ command }.longClickable(#{ hash[:long_clickable] })" if hash[:long_clickable]
+      command = "#{ command }.checkable(#{ hash[:checkable] })" unless hash[:checkable].nil?
+      command = "#{ command }.checked(#{ hash[:checked] })" unless hash[:checked].nil?
+      command = "#{ command }.clickable(#{ hash[:clickable] })" unless hash[:clickable].nil?
+      command = "#{ command }.enabled(#{ hash[:enabled] })" unless hash[:enabled].nil?
+      command = "#{ command }.focusable(#{ hash[:focusable] })" unless hash[:focusable].nil?
+      command = "#{ command }.focused(#{ hash[:focused] })" unless hash[:focused].nil?
+      command = "#{ command }.index(#{ hash[:index].to_s })" unless hash[:index].nil?
+      command = "#{ command }.selected(#{ hash[:selected] })" unless hash[:selected].nil?
+      command = "#{ command }.scrollable(#{ hash[:scrollable] })" unless hash[:scrollable].nil?
+
+      command += ".instance(0)" if single
+
+      command
+    end
+
+
+    # supported selectors
+    # id: "com.my.package:id/myId"
+    # id: "myId" => will be converted to "com.my.package:id/myId"
+    # id: /my/ will find all elements with ids that contain my
+    # desc: "element description"
+    # desc: /ription/ will find all elements that contains ription
+    # class: "android.widget.Button"
+    # class: /Button/ will find all elements with classes that contain Button
+    # text: "Hello world"
+    # text: /ello/ will find all elements with text that contain ello
+    # package: "com.my.package"
+    # package: /my/ will find all elements with package that contains my
+    # long_clickable: true or false
+    # checkable: true or false
+    # checked: true or false
+    # clickable: true or false
+    # enabled: true or false
+    # focusable: true or false
+    # focused: true or false
+    # index: child index inside of a parent element, index starts from 0
+    # selected: true or false
+    # scrollable: true or false
+    # @param [Hash] hash selectors for finding elements
+    # @param [Boolean] single should the command return first instance or all of matched elements
+    # @return [String] hash selectors converted to xpath command
+    def hash_to_xpath(device, hash, single = true)
+      for_android = device == :android
+
+
+      command = "//"
+
+
+
+      if for_android
+        id = resolve_id(hash[:id])
+        if hash[:class] && hash[:class].kind_of?(String)
+          command = "#{ command }#{hash[:class] }"
+        elsif hash[:class] && hash[:class].kind_of?(Regexp)
+          command = "#{ command}*[contains(@class, \"#{ %(#{hash[:class].source }) }\")]"
+        else
+          command = "#{command}*"
+        end
+
+        # TODO: with new uiautomator sever you can use matches to look with regex instead of contains
+        command = "#{ command }[@resource-id=\"#{ %(#{ id }) }\"]" if  id &&  id.kind_of?(String)
+        command = "#{ command }[contains(@resource-id, \"#{ %(#{ id.source }) }\")]" if  id &&  id.kind_of?(Regexp)
+        command = "#{ command }[@content-desc=\"#{ %(#{hash[:desc] }) }\"]" if hash[:desc] && hash[:desc].kind_of?(String)
+        command = "#{ command }[contains(@content-desc, \"#{ %(#{hash[:desc].source }) }\")]" if hash[:desc] && hash[:desc].kind_of?(Regexp)
+        command = "#{ command }[contains(@class, \"#{ %(#{hash[:class].source }) }\")]" if hash[:class] && hash[:class].kind_of?(Regexp)
+        command = "#{ command }[@text=\"#{ %(#{hash[:text] }) }\"]" if hash[:text] && hash[:text].kind_of?(String)
+        command = "#{ command }[contains(@text, \"#{ %(#{hash[:text].source }) }\")]" if hash[:text] && hash[:text].kind_of?(Regexp)
+        command = "#{ command }[@package=\"#{ %(#{hash[:package] }) }\"]" if hash[:package] && hash[:package].kind_of?(String)
+        command = "#{ command }[contains=(@package, \"#{ %(#{hash[:package].source }) }\")]" if hash[:package] && hash[:package].kind_of?(Regexp)
+        command = "#{ command }[@long-clickable=\"#{ hash[:long_clickable] }\"]" if hash[:long_clickable]
+        command = "#{ command }[@checkable=\"#{ hash[:checkable] }\"]" unless hash[:checkable].nil?
+        command = "#{ command }[@checked=\"#{ hash[:checked] }\"]" unless hash[:checked].nil?
+        command = "#{ command }[@clickable=\"#{ hash[:clickable] }\"]" unless hash[:clickable].nil?
+        command = "#{ command }[@enabled=\"#{ hash[:enabled] }\"]" unless hash[:enabled].nil?
+        command = "#{ command }[@focusable=\"#{ hash[:focusable] }\"]" unless hash[:focusable].nil?
+        command = "#{ command }[@focused=\"#{ hash[:focused] }\"]" unless hash[:focused].nil?
+        command = "#{ command }[@index=\"#{ hash[:index] }\"]" unless hash[:index].nil?
+        command = "#{ command }[@selected=\"#{ hash[:selected] }\"]" unless hash[:selected].nil?
+
+        # it seems like you cannot query by scrollable
+        # command = "#{ command }[@scrollable=\"#{ hash[:scrollable] }\"]" unless hash[:scrollable].nil?
+      else
+
+        hash[:type] = hash[:class] unless hash[:class].nil?
+        if hash[:type] && hash[:type].kind_of?(String)
+          command = "#{ command }#{hash[:type] }"
+        elsif hash[:type] && hash[:type].kind_of?(Regexp)
+          command = "#{ command}*[contains(@type, \"#{ %(#{hash[:type].source }) }\")]"
+        else
+          command = "#{command}*"
+        end
+
+
+        #  # ios specific
+        hash[:label] = hash[:text] unless hash[:text].nil?
+        hash[:name] = hash[:id] unless hash[:id].nil?
+
+        command = "#{ command }[@enabled=\"#{ hash[:enabled] }\"]" unless hash[:enabled].nil?
+        command = "#{ command }[@label=\"#{ %(#{hash[:label] }) }\"]" if hash[:label] && hash[:label].kind_of?(String)
+        command = "#{ command }[contains(@label, \"#{ %(#{hash[:label].source }) }\")]" if hash[:label] && hash[:label].kind_of?(Regexp)
+        command = "#{ command }[@name=\"#{ %(#{hash[:name] }) }\"]" if hash[:name] && hash[:name].kind_of?(String)
+        command = "#{ command }[contains(@name, \"#{ %(#{hash[:name].source }) }\")]" if hash[:name] && hash[:name].kind_of?(Regexp)
+        command = "#{ command }[@value=\"#{ %(#{hash[:value] }) }\"]" if hash[:value] && hash[:value].kind_of?(String)
+        command = "#{ command }[contains(@value, \"#{ %(#{hash[:value].source }) }\")]" if hash[:value] && hash[:value].kind_of?(Regexp)
+        command = "#{ command }[@width=\"#{ hash[:width] }\"]" unless hash[:width].nil?
+        command = "#{ command }[@height=\"#{ hash[:height] }\"]" unless hash[:height].nil?
+        command = "#{ command }[@visible=\"#{ hash[:visible] }\"]" unless hash[:visible].nil?
+        command = "#{ command }[@index=\"#{ hash[:index] }\"]" unless hash[:index].nil?
+      end
+
+
+      command += "[1]" if single
+
+      command
+    end
+
+
+    def hash_to_class_chain(hash, single = true)
+      command = "**/"
+
+      hash[:type] = hash[:class] unless hash[:class].nil?
+      hash[:label] = hash[:text] unless hash[:text].nil?
+      hash[:name] = hash[:id] unless hash[:id].nil?
+      if hash[:type] && hash[:type].kind_of?(String)
+        command = "#{ command }#{hash[:type] }"
+      else
+        command = "#{command}*"
+      end
+
+      command = "#{ command }[`enabled == #{ hash[:enabled] }`]" unless hash[:enabled].nil?
+      command = "#{ command }[`label == \"#{ %(#{hash[:label] }) }\"`]" if hash[:label] && hash[:label].kind_of?(String)
+      command = "#{ command }[`label CONTAINS \"#{ %(#{hash[:label].source }) }\"`]" if hash[:label] && hash[:label].kind_of?(Regexp)
+      command = "#{ command }[`name == \"#{ %(#{hash[:name] }) }\"`]" if hash[:name] && hash[:name].kind_of?(String)
+      command = "#{ command }[`name CONTAINS \"#{ %(#{hash[:name].source }) }\"`]" if hash[:name] && hash[:name].kind_of?(Regexp)
+      command = "#{ command }[`value == \"#{ %(#{hash[:value] }) }\"`]" if hash[:value] && hash[:value].kind_of?(String)
+      command = "#{ command }[`value CONTAINS \"#{ %(#{hash[:value].source }) }\"`]" if hash[:value] && hash[:value].kind_of?(Regexp)
+      command = "#{ command }[`visible == #{ hash[:visible] }`]" unless hash[:visible].nil?
+
+      command += "[1]" if single
+
+      command
+    end
+
+    # check if selectors are for a scrollable element
+    # @param [Boolean] single should the command return first instance or all of matched elements
+    # @param [Hash] selectors for fetching elements
+    # @return [Boolean] true if element has scrollable attribute true or is class one of (RecyclerView, HorizontalScrollView, ScrollView, ListView)
+    def is_scrollable_selector?(selectors, single)
+      return false unless single
+      return true if selectors[:scrollable]
+      if selectors[:class] == "androidx.recyclerview.widget.RecyclerView" ||
+          selectors[:class] == "android.widget.HorizontalScrollView" ||
+          selectors[:class] == "android.widget.ScrollView" ||
+          selectors[:class] == "android.widget.ListView"
+        return true
+      elsif selectors[:type] == "XCUIElementTypeScrollView" ||
+        selectors[:type] == "XCUIElementTypeTable"
+        return true
+      end
+      false
+    end
+
+    #noinspection RubyUnnecessaryReturnStatement,RubyUnusedLocalVariable
+    # separate selectors from given hash parameters
+    # @param [Hash] params
+    # @return [Array] first element is params, second are selectors
+    def extract_selectors_from_params(params = {})
+      selectors = params.select { |key, value| [
+          :id,
+          :long_clickable,
+          :desc,
+          :class,
+          :text,
+          :package,
+          :checkable,
+          :checked,
+          :clickable,
+          :enabled,
+          :focusable,
+          :focused,
+          :index,
+          :selected,
+          :scrollable,
+
+          # ios specific
+          :type,
+          :label,
+          :x,
+          :y,
+          :width,
+          :height,
+          :visible,
+          :name,
+          :value,
+
+          :image
+      ].include?(key) }
+      params = Hash[params.to_a - selectors.to_a]
+
+      # default params
+      params[:single] = true if params[:single].nil?
+      params[:scrollable_locator] = nil if params[:scrollable_locator].nil?
+      if params[:default_find_strategy].nil?
+        params[:default_find_strategy] = DEFAULT_ANDROID_FIND_STRATEGY if @driver.device == :android
+        params[:default_find_strategy] = DEFAULT_IOS_FIND_STRATEGY if @driver.device == :ios || @driver.device == :tvos
+      end
+      if params[:default_scroll_strategy].nil?
+        params[:default_scroll_strategy] = DEFAULT_ANDROID_SCROLL_STRATEGY if @driver.device == :android
+        params[:default_scroll_strategy] = DEFAULT_IOS_SCROLL_STRATEGY if @driver.device == :ios || @driver.device == :tvos
+      end
+      return params, selectors
+    end
+
+
+    def resolve_id(id)
+      if id && id.kind_of?(String) && !id.match?(/.*:id\//)
+        # shorthand ids like myId make full ids => my.app.package:id/myId
+        if id[0] == "="
+          return id[1..-1]
+        else
+          return "#{@driver.current_package}:id/#{id}"
+        end
+      else
+        id
+      end
+    end
+  end
+end

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

@@ -0,0 +1,390 @@
+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
+      b = bounds
+      f1 = action_builder.add_pointer_input(:touch, "finger1")
+      f1.create_pointer_move(duration: 0, x: b.center.x, y: b.center.y, origin: ::Selenium::WebDriver::Interactions::PointerMove::VIEWPORT)
+      f1.create_pointer_down(:left)
+      f1.create_pause(duration)
+      f1.create_pointer_up(:left)
+      puts "long tap execute:  {x: #{b.center.x}, y: #{b.center.y}}"
+      @driver.perform_actions [f1]
+    end
+
+    # 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 scroll_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)
+      if direction.nil?
+        sa.scroll_each(&block)
+      else
+        sa.send("scroll_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 scroll_each_down(top: nil, bottom: nil, right: nil, left: nil, &block)
+      scroll_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 scroll_each_up(top: nil, bottom: nil, right: nil, left: nil, &block)
+      scroll_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 scroll_each_right(top: nil, bottom: nil, right: nil, left: nil, &block)
+      scroll_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 scroll_each_left(top: nil, bottom: nil, right: nil, left: nil, &block)
+      scroll_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, top: nil, bottom: nil, right: nil, left: nil, scroll_to_find: false, max_attempts: 3)
+      deadzone = _process_deadzone(top, bottom, right, left)
+      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.align(with, scroll_to_find, max_attempts)
+      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(top: nil, bottom: nil, right: nil, left: nil, max_attempts: 3)
+      align(:top, top: top, bottom: bottom, right: right, left: left, max_attempts: max_attempts)
+    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(top: nil, bottom: nil, right: nil, left: nil, max_attempts: 3)
+      align(:bottom, top: top, bottom: bottom, right: right, left: left, max_attempts: max_attempts)
+    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(top: nil, bottom: nil, right: nil, left: nil, max_attempts: 3)
+      align(:left, top: top, bottom: bottom, right: right, left: left, max_attempts: max_attempts)
+    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(top: nil, bottom: nil, right: nil, left: nil,  max_attempts: 3)
+      align(:right, top: top, bottom: bottom, right: right, left: left, max_attempts: max_attempts)
+    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, top: nil, bottom: nil, right: nil, left: nil,  max_attempts: 3)
+      align(with, top: top, bottom: bottom, right: right, left: left, scroll_to_find: true, max_attempts: max_attempts)
+    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!(top: nil, bottom: nil, right: nil, left: nil, max_attempts: 3)
+      align(:top, top: top, bottom: bottom, right: right, left: left, scroll_to_find: true, max_attempts: max_attempts)
+    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!(top: nil, bottom: nil, right: nil, left: nil,  max_attempts: 3)
+      align(:bottom, top: top, bottom: bottom, right: right, left: left, scroll_to_find: true, max_attempts: max_attempts)
+    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!(top: nil, bottom: nil, right: nil, left: nil,  max_attempts: 3)
+      align(:left, top: top, bottom: bottom, right: right, left: left, scroll_to_find: true, max_attempts: max_attempts)
+    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!(top: nil, bottom: nil, right: nil, left: nil,  max_attempts: 3)
+      align(:right, top: top, bottom: bottom, right: right, left: left, scroll_to_find: true, max_attempts: max_attempts)
+    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(top: nil, bottom: nil, right: nil, left: nil, max_scrolls: nil, direction: nil)
+      if direction
+        _scroll_dir_to(_process_deadzone(top, bottom, right, left), max_scrolls, direction)
+      else
+        _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(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(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(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(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(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(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(top: nil, bottom: nil, right: nil, left: nil)
+      _page(:down, _process_deadzone(top, bottom, right, left))
+    end
+
+    # @return [TestaAppiumDriver::Locator]
+    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(top: nil, bottom: nil, right: nil, left: nil)
+      _page(:left, _process_deadzone(top, bottom, right, left))
+    end
+
+    # @return [TestaAppiumDriver::Locator]
+    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(top: nil, bottom: nil, right: nil, left: nil)
+      _fling(:down, _process_deadzone(top, bottom, right, left))
+    end
+
+    # @return [TestaAppiumDriver::Locator]
+    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(top: nil, bottom: nil, right: nil, left: nil)
+      _fling(:left, _process_deadzone(top, bottom, right, left))
+    end
+
+    # @return [TestaAppiumDriver::Locator]
+    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
+
+    # @param [TestaAppiumDriver::Locator, Hash, Selenium::WebDriver::Element, String] to
+    # noinspection RubyYardParamTypeMatch,RubyScope
+    def drag_to(to)
+      if !to.kind_of?(::Selenium::WebDriver::Element) && !to.kind_of?(::Appium::Core::Element) && !to.kind_of?(TestaAppiumDriver::Locator) && !to.kind_of?(Hash)
+        raise "Parameter not accepted, acceptable instances of [TestaAppiumDriver::Locator, Hash, Selenium::WebDriver::Element]"
+      end
+
+      if to.kind_of?(::Selenium::WebDriver::Element) || to.kind_of?(::Appium::Core::Element)
+        bounds = TestaAppiumDriver::Bounds.from_android(to.bounds, @driver)
+        x = bounds.center.x
+        y = bounds.center.y
+      end
+      if to.kind_of?(TestaAppiumDriver::Locator)
+        bounds = to.bounds
+        x = bounds.center.x
+        y = bounds.center.y
+      end
+      if to.kind_of?(Hash)
+        raise "Missing x coordinate" if to[:x].nil?
+        raise "Missing y coordinate" if to[:y].nil?
+
+        x = to[:x]
+        y = to[:y]
+      end
+      _drag_to(bounds.center.x, bounds.center.y, x, y)
+    end
+
+    def drag_by(amount, direction: :top)
+      b = bounds
+      x = b.center.x
+      y = b.center.y
+      case direction
+      when :top
+        y -= amount.to_i
+      when :bottom
+        y += amount.to_i
+      when :left
+        x -= amount.to_i
+      when :right
+        x += amount.to_i
+      else
+        raise "Unknown direction #{direction}"
+      end
+      _drag_to(b.center.x, b.center.y, x, y)
+    end
+
+    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(x0, y0, x1, y1)
+      sa = ScrollActions.new(@scrollable_locator,
+                             locator: self,
+                             default_scroll_strategy: @default_scroll_strategy)
+      sa.drag_to(x0, y0, x1, y1)
+      self
+    end
+
+    def _page(direction, deadzone)
+      deadzone = @scrollable_locator.scroll_deadzone if deadzone.nil? && !@scrollable_locator.nil?
+      sa = ScrollActions.new(@scrollable_locator,
+                             locator: self,
+                             deadzone: deadzone,
+                             direction: direction.to_sym,
+                             default_scroll_strategy: @default_scroll_strategy)
+      sa.send("page_#{direction}")
+      self
+    end
+
+    def _fling(direction, deadzone)
+      deadzone = @scrollable_locator.scroll_deadzone if deadzone.nil? && !@scrollable_locator.nil?
+      sa = ScrollActions.new(@scrollable_locator,
+                             locator: self,
+                             deadzone: deadzone,
+                             direction: direction.to_sym,
+                             default_scroll_strategy: @default_scroll_strategy)
+      sa.send("fling_#{direction}")
+      self
+    end
+
+    def _scroll_to_start_or_end(type, deadzone)
+      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)
+      if type == :start
+        sa.scroll_to_start
+      else
+        sa.scroll_to_end
+      end
+      self
+    end
+
+    def _scroll_to(deadzone, max_scrolls)
+      deadzone = @scrollable_locator.scroll_deadzone if deadzone.nil? && !@scrollable_locator.nil?
+      sa = ScrollActions.new(@scrollable_locator,
+                             locator: self,
+                             deadzone: deadzone,
+                             max_scrolls: max_scrolls,
+                             default_scroll_strategy: @default_scroll_strategy)
+      sa.scroll_to
+      self
+    end
+
+    def _scroll_dir_to(deadzone, max_scrolls, direction)
+      deadzone = @scrollable_locator.scroll_deadzone if deadzone.nil? && !@scrollable_locator.nil?
+      sa = ScrollActions.new(@scrollable_locator,
+                             locator: self,
+                             deadzone: deadzone,
+                             max_scrolls: max_scrolls,
+                             default_scroll_strategy: @default_scroll_strategy)
+
+      sa.send("scroll_#{direction}_to")
+      self
+    end
+  end
+end