testa_appium_driver 0.1.5 → 0.1.9

data/lib/testa_appium_driver/driver.rb

@@ -29,7 +29,6 @@ module TestaAppiumDriver
     def initialize(opts = {})
       @testa_opts = opts[:testa_appium_driver] || {}
 
-
       core = Appium::Core.for(opts)
       extend_for(core.device, core.automation_name)
       @device = core.device
@@ -41,6 +40,9 @@ module TestaAppiumDriver
       invalidate_cache
 
 
+      disable_wait_for_idle
+      disable_implicit_wait
+
       Selenium::WebDriver::Element.set_driver(self, opts[:caps][:udid])
     end
 
@@ -63,42 +65,55 @@ module TestaAppiumDriver
     # Cache stores last executed find_element with given selector, strategy and from_element. If given values are the same within
     # last 5 seconds element is retrieved from cache.
     # @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 or id for ID strategy
     # @param [Boolean] single fetch single or multiple results
-    # @param [Symbol, nil] strategy [TestaAppiumDriver::FIND_STRATEGY_UIAUTOMATOR], [TestaAppiumDriver::FIND_STRATEGY_XPATH] or [TestaAppiumDriver::FIND_STRATEGY_ID]
-    # @param [Symbol] default_strategy if strategy is not enforced, default can be used
+    # @param [Array<Hash>] strategies_and_selectors array of usable strategies and selectors
     # @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)
+    def execute(from_element, single, strategies_and_selectors, skip_cache: false, ignore_implicit_wait: false)
 
       # if user wants to wait for element to exist, he can use wait_until_present
-      disable_wait_for_idle
+      start_time = Time.now.to_f
+      ss_index = 0
+
 
 
-      # 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.strategy_and_selector[1] : nil
+      from_element_id = from_element.instance_of?(TestaAppiumDriver::Locator) ? from_element.strategies_and_selectors : nil
 
-      puts "Executing #{from_element_id ? "from #{from_element.strategy}: #{from_element.strategy_and_selector} => " : ""}#{strategy}: #{selector}"
       begin
-        if @cache[:selector] != selector || # cache miss, selector is different
+        ss = strategies_and_selectors[ss_index % strategies_and_selectors.count]
+        ss_index +=1
+
+        puts "Executing #{from_element_id ? "from #{from_element.strategy}: #{from_element.strategies_and_selectors} => " : ""}#{ss.keys[0]}: #{ss.values[0]}"
+
+        if @cache[:selector] != ss.values[0] || # 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[:strategy] != ss.keys[0] || # 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 single
-            execute_result = from_element.find_element("#{strategy}": selector)
+          if ss.keys[0] == FIND_STRATEGY_IMAGE
+            set_find_by_image_settings(ss.values[0].dup)
+            if single
+              execute_result = from_element.find_element_by_image(ss.values[0][:image])
+            else
+              execute_result = from_element.find_elements_by_image(ss.values[0][:image])
+            end
+            restore_set_by_image_settings
           else
-            execute_result = from_element.find_elements("#{strategy}": selector)
+            if single
+              execute_result = from_element.find_element(ss)
+            else
+              execute_result = from_element.find_elements(ss)
+            end
           end
 
 
+
           unless skip_cache
-            @cache[:selector] = selector
-            @cache[:strategy] = strategy
+            @cache[:selector] = ss.values[0]
+            @cache[:strategy] = ss.keys[0]
             @cache[:time] = Time.now
             @cache[:from_element_id] = from_element_id
             @cache[:element] = execute_result
@@ -109,9 +124,13 @@ module TestaAppiumDriver
           puts "Using cache from #{@cache[:time].strftime("%H:%M:%S.%L")}, strategy: #{@cache[:strategy]}"
         end
       rescue => e
-        raise e
-      ensure
-        enable_wait_for_idle
+        #if (start_time + @implicit_wait_ms/1000 < Time.now.to_f && !ignore_implicit_wait) || ss_index < strategies_and_selectors.count
+        if ss_index < strategies_and_selectors.count
+          sleep EXISTS_WAIT if ss_index >= strategies_and_selectors.count
+          retry
+        else
+          raise e
+        end
       end
 
       execute_result
@@ -128,31 +147,42 @@ module TestaAppiumDriver
 
     # disables implicit wait
     def disable_implicit_wait
-      @implicit_wait_ms = @driver.get_timeouts["implicit"]
-      @driver.manage.timeouts.implicit_wait = 0
+        @implicit_wait_ms = @driver.get_timeouts["implicit"].to_i
+        @implicit_wait_ms = @implicit_wait_ms/1000 if @implicit_wait_ms > 100000
+        @implicit_wait_uiautomator_ms = @driver.get_settings["waitForSelectorTimeout"]
+        @driver.manage.timeouts.implicit_wait = 0
+        @driver.update_settings({waitForSelectorTimeout: 1})
     end
 
-    # enables implicit wait, can be called only after disabling implicit wait
-    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
 
     # disables wait for idle, only executed for android devices
     def disable_wait_for_idle
       if @device == :android
         @wait_for_idle_timeout = @driver.settings.get["waitForIdleTimeout"]
-        @driver.update_settings({waitForIdleTimeout: 0})
+        @driver.update_settings({waitForIdleTimeout: 1})
       end
     end
 
-    # enables wait for idle, only executed for android devices
-    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
+
+    def set_find_by_image_settings(settings)
+      settings.delete(:image)
+      @default_find_image_settings = {}
+      old_settings = @driver.get_settings
+      @default_find_image_settings[:imageMatchThreshold] = old_settings["imageMatchThreshold"]
+      @default_find_image_settings[:fixImageFindScreenshotDims] = old_settings["fixImageFindScreenshotDims"]
+      @default_find_image_settings[:fixImageTemplateSize] = old_settings["fixImageTemplateSize"]
+      @default_find_image_settings[:fixImageTemplateScale] = old_settings["fixImageTemplateScale"]
+      @default_find_image_settings[:defaultImageTemplateScale] = old_settings["defaultImageTemplateScale"]
+      @default_find_image_settings[:checkForImageElementStaleness] = old_settings["checkForImageElementStaleness"]
+      @default_find_image_settings[:autoUpdateImageElementPosition] = old_settings["autoUpdateImageElementPosition"]
+      @default_find_image_settings[:imageElementTapStrategy] = old_settings["imageElementTapStrategy"]
+      @default_find_image_settings[:getMatchedImageResult] = old_settings["getMatchedImageResult"]
+
+      @driver.update_settings(settings)
+    end
+
+    def restore_set_by_image_settings
+      @driver.update_settings(@default_find_image_settings) if @default_find_image_settings
     end
 
 
@@ -179,6 +209,30 @@ module TestaAppiumDriver
       @driver.hide_keyboard
     end
 
+    def tab_key
+      @driver.press_keycode(61)
+    end
+
+    def dpad_up_key
+      @driver.press_keycode(19)
+    end
+
+    def dpad_down_key
+      @driver.press_keycode(20)
+    end
+
+    def dpad_right_key
+      @driver.press_keycode(22)
+    end
+
+    def dpad_left_key
+      @driver.press_keycode(23)
+    end
+
+    def enter_key
+      @driver.press_keycode(66)
+    end
+
     def press_keycode(code)
       @driver.press_keycode(code)
     end
@@ -188,13 +242,11 @@ module TestaAppiumDriver
     end
 
 
+
+
     # @return [Array<Selenium::WebDriver::Element] array of 2 elements, the first element without children and the last element without children in the current page
     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

data/lib/testa_appium_driver/ios/driver.rb

@@ -7,6 +7,19 @@ module TestaAppiumDriver
     include TypeSelectors
 
 
+
+    # @param params [Hash]
+    # @return [TestaAppiumDriver::Locator] first scrollable element
+    def scrollable(params = {})
+      scroll_view(params)
+    end
+
+    # @param params [Hash]
+    # @return [TestaAppiumDriver::Locator] first scrollable element
+    def scrollables(params = {})
+      scroll_views(params)
+    end
+
     private
     def handle_testa_opts
       if @testa_opts[:default_find_strategy].nil?

data/lib/testa_appium_driver/ios/locator.rb

@@ -3,6 +3,7 @@ require_relative 'locator/attributes'
 module TestaAppiumDriver
   class Locator
     include TypeSelectors
+    attr_accessor :class_chain_selector
 
     def init(params, selectors, single)
       if is_scrollable_selector?(selectors, single)
@@ -19,16 +20,23 @@ module TestaAppiumDriver
         params[:scrollable_locator] = self.dup
       end
 
+      @class_chain_selector = hash_to_class_chain(selectors, single)
+
+
       @scrollable_locator = params[:scrollable_locator] if params[:scrollable_locator]
     end
 
 
     # @return [Array] returns 2 elements. The first is the resolved find element strategy and the second is the resolved selector
-    def strategy_and_selector
+    def strategies_and_selectors
+      ss = []
       if @can_use_id_strategy
-        return FIND_STRATEGY_NAME, @can_use_id_strategy
+        ss.push({"#{FIND_STRATEGY_NAME}": @can_use_id_strategy})
       end
-      [FIND_STRATEGY_XPATH, @xpath_selector]
+      ss.push({"#{FIND_STRATEGY_CLASS_CHAIN}": @class_chain_selector}) if @strategy.nil? || @strategy == FIND_STRATEGY_CLASS_CHAIN
+      ss.push({"#{FIND_STRATEGY_XPATH}": @xpath_selector}) if @strategy.nil? || @strategy == FIND_STRATEGY_XPATH
+      ss.push({"#{FIND_STRATEGY_IMAGE}": @image_selector}) if @strategy == FIND_STRATEGY_IMAGE
+      ss
     end
 
 
@@ -41,13 +49,23 @@ module TestaAppiumDriver
 
       locator = self.dup
       add_xpath_child_selectors(locator, selectors, single)
+      if @strategy.nil? || @strategy == FIND_STRATEGY_CLASS_CHAIN
+        add_class_chain_child_selectors(locator, selectors, single)
+      end
+
       if is_scrollable_selector?(selectors, single)
         locator.scrollable_locator.scroll_orientation = :vertical
-        locator.scrollable_locator = self.dup
+        locator.scrollable_locator = locator
       end
 
       locator.last_selector_adjacent = false
       locator
     end
+
+
+    def add_class_chain_child_selectors(locator, selectors, single)
+      locator.single = false unless single # switching from single result to multiple
+      locator.class_chain_selector += "/" + hash_to_class_chain(selectors, single)
+    end
   end
 end

data/lib/testa_appium_driver/ios/type_selectors.rb

@@ -5,10 +5,15 @@ module TestaAppiumDriver
     # @return [TestaAppiumDriver::Locator]
     def add_selector(*args, &block)
       # if class selector is executed from driver, create new locator instance
-      if self.kind_of?(TestaAppiumDriver::Driver) || self.kind_of(Selenium::WebDriver::Element)
+      if self.kind_of?(TestaAppiumDriver::Driver) || self.instance_of?(Selenium::WebDriver::Element)
         args.last[:default_find_strategy] = @default_find_strategy
         args.last[:default_scroll_strategy] = @default_scroll_strategy
-        Locator.new(self, self, *args)
+        if self.instance_of?(Selenium::WebDriver::Element)
+          driver = self.get_driver
+        else
+          driver = self
+        end
+        Locator.new(driver, self, *args)
       else
         # class selector is executed from locator, just add child selector criteria
         self.add_child_selector(*args)
@@ -111,19 +116,6 @@ module TestaAppiumDriver
     end
 
 
-    # @param params [Hash]
-    # @return [TestaAppiumDriver::Locator] first scrollable element
-    def scrollable(params = {})
-      scroll_view(params)
-    end
-
-    # @param params [Hash]
-    # @return [TestaAppiumDriver::Locator] first scrollable element
-    def scrollables(params = {})
-      scroll_views(params)
-    end
-
-
     # @return [TestaAppiumDriver::Locator]
     def scroll_view(params = {})
       params[:type] = "XCUIElementTypeScrollView"
@@ -163,5 +155,34 @@ module TestaAppiumDriver
       params[:single] = false
       add_selector(params)
     end
+
+
+
+    # @return [TestaAppiumDriver::Locator]
+    def text_field(params = {})
+      params[:type] = "XCUIElementTypeTextField"
+      add_selector(params)
+    end
+
+    # @return [TestaAppiumDriver::Locator]
+    def text_fields(params = {})
+      params[:type] = "XCUIElementTypeTextField"
+      params[:single] = false
+      add_selector(params)
+    end
+
+
+    # @return [TestaAppiumDriver::Locator]
+    def secure_text_field(params = {})
+      params[:type] = "XCUIElementTypeSecureTextField"
+      add_selector(params)
+    end
+
+    # @return [TestaAppiumDriver::Locator]
+    def secure_text_fields(params = {})
+      params[:type] = "XCUIElementTypeSecureTextField"
+      params[:single] = false
+      add_selector(params)
+    end
   end
 end

data/lib/testa_appium_driver/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TestaAppiumDriver
-  VERSION = "0.1.5"
+  VERSION = "0.1.9"
 end

data/testa_appium_driver.iml

@@ -39,7 +39,41 @@
   </component>
   <component name="RakeTasksCache">
     <option name="myRootTask">
-      <RakeTaskImpl id="rake" />
+      <RakeTaskImpl id="rake">
+        <subtasks>
+          <RakeTaskImpl description="Build testa_appium_driver-0.1.5.gem into the pkg directory" fullCommand="build" id="build" />
+          <RakeTaskImpl id="build">
+            <subtasks>
+              <RakeTaskImpl description="Generate SHA512 checksum if testa_appium_driver-0.1.5.gem into the checksums directory" fullCommand="build:checksum" id="checksum" />
+            </subtasks>
+          </RakeTaskImpl>
+          <RakeTaskImpl description="Remove any temporary products" fullCommand="clean" id="clean" />
+          <RakeTaskImpl description="Remove any generated files" fullCommand="clobber" id="clobber" />
+          <RakeTaskImpl description="Build and install testa_appium_driver-0.1.5.gem into system gems" fullCommand="install" id="install" />
+          <RakeTaskImpl id="install">
+            <subtasks>
+              <RakeTaskImpl description="Build and install testa_appium_driver-0.1.5.gem into system gems without network access" fullCommand="install:local" id="local" />
+            </subtasks>
+          </RakeTaskImpl>
+          <RakeTaskImpl description="Create tag v0.1.5 and build and push testa_appium_driver-0.1.5.gem to rubygems.org" fullCommand="release[remote]" id="release[remote]" />
+          <RakeTaskImpl description="Run RuboCop" fullCommand="rubocop" id="rubocop" />
+          <RakeTaskImpl id="rubocop">
+            <subtasks>
+              <RakeTaskImpl description="Auto-correct RuboCop offenses" fullCommand="rubocop:auto_correct" id="auto_correct" />
+            </subtasks>
+          </RakeTaskImpl>
+          <RakeTaskImpl description="Run RSpec code examples" fullCommand="spec" id="spec" />
+          <RakeTaskImpl description="" fullCommand="default" id="default" />
+          <RakeTaskImpl description="" fullCommand="release" id="release" />
+          <RakeTaskImpl id="release">
+            <subtasks>
+              <RakeTaskImpl description="" fullCommand="release:guard_clean" id="guard_clean" />
+              <RakeTaskImpl description="" fullCommand="release:rubygem_push" id="rubygem_push" />
+              <RakeTaskImpl description="" fullCommand="release:source_control_push" id="source_control_push" />
+            </subtasks>
+          </RakeTaskImpl>
+        </subtasks>
+      </RakeTaskImpl>
     </option>
   </component>
 </module>

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: testa_appium_driver
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.9
 platform: ruby
 authors:
 - karlo.razumovic
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-08-24 00:00:00.000000000 Z
+date: 2021-11-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: appium_lib_core
@@ -80,6 +80,7 @@ files:
 - ".idea/inspectionProfiles/Project_Default.xml"
 - ".idea/misc.xml"
 - ".idea/modules.xml"
+- ".idea/runConfigurations.xml"
 - ".idea/runConfigurations/Android_Test.xml"
 - ".idea/sshConfigs.xml"
 - ".idea/vcs.xml"