testa_appium_driver 0.1.21 → 0.1.24

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

@@ -0,0 +1,380 @@
+module ::TestaAppiumDriver
+  module W3cScrollActions
+    # @return [Array]
+    def w3c_scroll_each(direction, &block)
+      default_deadzone!
+      if direction.nil?
+        scroll_to_start
+        if @scrollable.scroll_orientation == :vertical
+          direction = :down
+        else
+          direction = :right
+        end
+      end
+
+      case direction
+      when :up
+        align_with = :bottom
+      when :down
+        align_with = :top
+      when :right
+        align_with = :left
+      when :left
+        align_with = :right
+      else
+        align_with = :top
+      end
+
+      if @driver.ios?
+      # if true
+        w3c_scroll_each_ios(direction, align_with, &block)
+      else
+        w3c_scroll_each_android(direction, align_with, &block)
+      end
+    end
+
+    def w3c_scroll_each_android(direction, align_with, &block)
+      elements = []
+      begin
+
+        iterations = 0
+        ignore_element_ids = []
+        previous_element = nil
+
+        until is_end_of_scroll?
+          # # $__.puts "-- new iteration"
+          # # $__.puts "-------------"
+          aligned_items = 0
+          new_ignore_element_ids = []
+          matches = @locator.execute(skip_cache: true)
+          matches.each_with_index do |m, index|
+            # # $__.puts "Matches: #{matches.count}"
+            # # $__.puts "M: #{m.id}"
+            if ignore_element_ids.include?(m.id)
+              previous_element = m
+              next
+            end
+
+            sa = self.dup
+            sa.locator = m
+            sa.w3c_align(align_with, false, 1, speed_coef: 2.0)
+            is_aligned = sa.is_aligned?(align_with, m)
+
+            # add the previous to ignore if current is not aligned (probably means we cannot scroll any further)
+            new_ignore_element_ids << previous_element.id if !is_aligned && !previous_element.nil?
+
+            aligned_items += 1 if is_aligned
+
+            # add last element to ignore
+            new_ignore_element_ids << m.id if matches.count == index + 1
+
+            elements << m
+            if block_given? # block is given
+              @locator.driver.invalidate_cache
+              block.call(m) # 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
+            previous_element = m
+          end
+
+          iterations += 1
+          break if !@max_scrolls.nil? && iterations == @max_scrolls
+
+          if aligned_items.zero?
+            self.send("page_#{direction}")
+          else
+            ignore_element_ids = new_ignore_element_ids.dup
+          end
+        end
+      rescue StandardError => e
+        raise e
+      end
+
+      elements
+    end
+
+    def w3c_scroll_each_ios(direction, align_with, &block)
+      elements = []
+      elements_in_current_iteration = []
+      begin
+        iterations = 0
+
+        loop do
+          elements_in_last_iteration = elements_in_current_iteration
+          elements_in_current_iteration = []
+          elements_count_before_iteration = elements.count
+
+          new_element_in_this_iteration_found = false
+          matches = @locator.execute(skip_cache: true)
+          matches.each do |m|
+            elements_in_current_iteration << m.id
+
+            element_found_in_last_iteration = elements_in_last_iteration.include?(m.id)
+
+            # ignore all elements from last iteration until first new element is found
+            if !new_element_in_this_iteration_found && element_found_in_last_iteration
+              next
+            end
+
+            # new element in this iteration is found,
+            # process all remaining elements regardless if it is found in last iteration or not
+            new_element_in_this_iteration_found = true
+
+            sa = self.dup
+            sa.locator = m
+            sa.w3c_align(align_with, false, 1, speed_coef: 2.0)
+
+            elements << m.id
+            if block_given? # block is given
+              @locator.driver.invalidate_cache
+              block.call(m) # 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
+
+          iterations += 1
+          break if !@max_scrolls.nil? && iterations == @max_scrolls
+
+          if matches.count.positive?
+            # if there are elements on screen, but there are no new elements
+            # then we have reached the end of scrolling
+            if elements.count == elements_count_before_iteration
+              return elements
+            end
+          else
+            # there are no matching elements. to detect end of scroll,
+            # first and last leaf is compared before with first and last leaf of previous iteration
+            if is_end_of_scroll?
+              return elements
+            end
+          end
+
+          # if there are more than 1 match on screen,
+          # the page is scrolled by aligning elements 1 by one,
+          # but if there is only 1, or none elements.
+          # then scroll the page manually
+          self.send("page_#{direction}") if matches.count < 2
+        end
+      rescue Selenium::WebDriver::Error::StaleElementReferenceError
+        # if boundElementsByIndex is enabled, we can get stale element reference while doing scroll each
+        retry
+      rescue StandardError => e
+        raise e
+      end
+
+      elements
+    end
+
+    def w3c_align(with, scroll_to_find, max_attempts, speed_coef: 1.25)
+      default_deadzone!
+
+      @locator.scroll_to if scroll_to_find
+
+      if @locator.instance_of?(TestaAppiumDriver::Locator)
+        element = @locator.execute
+      else
+        element = @locator
+      end
+
+      max_attempts = 3 if max_attempts.nil? || max_attempts <= 0
+      # $ctx.puts("Is aligned: #{is_aligned?(with, element)}")
+      timeout = 0
+      stale_retries = 0
+      begin
+        until is_aligned?(with, element) || timeout == max_attempts
+          # $ctx.puts("align roudn: #{timeout}")
+          w3c_attempt_align(with, speed_coef)
+          timeout += 1
+        end
+      rescue Selenium::WebDriver::Error::StaleElementReferenceError
+        # if boundElementsByIndex is enabled, we can get stale element reference while doing scroll each
+        stale_retries += 1
+        element = @locator.execute if @locator.instance_of?(TestaAppiumDriver::Locator)
+        retry if stale_retries < 2
+      end
+      # $ctx.puts("end align")
+    end
+
+    def w3c_attempt_align(with, speed_coef)
+      case with
+      when :top
+        y0 = @bounds.bottom_right.y - @deadzone[:bottom]
+        y1 = y0 - @align_offset
+        x0 = @bounds.width / 2
+        x1 = x0
+        scroll_direction = :down
+      when :bottom
+        y0 = @bounds.top_left.y + @deadzone[:top]
+        y1 = y0 + @align_offset
+        x0 = @bounds.width / 2
+        x1 = x0
+        scroll_direction = :up
+      when :left
+        x0 = @bounds.bottom_right.x - @deadzone[:right]
+        x1 = x0 - @align_offset
+        y0 = @bounds.height / 2
+        y1 = y0
+        scroll_direction = :right
+      when :right
+        x0 = @bounds.top_left.x + @deadzone[:top]
+        x1 = x0 + @align_offset
+        y0 = @bounds.height / 2
+        y1 = y0
+        scroll_direction = :left
+      else
+        raise "Unsupported align with option: #{with}"
+      end
+
+      x1, y1 = apply_w3c_correction(x1, y1, scroll_direction) if @driver.device == :android
+      w3c_action(x0, y0, x1, y1, SCROLL_ACTION_TYPE_SCROLL, speed_coef: speed_coef)
+    end
+
+    def w3c_scroll_to(direction)
+      rounds = 0
+      max_scrolls_reached = false
+      end_of_scroll_reached = false
+      # $ctx.puts("starting scroll to")
+      until (@driver.android? && @locator.exists?) ||
+        (@driver.ios? && @locator.exists? && @locator.in_viewport?) || end_of_scroll_reached
+        # $ctx.puts("Scroll to round: #{rounds}")
+        end_of_scroll_reached = is_end_of_scroll?
+        case direction
+        when :down
+          page_down
+        when :right
+          page_right
+        when :left
+          page_left
+        when :up
+          page_up
+        else
+          scroll_to_start
+          @previous_elements = nil
+          if @scrollable.scroll_orientation == :vertical
+            direction = :down
+          else
+            direction = :right
+          end
+        end
+
+        rounds += 1
+
+        max_scrolls_reached = true if rounds == @max_scrolls
+        break if rounds == @max_scrolls
+      end
+      # $ctx.puts("end scroll to")
+      raise Selenium::WebDriver::Error::NoSuchElementError if max_scrolls_reached || end_of_scroll_reached
+    end
+
+    def w3c_scroll_to_start_or_end(type)
+      default_deadzone!
+
+      @previous_elements = nil
+
+      if type == :start
+        if @scrollable.scroll_orientation == :vertical
+          method = "fling_up"
+        else
+          method = "fling_left"
+        end
+      else
+        if @scrollable.scroll_orientation == :vertical
+          method = "fling_down"
+        else
+          method = "fling_right"
+        end
+      end
+
+      iterations = 0
+      until is_end_of_scroll? || iterations >= 3
+        self.send(method)
+        iterations += 1
+      end
+
+      # reset the flag for end of scroll elements
+      @previous_elements = nil
+    end
+
+    def w3c_page_or_fling(type, direction)
+      default_deadzone!
+
+      if direction == :down || direction == :up
+        if direction == :down
+          y0 = @bounds.bottom_right.y - @deadzone[:bottom].to_i
+          y1 = @bounds.top_left.y + @deadzone[:top].to_i
+        else
+          y0 = @bounds.top_left.y + @deadzone[:top].to_i
+          y1 = @bounds.bottom_right.y - @deadzone[:bottom].to_i
+        end
+        x0 = @bounds.top_left.x + (@bounds.width - @deadzone[:left].to_i - @deadzone[:right].to_i) / 2
+        x0 = @bounds.top_left.x if x0 < @bounds.top_left.x
+        x0 = @bounds.bottom_right.x if x0 > @bounds.bottom_right.x
+        x1 = x0
+      else
+        if direction == :right
+          x0 = @bounds.bottom_right.x - @deadzone[:right].to_i
+          x1 = @bounds.top_left.x + @deadzone[:left].to_i
+        else
+          x0 = @bounds.top_left.x + @deadzone[:left].to_i
+          x1 = @bounds.bottom_right.x - @deadzone[:right].to_i
+        end
+
+        y0 = @bounds.top_left.y + (@bounds.height - @deadzone[:top].to_i - @deadzone[:bottom].to_i) / 2
+        y0 = @bounds.top_left.y if y0 < @bounds.top_left.y
+        y0 = @bounds.bottom_right.y if y0 > @bounds.bottom_right.y
+        y1 = y0
+      end
+      x1, y1 = apply_w3c_correction(x1, y1, direction) if @driver.device == :android
+
+      speed_coef = 1
+      speed_coef = 1.5 if type == SCROLL_ACTION_TYPE_SCROLL
+
+      w3c_action(x0, y0, x1, y1, type, speed_coef: speed_coef)
+    end
+
+    def w3c_action(x0, y0, x1, y1, type, speed_coef: 1.0)
+      speed_coef = 1 / speed_coef
+      if type == SCROLL_ACTION_TYPE_SCROLL
+        duration = 1.8 * speed_coef
+      elsif type == SCROLL_ACTION_TYPE_FLING
+        duration = 0.1 * speed_coef
+      elsif type == SCROLL_ACTION_TYPE_DRAG
+        duration = 3.5 * speed_coef
+      else
+        raise "Unknown scroll action type #{type}"
+      end
+
+      action_builder = @driver.action
+      f1 = action_builder.add_pointer_input(:touch, "finger1")
+      f1.create_pointer_move(duration: 0, x: x0, y: y0, origin: ::Selenium::WebDriver::Interactions::PointerMove::VIEWPORT)
+      f1.create_pointer_down(:left)
+
+      f1.create_pointer_move(duration: duration, x: x1, y: y1, origin: ::Selenium::WebDriver::Interactions::PointerMove::VIEWPORT)
+      unless type == SCROLL_ACTION_TYPE_FLING
+        # with this move we prevent flinging/overscroll
+        overscroll_pause = @driver.ios? ? 1 : 0.5
+        f1.create_pointer_move(duration: overscroll_pause, x: x1, y: y1, origin: ::Selenium::WebDriver::Interactions::PointerMove::VIEWPORT)
+      end
+      f1.create_pointer_up(:left)
+      puts "Scroll execute[w3c_action]:  #{type}: {x0: #{x0}, y0: #{y0}} => (duration: #{duration}) => {x1: #{x1}, y1: #{y1}}"
+      # $ctx.puts "Scroll execute[w3c_action]:  #{type}: {x0: #{x0}, y0: #{y0}} => (duration: #{duration}) => {x1: #{x1}, y1: #{y1}}"
+      @driver.perform_actions [f1]
+    end
+
+    def apply_w3c_correction(x1, y1, direction)
+      y1 -= SCROLL_CORRECTION_W3C if direction == :down
+      y1 += SCROLL_CORRECTION_W3C if direction == :up
+      x1 -= SCROLL_CORRECTION_W3C if direction == :right
+      x1 += SCROLL_CORRECTION_W3C if direction == :left
+      [x1, y1]
+    end
+
+    def w3c_drag_to(x0, y0, x1, y1)
+      w3c_action(x0, y0, x1, y1, SCROLL_ACTION_TYPE_DRAG)
+    end
+  end
+end

data/lib/testa_appium_driver/common/scroll_actions.rb

@@ -0,0 +1,275 @@
+require_relative 'scroll_actions/json_wire_scroll_actions'
+require_relative 'scroll_actions/w3c_scroll_actions'
+
+module ::TestaAppiumDriver
+
+  # Class for handling scroll actions
+  class ScrollActions
+    include W3cScrollActions
+    include JsonWireScrollActions
+
+    attr_accessor :locator
+    # @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]
+      # TODO: raise error if locator is for multiple, but not for scroll each, chekc other cases aswell
+      @deadzone = params[:deadzone]
+      @max_scrolls = params[:max_scrolls]
+      @default_scroll_strategy = params[:default_scroll_strategy]
+      @driver = @locator.driver
+
+      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, scroll_to_find, max_attempts)
+      w3c_align(with, scroll_to_find, max_attempts)
+      @locator
+    end
+
+    # @return [Array]
+    def scroll_each(&block)
+      w3c_scroll_each(nil, &block)
+    end
+
+    def scroll_each_down(&block)
+      w3c_scroll_each(:down, &block)
+    end
+
+    def scroll_each_up(&block)
+      w3c_scroll_each(:up, &block)
+    end
+
+    def scroll_each_right(&block)
+      w3c_scroll_each(:right, &block)
+    end
+
+    def scroll_each_left(&block)
+      w3c_scroll_each(:left, &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
+      w3c_scroll_to(:down)
+    end
+
+    def scroll_up_to
+      w3c_scroll_to(:up)
+    end
+
+    def scroll_right_to
+      w3c_scroll_to(:right)
+    end
+
+    def scroll_left_to
+      w3c_scroll_to(:left)
+    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)
+      b = @locator.bounds
+      coords = b.center
+      w3c_drag_to(coords.x, coords.y, x, y)
+    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
+
+
+
+    def is_end_of_scroll?
+      # if @driver.device == :android
+
+        old_elements = @previous_elements
+        @previous_elements = @scrollable.first_and_last_leaf
+
+
+        # $__.puts "old: #{old_elements}"
+        # $__.puts "new: #{@previous_elements}"
+        # $__.puts "end_of_scroll? #{     old_elements == @previous_elements}"
+        old_elements == @previous_elements
+      # else
+      #   # for ios, check location of first and last elements
+      #   old_elements = @previous_elements
+      #   @previous_elements = @scrollable.first_and_last_child&.map(&:location)
+      #   # $__.puts "old:"
+      #   # $__.puts old_elements
+      #   # $__.puts "prev:"
+      #   # $__.puts @previous_elements
+      #   old_elements == @previous_elements
+      # end
+    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
+
+  end
+end

data/lib/testa_appium_driver/common/selenium_element.rb

@@ -0,0 +1,19 @@
+module ::Appium
+  module Core
+    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