eyes_selenium 6.12.10 → 6.12.11

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

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-require 'thread'
-
-module Applitools
-  module Selenium
-    class VGThreadPool
-      extend Forwardable
-      attr_accessor :concurrency
-      def_delegator 'Applitools::EyesLogger', :logger
-
-      def initialize(concurrency = 10)
-        self.concurrency = concurrency
-        @stopped = true
-        @thread_group = ThreadGroup.new
-        @semaphore = Mutex.new
-        @next_task_block = nil
-        @watchdog = nil
-      end
-
-      def on_next_task_needed(&block)
-        @next_task_block = block if block_given?
-      end
-
-      def start
-        @semaphore.synchronize { @stopped = false }
-        init_or_renew_threads
-        @watchdog = Thread.new do
-          catch(:exit) do
-            loop do
-              throw :exit if stopped?
-              sleep 5
-              init_or_renew_threads
-            end
-          end
-        end
-      end
-
-      def stop
-        @watchdog.exit
-        @semaphore.synchronize do
-          @stopped = true
-        end
-        @thread_group.list.each(&:join)
-        stopped?
-      end
-
-      def stopped?
-        @semaphore.synchronize { @stopped }
-      end
-
-      private
-
-      def next_task
-        @semaphore.synchronize do
-          return @next_task_block.call if @next_task_block && @next_task_block.respond_to?(:call)
-        end
-        nil
-      end
-
-      def init_or_renew_threads
-        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
-      end
-
-      def next_thread
-        thread = Thread.new do
-          begin
-            catch(:exit) do
-              loop do
-                throw :exit if stopped?
-                task_to_run = next_task
-                if task_to_run && task_to_run.respond_to?(:call)
-                  logger.debug "Executing new task... #{task_to_run.name}"
-                  task_to_run.call
-                  logger.debug 'Done!'
-                else
-                  sleep 0.5
-                end
-              end
-            end
-            Applitools::EyesLogger.logger.info 'Worker is stopped'
-          rescue => e
-            Applitools::EyesLogger.logger.error "Failed to execute task - #{task_to_run.name}"
-            Applitools::EyesLogger.logger.error e.message
-            Applitools::EyesLogger.logger.error e.backtrace.join(' ')
-          end
-        end
-        @thread_group.add thread
-      end
-    end
-  end
-end

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

@@ -1,187 +0,0 @@
-# frozen_string_literal: true
-
-module Applitools
-  module Selenium
-    class VgMatchWindowData < Applitools::MatchWindowData
-      CONVERT_COORDINATES = proc do |region, selector_regions|
-        begin
-          offset_region = selector_regions.last
-          new_location = region.location.offset_negative(Applitools::Location.new(offset_region['x'].to_i, offset_region['y'].to_i))
-          region.location = new_location
-        rescue
-          Applitools::EyesLogger.error("Failed to convert coordinates for #{region}")
-        end
-      end
-      class RegionCoordinatesError < ::Applitools::EyesError
-        attr_accessor :region
-        def initialize(region, message)
-          super(message)
-          self.region = region
-        end
-      end
-      attr_accessor :target, :selector_regions
-      def read_target(target, driver, selector_regions)
-        self.target = target
-        self.selector_regions = selector_regions
-        # options
-        target_options_to_read.each do |field|
-          a_value = target.options[field.to_sym]
-          send("#{field}=", a_value) unless a_value.nil?
-        end
-        # ignored regions
-        if target.respond_to? :ignored_regions
-          target.ignored_regions.each do |r|
-            @need_convert_ignored_regions_coordinates = true unless @need_convert_ignored_regions_coordinates
-            case r
-            when Proc
-              region, padding_proc = r.call(driver, true)
-              region = selector_regions[target.regions[region]]
-              retrieved_region = Applitools::Region.new(region['x'], region['y'], region['width'], region['height'])
-              @ignored_regions << padding_proc.call(retrieved_region) if padding_proc.is_a? Proc
-            when Applitools::Region
-              @ignored_regions << r
-            when Applitools::Selenium::VGRegion
-              region = target.regions.key?(r.region) ? selector_regions[target.regions[r.region]] : r.region
-              raise RegionCoordinatesError.new(r, region['error']) if region['error']
-              retrieved_region = Applitools::Region.new(region['x'], region['y'], region['width'], region['height'])
-              @ignored_regions << if r.padding_proc.is_a?(Proc)
-                                    r.padding_proc.call(retrieved_region)
-                                  else
-                                    retrieved_region
-                                  end
-            end
-          end
-        end
-
-        if target.respond_to? :layout_regions
-          @layout_regions = obtain_regions_coordinates(target.layout_regions, driver)
-          @need_convert_layout_regions_coordinates = true unless @layout_regions.empty?
-        end
-
-        if target.respond_to? :content_regions
-          @content_regions = obtain_regions_coordinates(target.content_regions, driver)
-          @need_convert_content_regions_coordinates = true unless @content_regions.empty?
-        end
-
-        if target.respond_to? :strict_regions
-          @strict_regions = obtain_regions_coordinates(target.strict_regions, driver)
-          @need_convert_strict_regions_coordinates = true unless @strict_regions.empty?
-        end
-
-        if target.respond_to? :accessibility_regions
-          @accessibility_regions = obtain_regions_coordinates(target.accessibility_regions, driver)
-          @need_convert_accessibility_regions_coordinates = true unless @accessibility_regions.empty?
-        end
-
-        # # floating regions
-        return unless target.respond_to? :floating_regions
-        target.floating_regions.each do |r|
-          case r
-          when Proc
-            region, padding_proc = r.call(driver, true)
-            region = selector_regions[target.regions[region]]
-            retrieved_region = Applitools::Region.new(region['x'], region['y'], region['width'], region['height'])
-            floating_region = padding_proc.call(retrieved_region) if padding_proc.is_a? Proc
-            raise Applitools::EyesError.new "Wrong floating region: #{region.class}" unless
-                floating_region.is_a? Applitools::FloatingRegion
-            @floating_regions << floating_region
-            @need_convert_floating_regions_coordinates = true
-          when Applitools::FloatingRegion
-            @floating_regions << r
-            @need_convert_floating_regions_coordinates = true
-          when Applitools::Selenium::VGRegion
-            region = r.region
-            region = selector_regions[target.regions[region]]
-            raise RegionCoordinatesError.new(r, region['error']) if region['error']
-            retrieved_region = Applitools::Region.new(region['x'], region['y'], region['width'], region['height'])
-            floating_region = r.padding_proc.call(retrieved_region) if r.padding_proc.is_a? Proc
-            raise Applitools::EyesError.new "Wrong floating region: #{region.class}" unless
-                floating_region.is_a? Applitools::FloatingRegion
-            @floating_regions << floating_region
-            @need_convert_floating_regions_coordinates = true
-          end
-        end
-      end
-
-      def obtain_regions_coordinates(regions, driver)
-        result = []
-        regions.each do |r|
-          case r
-          when Proc
-            region = r.call(driver)
-            region = selector_regions[target.regions[region]]
-            result << Applitools::Region.new(region['x'], region['y'], region['width'], region['height'])
-          when Applitools::Region
-            result << r
-          when Applitools::Selenium::VGRegion
-            region = r.region
-            region = selector_regions[target.regions[region]]
-            raise RegionCoordinatesError.new(r, region['error']) if region['error']
-            retrieved_region = Applitools::Region.new(region['x'], region['y'], region['width'], region['height'])
-            result_region = if r.padding_proc.is_a? Proc
-              r.padding_proc.call(retrieved_region)
-            else
-              retrieved_region
-            end
-            result << result_region
-          end
-        end
-        result
-      end
-
-      def convert_ignored_regions_coordinates
-        return unless @need_convert_ignored_regions_coordinates
-        if target.convert_coordinates_block.is_a?(Proc)
-          @ignored_regions.each { |r| target.convert_coordinates_block.call(r, selector_regions)}
-        end
-        self.ignored_regions = @ignored_regions.map(&:with_padding).map(&:to_hash)
-        @need_convert_ignored_regions_coordinates = false
-      end
-
-      def convert_floating_regions_coordinates
-        return unless @need_convert_floating_regions_coordinates
-        if target.convert_coordinates_block.is_a?(Proc)
-          @floating_regions.each { |r| target.convert_coordinates_block.call(r, selector_regions)}
-        end
-        self.floating_regions = @floating_regions
-        @need_convert_floating_regions_coordinates = false
-      end
-
-      def convert_layout_regions_coordinates
-        return unless @need_convert_layout_regions_coordinates
-        if target.convert_coordinates_block.is_a?(Proc)
-          @layout_regions.each { |r| target.convert_coordinates_block.call(r, selector_regions)}
-        end
-        self.layout_regions = @layout_regions
-        @need_convert_layout_regions_coordinates = false
-      end
-
-      def convert_strict_regions_coordinates
-        return unless @need_convert_strict_regions_coordinates
-        if target.convert_coordinates_block.is_a?(Proc)
-          @strict_regions.each { |r| target.convert_coordinates_block.call(r, selector_regions)}
-        end
-        self.strict_regions = @strict_regions
-        @need_convert_strict_regions_coordinates = false
-      end
-
-      def convert_content_regions_coordinates
-        return unless @need_convert_content_regions_coordinates
-        if target.convert_coordinates_block.is_a?(Proc)
-          @content_regions.each { |r| target.convert_coordinates_block.call(r, selector_regions)}
-        end
-        self.content_regions = @content_regions
-        @need_convert_content_regions_coordinates = false
-      end
-
-      def convert_accessibility_regions_coordinates
-        return unless @need_convert_accessibility_regions_coordinates
-        if target.convert_coordinates_block.is_a?(Proc)
-          @accessibility_regions.each { |r| target.convert_coordinates_block.call(r, selector_regions)}
-        end
-        self.accessibility_regions = @accessibility_regions
-        @need_convert_accessibility_regions_coordinates = false
-      end
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-module Applitools
-  module Selenium
-    class VGRegion
-      attr_accessor :region, :padding_proc
-      def initialize(region, padding_proc)
-        self.region = region
-        self.padding_proc = padding_proc
-      end
-
-      def to_s
-        region.inspect
-      end
-    end
-  end
-end

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

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-require 'base64'
-require 'digest'
-# require 'nokogiri'
-
-module Applitools
-  module Selenium
-    class VGResource
-      include Applitools::Jsonable
-      json_fields :contentType, :hash, :hashFormat, :errorStatusCode
-      attr_accessor :url, :content, :handle_discovered_resources_block
-      alias content_type contentType
-      alias content_type= contentType=
-
-      class << self
-        def parse_blob_from_script(blob, options = {})
-          return new(
-            blob['url'],
-            "application/X-error-response-#{blob['errorStatusCode']}",
-            blob['value'] || ''
-          ).tap {|r| r.error_status_code = blob['errorStatusCode']} if blob['errorStatusCode']
-          content = Base64.decode64(blob['value'])
-          new(blob['url'], blob['type'], content, options)
-        end
-
-        def parse_response(url, response, options = {})
-          return new(url, 'application/empty-response', '') unless response.status == 200
-          new(url, response.headers['Content-Type'], response.body, options)
-        end
-      end
-
-      def initialize(url, content_type, content, options = {})
-        self.handle_discovered_resources_block = options[:on_resources_fetched] if
-            options[:on_resources_fetched].is_a? Proc
-        self.url = URI(url)
-        self.content_type = content_type
-        self.content = content
-        self.hash = Digest::SHA256.hexdigest(content)
-        self.hashFormat = 'sha256'
-        lookup_for_resources
-      end
-
-      def on_resources_fetched(block)
-        self.handle_discovered_resources_block = block
-      end
-
-      def lookup_for_resources
-        lookup_for_css_resources
-        lookup_for_svg_resources
-      end
-
-      def lookup_for_css_resources
-        return unless %r{^text/css}i =~ content_type && handle_discovered_resources_block
-        parser = Applitools::Selenium::CssParser::FindEmbeddedResources.new(content)
-        handle_discovered_resources_block.call(parser.imported_css + parser.fonts + parser.images, url)
-      end
-
-      def lookup_for_svg_resources
-        return unless %r{^image/svg\+xml} =~ content_type && handle_discovered_resources_block
-        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
-
-      def stringify
-        url.to_s + content_type.to_s + hash
-      end
-
-      private :lookup_for_svg_resources, :lookup_for_css_resources
-    end
-  end
-end

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

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-require 'securerandom'
-module Applitools
-  module Selenium
-    class VGTask
-      attr_accessor :name, :uuid
-      def initialize(name, &block)
-        self.name = name
-        @block_to_run = block if block_given?
-        @callback = []
-        @error_callback = []
-        @completed_callback = []
-        self.uuid = SecureRandom.uuid
-      end
-
-      def on_task_succeeded(&block)
-        @callback.push block if block_given?
-        self
-      end
-
-      def on_task_error(&block)
-        @error_callback.push block if block_given?
-        self
-      end
-
-      def on_task_completed(&block)
-        @completed_callback.push block if block_given?
-        self
-      end
-
-      def call
-        return unless @block_to_run.respond_to? :call
-        begin
-          res = @block_to_run.call
-          @callback.each do |cb|
-            cb.call(res) if cb.respond_to? :call
-          end
-        rescue StandardError => e
-          Applitools::EyesLogger.logger.error 'Failed to execute task!'
-          Applitools::EyesLogger.logger.error e.message
-          Applitools::EyesLogger.logger.error e.backtrace.join('\n\t')
-          @error_callback.each do |ecb|
-            ecb.call(e) if ecb.respond_to? :call
-          end
-        ensure
-          @completed_callback.each do |ccb|
-            ccb.call if ccb.respond_to? :call
-          end
-        end
-      end
-    end
-  end
-end