eyes_selenium 3.18.1 → 4.0.0

data/lib/applitools/selenium/scripts/templates.rb

@@ -4,6 +4,7 @@ module Applitools
       extend self
       def get_script_by_file_name(fname)
         script = nil
+        return script unless Dir.exist?(Applitools::JS_PATH)
         begin
           Dir.chdir(Applitools::JS_PATH) do
             script = File.open(File.join('@applitools', 'dom-snapshot', 'dist', "#{fname}.js"), 'r').read

data/lib/applitools/selenium/selenium_eyes.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: false
 
+
 module Applitools::Selenium
   # The main API gateway for the SDK
   class SeleniumEyes < Applitools::EyesBase
@@ -56,16 +57,7 @@ module Applitools::Selenium
       # @param [Applitools::Selenium::Driver] driver The driver instance.
       # @param [Hash] viewport_size The required browser's viewport size.
       def set_viewport_size(driver, viewport_size)
-        Applitools::ArgumentGuard.not_nil(driver, 'Driver')
-        Applitools::ArgumentGuard.not_nil(viewport_size, 'viewport_size')
-        Applitools::ArgumentGuard.is_a?(viewport_size, 'viewport_size', Applitools::RectangleSize)
-        begin
-          Applitools::Utils::EyesSeleniumUtils.set_viewport_size eyes_driver(driver), viewport_size
-        rescue => e
-          Applitools::EyesLogger.error e.class
-          Applitools::EyesLogger.error e.message
-          raise Applitools::EyesError.new 'Failed to set viewport size!'
-        end
+        super
       end
     end
 
@@ -100,7 +92,7 @@ module Applitools::Selenium
       :full_page_capture_algorithm_left_top_offset, :screenshot_type, :send_dom, :use_dom, :enable_patterns,
       :utils,
       :config
-    attr_reader :driver
+    attr_accessor :driver
 
     def_delegators 'Applitools::EyesLogger', :logger, :log_handler, :log_handler=
     def_delegators 'config', *Applitools::Selenium::Configuration.methods_to_delegate
@@ -116,7 +108,7 @@ module Applitools::Selenium
       self.base_agent_id = "eyes.selenium.ruby/#{Applitools::VERSION}".freeze
       self.check_frame_or_element = false
       self.region_to_check = nil
-      self.force_full_page_screenshot = false
+      # self.force_full_page_screenshot = false
       self.dont_get_title = false
       self.device_pixel_ratio = UNKNOWN_DEVICE_PIXEL_RATIO
       self.stitch_mode = Applitools::STITCH_MODE[:scroll]
@@ -162,41 +154,42 @@ module Applitools::Selenium
     # @return [Applitools::Selenium::Driver] A wrapped web driver which enables Eyes
     #   trigger recording and frame handling
     def open(options = {})
-      original_driver = options.delete(:driver)
-      options[:viewport_size] = Applitools::RectangleSize.from_any_argument options[:viewport_size] if
-          options[:viewport_size]
-      Applitools::ArgumentGuard.not_nil original_driver, 'options[:driver]'
-      # Applitools::ArgumentGuard.hash options, 'open(options)', [:app_name, :test_name]
-
-      if disabled?
-        logger.info('Ignored')
-        return driver
-      end
-
-      @driver = self.class.eyes_driver(original_driver, self)
-      perform_driver_specific_settings(original_driver)
-
-      self.device_pixel_ratio = UNKNOWN_DEVICE_PIXEL_RATIO
-      self.position_provider = self.class.position_provider(
-        stitch_mode, driver, disable_horizontal_scrolling, disable_vertical_scrolling, explicit_entire_size
-      )
-
-      self.eyes_screenshot_factory = lambda do |image|
-        Applitools::Selenium::ViewportScreenshot.new(
-          image, driver: @driver, force_offset: position_provider.force_offset
-        )
-      end
-
-      open_base(options) do
-        self.viewport_size = get_viewport_size if force_driver_resolution_as_viewport_size
-        ensure_running_session
-      end
-      if runner
-        runner.add_batch(batch.id) do
-          server_connector.close_batch(batch.id)
-        end
-      end
-      @driver
+      universal_open(options)
+      # original_driver = options.delete(:driver)
+      # options[:viewport_size] = Applitools::RectangleSize.from_any_argument options[:viewport_size] if
+      #     options[:viewport_size]
+      # Applitools::ArgumentGuard.not_nil original_driver, 'options[:driver]'
+      # # Applitools::ArgumentGuard.hash options, 'open(options)', [:app_name, :test_name]
+      #
+      # if disabled?
+      #   logger.info('Ignored')
+      #   return driver
+      # end
+      #
+      # @driver = self.class.eyes_driver(original_driver, self)
+      # perform_driver_specific_settings(original_driver)
+      #
+      # self.device_pixel_ratio = UNKNOWN_DEVICE_PIXEL_RATIO
+      # self.position_provider = self.class.position_provider(
+      #   stitch_mode, driver, disable_horizontal_scrolling, disable_vertical_scrolling, explicit_entire_size
+      # )
+      #
+      # self.eyes_screenshot_factory = lambda do |image|
+      #   Applitools::Selenium::ViewportScreenshot.new(
+      #     image, driver: @driver, force_offset: position_provider.force_offset
+      #   )
+      # end
+      #
+      # open_base(options) do
+      #   self.viewport_size = get_viewport_size if force_driver_resolution_as_viewport_size
+      #   ensure_running_session
+      # end
+      # if runner
+      #   runner.add_batch(batch.id) do
+      #     server_connector.close_batch(batch.id)
+      #   end
+      # end
+      # @driver
     end
 
     def perform_driver_specific_settings(original_driver)
@@ -219,7 +212,15 @@ module Applitools::Selenium
     # @!visibility private
     def get_viewport_size(web_driver = driver)
       Applitools::ArgumentGuard.not_nil 'web_driver', web_driver
-      self.utils.extract_viewport_size(driver)
+      # self.utils.extract_viewport_size(driver)
+      driver_config_json = web_driver.universal_driver_config
+
+      Applitools::EyesLogger.debug 'extract_viewport_size()'
+      viewport_size = runner.universal_client.core_get_viewport_size(driver_config_json)
+      result = Applitools::RectangleSize.new viewport_size[:width], viewport_size[:height]
+
+      Applitools::EyesLogger.debug "Viewport size is #{result}."
+      result
     end
 
     # Takes a snapshot and matches it with the expected output.
@@ -242,6 +243,9 @@ module Applitools::Selenium
       logger.info "check(#{name}) is called"
       self.tag_for_debug = name
       Applitools::ArgumentGuard.is_a? target, 'target', Applitools::Selenium::Target
+
+      return universal_check(name, target)
+
       target_to_check = target.finalize
       original_overflow = nil
       original_position_provider = position_provider
@@ -263,6 +267,7 @@ module Applitools::Selenium
         begin
           match_data = Applitools::MatchWindowData.new(default_match_settings)
           match_data.tag = name
+          match_data.variation_group_id = target_to_check.options[:variation_group_id] if target_to_check.options[:variation_group_id]
           eyes_element = target_to_check.region_to_check.call(driver)
 
           unless force_full_page_screenshot

data/lib/applitools/selenium/target.rb

@@ -49,49 +49,10 @@ 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
-
+          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')
+          ignored_regions << value
         end
         self
       end
@@ -120,49 +81,11 @@ 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
+        requested_padding = get_requested_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')
+        value = { region: value }.merge(requested_padding)
         floating_regions << value
         self
       end
@@ -249,6 +172,12 @@ module Applitools
         self
       end
 
+      def variation_group_id(value)
+        Applitools::ArgumentGuard.not_nil(value, 'variation_group_id')
+        options[:variation_group_id] = value
+        self
+      end
+
       def frame(*args)
         element = case args.first
                   when ::Selenium::WebDriver::Element, Applitools::Selenium::Element, String
@@ -256,8 +185,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
@@ -274,23 +204,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
@@ -309,11 +226,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
@@ -333,11 +255,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
@@ -361,30 +279,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
 
@@ -392,6 +314,24 @@ 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
+
       private
 
       def reset_for_fullscreen
@@ -442,6 +382,67 @@ 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(args)
+        if args.last.is_a? Applitools::PaddingBounds
+          args.pop
+        elsif args.last.is_a?(Applitools::FloatingBounds)
+          args.pop.to_hash
+        else
+          {}
+        end
+      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])
+            return {type: Applitools::Selenium::Driver::FINDERS[args[0]], selector: args[1]}
+          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