testa_appium_driver 0.1.21 → 0.1.22

data/lib/testa_appium_driver/android/locator/attributes.rb

@@ -0,0 +1,115 @@
+module TestaAppiumDriver
+  module Attributes
+
+    #noinspection RubyNilAnalysis
+    def testa_attribute(name, *args)
+      if self.instance_of?(::Selenium::WebDriver::Element) || self.instance_of?(::Appium::Core::Element)
+        @driver = get_driver # does not get correct driver
+        elements = self
+      else
+        elements = execute(*args)
+        raise "Element not found" if elements.nil?
+      end
+      
+      if elements.kind_of?(::Selenium::WebDriver::Element) || elements.kind_of?(::Appium::Core::Element)
+        r = elements.send(:attribute, name.to_s)
+        r = TestaAppiumDriver::Bounds.from_android(r, @driver) if name.to_s == "bounds"
+      else
+        r = elements.map { |e| e.send(:attribute, name.to_s) }
+        r.map! { |b| TestaAppiumDriver::Bounds.from_android(b, @driver) } if name.to_s == "bounds"
+      end
+      r
+    end
+
+    def text(*args)
+      testa_attribute("text", *args)
+    end
+
+    def package(*args)
+      testa_attribute("package", *args)
+    end
+
+    def class_name(*args)
+      testa_attribute("className", *args)
+    end
+
+    def checkable?(*args)
+      testa_attribute("checkable", *args).to_s == "true"
+    end
+
+    def checked?(*args)
+      testa_attribute("checked", *args).to_s == "true"
+    end
+
+    def clickable?(*args)
+      testa_attribute("clickable", *args).to_s == "true"
+    end
+
+    def desc(*args)
+      testa_attribute("contentDescription", *args)
+    end
+
+    def enabled?(*args)
+      testa_attribute("enabled", *args).to_s == "true"
+    end
+
+    def focusable?(*args)
+      testa_attribute("focusable", *args).to_s == "true"
+    end
+
+    def focused?(*args)
+      testa_attribute("focused", *args).to_s == "true"
+    end
+
+    def long_clickable?(*args)
+      testa_attribute("longClickable", *args).to_s == "true"
+    end
+
+    def password?(*args)
+      testa_attribute("password", *args).to_s == "true"
+    end
+
+    def id(*args)
+      testa_attribute("resourceId", *args)
+    end
+
+    def scrollable?(*args)
+      testa_attribute("scrollable", *args).to_s == "true"
+    end
+
+    def selected?(*args)
+      testa_attribute("selected", *args).to_s == "true"
+    end
+
+    def displayed?(*args)
+      testa_attribute("displayed", *args).to_s == "true"
+    end
+
+    def selection_start(*args)
+      testa_attribute("selection-start", *args)
+    end
+
+    def selection_end(*args)
+      testa_attribute("selection-end", *args)
+    end
+
+    def bounds(*args)
+      testa_attribute("bounds", *args)
+    end
+  end
+
+  class Locator
+
+    # element index in parent element, starts from 0
+    #noinspection RubyNilAnalysis,RubyYardReturnMatch
+    # @return [Integer, nil] index of element
+    def index(*args)
+      raise "Index not supported for uiautomator strategy" if @strategy == FIND_STRATEGY_UIAUTOMATOR
+      this = execute(*args)
+      children = self.dup.parent.children.execute
+      index = children.index(this)
+      raise "Index not found" if index.nil?
+      index.to_i
+    end
+  end
+end

data/lib/testa_appium_driver/android/locator.rb

@@ -0,0 +1,142 @@
+require_relative 'locator/attributes'
+
+module TestaAppiumDriver
+  #noinspection RubyTooManyInstanceVariablesInspection
+  class Locator
+    attr_accessor :closing_parenthesis
+    include ClassSelectors
+    include Attributes
+
+    def init(params, selectors, single)
+      @closing_parenthesis = 0
+
+
+      @ui_selector = hash_to_uiautomator(selectors, single)
+
+      if is_scrollable_selector?(selectors, single)
+        if selectors[:class] == "android.widget.HorizontalScrollView"
+          @scroll_orientation = :horizontal
+        else
+          @scroll_orientation = :vertical
+        end
+
+        if !params[:top].nil? || !params[:bottom].nil? || !params[:right].nil? || !params[:left].nil?
+          @scroll_deadzone = {}
+          @scroll_deadzone[:top] = params[:top].to_f unless params[:top].nil?
+          @scroll_deadzone[:bottom] = params[:bottom].to_f unless params[:bottom].nil?
+          @scroll_deadzone[:right] = params[:right].to_f unless params[:right].nil?
+          @scroll_deadzone[:left] = params[:left].to_f unless params[:left].nil?
+        end
+
+        params[:scrollable_locator] = self.dup
+      end
+
+      @scrollable_locator = params[:scrollable_locator] if params[:scrollable_locator]
+    end
+
+
+    # resolve selector which will be used for finding element
+    def strategies_and_selectors
+      ss = []
+      if @can_use_id_strategy
+        ss.push({"#{FIND_STRATEGY_ID}": @can_use_id_strategy})
+      end
+      if @strategy.nil? || @strategy == FIND_STRATEGY_UIAUTOMATOR
+        ss.push({"#{FIND_STRATEGY_UIAUTOMATOR}": ui_selector})
+      end
+
+      if @strategy.nil? || @strategy == FIND_STRATEGY_XPATH
+        ss.push({"#{FIND_STRATEGY_XPATH}": @xpath_selector})
+      end
+
+      if @strategy == FIND_STRATEGY_IMAGE
+        ss.push({"#{FIND_STRATEGY_IMAGE}": @image_selector})
+      end
+      ss
+    end
+
+
+    # @param [Boolean] include_semicolon should the semicolon be included at the end
+    # @return ui_selector for uiautomator find strategy
+    def ui_selector(include_semicolon = true)
+      @ui_selector + ")" * @closing_parenthesis + (include_semicolon ? ";" : "");
+    end
+
+    def ui_selector=(value)
+      @ui_selector = value
+    end
+
+
+
+
+    # @return [TestaAppiumDriver::Locator]
+    def from_parent(selectors = {})
+      raise "Cannot add from_parent selector to array" unless @single
+      raise StrategyMixException.new(@strategy, @strategy_reason, FIND_STRATEGY_UIAUTOMATOR, "from_parent") if @strategy != FIND_STRATEGY_UIAUTOMATOR
+
+      locator = self.dup
+      locator.strategy = FIND_STRATEGY_UIAUTOMATOR
+      locator.strategy_reason = "from_parent"
+      locator.closing_parenthesis += 1
+      locator.ui_selector = "#{locator.ui_selector}.fromParent(#{hash_to_uiautomator(selectors)}"
+      locator
+    end
+
+
+    # @return [Locator] new child locator element
+    def add_child_selector(params)
+      params, selectors = extract_selectors_from_params(params)
+      single = params[:single]
+      raise "Cannot add child selector to Array" if single && !@single
+
+      locator = self.dup
+      locator.can_use_id_strategy = false
+      if (@strategy.nil? && !single) || @strategy == FIND_STRATEGY_XPATH
+        locator.strategy = FIND_STRATEGY_XPATH
+        locator.strategy_reason = "multiple child selector"
+        add_xpath_child_selectors(locator, selectors, single)
+      elsif @strategy == FIND_STRATEGY_UIAUTOMATOR
+        locator = add_uiautomator_child_selector(locator, selectors, single)
+      elsif @strategy == FIND_STRATEGY_IMAGE
+        locator = add_image_child_selector(locator, selectors, single)
+      else
+        # both paths are valid
+        add_xpath_child_selectors(locator, selectors, single)
+        locator = add_uiautomator_child_selector(locator, selectors, single)
+      end
+
+      if is_scrollable_selector?(selectors, single)
+        locator.scrollable_locator = locator
+        if selectors[:class] == "android.widget.HorizontalScrollView"
+          locator.scrollable_locator.scroll_orientation = :horizontal
+        else
+          locator.scrollable_locator.scroll_orientation = :vertical
+        end
+      end
+
+      locator.last_selector_adjacent = false
+      locator
+    end
+
+
+    private
+    def add_uiautomator_child_selector(locator, selectors, single)
+      if locator.single && !single
+        # current locator stays single, the child locator looks for multiple
+        params = selectors.merge({single: single, scrollable_locator: locator.scrollable_locator})
+        params[:default_find_strategy] = locator.default_find_strategy
+        params[:default_scroll_strategy] = locator.default_scroll_strategy
+        Locator.new(@driver, self, params)
+      else
+        locator.single = true
+        locator.ui_selector = "#{locator.ui_selector(false)}.childSelector(#{hash_to_uiautomator(selectors, single)})"
+        locator
+      end
+    end
+
+    def add_image_child_selector(locator, selectors, single)
+      params = selectors.merge({single: single, scrollable_locator: locator.scrollable_locator})
+      Locator.new(@driver, self, params)
+    end
+  end
+end

data/lib/testa_appium_driver/android/scroll_actions/uiautomator_scroll_actions.rb

@@ -0,0 +1,62 @@
+module TestaAppiumDriver
+  #noinspection RubyInstanceMethodNamingConvention
+  class ScrollActions
+    private
+
+    def uiautomator_scroll_to_start_or_end(type)
+
+      scrollable_selector = @scrollable.ui_selector(false)
+      orientation = @scrollable.scroll_orientation == :vertical ? ".setAsVerticalList()" : ".setAsHorizontalList()"
+      scroll_command = type == :start ? ".scrollToBeginning(#{DEFAULT_UIAUTOMATOR_MAX_SWIPES})" : ".scrollToEnd(#{DEFAULT_UIAUTOMATOR_MAX_SWIPES})"
+      cmd = "new UiScrollable(#{scrollable_selector})#{orientation}#{scroll_command};"
+      begin
+        puts "Scroll execute[uiautomator_#{type}]: #{cmd}"
+        @driver.find_element(uiautomator: cmd)
+      rescue
+        # Ignored
+      end
+
+
+    end
+
+
+    def uiautomator_scroll_to
+      raise "UiAutomator scroll cannot work with specified direction" unless @direction.nil?
+
+      scrollable_selector = @scrollable.ui_selector(false)
+      element_selector = @locator.ui_selector(false)
+      orientation_command = @scrollable.scroll_orientation == :vertical ? ".setAsVerticalList()" : ".setAsHorizontalList()"
+      cmd = "new UiScrollable(#{scrollable_selector})#{orientation_command}.scrollIntoView(#{element_selector});"
+      begin
+        puts "Scroll execute[uiautomator_scroll_to]: #{cmd}"
+        @driver.find_element(uiautomator: cmd)
+      rescue
+        # Ignored
+      ensure
+      end
+    end
+
+
+    def uiautomator_page_or_fling(type, direction)
+      scrollable_selector = @scrollable.ui_selector(false)
+      orientation = direction == :up || direction == :down ? ".setAsVerticalList()" : ".setAsHorizontalList()"
+      if type == SCROLL_ACTION_TYPE_SCROLL
+        direction_command = direction == :down || direction == :right ? ".scrollForward()" : ".scrollBackward()"
+      elsif type == SCROLL_ACTION_TYPE_FLING
+        direction_command = direction == :down || direction == :right ? ".flingForward()" : ".flingBackward()"
+      else
+        raise "Unknown scroll action type #{type}"
+      end
+      cmd = "new UiScrollable(#{scrollable_selector})#{orientation}#{direction_command};"
+      begin
+        puts "Scroll execute[uiautomator_#{type}]: #{cmd}"
+        @driver.find_element(uiautomator: cmd)
+      rescue
+        # Ignored
+      end
+    end
+
+
+  end
+
+end

data/lib/testa_appium_driver/android/selenium_element.rb

@@ -0,0 +1,12 @@
+module ::Appium
+  module Core
+    class Element
+      include TestaAppiumDriver::ClassSelectors
+      include TestaAppiumDriver::Attributes
+
+      def parent
+        self.find_element(xpath: "./..")
+      end
+    end
+  end
+end

data/lib/testa_appium_driver/common/bounds.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require 'json'
+module TestaAppiumDriver
+  class Bounds
+
+    attr_reader :width
+    attr_reader :height
+    attr_reader :offset
+
+
+    # @param top_left [Coordinates]
+    # @param bottom_right [Coordinates]
+    # @param window_width [Integer]
+    # @param window_height [Integer]
+    def initialize(top_left, bottom_right, window_width, window_height)
+      @top_left = top_left
+      @bottom_right = bottom_right
+      @width = bottom_right.x - top_left.x
+      @height = bottom_right.y - top_left.y
+      @offset = Offset.new(self, window_width, window_height)
+      @center = TestaAppiumDriver::Coordinates.new(@top_left.x + @width/2, @top_left.y + @height / 2)
+    end
+
+    def as_json
+      {
+        width: @width,
+        height: @height,
+        top_left: @top_left.as_json,
+        bottom_right: @bottom_right.as_json,
+        offset: @offset.as_json
+      }
+    end
+
+    # @return [TestaAppiumDriver::Offset]
+    def offset
+      @offset
+    end
+
+    # @return [TestaAppiumDriver::Coordinates]
+    def top_left
+      @top_left
+    end
+    # @return [TestaAppiumDriver::Coordinates]
+    def bottom_right
+      @bottom_right
+    end
+
+    # @return [TestaAppiumDriver::Coordinates]
+    def center
+      @center
+    end
+
+    def to_s
+      JSON.dump(as_json)
+    end
+
+    # @param bounds [String] bounds that driver.attribute("bounds") return
+    # @param driver [TestaAppiumDriver::Driver]
+    def self.from_android(bounds, driver)
+      matches = bounds.match(/\[(\d+),(\d+)\]\[(\d+),(\d+)\]/)
+      raise "Unexpected bounds: #{bounds}" unless matches
+
+      captures = matches.captures
+      top_left = Coordinates.new(captures[0], captures[1])
+      bottom_right = Coordinates.new(captures[2], captures[3])
+      ws = driver.window_size
+      window_width = ws.width.to_i
+      window_height = ws.height.to_i
+      Bounds.new(top_left, bottom_right, window_width, window_height)
+    end
+
+    def self.from_ios(rect, driver)
+      rect = JSON.parse(rect)
+      top_left = Coordinates.new(rect["x"], rect["y"])
+      bottom_right = Coordinates.new(top_left.x + rect["width"].to_i, top_left.y + rect["height"].to_i)
+      ws = driver.window_size
+      window_width = ws.width.to_i
+      window_height = ws.height.to_i
+      Bounds.new(top_left, bottom_right, window_width, window_height)
+    end
+  end
+
+  #noinspection ALL
+  class Coordinates
+    def initialize(x, y)
+      @x = x.to_i
+      @y = y.to_i
+    end
+
+    def as_json
+      {
+        x: @x,
+        y: @y
+      }
+    end
+
+
+    # @return [Integer]
+    def x
+      @x
+    end
+
+    # @return [Integer]
+    def y
+      @y
+    end
+  end
+
+
+  class Offset
+    def initialize(bounds, window_width, window_height)
+      @top = bounds.top_left.y
+      @right = window_width - bounds.bottom_right.x
+      @bottom = window_height - bounds.bottom_right.y
+      @left = bounds.top_left.x
+    end
+
+    def as_json
+      {
+        top: @top,
+        right: @right,
+        bottom: @bottom,
+        left: @left
+      }
+    end
+
+
+    # @return [Integer]
+    def top
+      @top
+    end
+
+    # @return [Integer]
+    def right
+      @right
+    end
+
+    # @return [Integer]
+    def bottom
+      @bottom
+    end
+
+    # @return [Integer]
+    def left
+      @left
+    end
+
+  end
+end

data/lib/testa_appium_driver/common/constants.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+#noinspection ALL
+module TestaAppiumDriver
+  FIND_STRATEGY_UIAUTOMATOR = :uiautomator
+  FIND_STRATEGY_XPATH = :xpath
+  FIND_STRATEGY_ID = :id
+  FIND_STRATEGY_NAME = :name
+  FIND_STRATEGY_IMAGE = :image
+  FIND_STRATEGY_CLASS_CHAIN = :class_chain
+
+  SCROLL_STRATEGY_UIAUTOMATOR = :uiautomator
+  SCROLL_STRATEGY_W3C = :w3c
+
+
+  SCROLL_CORRECTION_W3C = 30
+  SCROLL_ALIGNMENT_THRESHOLD = 25
+
+  SCROLL_ACTION_TYPE_SCROLL = :scroll
+  SCROLL_ACTION_TYPE_FLING = :fling
+  SCROLL_ACTION_TYPE_DRAG = :drag
+
+
+  DEFAULT_UIAUTOMATOR_MAX_SWIPES = 20
+
+  DEFAULT_ANDROID_FIND_STRATEGY = FIND_STRATEGY_UIAUTOMATOR
+  #DEFAULT_ANDROID_SCROLL_STRATEGY = SCROLL_STRATEGY_UIAUTOMATOR
+  DEFAULT_ANDROID_SCROLL_STRATEGY = SCROLL_STRATEGY_W3C
+
+
+  DEFAULT_IOS_FIND_STRATEGY = FIND_STRATEGY_XPATH
+  DEFAULT_IOS_SCROLL_STRATEGY = SCROLL_STRATEGY_W3C
+
+  DEFAULT_W3C_MAX_SCROLLS = 7
+
+  EXISTS_WAIT = 0.5
+  LONG_TAP_DURATION = 1.5
+end

data/lib/testa_appium_driver/common/exceptions/strategy_mix_exception.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module TestaAppiumDriver
+  class StrategyMixException < Exception
+    def initialize(strategy, strategy_reason, mixed_strategy, mixed_reason)
+
+      # example: parent is only available in xpath strategy and cannot be used with from_element which is only available in uiautomator strategy
+      msg = "strategy mix exception: '#{strategy_reason}' is only available in #{strategy} strategy and cannot be used with '#{mixed_reason}' which is only available in #{mixed_strategy} strategy"
+      super(msg)
+    end
+  end
+end