testa_appium_driver 0.1.18 → 0.1.20

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

@@ -1,305 +0,0 @@
-module ::TestaAppiumDriver
-  module W3cScrollActions
-
-
-    # @return [Array]
-    def w3c_scroll_each(direction, &block)
-      elements = []
-      begin
-        default_deadzone!
-
-        iterations = 0
-
-
-        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
-
-
-
-        ignore_element_ids = []
-        previous_element = nil
-
-        until is_end_of_scroll?
-          aligned_items = 0
-          new_ignore_element_ids = []
-          matches = @locator.execute(skip_cache: true)
-          matches.each_with_index do |m, index|
-            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)
-            if !is_aligned && !previous_element.nil?
-              new_ignore_element_ids << previous_element.id
-            end
-
-            if is_aligned
-              aligned_items += 1
-            end
-
-            if matches.count == index + 1
-              new_ignore_element_ids << m.id
-            end
-
-            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 == 0
-            self.send("page_#{direction}")
-          else
-            ignore_element_ids = new_ignore_element_ids.dup
-          end
-
-
-
-        end
-      rescue => 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
-
-      timeout = 0
-      until is_aligned?(with, element) || timeout == max_attempts
-        w3c_attempt_align(with, speed_coef)
-        timeout += 1
-      end
-
-    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
-      until @locator.exists? || end_of_scroll_reached
-        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
-      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
-      if type == SCROLL_ACTION_TYPE_SCROLL
-        speed_coef = 1.5
-      end
-
-      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
-        f1.create_pointer_move(duration: 0.5, 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}} => {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

@@ -1,267 +0,0 @@
-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(x0, y0, x1, y1)
-      w3c_drag_to(x0, y0, x1, y1)
-    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
-        # $__ctx.puts "end_of_scroll?"
-        # $__ctx.puts "old: #{@previous_elements}"
-        # $__ctx.puts "device: #{@driver.device}"
-
-        old_elements = @previous_elements
-        @previous_elements = @scrollable.first_and_last_leaf
-        # $__ctx.puts "new: #{@previous_elements}"
-
-        old_elements == @previous_elements
-      else
-        # for is, check location of first and last elements
-        old_elements = @previous_elements
-        @previous_elements = @scrollable.first_and_last_child&.map(&:location)
-        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

@@ -1,19 +0,0 @@
-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