eyes_selenium 3.18.3 → 4.6.3

data/lib/applitools/selenium/target.rb

@@ -49,49 +49,8 @@ module Applitools
         if args.empty?
           reset_ignore
         else
-          requested_padding = if args.last.is_a? Applitools::PaddingBounds
-                                args.pop
-                              else
-                                Applitools::PaddingBounds::PIXEL_PADDING
-                              end
-          ignored_regions << case args.first
-                             when Applitools::Region
-                               proc { args.first.padding(requested_padding) }
-                             when ::Selenium::WebDriver::Element
-                               proc do |driver, return_element = false|
-                                 region = applitools_element_from_selenium_element(driver, args.first)
-                                 padding_proc = proc do |reg|
-                                   Applitools::Region.from_location_size(
-                                     reg.location, reg.size
-                                   ).padding(requested_padding)
-                                 end
-                                 next region, padding_proc if return_element
-                                 padding_proc.call(region)
-                               end
-                             when Applitools::Selenium::Element
-                               proc do |_driver, return_element = false|
-                                 region = args.first
-                                 padding_proc = proc do |reg|
-                                   Applitools::Region.from_location_size(
-                                     reg.location, reg.size
-                                   ).padding(requested_padding)
-                                 end
-                                 next region, padding_proc if return_element
-                                 padding_proc.call(region)
-                               end
-                             else
-                               proc do |driver, return_element = false|
-                                 region = driver.find_element(*args)
-                                 padding_proc = proc do |reg|
-                                   Applitools::Region.from_location_size(
-                                     reg.location, reg.size
-                                   ).padding(requested_padding)
-                                 end
-                                 next region, padding_proc if return_element
-                                 padding_proc.call(region)
-                               end
-                             end
-
+          region = region_from_args(args)
+          ignored_regions << region if region
         end
         self
       end
@@ -120,71 +79,36 @@ module Applitools
       # @!parse def floating(region_or_element, bounds, left,top, right, bottom, padding); end;
 
       def floating(*args)
-        requested_padding = if args.last.is_a? Applitools::PaddingBounds
-                              args.pop
-                            else
-                              Applitools::PaddingBounds::PIXEL_PADDING
-                            end
-        value = case args.first
-                when Applitools::FloatingRegion
-                  args.first.padding(requested_padding)
-                when ::Applitools::Region
-                  Applitools::FloatingRegion.any(args.shift, *args).padding(requested_padding)
-                when ::Selenium::WebDriver::Element
-                  proc do |driver, return_element = false|
-                    args_dup = args.dup
-                    region = applitools_element_from_selenium_element(driver, args_dup.shift)
-                    padding_proc = proc do |reg|
-                      Applitools::FloatingRegion.any(reg, *args_dup).padding(requested_padding)
-                    end
-                    next region, padding_proc if return_element
-                    padding_proc.call(region)
-                  end
-                when ::Applitools::Selenium::Element
-                  proc do |_driver, return_element = false|
-                    args_dup = args.dup
-                    region = args_dup.shift
-                    padding_proc = proc do |reg|
-                      Applitools::FloatingRegion.any(reg, *args_dup).padding(requested_padding)
-                    end
-                    next region, padding_proc if return_element
-                    padding_proc.call(region)
-                  end
-                else
-                  proc do |driver, return_element = false|
-                    args_dup = args.dup
-                    region = driver.find_element(args_dup.shift, args_dup.shift)
-                    padding_proc = proc do |reg|
-                      Applitools::FloatingRegion.any(
-                        reg, *args_dup
-                      ).padding(requested_padding)
-                    end
-                    next region, padding_proc if return_element
-                    padding_proc.call(region)
-                  end
-                end
-        floating_regions << value
+        options = Applitools::Utils.extract_options!(args)
+        padding = options && options[:padding]
+        requested_padding = get_requested_padding(padding, args)
+        bounds = get_bounds(args)
+        value = convert_to_universal(args)
+        value = { type: args[0], selector: args[1] } if value.nil?
+        value = value[:selector] if value.is_a?(Hash) && (value[:type].to_s === 'id')
+        region = { region: value }
+        region.merge!(bounds) if bounds != {}
+        region.merge!(padding: requested_padding) if requested_padding != {}
+        region.merge!(regionId: options[:region_id]) if options[:region_id]
+        floating_regions << region
         self
       end
 
       def layout(*args)
-        return match_level(Applitools::MatchLevel::LAYOUT) if args.empty?
-        region = process_region(*args)
-        layout_regions << region
+        region = region_from_args(args)
+        layout_regions << region if region
         self
       end
 
       def content(*args)
-        return match_level(Applitools::MatchLevel::CONTENT) if args.empty?
-        region = process_region(*args)
-        content_regions << region
+        region = region_from_args(args)
+        content_regions << region if region
         self
       end
 
       def strict(*args)
-        return match_level(Applitools::MatchLevel::STRICT) if args.empty?
-        region = process_region(*args)
-        strict_regions << region
+        region = region_from_args(args)
+        strict_regions << region if region
         self
       end
 
@@ -262,8 +186,9 @@ module Applitools
                   else
                     proc { |d| d.find_element(*args) }
                   end
-        frames << frame_or_element if frame_or_element
-        self.frame_or_element = element
+        frames << element
+        # frames << frame_or_element if frame_or_element
+        # self.frame_or_element = element
         reset_for_fullscreen
         self
       end
@@ -280,23 +205,10 @@ module Applitools
       # @!parse def region(element, how, what); end;
 
       def region(*args)
-        handle_frames
-        self.region_to_check = case args.first
-                               when ::Selenium::WebDriver::Element
-                                 proc do |driver|
-                                   applitools_element_from_selenium_element(driver, args.first)
-                                 end
-                               when Applitools::Selenium::Element, Applitools::Region
-                                 proc { args.first }
-                               when String
-                                 proc do |driver|
-                                   driver.find_element(name_or_id: args.first)
-                                 end
-                               else
-                                 proc do |driver|
-                                   driver.find_element(*args)
-                                 end
-                               end
+        value = convert_to_universal(args)
+        value = { type: args[0], selector: args[1] } if value.nil?
+        value = value[:selector] if value.is_a?(Hash) && (value[:type].to_s === 'id')
+        self.region_to_check = value
         self.coordinate_type = Applitools::EyesScreenshot::COORDINATE_TYPES[:context_relative]
         options[:timeout] = nil
         reset_ignore
@@ -315,11 +227,16 @@ module Applitools
       end
 
       def before_render_screenshot_hook(hook)
-        options[:script_hooks][:beforeCaptureScreenshot] = hook
+        if hook.is_a?(Hash) && hook[:beforeCaptureScreenshot]
+          options[:script_hooks] = hook
+        else
+          options[:script_hooks][:beforeCaptureScreenshot] = hook
+        end
         self
       end
 
       alias script_hook before_render_screenshot_hook
+      alias hooks before_render_screenshot_hook
 
       def finalize
         return self unless frame_or_element
@@ -339,11 +256,7 @@ module Applitools
             "The region type should be one of [#{Applitools::AccessibilityRegionType.enum_values.join(', ')}]"
         end
         handle_frames
-        padding_proc = proc do |region|
-          Applitools::AccessibilityRegion.new(
-            region, options[:type]
-          )
-        end
+        padding_proc = proc { |region| Applitools::AccessibilityRegion.new(region, options[:type]) }
 
         accessibility_regions << case args.first
                                  when ::Selenium::WebDriver::Element
@@ -367,30 +280,34 @@ module Applitools
                                      next element, padding_proc if return_element
                                      padding_proc.call(element)
                                    end
+          when :css
+            # (:css, '.ignore', type: 'LargeText')
+            { region: args[1], type: options[:type] }
                                  else
                                    proc do |driver, return_element = false|
                                      elements = driver.find_elements(*args)
                                      next elements, padding_proc if return_element
                                      elements.map { |e| padding_proc.call(e) }
                                    end
+
                                  end
         self
       end
 
       def default_full_page_for_vg
-        if options[:stitch_content].nil?
-          case region_to_check
-          when nil
-            fully(true)
-          when Proc
-            begin
-              r = region_to_check.call
-              fully(true) if r == Applitools::Region::EMPTY
-            rescue StandardError
-              fully(false)
-            end
-          end
-        end
+        # if options[:stitch_content].nil?
+        #   case region_to_check
+        #   when nil
+        #     fully(true)
+        #   when Proc
+        #     begin
+        #       r = region_to_check.call
+        #       # fully(true) if r == Applitools::Region::EMPTY
+        #     rescue StandardError
+        #       fully(false)
+        #     end
+        #   end
+        # end
         nil
       end
 
@@ -398,6 +315,41 @@ module Applitools
         self.convert_coordinates_block = block
       end
 
+      def scroll_root_element(by, what = nil)
+        options[:scroll_root_element] = if is_element?(by)
+          ref = by.ref
+          ref = by.ref[1] if ref.is_a?(Array) && ref[0] === :element
+          { elementId: ref }
+        elsif what
+          { type: by.to_s, selector: what }
+        else
+          by
+        end
+        self
+      end
+
+      def layout_breakpoints(value = true)
+        options[:layout_breakpoints] = value.is_a?(Array) ? value : value
+        self
+      end
+
+      def wait_before_capture(value)
+        Applitools::ArgumentGuard.not_nil(value, 'wait_before_capture')
+        options[:wait_before_capture] = value
+        self
+      end
+
+      def page_id(value)
+        Applitools::ArgumentGuard.not_nil(value, 'page_id')
+        options[:page_id] = value
+        self
+      end
+
+      def lazy_load(*args) # scroll_length, waiting_time, max_amount_to_scroll
+        options[:lazy_load] = args.is_a?(Hash) ? args : true
+        self
+      end
+
       private
 
       def reset_for_fullscreen
@@ -448,6 +400,94 @@ module Applitools
         xpath = driver.execute_script(Applitools::Selenium::Scripts::GET_ELEMENT_XPATH_JS, selenium_element)
         driver.find_element(:xpath, xpath)
       end
+
+      def get_requested_padding(padding, args)
+        return padding.to_hash if padding && padding.is_a?(Applitools::PaddingBounds)
+        return padding if padding && (padding.is_a?(Hash) || padding.is_a?(Numeric))
+        if args.last.is_a? Applitools::PaddingBounds
+          args.pop
+        # elsif args.last.is_a?(Applitools::FloatingBounds)
+        #   args.pop.to_hash
+        else
+          {}
+        end
+      end
+
+      def get_bounds(args)
+        return args.pop.to_hash if args.last.is_a?(Applitools::FloatingBounds)
+        last4 = args.last(4)
+        if last4.size === 4 && last4.all? { |e| e.is_a?(Numeric) }
+          FloatingBounds.new(*last4).to_hash
+        else
+          {}
+        end
+      end
+
+      def region_from_args(args)
+        options = Applitools::Utils.extract_options!(args)
+        padding = options && options[:padding]
+        requested_padding = get_requested_padding(padding, args)
+        value = convert_to_universal(args)
+        value = { type: args[0], selector: args[1] } if value.nil?
+        value = value[:selector] if value.is_a?(Hash) && (value[:type].to_s === 'id')
+        return nil if value === {selector: nil, type: nil}
+        region = { region: value }
+        region.merge!(padding: requested_padding) if requested_padding != {}
+        region.merge!(regionId: options[:region_id]) if options[:region_id]
+        region
+      end
+
+
+      def is_element?(el)
+        el.is_a?(::Selenium::WebDriver::Element) || (el.is_a?(Applitools::Selenium::Element) && el.respond_to?(:ref))
+      end
+
+      def is_region?(region)
+        region.is_a?(Applitools::FloatingRegion) || region.is_a?(Applitools::Region) # || region.is_a?(Applitools::Selenium::Element)
+      end
+
+      def is_finder?(finders)
+        return false unless finders.is_a?(Array)
+        return false unless finders[1]
+        return true if [:uiautomator, :predicate, :accessibility_id].include?(finders[0].to_sym)
+        Applitools::Selenium::Driver::FINDERS.has_key?(finders[0].to_sym)
+      end
+
+      def convert_to_universal(args)
+        if is_element?(args.first)
+          ref = args.first.ref
+          ref = args.first.ref[1] if ref.is_a?(Array) && ref[0] === :element
+          return { elementId: ref }
+        end
+        return args.first.to_hash if is_region?(args.first)
+        if is_finder?(args)
+          if Applitools::Selenium::Driver::FINDERS.has_key?(args[0])
+            selector = args[1]
+            selector = "##{args[1]}" if args[0] === :id && !args[1].start_with?('#') && instance_of?(Applitools::Selenium::Target)
+            return {type: Applitools::Selenium::Driver::FINDERS[args[0]], selector: selector}
+          end
+          case args[0]
+            when :uiautomator # ANDROID_UI_AUTOMATOR: '-android uiautomator'
+              return {type: '-android uiautomator', selector: args[1]}
+            when :predicate # IOS_PREDICATE: '-ios predicate string',
+              return {type: '-ios predicate string', selector: args[1]}
+            when :accessibility_id
+              return {type: 'accessibility id', selector: args[1]}
+          end
+        end
+        if args.first.is_a?(String)
+          return proc { |driver| driver.find_element(name_or_id: args.first) }
+        end
+        if args.first.is_a?(Hash) && args.first.has_key?('selector')
+          if args.first.has_key?('shadow')
+            return {selector: args.first['selector'], shadow: args.first['shadow']}
+          else
+            return {selector: args.first['selector']}
+          end
+        end
+        nil
+      end
+
     end
   end
 end

data/lib/applitools/selenium/visual_grid/android_device_info.rb

@@ -0,0 +1,65 @@
+require_relative 'i_render_browser_info'
+require_relative 'emulation_base_info'
+
+module Applitools
+  module Selenium
+    class AndroidDeviceInfo < IRenderBrowserInfo
+      DEFAULT_CONFIG = proc do
+        {
+          viewport_size: Applitools::RectangleSize.from_any_argument(width: 0, height: 0)
+        }
+      end
+
+      object_field :android_device_info, Applitools::Selenium::EmulationBaseInfo
+
+      class << self
+        def default_config
+          DEFAULT_CONFIG.call
+        end
+      end
+
+      def initialize(options = {})
+        super
+        self.android_device_info = EmulationInfo.new.tap do |ei|
+          ei.device_name = options[:device_name]
+          ei.screen_orientation = options[:screen_orientation] || options[:orientation] || Orientation::PORTRAIT
+        end
+      end
+
+      def to_s
+        "#{android_device_info.device_name} - #{android_device_info.screen_orientation}"
+      end
+
+      def device_name
+        android_device_info.device_name
+      end
+
+      def to_hash
+        {androidDeviceInfo: android_device_info.to_hash}
+      end
+
+      private
+
+      class EmulationInfo < EmulationBaseInfo
+        enum_field :device_name, Devices.enum_values
+        enum_field :screen_orientation, Orientation.enum_values
+
+        def json_data
+          {
+            name: device_name,
+            screenOrientation: screen_orientation,
+            version: 'latest'
+          }
+        end
+
+        def to_hash
+          {
+            deviceName: device_name,
+            screenOrientation: screen_orientation,
+            iosVersion: 'latest'
+          }
+        end
+      end
+    end
+  end
+end

data/lib/applitools/selenium/visual_grid/android_device_name.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: false
+module AndroidDeviceName
+  extend self
+  Pixel3XL = 'Pixel 3 XL'.freeze
+  Pixel4 = 'Pixel 4'.freeze
+  Pixel4XL = 'Pixel 4 XL'.freeze
+  GalaxyNote8 = 'Galaxy Note 8'.freeze
+  GalaxyNote9 = 'Galaxy Note 9'.freeze
+  GalaxyS8 = 'Galaxy S8'.freeze
+  GalaxyS8Plus = 'Galaxy S8 Plus'.freeze
+  GalaxyS9 = 'Galaxy S9'.freeze
+  GalaxyS9Plus = 'Galaxy S9 Plus'.freeze
+  GalaxyS10 = 'Galaxy S10'.freeze
+  GalaxyS10Plus = 'Galaxy S10 Plus'.freeze
+  GalaxyNote10 = 'Galaxy Note 10'.freeze
+  GalaxyNote10Plus = 'Galaxy Note 10 Plus'.freeze
+  GalaxyS20 = 'Galaxy S20'.freeze
+  GalaxyS20Plus = 'Galaxy S20 Plus'.freeze
+  GalaxyS21 = 'Galaxy S21'.freeze
+  GalaxyS21Plus = 'Galaxy S21 Plus'.freeze
+  GalaxyS21Ultra = 'Galaxy S21 Ultra'.freeze
+
+  def enum_values
+    [
+      Pixel3XL,
+      Pixel4,
+      Pixel4XL,
+      GalaxyNote8,
+      GalaxyNote9,
+      GalaxyS8,
+      GalaxyS8Plus,
+      GalaxyS9,
+      GalaxyS9Plus,
+      GalaxyS10,
+      GalaxyS10Plus,
+      GalaxyNote10,
+      GalaxyNote10Plus,
+      GalaxyS20,
+      GalaxyS20Plus,
+      GalaxyS21,
+      GalaxyS21Plus,
+      GalaxyS21Ultra,
+    ]
+  end
+end

data/lib/applitools/selenium/visual_grid/chrome_emulation_info.rb

@@ -51,6 +51,10 @@ module Applitools
         emulation_info.device_name + ' (chrome emulation)'
       end
 
+      def to_hash
+        {chromeEmulationInfo: emulation_info.json_data}
+      end
+
 
       private
 

data/lib/applitools/selenium/visual_grid/desktop_browser_info.rb

@@ -40,6 +40,12 @@ module Applitools
         'desktop'
       end
 
+      def to_hash
+        result = viewport_size.to_h
+        result[:name] = browser_type unless browser_type.nil?
+        result
+      end
+
     end
   end
 end

data/lib/applitools/selenium/visual_grid/dom_snapshot_script.rb

@@ -48,7 +48,8 @@ module Applitools
         end
 
         def process_page_script
-          Applitools::Selenium::Scripts::PROCESS_PAGE_AND_POLL
+          ''
+          # Applitools::Selenium::Scripts::PROCESS_PAGE_AND_POLL
         end
 
         def script_options

data/lib/applitools/selenium/visual_grid/ios_device_info.rb

@@ -36,6 +36,10 @@ module Applitools
         ios_device_info.device_name
       end
 
+      def to_hash
+        {iosDeviceInfo: ios_device_info.to_hash}
+      end
+
       private
 
       class EmulationInfo < EmulationBaseInfo
@@ -49,6 +53,14 @@ module Applitools
               version: 'latest'
           }
         end
+
+        def to_hash
+          {
+            deviceName: device_name,
+            screenOrientation: screen_orientation,
+            iosVersion: 'latest'
+          }
+        end
       end
     end
   end

data/lib/applitools/selenium/visual_grid/ios_device_name.rb

@@ -1,5 +1,10 @@
 module IosDeviceName
   extend self
+  IPhone_14 = 'iPhone 14'
+  IPhone_14_Pro_Max = 'iPhone 14 Pro Max'
+  IPhone_13_Pro_Max = 'iPhone 13 Pro Max'
+  IPhone_13_Pro = 'iPhone 13 Pro'
+  IPhone_13 = 'iPhone 13'
   IPhone_12_Pro_Max = 'iPhone 12 Pro Max'
   IPhone_12_Pro = 'iPhone 12 Pro'
   IPhone_12 = 'iPhone 12'
@@ -14,10 +19,18 @@ module IosDeviceName
   IPhone_7 = 'iPhone 7'
   IPad_Pro_3 = 'iPad Pro (12.9-inch) (3rd generation)'
   IPad_7 = 'iPad (7th generation)'
+  IPad_9 = 'iPad (9th generation)'
   IPad_Air_2 = 'iPad Air (2nd generation)'
+  IPhone_8_Plus = 'iPhone 8 Plus'
+  IPhone_SE = 'iPhone SE (1st generation)'
 
   def enum_values
     [
+      IPhone_14,
+      IPhone_14_Pro_Max,
+      IPhone_13_Pro_Max,
+      IPhone_13_Pro,
+      IPhone_13,
       IPhone_12_Pro_Max,
       IPhone_12_Pro,
       IPhone_12,
@@ -32,7 +45,10 @@ module IosDeviceName
       IPhone_7,
       IPad_Pro_3,
       IPad_7,
-      IPad_Air_2
+      IPad_9,
+      IPad_Air_2,
+      IPhone_8_Plus,
+      IPhone_SE
     ]
   end
 end

data/lib/applitools/selenium/visual_grid/thread_pool.rb

@@ -58,7 +58,8 @@ module Applitools
       end
 
       def init_or_renew_threads
-        (concurrency - @thread_group.list.count).times do
+        one_concurrency = 1 # Thread's moved to universal server
+        (one_concurrency - @thread_group.list.count).times do
           logger.debug 'starting new thread (task worker)'
           next_thread
         end

data/lib/applitools/selenium/visual_grid/vg_resource.rb

@@ -2,7 +2,7 @@
 
 require 'base64'
 require 'digest'
-require 'nokogiri'
+# require 'nokogiri'
 
 module Applitools
   module Selenium
@@ -58,11 +58,12 @@ module Applitools
 
       def lookup_for_svg_resources
         return unless %r{^image/svg\+xml} =~ content_type && handle_discovered_resources_block
-        attrs = Nokogiri::XML(content)
-                        .xpath("//@*[namespace-uri(.) = 'http://www.w3.org/1999/xlink'] | //@href")
-                        .select { |a| a.name == 'href' }
-                        .map(&:value)
-                        .select { |a| /^(?!#).*/.match(a) }
+        attrs = []
+        # attrs = Nokogiri::XML(content)
+        #                 .xpath("//@*[namespace-uri(.) = 'http://www.w3.org/1999/xlink'] | //@href")
+        #                 .select { |a| a.name == 'href' }
+        #                 .map(&:value)
+        #                 .select { |a| /^(?!#).*/.match(a) }
         handle_discovered_resources_block.call(attrs, url)
       end