testa_appium_driver 0.1.0

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

@@ -0,0 +1,287 @@
+module TestaAppiumDriver
+  #noinspection RubyTooManyMethodsInspection
+  class Locator
+
+    # @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
+
+    # @return [Array] array of [Selenium::WebDriver::Element]
+    def each(deadzone: nil, skip_scroll_to_start: false, &block)
+      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)
+    end
+
+
+    # Aligns element (by default) on top of the scrollable container, if the element does not exists it will scroll to find it
+    # @return [TestaAppiumDriver::Locator]
+    def align(with = :top, deadzone: nil, raise: 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)
+      self
+    end
+
+    # Aligns element on top of the scrollable container, if the element does not exists it will scroll to find it
+    # @return [TestaAppiumDriver::Locator]
+    def align_top(deadzone: nil)
+      align(:top, deadzone: deadzone)
+    end
+
+    # Aligns element on bottom of the scrollable container, if the element does not exists it will scroll to find it
+    # @return [TestaAppiumDriver::Locator]
+    def align_bottom(deadzone: nil)
+      align(:bottom, deadzone: deadzone)
+    end
+
+    # Aligns element on left of the scrollable container, if the element does not exists it will scroll to find it
+    # @return [TestaAppiumDriver::Locator]
+    def align_left(deadzone: nil)
+      align(:left, deadzone: deadzone)
+    end
+
+    # Aligns element on right of the scrollable container, if the element does not exists it will scroll to find it
+    # @return [TestaAppiumDriver::Locator]
+    def align_right(deadzone: nil)
+      align(:right, deadzone: deadzone)
+    end
+
+    # Aligns element (by default) on top of the scrollable container, if the element does not exists it raise an exception
+    # @return [TestaAppiumDriver::Locator]
+    def align!(with = :top, deadzone: nil)
+      align(with, deadzone: deadzone, raise: true)
+    end
+
+    # Aligns element on top of the scrollable container, if the element does not exists it raise an exception
+    # @return [TestaAppiumDriver::Locator]
+    def align_top!(deadzone: nil)
+      align(:top, deadzone: deadzone, raise: true)
+    end
+
+    # Aligns element on bottom of the scrollable container, if the element does not exists it raise an exception
+    # @return [TestaAppiumDriver::Locator]
+    def align_bottom!(deadzone: nil)
+      align(:bottom, deadzone: deadzone, raise: true)
+    end
+
+    # Aligns element on left of the scrollable container, if the element does not exists it raise an exception
+    # @return [TestaAppiumDriver::Locator]
+    def align_left!(deadzone: nil)
+      align(:left, deadzone: deadzone, raise: true)
+    end
+
+    # Aligns element on right of the scrollable container, if the element does not exists it raise an exception
+    # @return [TestaAppiumDriver::Locator]
+    def align_right!(deadzone: nil)
+      align(:right, deadzone: deadzone, raise: 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)
+      _scroll_to(deadzone, max_scrolls, direction)
+    end
+
+
+    # Scrolls down until element is found or end is reached
+    # @return [TestaAppiumDriver::Locator]
+    def scroll_down_to(deadzone: nil, max_scrolls: nil)
+      _scroll_to(deadzone, 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_to(deadzone, 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_to(deadzone, 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_to(deadzone, 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)
+    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)
+    end
+
+
+    # @return [TestaAppiumDriver::Locator]
+    def page_down(deadzone: nil)
+      _page(:down, deadzone)
+    end
+
+    # @return [TestaAppiumDriver::Locator]
+    def page_up(deadzone: nil)
+      _page(:up, deadzone)
+    end
+
+    # @return [TestaAppiumDriver::Locator]
+    def page_left(deadzone: nil)
+      _page(:left, deadzone)
+    end
+
+    # @return [TestaAppiumDriver::Locator]
+    def page_right(deadzone: nil)
+      _page(:right, deadzone)
+    end
+
+    # @return [TestaAppiumDriver::Locator]
+    def fling_down(deadzone: nil)
+      _fling(:down, deadzone)
+    end
+
+    # @return [TestaAppiumDriver::Locator]
+    def fling_up(deadzone: nil)
+      _fling(:up, deadzone)
+    end
+
+    # @return [TestaAppiumDriver::Locator]
+    def fling_left(deadzone: nil)
+      _fling(:left, deadzone)
+    end
+
+    # @return [TestaAppiumDriver::Locator]
+    def fling_right(deadzone: nil)
+      _fling(:right, deadzone)
+    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?(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)
+        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(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(x, y)
+    end
+
+
+
+    private
+    def _drag_to(x, y)
+      sa = ScrollActions.new(@scrollable_locator,
+                             locator: self,
+                             default_scroll_strategy: @default_scroll_strategy)
+      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,
+                             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,
+                             direction: :left,
+                             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, 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,
+                             direction: direction,
+                             default_scroll_strategy: @default_scroll_strategy)
+      sa.scroll_to
+      self
+    end
+  end
+end

data/lib/testa_appium_driver/common/scroll_actions.rb

@@ -0,0 +1,253 @@
+require_relative 'scroll_actions/json_wire_scroll_actions'
+require_relative 'scroll_actions/w3c_scroll_actions'
+
+
+module TestaAppiumDriver
+  #noinspection RubyResolve,RubyTooManyInstanceVariablesInspection
+  class ScrollActions
+
+    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
+        # then find first scrollable in document
+        @scrollable = @driver.scrollable
+      end
+
+      @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
+        @strategy = SCROLL_STRATEGY_W3C
+      end
+
+
+      @bounds = @scrollable.bounds
+    end
+
+
+    def align(with)
+      w3c_align(with)
+      @locator
+    end
+
+    # @return [Array]
+    def each(skip_scroll_to_start,  &block)
+      w3c_each(skip_scroll_to_start,  &block)
+    end
+
+    def resolve_strategy
+      if @strategy.nil?
+        @default_scroll_strategy
+      else
+        @strategy
+      end
+    end
+
+
+    def scroll_to
+      if @locator.strategy != FIND_STRATEGY_XPATH && resolve_strategy == SCROLL_STRATEGY_UIAUTOMATOR
+        uiautomator_scroll_to
+      elsif resolve_strategy == SCROLL_STRATEGY_W3C
+        w3c_scroll_to(nil)
+      end
+    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
+    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
+    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
+    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
+    end
+
+    def page_next
+      if @scrollable.scroll_orientation == :vertical
+        page_down
+      else
+        page_left
+      end
+    end
+
+    def page_back
+      if @scrollable.scroll_orientation == :vertical
+        page_up
+      else
+        page_right
+      end
+    end
+
+
+    def page_down
+      if resolve_strategy == SCROLL_STRATEGY_UIAUTOMATOR
+        uiautomator_page_or_fling(SCROLL_ACTION_TYPE_SCROLL, :down)
+      elsif resolve_strategy == SCROLL_STRATEGY_W3C
+        w3c_page_or_fling(SCROLL_ACTION_TYPE_SCROLL, :down)
+      end
+    end
+
+    def page_right
+      if resolve_strategy == SCROLL_STRATEGY_UIAUTOMATOR
+        uiautomator_page_or_fling(SCROLL_ACTION_TYPE_SCROLL, :right)
+      elsif resolve_strategy == SCROLL_STRATEGY_W3C
+        w3c_page_or_fling(SCROLL_ACTION_TYPE_SCROLL, :right)
+      end
+    end
+
+    def page_up
+      if resolve_strategy == SCROLL_STRATEGY_UIAUTOMATOR
+        uiautomator_page_or_fling(SCROLL_ACTION_TYPE_SCROLL, :up)
+      elsif resolve_strategy == SCROLL_STRATEGY_W3C
+        w3c_page_or_fling(SCROLL_ACTION_TYPE_SCROLL, :up)
+      end
+    end
+
+    def page_left
+      if resolve_strategy == SCROLL_STRATEGY_UIAUTOMATOR
+        uiautomator_page_or_fling(SCROLL_ACTION_TYPE_SCROLL, :left)
+      elsif resolve_strategy == SCROLL_STRATEGY_W3C
+        w3c_page_or_fling(SCROLL_ACTION_TYPE_SCROLL, :left)
+      end
+    end
+
+
+    def scroll_to_start
+      if resolve_strategy == SCROLL_STRATEGY_UIAUTOMATOR
+        uiautomator_scroll_to_start_or_end(:start)
+      elsif resolve_strategy == SCROLL_STRATEGY_W3C
+        w3c_scroll_to_start_or_end(:start)
+      end
+    end
+
+    def scroll_to_end
+      if resolve_strategy == SCROLL_STRATEGY_UIAUTOMATOR
+        uiautomator_scroll_to_start_or_end(:end)
+      elsif resolve_strategy == SCROLL_STRATEGY_W3C
+        w3c_scroll_to_start_or_end(:end)
+      end
+    end
+
+    def fling_down
+      if resolve_strategy == SCROLL_STRATEGY_UIAUTOMATOR
+        uiautomator_page_or_fling(SCROLL_ACTION_TYPE_FLING, :down)
+      elsif resolve_strategy == SCROLL_STRATEGY_W3C
+        w3c_page_or_fling(SCROLL_ACTION_TYPE_FLING, :down)
+      end
+    end
+
+    def fling_right
+      if resolve_strategy == SCROLL_STRATEGY_UIAUTOMATOR
+        uiautomator_page_or_fling(SCROLL_ACTION_TYPE_FLING, :right)
+      elsif resolve_strategy == SCROLL_STRATEGY_W3C
+        w3c_page_or_fling(SCROLL_ACTION_TYPE_FLING, :right)
+      end
+    end
+
+    def fling_up
+      if resolve_strategy == SCROLL_STRATEGY_UIAUTOMATOR
+        uiautomator_page_or_fling(SCROLL_ACTION_TYPE_FLING, :up)
+      elsif resolve_strategy == SCROLL_STRATEGY_W3C
+        w3c_page_or_fling(SCROLL_ACTION_TYPE_FLING, :up)
+      end
+    end
+
+    def fling_left
+      if resolve_strategy == SCROLL_STRATEGY_UIAUTOMATOR
+        uiautomator_page_or_fling(SCROLL_ACTION_TYPE_FLING, :left)
+      elsif resolve_strategy == SCROLL_STRATEGY_W3C
+        w3c_page_or_fling(SCROLL_ACTION_TYPE_FLING, :left)
+      end
+    end
+
+    def drag_to(x, y)
+      w3c_drag_to(x, y)
+    end
+
+
+    private
+    def is_end_of_scroll?
+      old_elements = @previous_elements
+      @previous_elements = @scrollable.first_and_last_leaf
+      old_elements == @previous_elements
+    end
+
+
+    def default_deadzone!
+      @deadzone = {} if @deadzone.nil?
+      if @deadzone[:top].nil?
+        @deadzone[:top] = 1
+      else
+        @deadzone[:top] = @deadzone[:top].to_f
+      end
+      if @deadzone[:bottom].nil?
+        @deadzone[:bottom] = 1
+      else
+        @deadzone[:bottom] = @deadzone[:bottom].to_f
+      end
+      if @deadzone[:right].nil?
+        @deadzone[:right] = 1
+      else
+        @deadzone[:right] = @deadzone[:right].to_f
+      end
+      if @deadzone[:left].nil?
+        @deadzone[:left] = 1
+      else
+        @deadzone[:left] = @deadzone[:left].to_f
+      end
+    end
+
+    def is_aligned?(with, element)
+      align_bounds = @locator.bounds(force_cache_element: element)
+      case with
+      when :top
+        @align_offset = align_bounds.top_left.y - @bounds.top_left.y + @deadzone[:top]
+      when :bottom
+        @align_offset = @bounds.bottom_right.y - @deadzone[:bottom] - align_bounds.bottom_right.y
+      when :right
+        @align_offset = @bounds.bottom_right.x - @deadzone[:right] - align_bounds.bottom_right.x
+      when :left
+        @align_offset = align_bounds.top_left.x - @bounds.top_left.x + @deadzone[:left]
+      else
+        raise "Unsupported align with option: #{with}"
+      end
+      @align_offset < SCROLL_ALIGNMENT_THRESHOLD
+    end
+  end
+end