eyes_selenium 6.12.10 → 6.12.11

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

@@ -1,198 +0,0 @@
-# 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/eyes_connector.rb

@@ -1,170 +0,0 @@
-# frozen_string_literal: true
-module Applitools
-  module Selenium
-    class EyesConnector < ::Applitools::EyesBase
-      USE_DEFAULT_MATCH_TIMEOUT = -1
-
-      attr_accessor :browser_info, :test_result, :driver, :dummy_region_provider, :dont_get_title,
-        :current_uuid, :render_statuses, :device_name, :driver_lock, :title
-      public :server_connector
-
-      class RegionProvider
-        def region
-          Applitools::Region::EMPTY
-        end
-      end
-
-      def initialize(*args)
-        options = Applitools::Utils.extract_options!(args)
-        super
-        self.render_statuses = {}
-        self.dummy_region_provider = RegionProvider.new
-        self.dont_get_title = false
-        self.driver_lock = options[:driver_lock]
-        self.should_match_window_run_once_on_timeout = true
-      end
-
-      def ensure_config
-        self.config = Applitools::Selenium::Configuration.new
-      end
-
-      def open(driver, browser_info)
-        self.driver = driver
-        self.browser_info = browser_info
-        self.device_name = browser_info.device_name
-        logger.info "opening EyesConnector for #{config.short_description} with viewport size: #{browser_info}"
-        config.viewport_size = browser_info.viewport_size
-        title
-        open_base
-        # ensure_running_session
-      end
-
-      def check(name, target, check_task_uuid)
-        self.current_uuid = check_task_uuid
-        target_to_check = target.finalize
-        timeout = target_to_check.options[:timeout] || USE_DEFAULT_MATCH_TIMEOUT
-
-        match_data = Applitools::Selenium::VgMatchWindowData.new(default_match_settings)
-        match_data.tag = name
-        match_data.render_id = render_status['renderId']
-        begin
-          driver_lock.synchronize do
-            match_data.read_target(target_to_check, driver, selector_regions)
-          end
-        rescue Applitools::Selenium::VgMatchWindowData::RegionCoordinatesError => e
-          logger.error "Error retrieving coordinates for region #{e.region}"
-          logger.error e.message
-        end
-
-        match_data.variation_group_id = match_data.target.options[:variation_group_id] if match_data.target.options[:variation_group_id]
-
-        check_result = check_window_base(
-          dummy_region_provider, timeout, match_data
-        )
-        self.current_uuid = nil
-        check_result
-      end
-
-      def start_session
-        super
-        self.should_match_window_run_once_on_timeout = true
-      end
-
-      def base_agent_id
-        "eyes.selenium.visualgrid.ruby/#{Applitools::VERSION}"
-      end
-
-      def close(throw_exception = true, be_silent = false)
-        self.current_uuid = nil
-        self.test_result = super
-      end
-
-      def capture_screenshot
-        nil
-      end
-
-      def render_status_for_task(uuid, status)
-        render_statuses[uuid] = status
-      end
-
-      def render_status
-        status = render_statuses[current_uuid]
-        raise Applitools::EyesError, 'Got empty render status!' if
-            status.nil? || !status.is_a?(Hash) || status.keys.empty?
-        status
-      end
-
-      def screenshot_url
-        render_status['imageLocation']
-      end
-
-      def dom_url
-        render_status['domLocation']
-      end
-
-      def selector_regions
-        render_status['selectorRegions']
-      end
-
-      def visual_viewport
-        render_status['visualViewport']
-      end
-
-      # def match_level_keys
-      #   %w(match_level exact scale remainder ).map(&:to_sym)
-      # end
-
-      def inferred_environment
-        "useragent: #{render_status['userAgent']}"
-      end
-
-      # def default_match_settings
-      #   {
-      #       match_level: match_level,
-      #       exact: exact,
-      #       scale: server_scale,
-      #       remainder: server_remainder
-      #   }
-      # end
-
-      # rubocop:disable Style/AccessorMethodName
-      def set_viewport_size(*_args); end
-      # rubocop:enable Style/AccessorMethodName
-
-      def app_environment
-        super.tap do |env|
-          env.device_info = device_name
-        end
-      end
-
-      def viewport_size
-        status = render_statuses[render_statuses.keys.first]
-        size = status['deviceSize']
-        Applitools::RectangleSize.new(size['width'], size['height'])
-      end
-
-      def title
-        @title ||= driver.title unless dont_get_title
-      rescue StandardError => e
-        logger.warn "failed (#{e.message})"
-        self.dont_get_title = false
-        ''
-      end
-
-      def get_app_output_with_screenshot(region_provider, _last_screenshot)
-        region = region_provider.region
-        a_title = title
-        Applitools::AppOutputWithScreenshot.new(
-          Applitools::AppOutput.new(a_title, '').tap do |o|
-            o.location = region.location unless region.empty?
-            o.dom_url = dom_url
-            o.screenshot_url = screenshot_url if respond_to?(:screenshot_url) && !screenshot_url.nil?
-            o.visual_viewport = visual_viewport unless visual_viewport.nil?
-          end,
-          nil,
-          true
-        )
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-module Applitools
-  module Selenium
-    class RenderInfo
-      include Applitools::Jsonable
-      json_fields :width, :height, :sizeMode, :emulationInfo, :region, :selector, :IosDeviceInfo
-      # , :region, :emulationInfo
-
-      def json_data
-        result = {
-          width: width,
-          height: height,
-          sizeMode: size_mode
-        }
-        result['emulationInfo'] = json_value(emulation_info) if emulation_info
-        result['iosDeviceInfo'] = json_value(ios_device_info) if ios_device_info
-        result['region'] = json_value(region) if size_mode == 'region'
-        result['selector'] = json_value(region) if size_mode == 'selector'
-        result['selector'] = json_value(region) if size_mode == 'full-selector'
-        result
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require 'oj'
-module Applitools
-  module Selenium
-    class RenderRequest
-      include Applitools::Jsonable
-      json_fields :renderId, :webhook, :url, :dom, :resources, :scriptHooks,
-        :selectorsToFindRegionsFor, :sendDom, :agentId
-
-      json_fields :renderInfo, :browser, :platform, :stitchingService, :options
-
-      def initialize(*args)
-        options = Applitools::Utils.extract_options! args
-        self.agent_id = "eyes.selenium.visualgrid.ruby/#{Applitools::VERSION}"
-        self.script_hooks = {}
-        self.selectors_to_find_regions_for = []
-        options.keys.each do |k|
-          send("#{k}=", options[k]) if options[k] && respond_to?("#{k}=")
-        end
-      end
-    end
-  end
-end

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

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-module Applitools
-  module Selenium
-    class RenderRequests < Array
-      include Applitools::Jsonable
-
-      def json_data
-        json_value(self)
-      end
-    end
-  end
-end