testa_appium_driver 0.1.0

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

@@ -0,0 +1,4 @@
+module TestaAppiumDriver
+  class ScrollActions
+  end
+end

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

@@ -0,0 +1,261 @@
+module TestaAppiumDriver
+  class ScrollActions
+
+    private
+    # @return [Array]
+    def w3c_each(skip_scroll_to_start, &block)
+      elements = []
+      begin
+        @driver.disable_wait_for_idle
+        @driver.disable_implicit_wait
+        default_deadzone!
+
+        iterations = 0
+
+
+        scroll_to_start unless skip_scroll_to_start
+
+        until is_end_of_scroll?
+          matches = @locator.execute(skip_cache: true)
+          matches.each_with_index do |m|
+            elements << m
+            if block_given? # block is given
+              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
+        end
+      rescue => e
+        raise e
+      ensure
+        @driver.enable_implicit_wait
+        @driver.enable_wait_for_idle
+      end
+      elements
+    end
+
+    def w3c_align(with)
+      @driver.disable_wait_for_idle
+      default_deadzone!
+
+
+
+      @locator.scroll_to unless @raise # called with !
+
+      element = @locator.execute
+      @driver.disable_implicit_wait
+
+      case with
+      when :top
+        page_down if is_aligned?(with, element)
+      when :bottom
+        page_up if is_aligned?(with, element)
+      when :right
+        page_right if is_aligned?(with, element)
+      when :left
+        page_left if is_aligned?(with, element)
+      else
+        raise "Unsupported align with option: #{with}"
+      end
+
+      timeout = 0
+      until is_aligned?(with, element) || timeout == 3
+        w3c_attempt_align(with)
+        timeout += 1
+      end
+
+      @driver.enable_implicit_wait
+      @driver.enable_wait_for_idle
+    end
+
+
+    def w3c_attempt_align(with)
+      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)
+    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)
+      @driver.disable_wait_for_idle
+      @driver.disable_implicit_wait
+      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
+
+      @driver.enable_implicit_wait
+      @driver.enable_wait_for_idle
+    end
+
+
+    def w3c_page_or_fling(type, direction)
+      @driver.disable_wait_for_idle
+      @driver.disable_implicit_wait
+      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.width / 2
+        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.height / 2
+        y1 = y0
+      end
+      x1, y1 = apply_w3c_correction(x1, y1, direction) if @driver.device == :android
+
+
+      w3c_action(x0, y0, x1, y1, type)
+
+      @driver.enable_implicit_wait
+      @driver.enable_wait_for_idle
+    end
+
+
+    def w3c_action(x0, y0, x1, y1, type)
+      if type == SCROLL_ACTION_TYPE_SCROLL
+        duration = 1.8
+      elsif type == SCROLL_ACTION_TYPE_FLING
+        duration = 0.1
+      elsif type == SCROLL_ACTION_TYPE_DRAG
+        duration = 3.5
+      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 drag_to(x, y)
+      x0 = @bounds.center.x
+      y0 = @bounds.center.y
+      w3c_action(x0, y0, x, y, SCROLL_ACTION_TYPE_DRAG)
+    end
+
+  end
+
+end

data/lib/testa_appium_driver/driver.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require_relative 'common/bounds'
+require_relative 'common/exceptions/strategy_mix_exception'
+require_relative 'common/helpers'
+require_relative 'common/locator'
+require_relative 'common/scroll_actions'
+
+module TestaAppiumDriver
+  class Driver
+    attr_accessor :driver
+    attr_reader :device
+    attr_reader :automation_name
+
+    # custom options
+    # - default_strategy: default strategy to be used for finding elements. Available strategies :uiautomator or :xpath
+    def initialize(opts = {})
+      @testa_opts = opts[:testa_appium_driver] || {}
+
+
+
+      core = Appium::Core.for(opts)
+      extend_for(core.device, core.automation_name)
+      @device = core.device
+      @automation_name = core.automation_name
+
+      handle_testa_opts
+
+      @driver = core.start_driver
+      invalidate_cache!
+
+
+
+      extend_element_with_driver(opts[:caps][:udid])
+    end
+
+
+    def invalidate_cache!
+      @cache = {
+          strategy: nil,
+          selector: nil,
+          element: nil,
+          from_element: nil,
+          time: Time.at(0)
+      }
+    end
+
+    #noinspection RubyClassVariableUsageInspection
+    def extend_element_with_driver(udid)
+      Selenium::WebDriver::Element.define_singleton_method(:set_driver) do |driver|
+        udid = "unknown" if udid.nil?
+        @@drivers ||={}
+        @@drivers[udid] = driver
+      end
+
+      Selenium::WebDriver::Element.set_driver(self)
+      Selenium::WebDriver::Element.define_method(:get_driver) do
+        udid = self.instance_variable_get(:@bridge).instance_variable_get(:@capabilities).instance_variable_get(:@capabilities)["udid"]
+        udid = "unknown" if udid.nil?
+        @@drivers[udid]
+      end
+    end
+
+
+    #noinspection RubyScope
+    # @param [TestaAppiumDriver::Locator, TestaAppiumDriver::Driver] from_element element from which start the search
+    # @param [String] selector resolved string of a [TestaAppiumDriver::Locator] selector xpath for xpath strategy, java UiSelectors for uiautomator
+    # @param [Boolean] single fetch single or multiple results
+    # @param [Symbol, nil] strategy [TestaAppiumDriver:FIND_STRATEGY_UIAUTOMATOR] or [FIND_STRATEGY_XPATH]
+    # @param [Symbol] default_strategy if strategy is not enforced, default can be used
+    # @param [Boolean] skip_cache to skip checking and storing cache
+    # @return [Selenium::WebDriver::Element, Array] element is returned if single is true, array otherwise
+    def execute(from_element, selector, single, strategy, default_strategy, skip_cache = false)
+
+      # if user wants to wait for element to exist, he can use wait_until_present
+      disable_wait_for_idle
+
+      # if not restricted to a strategy, use the default one
+      strategy = default_strategy if strategy.nil?
+
+      # resolve from_element unique id, so that we can cache it properly
+      from_element_id = from_element.kind_of?(TestaAppiumDriver::Locator) ? from_element.selector : nil
+
+      puts "Executing #{from_element_id ? "from #{from_element.strategy}: #{from_element.selector} => " : ""}#{strategy}: #{selector}"
+      begin
+        if @cache[:selector] != selector || # cache miss, selector is different
+            @cache[:time] + 5 <= Time.now || # cache miss, older than 5 seconds
+            @cache[:strategy] != strategy || # cache miss, different find strategy
+            @cache[:from_element_id] != from_element_id || # cache miss, search is started from different element
+            skip_cache # cache is skipped
+
+          if strategy == FIND_STRATEGY_UIAUTOMATOR
+            if single
+              execute_result = from_element.find_element(uiautomator: selector)
+            else
+              execute_result = from_element.find_elements(uiautomator: selector)
+            end
+
+          elsif strategy == FIND_STRATEGY_XPATH
+            if single
+              execute_result = from_element.find_element(xpath: selector)
+            else
+              execute_result = from_element.find_elements(xpath: selector)
+            end
+          else
+            raise "Unknown find_element strategy"
+          end
+
+          unless skip_cache
+            @cache[:selector] = selector
+            @cache[:strategy] = strategy
+            @cache[:time] = Time.now
+            @cache[:from_element_id] = from_element_id
+            @cache[:element] = execute_result
+          end
+        else
+          # this is a cache hit, use the element from cache
+          execute_result = @cache[:element]
+          puts "Using cache from #{@cache[:time].strftime("%H:%M:%S.%L")}, strategy: #{@cache[:strategy]}"
+        end
+      rescue => e
+        raise e
+      ensure
+        enable_wait_for_idle
+      end
+
+      execute_result
+    end
+
+
+    # method missing is used to forward methods to the actual appium driver
+    def method_missing(method, *args, &block)
+      @driver.send(method, *args, &block)
+    end
+
+    def disable_implicit_wait
+      @implicit_wait_ms = @driver.get_timeouts["implicit"]
+      @driver.manage.timeouts.implicit_wait = 0
+    end
+
+    def enable_implicit_wait
+      raise "Implicit wait is not disabled" if @implicit_wait_ms.nil?
+      # get_timeouts always returns in milliseconds, but we should set in seconds
+      @driver.manage.timeouts.implicit_wait = @implicit_wait_ms / 1000
+    end
+
+    def disable_wait_for_idle
+      if @device == :android
+        @wait_for_idle_timeout = @driver.settings.get["waitForIdleTimeout"]
+        @driver.update_settings({waitForIdleTimeout: 0})
+      end
+    end
+
+    def enable_wait_for_idle
+      if @device == :android
+        raise "Wait for idle is not disabled" if @wait_for_idle_timeout.nil?
+        @driver.update_settings({waitForIdleTimeout: @wait_for_idle_timeout})
+      end
+    end
+
+    def current_package
+      @driver.current_package
+    end
+
+    def window_size(*args)
+      @driver.window_size(*args)
+    end
+
+    def back
+      @driver.back
+    end
+
+
+    def is_keyboard_shown?
+      @driver.is_keyboard_shown
+    end
+
+    def hide_keyboard
+      @driver.hide_keyboard
+    end
+
+    def press_keycode(code)
+      @driver.press_keycode(code)
+    end
+
+    def long_press_keycode(code)
+      @driver.long_press_keycode(code)
+    end
+
+
+    def first_and_last_leaf(from_element = @driver)
+      disable_wait_for_idle
+      disable_implicit_wait
+      elements = from_element.find_elements(xpath: "//*[not(*)]")
+      enable_implicit_wait
+      enable_wait_for_idle
+      return nil if elements.count == 0
+      [elements[0], elements[-1]]
+    end
+
+    private
+    def extend_for(device, automation_name)
+      case device
+      when :android
+        case automation_name
+        when :uiautomator2
+          require_relative 'android/driver'
+        else
+          raise "Testa appium driver not supported for #{automation_name} automation"
+        end
+      when :ios, :tvos
+        case automation_name
+        when :xcuitest
+          require_relative 'ios/driver'
+        else
+          raise "Testa appium driver not supported for #{automation_name} automation"
+        end
+      else
+        raise "Unknown device #{device}, should be either android, ios or tvos"
+      end
+    end
+
+
+  end
+
+end