eyes_selenium 3.18.2 → 4.0.2

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

@@ -0,0 +1,197 @@
+# frozen_string_literal: false
+
+require 'selenium-webdriver'
+
+
+module Applitools
+  module Selenium
+    class DomSnapshotScript
+
+      attr_accessor :driver
+
+      def initialize(driver)
+        self.driver = driver
+      end
+
+      def create_dom_snapshot(
+        dont_fetch_resources,
+        urls_to_skip,
+        cross_origin_rendering,
+        use_cookies
+      )
+        serialize_resources = true
+        compress_resources = false
+        script = DomSnapshotScript.new(driver, urls_to_skip, dont_fetch_resources, serialize_resources, compress_resources)
+        snapshotter = RecursiveSnapshotter.new(driver, script, cross_origin_rendering, use_cookies)
+
+        begin
+          snapshotter.create_cross_frames_dom_snapshots
+        rescue StandardError => e
+          Applitools::EyesLogger.error e.class.to_s
+          Applitools::EyesLogger.error e.message
+          raise ::Applitools::EyesError.new 'Error while getting dom snapshot!'
+        end
+
+      end
+
+      class DomSnapshotScript
+        DOM_EXTRACTION_TIMEOUT = 300
+
+        attr_accessor :driver, :urls_to_skip, :dont_fetch_resources, :serialize_resources, :compress_resources
+
+        def initialize(driver, urls_to_skip, dont_fetch_resources, serialize_resources = false, compress_resources = false)
+          self.driver = driver
+          self.urls_to_skip = urls_to_skip
+          self.dont_fetch_resources = dont_fetch_resources
+          self.compress_resources = compress_resources
+          self.serialize_resources = serialize_resources
+        end
+
+        def process_page_script
+          Applitools::Selenium::Scripts::PROCESS_PAGE_AND_POLL
+        end
+
+        def script_options
+          options = []
+          options.push("dontFetchResources: #{dont_fetch_resources}")
+          options.push("skipResources: [#{urls_to_skip}]")
+          options.push("compressResources: #{compress_resources}")
+          options.push("serializeResources: #{serialize_resources}")
+          "{#{options.join(', ')}}"
+        end
+
+        def script
+          "#{process_page_script} return __processPageAndSerializePoll(#{script_options});"
+        end
+
+        def run
+          Applitools::EyesLogger.info 'Trying to get DOM snapshot...'
+
+          script_thread = Thread.new do
+            result = {}
+            while result['status'] != 'SUCCESS'
+              Thread.current[:script_result] = driver.execute_script(script)
+              begin
+                Thread.current[:result] = result = Oj.load(Thread.current[:script_result])
+                sleep 0.5
+              rescue Oj::ParseError => e
+                Applitools::EyesLogger.warn e.message
+              end
+            end
+          end
+          sleep 0.5
+          script_thread_result = script_thread.join(DOM_EXTRACTION_TIMEOUT)
+          raise ::Applitools::EyesError.new 'Timeout error while getting dom snapshot!' unless script_thread_result
+          Applitools::EyesLogger.info 'Done!'
+
+          script_thread_result[:result]['value']
+        end
+
+      end
+
+
+      class RecursiveSnapshotter
+
+        POLL_INTERVAL_MS = 0.5
+
+        attr_accessor :should_skip_failed_frames
+
+        attr_accessor :driver, :script, :cross_origin_rendering, :use_cookies
+
+        def initialize(driver, script, cross_origin_rendering, use_cookies)
+          self.should_skip_failed_frames = true
+          self.driver = driver
+          self.script = script
+          self.cross_origin_rendering = cross_origin_rendering
+          self.use_cookies = use_cookies
+        end
+
+        def create_cross_frames_dom_snapshots
+          dom = create_dom_snapshot_threaded
+          process_dom_snapshot_frames dom
+          dom
+        end
+
+        def create_dom_snapshot_threaded
+          script.run
+        end
+
+        def process_dom_snapshot_frames dom
+          dom["cookies"] = driver.manage.all_cookies if use_cookies
+
+          dom["frames"].each do |frame|
+            selector = frame['selector']
+            unless selector
+              Applitools::EyesLogger.warn "inner frame with null selector"
+              next
+            end
+            begin
+              original_frame_chain = driver.frame_chain
+              frame_element = driver.find_element(:css, selector)
+              frame_src = frame_element.attribute('src')
+              Applitools::EyesLogger.info "process_dom_snapshot_frames src = #{frame_src}"
+              driver.switch_to.frame(frame_element)
+
+              process_dom_snapshot_frames frame
+
+              driver.switch_to.default_content
+              unless original_frame_chain.empty?
+                driver.switch_to.frames frame_chain: original_frame_chain
+              end
+            rescue StandardError => e
+              Applitools::EyesLogger.error e.class.to_s
+              Applitools::EyesLogger.error e.message
+              if should_skip_failed_frames
+                Applitools::EyesLogger.warn "failed switching to frame #{selector}"
+              else
+                raise ::Applitools::EyesError.new 'failed switching to frame'
+              end
+            end
+          end
+
+          self.snapshot_and_process_cors_frames(dom) if self.cross_origin_rendering
+        end
+
+        def snapshot_and_process_cors_frames(dom)
+          dom["crossFrames"].each do |frame|
+            selector = frame['selector']
+            unless selector
+              Applitools::EyesLogger.warn "cross frame with null selector"
+              next
+            end
+            frame_index = frame['index']
+            begin
+              original_frame_chain = driver.frame_chain
+              frame_element = driver.find_element(:css, selector) #
+              frame_src = frame_element.attribute('src')
+              Applitools::EyesLogger.info "snapshot_and_process_cors_frames src = #{frame_src}"
+              driver.switch_to.frame(frame_element)
+
+              frame_dom = create_cross_frames_dom_snapshots
+              dom['frames'] ||= []
+              dom['frames'].push frame_dom
+              frame_url = frame_dom['url']
+              dom['cdt'][frame_index]['attributes'].push({ 'name' => 'data-applitools-src', 'value' => frame_url })
+              Applitools::EyesLogger.info "Created cross origin frame snapshot #{frame_url}"
+              process_dom_snapshot_frames frame_dom
+
+              driver.switch_to.default_content
+              unless original_frame_chain.empty?
+                driver.switch_to.frames(frame_chain: original_frame_chain)
+              end
+            rescue StandardError => e
+              Applitools::EyesLogger.error e.class.to_s
+              Applitools::EyesLogger.error e.message
+              if should_skip_failed_frames
+                Applitools::EyesLogger.warn "failed extracting and processing cross frame #{selector}"
+              else
+                raise ::Applitools::EyesError.new 'failed switching to frame'
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

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,8 @@
 module IosDeviceName
   extend self
+  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 +17,14 @@ 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)'
 
   def enum_values
     [
+      IPhone_13_Pro_Max,
+      IPhone_13_Pro,
+      IPhone_13,
       IPhone_12_Pro_Max,
       IPhone_12_Pro,
       IPhone_12,
@@ -32,6 +39,7 @@ module IosDeviceName
       IPhone_7,
       IPad_Pro_3,
       IPad_7,
+      IPad_9,
       IPad_Air_2
     ]
   end

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

@@ -188,12 +188,13 @@ module Applitools
         end
 
         fetch_block = proc do |_s, key|
-          resp_proc = proc { |u| server_connector.download_resource(u, ua_string) }
+          resp_proc = proc { |u, cookies| server_connector.download_resource(u, ua_string, cookies) }
           retry_count = 3
+          matching_cookies = data['cookies'].to_a.select {|c| is_cookie_for_url(c, key)}
           response = nil
           loop do
             retry_count -= 1
-            response = resp_proc.call(key.dup)
+            response = resp_proc.call(key.dup, matching_cookies)
             break unless response.status != 200 && retry_count > 0
           end
           Applitools::Selenium::VGResource.parse_response(
@@ -287,6 +288,24 @@ module Applitools
         running_tests << running_test
         running_tests.length - 1
       end
+
+      def is_cookie_for_url(cookie, url)
+        return false if cookie[:secure] && url.scheme != 'https'
+        return false if cookie[:expires] && DateTime.now > cookie[:expires]
+
+        subdomains_allowed = cookie[:domain].start_with? '.'
+        domain = subdomains_allowed ? cookie[:domain][1..-1] : cookie[:domain]
+        domain_match = url.hostname === domain
+        subdomain_match = url.hostname.end_with?('.' + domain)
+        return false unless domain_match || (subdomains_allowed && subdomain_match)
+
+        path = cookie[:path]
+        path = path.end_with?('/') ? path[0..-2] : path
+
+        return true if url.path === path
+        return true if url.path.start_with?(path + '/')
+        false
+      end
     end
   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/visual_grid_eyes.rb

@@ -7,8 +7,14 @@ require 'securerandom'
 module Applitools
   module Selenium
     class VisualGridEyes
+      # new open, with eyes-manager
+      include Applitools::UniversalEyesOpen
+      # all checks here
+      include Applitools::UniversalEyesChecks
+      # add extract_text, extract_text_regions, locate
+      include Applitools::UniversalNewApi
+
       include Applitools::Selenium::Concerns::SeleniumEyes
-      DOM_EXTRACTION_TIMEOUT = 300 # seconds or 5 minutes
       USE_DEFAULT_MATCH_TIMEOUT = -1
       extend Forwardable
 
@@ -27,6 +33,10 @@ module Applitools
       def_delegators 'config', *Applitools::Selenium::Configuration.methods_to_delegate
       def_delegators 'config', *Applitools::EyesBaseConfiguration.methods_to_delegate
 
+      alias runner visual_grid_manager
+      attr_accessor :universal_eyes, :universal_driver
+      attr_accessor :debug_screenshots, :save_failed_tests, :scale_ratio, :disabled, :stitching_overlap, :compare_with_parent_branch
+
       def initialize(visual_grid_manager, server_url = nil)
         ensure_config
         @server_connector = Applitools::Connectivity::ServerConnector.new(server_url)
@@ -44,6 +54,7 @@ module Applitools
 
       def ensure_config
         self.config = Applitools::Selenium::Configuration.new
+        self.send_dom = true
       end
 
       def full_agent_id
@@ -57,51 +68,60 @@ module Applitools
       end
 
       def open(*args)
-        self.test_uuid = SecureRandom.uuid
+        # self.test_uuid = SecureRandom.uuid
         options = Applitools::Utils.extract_options!(args)
-        Applitools::ArgumentGuard.hash(options, 'options', [:driver])
-
-        config.app_name = options[:app_name] if options[:app_name]
-        config.test_name = options[:test_name] if options[:test_name]
-        config.agent_run_id = "#{config.test_name}--#{SecureRandom.hex(10)}"
-
-        if config.viewport_size.nil? || config.viewport_size && config.viewport_size.empty?
-          config.viewport_size = Applitools::RectangleSize.from_any_argument(options[:viewport_size]) if options[:viewport_size]
-        end
-
-        self.driver = Applitools::Selenium::SeleniumEyes.eyes_driver(options.delete(:driver), self)
-        self.current_url = driver.current_url
-
-        if viewport_size
-          set_viewport_size(viewport_size)
-        else
-          self.viewport_size = get_viewport_size
-        end
-
-        visual_grid_manager.open(self)
-        visual_grid_manager.add_batch(batch.id) do
-          server_connector.close_batch(batch.id)
-        end
-
-        logger.info('Getting all browsers info...')
-        browsers_info_list = config.browsers_info
-        logger.info('Creating test descriptors for each browser info...')
-        browsers_info_list.each(viewport_size) do |bi|
-          test = Applitools::Selenium::RunningTest.new(eyes_connector, bi, driver).tap do |t|
-            t.on_results_received do |results|
-              visual_grid_manager.aggregate_result(results)
-            end
-            t.test_uuid = test_uuid
-          end
-          test_list.push test
-        end
-        self.opened = true
-        driver
+        universal_open(options)
+        # Applitools::ArgumentGuard.hash(options, 'options', [:driver])
+        #
+        # config.app_name = options[:app_name] if options[:app_name]
+        # config.test_name = options[:test_name] if options[:test_name]
+        # config.agent_run_id = "#{config.test_name}--#{SecureRandom.hex(10)}"
+        #
+        # if config.viewport_size.nil? || config.viewport_size && config.viewport_size.empty?
+        #   config.viewport_size = Applitools::RectangleSize.from_any_argument(options[:viewport_size]) if options[:viewport_size]
+        # end
+        #
+        # self.driver = Applitools::Selenium::SeleniumEyes.eyes_driver(options.delete(:driver), self)
+        # self.current_url = driver.current_url
+        #
+        # if viewport_size
+        #   set_viewport_size(viewport_size)
+        # else
+        #   self.viewport_size = get_viewport_size
+        # end
+        #
+        # visual_grid_manager.open(self)
+        # visual_grid_manager.add_batch(batch.id) do
+        #   server_connector.close_batch(batch.id)
+        # end
+        #
+        # logger.info('Getting all browsers info...')
+        # browsers_info_list = config.browsers_info
+        # logger.info('Creating test descriptors for each browser info...')
+        # browsers_info_list.each(viewport_size) do |bi|
+        #   test = Applitools::Selenium::RunningTest.new(eyes_connector, bi, driver).tap do |t|
+        #     t.on_results_received do |results|
+        #       visual_grid_manager.aggregate_result(results)
+        #     end
+        #     t.test_uuid = test_uuid
+        #   end
+        #   test_list.push test
+        # end
+        # self.opened = true
+        # driver
       end
 
       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 = universal_driver_config(web_driver)
+
+        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
 
       def eyes_connector
@@ -125,42 +145,43 @@ module Applitools
           tag = first_arg[:name] || first_arg[:tag]
         end
 
-        script = <<-END
-          #{Applitools::Selenium::Scripts::PROCESS_PAGE_AND_POLL} return __processPageAndSerializePoll(document, {skipResources: [#{visual_grid_manager.resource_cache.urls_to_skip}]});
-        END
         render_task = nil
         target.default_full_page_for_vg
 
+        return universal_check(tag, target)
+
         target_to_check = target.finalize
         begin
           check_in_frame(target_frames: target_to_check.frames) do
             sleep wait_before_screenshots
             Applitools::EyesLogger.info 'Trying to get DOM snapshot...'
-
-            script_thread = Thread.new do
-              result = {}
-              while result['status'] != 'SUCCESS'
-                Thread.current[:script_result] = driver.execute_script(script)
-                begin
-                  Thread.current[:result] = result = Oj.load(Thread.current[:script_result])
-                  sleep 0.5
-                rescue Oj::ParseError => e
-                  Applitools::EyesLogger.warn e.message
-                end
-              end
+            begin
+              dont_fetch_resources = self.dont_fetch_resources
+              enable_cross_origin_rendering = self.enable_cross_origin_rendering
+              use_cookies = !self.dont_use_cookies
+              urls_to_skip = visual_grid_manager.resource_cache.urls_to_skip
+              dom_script = Applitools::Selenium::DomSnapshotScript.new driver
+
+              script_dom = dom_script.create_dom_snapshot(
+                dont_fetch_resources,
+                urls_to_skip,
+                enable_cross_origin_rendering,
+                use_cookies
+              )
+            rescue StandardError => e
+              Applitools::EyesLogger.error e.class.to_s
+              Applitools::EyesLogger.error e.message
+              raise ::Applitools::EyesError.new 'Error while getting dom snapshot!'
             end
-            sleep 0.5
-            script_thread_result = script_thread.join(DOM_EXTRACTION_TIMEOUT)
-            raise ::Applitools::EyesError.new 'Timeout error while getting dom snapshot!' unless script_thread_result
             Applitools::EyesLogger.info 'Done!'
 
-            mod = Digest::SHA2.hexdigest(script_thread_result[:script_result])
+            mod = Digest::SHA2.hexdigest(script_dom.to_s)
 
             region_x_paths = get_regions_x_paths(target_to_check)
 
             render_task = RenderTask.new(
               "Render #{config.short_description} - #{tag}",
-              script_thread_result[:result]['value'],
+              script_dom,
               visual_grid_manager,
               server_connector,
               region_x_paths,
@@ -298,21 +319,33 @@ module Applitools
       end
 
       def close(throw_exception = true)
-        return false if test_list.empty?
-        close_async
-
-        until (states = test_list.map(&:state_name).uniq).count == 1 && states.first == :completed
-          sleep 0.5
-        end
-        self.opened = false
-
-        test_list.select { |t| t.pending_exceptions && !t.pending_exceptions.empty? }.each do |t|
-          t.pending_exceptions.each do |e|
-            raise e
-          end
-        end
-
-        all_results = test_list.map(&:test_result).compact
+        logger.info "close(#{throw_exception})"
+        logger.info 'Ending server session...'
+
+        universal_results = universal_eyes.close # Array even for one test
+        raise Applitools::EyesError.new("Request failed: #{universal_results[:message]}") if server_error?(universal_results)
+        key_transformed_results = Applitools::Utils.deep_stringify_keys(universal_results)
+        results = key_transformed_results.map {|result| Applitools::TestResults.new(result) }
+        # results = results.first if results.size == 1
+        # session_results_url = results.url
+        all_results = results.compact
+
+
+        # return false if test_list.empty?
+        # close_async
+        #
+        # until (states = test_list.map(&:state_name).uniq).count == 1 && states.first == :completed
+        #   sleep 0.5
+        # end
+        # self.opened = false
+        #
+        # test_list.select { |t| t.pending_exceptions && !t.pending_exceptions.empty? }.each do |t|
+        #   t.pending_exceptions.each do |e|
+        #     raise e
+        #   end
+        # end
+        #
+        # all_results = test_list.map(&:test_result).compact
         failed_results = all_results.select { |r| !r.as_expected? }
 
         if throw_exception
@@ -323,16 +356,18 @@ module Applitools
           end
         end
 
-        failed_results.empty? ? all_results.first : failed_results
+        failed_results.empty? ? all_results.first : failed_results.first
       end
 
       def abort_async
         test_list.each(&:abort)
+        universal_sdk_abort
       end
 
       def abort_if_not_closed
         self.opened = false
         test_list.each(&:abort)
+        universal_sdk_abort
       end
 
       alias abort abort_if_not_closed
@@ -349,6 +384,8 @@ module Applitools
 
       # rubocop:disable Style/AccessorMethodName
       def set_viewport_size(value)
+        # require('pry')
+        # binding.pry
         self.utils.set_viewport_size driver, value
       rescue => e
         logger.error e.class.to_s
@@ -400,6 +437,14 @@ module Applitools
 
       def add_text_trigger(_control, _text); end
 
+      def disabled=(value)
+        @disabled = Applitools::Utils.boolean_value value
+      end
+
+      def disabled?
+        @disabled
+      end
+
       private :new_test_error_message, :diffs_found_error_message, :test_failed_error_message
 
       private

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

@@ -61,6 +61,10 @@ module Applitools
         super
       end
 
+      def universal_eyes_manager_config
+        Applitools::UniversalEyesManagerConfig.vg(@thread_pool.concurrency)
+      end
+
       private
 
       def all_running_tests

data/lib/applitools/version.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: false
 
 module Applitools
-  VERSION = '3.18.2'.freeze
+  VERSION = '4.0.2'.freeze
+  UNIVERSAL_VERSION = '1.0.9'.freeze
 end

data/lib/eyes_selenium.rb

@@ -31,5 +31,14 @@ if defined? Selenium::WebDriver::Driver
       is_mobile_device = capabilities['platformName'] ? true : false
       Applitools::Selenium::Driver.new(eyes, driver: self, is_mobile_device: is_mobile_device)
     end
+
+    def universal_driver_config
+      hidden_server_url = bridge.http.send(:server_url).to_s
+      {
+        serverUrl: hidden_server_url,
+        sessionId: session_id,
+        capabilities: capabilities.as_json
+      }
+    end
   end
 end