eyes_selenium 3.18.4 → 6.9.0

data/lib/applitools/selenium/target.rb

@@ -21,7 +21,7 @@ module Applitools
 
       attr_accessor :element, :frames, :region_to_check, :coordinate_type, :options, :ignored_regions,
         :floating_regions, :frame_or_element, :regions, :layout_regions, :content_regions,
-        :strict_regions, :accessibility_regions, :convert_coordinates_block
+        :strict_regions, :accessibility_regions, :dynamic_regions, :convert_coordinates_block
 
       private :frame_or_element, :frame_or_element=
 
@@ -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
 
@@ -229,6 +153,8 @@ module Applitools
           replace_element(original_region, new_region, ignored_regions)
         when :accessibility_regions
           replace_element(original_region, new_region, accessibility_regions)
+        when :dynamic_regions
+          replace_element(original_region, new_region, dynamic_regions)
         end
       end
 
@@ -262,8 +188,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 +207,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 +229,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,58 +258,95 @@ 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
-                                   proc do |driver, return_element = false|
-                                     element = applitools_element_from_selenium_element(driver, args.first)
-                                     next element, padding_proc if return_element
-                                     padding_proc.call(element)
-                                   end
-                                 when Applitools::Selenium::Element
-                                   proc do |_driver, return_element = false|
-                                     next args.first, padding_proc if return_element
-                                     padding_proc.call(args.first)
-                                   end
-                                 when Applitools::Region
-                                   Applitools::AccessibilityRegion.new(
-                                     args.first, options[:type]
-                                   )
-                                 when String
-                                   proc do |driver, return_element = false|
-                                     element = driver.find_element(name_or_id: args.first)
-                                     next element, padding_proc if return_element
-                                     padding_proc.call(element)
-                                   end
-                                 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
+          when ::Selenium::WebDriver::Element
+            proc do |driver, return_element = false|
+              element = applitools_element_from_selenium_element(driver, args.first)
+              next element, padding_proc if return_element
+              padding_proc.call(element)
+          end
+          when Applitools::Selenium::Element
+            proc do |_driver, return_element = false|
+              next args.first, padding_proc if return_element
+              padding_proc.call(args.first)
+            end
+          when Applitools::Region
+            Applitools::AccessibilityRegion.new(
+              args.first, options[:type]
+            )
+          when String
+            proc do |driver, return_element = false|
+              element = driver.find_element(name_or_id: args.first)
+              next element, padding_proc if return_element
+              padding_proc.call(element)
+            end
+          when :css
+            { 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)
+      def dynamic(*args)
+        options = Applitools::Utils.extract_options! args
+        handle_frames
+        padding_proc = proc { |region| Applitools::DynamicRegion.new(region, options[:type]) }
+
+        dynamic_regions << case args.first
+          when ::Selenium::WebDriver::Element
+            proc do |driver, return_element = false|
+              element = applitools_element_from_selenium_element(driver, args.first)
+              next element, padding_proc if return_element
+              padding_proc.call(element)
+            end
+          when Applitools::Selenium::Element
+            proc do |_driver, return_element = false|
+              next args.first, padding_proc if return_element
+              padding_proc.call(args.first)
+            end
+          when Applitools::Region
+            Applitools::DynamicRegion.new(
+              args.first, options[:type]
+            )
+          when String
+            proc do |driver, return_element = false|
+              element = driver.find_element(name_or_id: args.first)
+              next element, padding_proc if return_element
+              padding_proc.call(element)
+            end
+          when :css
+            { 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
-        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
         nil
       end
 
@@ -398,6 +354,54 @@ 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, reload: nil, height_breakpoints: nil)
+        if value.is_a?(Hash) && (value.has_key?(:breakpoints) || value.has_key?('breakpoints'))
+          options[:layout_breakpoints] = value
+
+          # Set defaults for the new options if they're not in the hash
+          # Need to check both symbol and string keys
+          options[:layout_breakpoints][:reload] = value[:reload] || value['reload'] || reload
+          options[:layout_breakpoints][:height_breakpoints] = value[:height_breakpoints] || value['height_breakpoints'] || height_breakpoints
+        else
+          options[:layout_breakpoints] = {
+            breakpoints: value,
+            reload: reload,
+            height_breakpoints: height_breakpoints
+          }
+        end
+        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
@@ -409,6 +413,7 @@ module Applitools
         reset_layout_regions
         reset_strict_regions
         reset_accessibility_regions
+        reset_dynamic_regions
         options[:stitch_content] = nil
         options[:timeout] = nil
         options[:trim] = false
@@ -418,6 +423,10 @@ module Applitools
         self.accessibility_regions = []
       end
 
+      def reset_dynamic_regions
+        self.dynamic_regions = []
+      end
+
       def reset_ignore
         self.ignored_regions = []
       end
@@ -448,6 +457,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/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,38 +1,6 @@
+require_relative 'ios_device_name_generated'
+
 module IosDeviceName
+  include IosDeviceNameGenerated
   extend self
-  IPhone_12_Pro_Max = 'iPhone 12 Pro Max'
-  IPhone_12_Pro = 'iPhone 12 Pro'
-  IPhone_12 = 'iPhone 12'
-  IPhone_12_mini = 'iPhone 12 mini'
-  IPhone_11_Pro = 'iPhone 11 Pro'
-  IPhone_11_Pro_Max = 'iPhone 11 Pro Max'
-  IPhone_11 = 'iPhone 11'
-  IPhone_XR = 'iPhone XR'
-  IPhone_XS =  'iPhone Xs'
-  IPhone_X = 'iPhone X'
-  IPhone_8 = 'iPhone 8'
-  IPhone_7 = 'iPhone 7'
-  IPad_Pro_3 = 'iPad Pro (12.9-inch) (3rd generation)'
-  IPad_7 = 'iPad (7th generation)'
-  IPad_Air_2 = 'iPad Air (2nd generation)'
-
-  def enum_values
-    [
-      IPhone_12_Pro_Max,
-      IPhone_12_Pro,
-      IPhone_12,
-      IPhone_12_mini,
-      IPhone_11_Pro,
-      IPhone_11_Pro_Max,
-      IPhone_11,
-      IPhone_XR,
-      IPhone_XS,
-      IPhone_X,
-      IPhone_8,
-      IPhone_7,
-      IPad_Pro_3,
-      IPad_7,
-      IPad_Air_2
-    ]
-  end
 end