eyes_selenium 6.12.10 → 6.12.11

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

@@ -1,110 +1,51 @@
 # frozen_string_literal: true
+
 module Applitools
   module Selenium
-    class VisualGridRunner < ::Applitools::ClassicRunner
-      # rubocop:disable Style/MutableConstant
-      EMPTY_QUEUE = []
-      attr_accessor :all_eyes, :resource_cache, :put_cache, :rendering_info, :render_queue
-      # rubocop:enable Style/MutableConstant
-
-      alias queue render_queue
-
-      def initialize(concurrent_open_sessions = 10, mask_log = false)
-        super(mask_log=mask_log)
-        self.all_eyes = []
-        self.render_queue = []
-        @thread_pool = Applitools::Selenium::VGThreadPool.new(concurrent_open_sessions)
-        self.resource_cache = Applitools::Selenium::ResourceCache.new
-        self.put_cache = Applitools::Selenium::ResourceCache.new
-        init
-      end
-
-      def init
-        @thread_pool.on_next_task_needed do
-          (task = get_task_queue.pop).is_a?(Applitools::Selenium::VGTask) ? task : nil
+    class VisualGridRunner < Applitools::EyesRunner
+      attr_accessor :all_test_results, :all_pending_exceptions
+      attr_reader :test_concurrency
+
+      DEFAULT_CONCURRENCY = 5
+
+      def initialize(concurrency_or_options = DEFAULT_CONCURRENCY, mask_log = nil)
+        if concurrency_or_options.is_a?(Hash)
+          @test_concurrency = concurrency_or_options[:test_concurrency] || DEFAULT_CONCURRENCY
+          mask_log = concurrency_or_options[:mask_log]
+        else
+          @test_concurrency = concurrency_or_options || DEFAULT_CONCURRENCY
         end
-        @thread_pool.start
-      end
-
-      def open(eyes)
-        all_eyes << eyes
+        super(mask_log)
+        self.all_test_results = []
+        self.all_pending_exceptions = {}
       end
 
-      def enqueue_render_task(render_task)
-        render_queue.push render_task if render_task.is_a? Applitools::Selenium::RenderTask
+      def aggregate_result(test_result)
+        Applitools::ArgumentGuard.is_a?(test_result, 'test_result', Applitools::TestResults)
+        all_test_results << test_result
       end
 
-      def stop
-        sleep 0.5 while all_running_tests.map(&:score).reduce(0, :+) > 0
-        @thread_pool.stop
-      end
-
-      def rendering_info(connector)
-        @rendering_info ||= connector.rendering_info
+      def aggregate_exceptions(result, exception)
+        all_pending_exceptions[result] = exception
       end
 
       def get_all_test_results(throw_exception = false)
-        all_tasks_completed = proc do
-          all_running_tests.count == 0 ||
-            (states = all_running_tests.map(&:state_name).uniq).count == 1 && states.first == :completed
-        end
-
-        sleep 0.5 until all_tasks_completed.call
-
-        failed_results = all_test_results.select { |r| !r.as_expected? }
-        failed_results.each do |r|
-          exception = Applitools::NewTestError.new new_test_error_message(r), r if r.new?
-          exception = Applitools::DiffsFoundError.new diffs_found_error_message(r), r if r.unresolved? && !r.new?
-          exception = Applitools::TestFailedError.new test_failed_error_message(r), r if r.failed?
-          aggregate_exceptions(r, exception)
+        begin
+          if throw_exception
+            all_pending_exceptions.each do |_result, exception|
+              raise exception
+            end
+          end
+        ensure
+          delete_all_batches
         end
-        super
+        all_universal_results = close_all_eyes
+        Applitools::TestResultSummary.new(all_universal_results)
       end
 
       def universal_eyes_manager_config
-        Applitools::UniversalEyesManagerConfig.vg(@thread_pool.concurrency)
-      end
-
-      private
-
-      def all_running_tests
-        all_eyes.collect(&:test_list).flatten
-      end
-
-      def all_running_tests_by_score
-        all_running_tests.sort { |x, y| y.score <=> x.score }
-      end
-
-      # rubocop:disable Style/AccessorMethodName
-      def get_task_queue
-        test_to_run = if render_queue.empty?
-                        all_running_tests_by_score.first
-                      else
-                        self
-                      end
-        test_to_run ? test_to_run.queue : EMPTY_QUEUE
-      end
-      # rubocop:enable Style/AccessorMethodName
-
-      def new_test_error_message(result)
-        original_results = result.original_results
-        "New test '#{original_results['name']}' " \
-            "of '#{original_results['appName']}' " \
-            "Please approve the baseline at #{original_results['appUrls']['session']} "
-      end
-
-      def diffs_found_error_message(result)
-        original_results = result.original_results
-        "Test '#{original_results['name']}' " \
-            "of '#{original_results['appname']}' " \
-            "detected differences! See details at #{original_results['appUrls']['session']}"
-      end
-
-      def test_failed_error_message(result)
-        original_results = result.original_results
-        "Test '#{original_results['name']}' of '#{original_results['appName']}' " \
-            "is failed! See details at #{original_results['appUrls']['session']}"
+        Applitools::UniversalEyesManagerConfig.vg(test_concurrency)
       end
     end
   end
-end
+end

data/lib/eyes_selenium.rb

@@ -45,8 +45,6 @@ Applitools::Selenium.require_dir 'selenium/scripts'
 Applitools::Selenium.require_dir 'selenium'
 Applitools::Selenium.require_dir 'eyes_selenium'
 Applitools::Selenium.require_dir 'selenium/visual_grid'
-Applitools::Selenium.require_dir 'selenium/dom_capture'
-Applitools::Selenium.require_dir 'selenium/css_parser'
 
 if defined? Selenium::WebDriver::Driver
   Selenium::WebDriver::Driver.class_eval do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eyes_selenium
 version: !ruby/object:Gem::Version
-  version: 6.12.10
+  version: 6.12.11
 platform: ruby
 authors:
 - Applitools Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-12-07 00:00:00.000000000 Z
+date: 2025-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eyes_core
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 6.9.10
+        version: 6.9.11
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 6.9.10
+        version: 6.9.11
 - !ruby/object:Gem::Dependency
   name: selenium-webdriver
   requirement: !ruby/object:Gem::Requirement
@@ -31,55 +31,19 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '3'
-- !ruby/object:Gem::Dependency
-  name: css_parser
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+        version: '5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: crass
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: state_machines
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
+        version: '3'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5'
 description: Provides SDK for writing Applitools Selenium-based tests
 email:
 - team@applitools.com
@@ -100,19 +64,15 @@ files:
 - lib/applitools/selenium/concerns/selenium_eyes.rb
 - lib/applitools/selenium/configuration.rb
 - lib/applitools/selenium/context_based_scale_provider.rb
-- lib/applitools/selenium/css_parser/find_embedded_resources.rb
 - lib/applitools/selenium/css_transform/css_transform.rb
 - lib/applitools/selenium/css_translate_element_position_provider.rb
 - lib/applitools/selenium/css_translate_position_provider.rb
 - lib/applitools/selenium/device_name_generated.rb
 - lib/applitools/selenium/devices.rb
-- lib/applitools/selenium/dom_capture/dom_capture.rb
-- lib/applitools/selenium/dom_capture/dom_capture_script.rb
 - lib/applitools/selenium/driver.rb
 - lib/applitools/selenium/element.rb
 - lib/applitools/selenium/element_position_provider.rb
 - lib/applitools/selenium/entire_element_screenshot.rb
-- lib/applitools/selenium/external_css_resources.rb
 - lib/applitools/selenium/eyes.rb
 - lib/applitools/selenium/eyes_screenshot.rb
 - lib/applitools/selenium/eyes_target_locator.rb
@@ -147,29 +107,14 @@ files:
 - lib/applitools/selenium/visual_grid/android_multi_device_target.rb
 - lib/applitools/selenium/visual_grid/chrome_emulation_info.rb
 - lib/applitools/selenium/visual_grid/desktop_browser_info.rb
-- lib/applitools/selenium/visual_grid/dom_snapshot_script.rb
 - lib/applitools/selenium/visual_grid/emulation_base_info.rb
-- lib/applitools/selenium/visual_grid/eyes_connector.rb
 - lib/applitools/selenium/visual_grid/i_render_browser_info.rb
 - lib/applitools/selenium/visual_grid/ios_device_info.rb
 - lib/applitools/selenium/visual_grid/ios_device_name.rb
 - lib/applitools/selenium/visual_grid/ios_device_name_generated.rb
 - lib/applitools/selenium/visual_grid/ios_multi_device_target.rb
 - lib/applitools/selenium/visual_grid/render_browser_info.rb
-- lib/applitools/selenium/visual_grid/render_info.rb
-- lib/applitools/selenium/visual_grid/render_request.rb
-- lib/applitools/selenium/visual_grid/render_requests.rb
-- lib/applitools/selenium/visual_grid/render_task.rb
-- lib/applitools/selenium/visual_grid/resource_cache.rb
-- lib/applitools/selenium/visual_grid/running_test.rb
-- lib/applitools/selenium/visual_grid/thread_pool.rb
-- lib/applitools/selenium/visual_grid/vg_match_window_data.rb
-- lib/applitools/selenium/visual_grid/vg_region.rb
-- lib/applitools/selenium/visual_grid/vg_resource.rb
-- lib/applitools/selenium/visual_grid/vg_task.rb
-- lib/applitools/selenium/visual_grid/visual_grid_eyes.rb
 - lib/applitools/selenium/visual_grid/visual_grid_runner.rb
-- lib/applitools/selenium/visual_grid/web_element_region.rb
 - lib/eyes_selenium.rb
 homepage: https://www.applitools.com
 licenses:

data/lib/applitools/selenium/css_parser/find_embedded_resources.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-require 'crass'
-
-module Applitools
-  module Selenium
-    module CssParser
-      class FindEmbeddedResources
-        class << self
-        end
-
-        class CssParseError < Applitools::EyesError; end
-
-        attr_accessor :css
-
-        def initialize(css)
-          self.css = css
-          @nodes_by_type = {}
-        end
-
-        def imported_css
-          fetch_urls(import_rules)
-        end
-
-        def fonts
-          fetch_urls(font_face_rules)
-        end
-
-        def images
-          fetch_urls(images_rules)
-        end
-
-        private
-
-        def url(node)
-          result = []
-          node[:tokens].select { |t| t[:node] == :url }.uniq.each do |nd|
-            result << nd[:value] if nd && !nd.empty?
-          end
-          node[:tokens].select { |t| t[:node] == :function && t[:value] == 'url' }.uniq.each do |nd|
-            url_index = node[:tokens].index(nd)
-            url_string_node = url_index && node[:tokens][url_index + 1]
-            result << (
-              url_string_node && url_string_node[:node] == :string &&
-                  !url_string_node[:value].empty? && url_string_node[:value]
-            )
-          end
-          result.compact
-        end
-
-        def fetch_urls(nodes)
-          nodes.map { |n| url(n) }.flatten.compact
-        end
-
-        def import_rules
-          # css_nodes.select { |n| n[:node] == :at_rule && n[:name] == 'import' }
-          nodes_by_type[:import_rules]
-        end
-
-        def font_face_rules
-          # css_nodes.select { |n| n[:node] == :at_rule && n[:name] == 'font-face' }
-          nodes_by_type[:font_face_rules]
-        end
-
-        def images_rules
-          # css_nodes.select { |n| n[:node] == :style_rule }.map { |n| n[:children] }
-          #          .flatten
-          #          .select { |n| n[:node] == :property && (n[:name] == 'background' || n[:name] == 'background-image') }
-          nodes_by_type[:images_rules]
-        end
-
-        def css_nodes
-          @css_nodes ||= parse_nodes
-        end
-
-        def nodes_by_type
-          return @nodes_by_type unless @nodes_by_type.empty?
-          @nodes_by_type[:import_rules] ||= []
-          @nodes_by_type[:font_face_rules] ||= []
-          @nodes_by_type[:images_rules] ||= []
-          css_nodes.each do |n|
-            @nodes_by_type[:import_rules] << n if n[:node] == :at_rule && n[:name] == 'import'
-            @nodes_by_type[:font_face_rules] << n if n[:node] == :at_rule && n[:name] == 'font-face'
-            @nodes_by_type[:images_rules] << n if n[:node] == :style_rule
-          end
-
-          unless @nodes_by_type[:images_rules].nil?
-            @nodes_by_type[:images_rules].map! { |n| n[:children] }.flatten!
-            @nodes_by_type[:images_rules] = @nodes_by_type[:images_rules].select do |n|
-              n[:node] == :property && (n[:name] == 'background' || n[:name] == 'background-image')
-            end
-          end
-          @nodes_by_type
-        end
-
-        def parse_nodes
-          Crass.parse css
-        end
-      end
-    end
-  end
-end

data/lib/applitools/selenium/dom_capture/dom_capture.rb

@@ -1,172 +0,0 @@
-# frozen_string_literal: true
-
-module Applitools
-  module Selenium
-    module DomCapture
-      extend self
-      DOM_EXTRACTION_TIMEOUT = 300 # seconds
-      def full_window_dom(driver, server_connector, logger, position_provider = nil)
-        return get_dom(driver, server_connector, logger) unless position_provider
-        scroll_top_and_return_back(position_provider) do
-          get_dom(driver, server_connector, logger)
-        end
-      end
-
-      def get_dom(driver, server_connector, logger)
-        original_frame_chain = driver.frame_chain
-        dom = get_frame_dom(driver, server_connector, logger)
-        unless original_frame_chain.empty?
-          driver.switch_to.default_content
-          driver.switch_to.frames(frame_chain: original_frame_chain)
-        end
-        # CSS processing
-        dom
-      end
-
-      def get_frame_dom(driver, server_connector, logger)
-        logger.info 'Trying to get DOM from driver'
-        start_time = Time.now
-        script_response = nil
-        loop do
-          result_as_string = driver.execute_script(CAPTURE_FRAME_SCRIPT + ' return __captureDomAndPoll();')
-          script_response = Oj.load(result_as_string)
-          status = script_response['status']
-          break if status == 'SUCCESS'
-          raise Applitools::EyesError, 'DOM extraction timeout!' if Time.now - start_time > DOM_EXTRACTION_TIMEOUT
-          raise Applitools::EyesError, "DOM extraction error: #{script_response['error']}" if script_response['error']
-          sleep(0.2)
-        end
-        response_lines = script_response['value'].split(/\r?\n/)
-        separators = Oj.load(response_lines.shift)
-        missing_css_list = []
-        missing_frame_list = []
-        data = []
-
-        blocks = DomParts.new(missing_css_list, missing_frame_list, data)
-        collector = blocks.collectors.next
-        response_lines.each do |line|
-          if line == separators['separator']
-            collector = blocks.collectors.next
-          else
-            collector << line
-          end
-        end
-        logger.info "Missing CSS: #{missing_css_list.count}"
-        logger.info "Missing frames: #{missing_frame_list.count}"
-
-        frame_data = recurse_frames(driver, server_connector, logger, missing_frame_list)
-        result = replace(separators['iframeStartToken'], separators['iframeEndToken'], data.first, frame_data)
-        css_data = fetch_css_files(missing_css_list, server_connector)
-        replace(separators['cssStartToken'], separators['cssEndToken'], result, css_data)
-      rescue StandardError => e
-        logger.error(e.class)
-        logger.error(e.message)
-        return ''
-      end
-
-      def fetch_css_files(missing_css_list, server_connector)
-        result = {}
-        missing_css_list.each do |url|
-          next if url.empty?
-          next if /^blob:/ =~ url
-
-          begin
-            missing_css_response = server_connector.download_resource(
-              url,
-              Applitools::Utils::EyesSeleniumUtils.user_agent(driver)
-            )
-            response_headers = missing_css_response.headers
-            raise Applitools::EyesError, "Wrong response header: #{response_headers['content-type']}" unless
-                %r{^text/css.*}i =~ response_headers['content-type']
-
-            css = missing_css_response.body
-
-            found_and_missing_css =
-              Applitools::Selenium::CssParser::FindEmbeddedResources.new(css).imported_css.map do |found_url|
-                base_url(url).merge(found_url).to_s
-              end
-            fetch_css_files(found_and_missing_css, server_connector).each do |_k, v|
-              css += v
-            end
-
-            result[url] = Oj.dump("\n/** #{url} **/\n" + css).gsub(/^\"|\"$/, '')
-          rescue StandardError
-            result[url] = ''
-          end
-        end
-        result
-      end
-
-      def recurse_frames(driver, server_connector, logger, missing_frame_list)
-        return if missing_frame_list.empty?
-        frame_data = {}
-        frame_chain = driver.frame_chain
-        origin_location = driver.execute_script('return document.location.href')
-        missing_frame_list.each do |missing_frame_line|
-          logger.info "Switching to frame line: #{missing_frame_line}"
-          missing_frame_line.split(/,/).each do |xpath|
-            logger.info "switching to specific frame: #{xpath}"
-            begin
-              frame_element = driver.find_element(:xpath, xpath)
-              frame_src = frame_element.attribute('src')
-              driver.switch_to.frame(frame_element)
-              logger.info "Switched to frame ( #{xpath} ) with src( #{frame_src} )"
-            ensure
-              location_after_switch = driver.execute_script('return document.location.href')
-
-              if origin_location == location_after_switch
-                logger.info "Switch to frame (#{missing_frame_line}) failed"
-                frame_data[missing_frame_line] = ''
-              else
-                result = get_frame_dom(driver, server_connector, logger)
-                frame_data[missing_frame_line] = result
-              end
-
-              driver.switch_to.default_content
-              driver.switch_to.frames(frame_chain: frame_chain)
-            end
-          end
-        end
-        frame_data
-      end
-
-      def scroll_top_and_return_back(position_provider)
-        original_position = position_provider.current_position
-        return yield if block_given? && original_position.nil?
-        position_provider.scroll_to Applitools::Location.new(0, 0)
-        result = yield if block_given?
-        position_provider.scroll_to original_position
-        result
-      end
-
-      def replace(open_token, close_token, input, replacements)
-        pattern = /#{open_token}(?<key>.+?)#{close_token}/
-        input.gsub(pattern) { |_m| replacements[Regexp.last_match(1)] }
-      end
-
-      def base_url(url)
-        uri = URI.parse(url)
-        uri.query = uri.fragment = nil
-        uri.path = ''
-        uri
-      end
-
-      class DomParts
-        attr_accessor :dom_part_collectors
-        def initialize(*args)
-          self.dom_part_collectors = args
-          @index = 0
-        end
-
-        def collectors
-          @collectors ||= Enumerator.new(dom_part_collectors.length) do |y|
-            loop do
-              y << dom_part_collectors[@index]
-              @index += 1
-            end
-          end
-        end
-      end
-    end
-  end
-end