testa_appium_driver 0.1.0

data/lib/testa_appium_driver/android/driver.rb

@@ -0,0 +1,52 @@
+require_relative 'class_selectors'
+require_relative 'locator'
+require_relative 'scroll_actions/uiautomator_scroll_actions'
+require_relative 'selenium_element'
+
+module TestaAppiumDriver
+  class Driver
+    include ClassSelectors
+
+
+    # @param [String] command Shell command name to execute for example echo or rm
+    # @param [Array<String>] args Array of command arguments, example: ['-f', '/sdcard/my_file.txt']
+    # @param [Integer] timeout Command timeout in milliseconds. If the command blocks for longer than this timeout then an exception is going to be thrown. The default timeout is 20000 ms
+    # @param [Boolean] includeStderr 	Whether to include stderr stream into the returned result.
+    #noinspection RubyParameterNamingConvention
+    def shell(command, args: nil, timeout: nil, includeStderr: true)
+      params = {
+          command: command,
+          includeStderr: includeStderr
+      }
+      params[:args] = args unless args.nil?
+      params[:timeout] = timeout unless timeout.nil?
+      @driver.execute_script("mobile: shell", params)
+    end
+
+
+    def handle_testa_opts
+      if @testa_opts[:default_find_strategy].nil?
+        @default_find_strategy = DEFAULT_ANDROID_FIND_STRATEGY
+      else
+        case @testa_opts[:default_find_strategy].to_sym
+        when FIND_STRATEGY_UIAUTOMATOR, FIND_STRATEGY_XPATH
+          @default_find_strategy = @testa_opts[:default_find_strategy].to_sym
+        else
+          raise "Default find strategy #{@testa_opts[:default_find_strategy]} not supported for Android"
+        end
+      end
+
+
+      if @testa_opts[:default_scroll_strategy].nil?
+        @default_scroll_strategy = DEFAULT_ANDROID_SCROLL_STRATEGY
+      else
+        case @testa_opts[:default_scroll_strategy].to_sym
+        when SCROLL_STRATEGY_W3C, SCROLL_STRATEGY_UIAUTOMATOR
+          @default_scroll_strategy = @testa_opts[:default_scroll_strategy].to_sym
+        else
+          raise "Default scroll strategy #{@testa_opts[:default_scroll_strategy]} not supported for Android"
+        end
+      end
+    end
+  end
+end

data/lib/testa_appium_driver/android/locator.rb

@@ -0,0 +1,115 @@
+require_relative 'locator/attributes'
+
+module TestaAppiumDriver
+  #noinspection RubyTooManyInstanceVariablesInspection
+  class Locator
+    attr_accessor :closing_parenthesis
+    include ClassSelectors
+
+    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
+        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 selector
+      if (@strategy.nil? && @default_find_strategy == FIND_STRATEGY_UIAUTOMATOR) || @strategy == FIND_STRATEGY_UIAUTOMATOR
+        ui_selector
+      elsif (@strategy.nil? && @default_find_strategy == FIND_STRATEGY_XPATH) || @strategy == FIND_STRATEGY_XPATH
+        @xpath_selector
+      end
+    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] existing 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
+      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)
+      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 = self
+        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
+  end
+end

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

@@ -0,0 +1,116 @@
+module TestaAppiumDriver
+  module AndroidAttributeModule
+
+    #noinspection RubyNilAnalysis
+    def attribute(name, *args)
+      elements = execute(*args)
+
+      @driver = get_driver if self.instance_of?(Selenium::WebDriver::Element)
+
+      @driver.disable_wait_for_idle
+      if elements.kind_of?(Selenium::WebDriver::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
+      @driver.enable_wait_for_idle
+      r
+    end
+
+    def text(*args)
+      attribute("text", *args)
+    end
+
+    def package(*args)
+      attribute("package", *args)
+    end
+
+    def class_name(*args)
+      attribute("className", *args)
+    end
+
+    def checkable?(*args)
+      attribute("checkable", *args).to_s == "true"
+    end
+
+    def checked?(*args)
+      attribute("checked", *args).to_s == "true"
+    end
+
+    def clickable?(*args)
+      attribute("clickable", *args).to_s == "true"
+    end
+
+    def desc(*args)
+      attribute("contentDescription", *args)
+    end
+
+    def enabled?(*args)
+      attribute("enabled", *args).to_s == "true"
+    end
+
+    def focusable?(*args)
+      attribute("focusable", *args).to_s == "true"
+    end
+
+    def focused?(*args)
+      attribute("focused", *args).to_s == "true"
+    end
+
+    def long_clickable?(*args)
+      attribute("longClickable", *args).to_s == "true"
+    end
+
+    def password(*args)
+      attribute("password", *args)
+    end
+
+    def id(*args)
+      attribute("resourceId", *args)
+    end
+
+    def scrollable?(*args)
+      attribute("scrollable", *args).to_s == "true"
+    end
+
+    def selected?(*args)
+      attribute("selected", *args).to_s == "true"
+    end
+
+    def displayed?(*args)
+      attribute("displayed", *args).to_s == "true"
+    end
+
+    def selection_start(*args)
+      attribute("selection-start", *args)
+    end
+
+    def selection_end(*args)
+      attribute("selection-end", *args)
+    end
+
+    def bounds(*args)
+      attribute("bounds", *args)
+    end
+
+  end
+
+  class Locator
+    include TestaAppiumDriver::AndroidAttributeModule
+
+
+    # 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
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+module TestaAppiumDriver
+  #noinspection RubyInstanceMethodNamingConvention
+  class ScrollActions
+    private
+
+    def uiautomator_scroll_to_start_or_end(type)
+      @driver.disable_wait_for_idle
+      @driver.disable_implicit_wait
+
+      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
+
+
+      @driver.enable_implicit_wait
+      @driver.enable_wait_for_idle
+    end
+
+
+    def uiautomator_scroll_to
+      raise "UiAutomator scroll cannot work with specified direction" unless @direction.nil?
+
+
+      @driver.disable_wait_for_idle
+      @driver.disable_implicit_wait
+
+      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
+        @driver.enable_implicit_wait
+        @driver.enable_wait_for_idle
+      end
+    end
+
+
+    def uiautomator_page_or_fling(type, direction)
+      @driver.disable_wait_for_idle
+      @driver.disable_implicit_wait
+
+      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
+      @driver.enable_implicit_wait
+      @driver.enable_wait_for_idle
+    end
+
+
+  end
+
+end

data/lib/testa_appium_driver/android/selenium_element.rb

@@ -0,0 +1,8 @@
+module Selenium
+  module WebDriver
+    class Element
+      include TestaAppiumDriver::ClassSelectors
+      include TestaAppiumDriver::AndroidAttributeModule
+    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