eyes_selenium 3.14.10 → 3.15.0.beta

data/lib/applitools/selenium/target.rb

@@ -118,8 +118,8 @@ module Applitools
         self
       end
 
-      def fully
-        options[:stitch_content] = true
+      def fully(value = true)
+        options[:stitch_content] = value ? true : false
         handle_frames
         self
       end

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

@@ -0,0 +1,170 @@
+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
+      public :server_connector
+
+      class RegionProvider
+        def region
+          Applitools::Region::EMPTY
+        end
+      end
+
+      def initialize(*args)
+        super
+        self.render_statuses = {}
+        self.dummy_region_provider = RegionProvider.new
+        self.dont_get_title = false
+      end
+
+      def ensure_config
+        self.config = Applitools::Selenium::SeleniumConfiguration.new
+      end
+
+
+      def open(driver, browser_info)
+        self.driver = driver
+        self.browser_info = browser_info
+        logger.info "opening EyesConnector for #{config.short_description} with viewport size: #{browser_info}"
+        config.viewport_size = browser_info.viewport_size
+        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::MatchWindowData.new
+        match_data.tag = name
+        update_default_settings(match_data)
+        match_data.read_target(target_to_check, driver)
+
+        check_result = check_window_base(
+            dummy_region_provider, timeout, match_data
+        )
+        self.current_uuid = nil
+        check_result
+      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.first
+      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 match_level_keys
+        %w(match_level exact scale remainder).map(&:to_sym)
+      end
+
+      def update_default_settings(match_data)
+        match_level_keys.each do |k|
+          match_data.send("#{k}=", default_match_settings[k])
+        end
+      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
+
+      def set_viewport_size(*_args)
+
+      end
+
+      def title
+        return 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)
+        dom_url = ''
+        # captured_dom_data = dom_data
+        # unless captured_dom_data.empty?
+        #   begin
+        #     logger.info 'Processing DOM..'
+        #     dom_url = server_connector.post_dom_json(captured_dom_data) do |json|
+        #       io = StringIO.new
+        #       gz = Zlib::GzipWriter.new(io)
+        #       gz.write(json.encode('UTF-8'))
+        #       gz.close
+        #       result = io.string
+        #       io.close
+        #       result
+        #     end
+        #     logger.info 'Done'
+        #     logger.info dom_url
+        #   rescue Applitools::EyesError => e
+        #     logger.warn e.message
+        #     dom_url = nil
+        #   end
+        # end
+        # logger.info 'Getting screenshot...'
+        # screenshot = capture_screenshot
+        # logger.info 'Done getting screenshot!'
+        region = region_provider.region
+
+        # unless region.empty?
+        #   screenshot = screenshot.sub_screenshot region, region_provider.coordinate_type, false
+        # end
+
+        # screenshot = yield(screenshot) if block_given?
+
+        # logger.info 'Compressing screenshot...'
+        # compress_result = compress_screenshot64 screenshot, last_screenshot
+        # logger.info 'Done! Getting title...'
+        a_title = title
+        # logger.info 'Done!'
+        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?
+            end,
+            nil,
+            true
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'applitools/selenium/concerns/browser_types'
+
+module Applitools
+  module Selenium
+    class RenderBrowserInfo < ::Applitools::AbstractConfiguration
+      DEFAULT_CONFIG = proc do
+        {
+          platform: 'linux',
+          browser_type: Applitools::Selenium::Concerns::BrowserTypes::CHROME,
+          size_mode: 'full-page',
+          viewport_size: Applitools::RectangleSize.from_any_argument(width: 0, height: 0)
+        }
+      end
+      class << self
+        def default_config
+          DEFAULT_CONFIG.call
+        end
+      end
+
+      object_field :viewport_size, Applitools::RectangleSize
+      enum_field :browser_type, Applitools::Selenium::Concerns::BrowserTypes.enum_values
+      string_field :platform
+      string_field :size_mode
+      string_field :baseline_env_name
+
+      def to_s
+        "#{viewport_size} (#{browser_type})"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Applitools
+  module Selenium
+    class RenderInfo
+      include Applitools::Jsonable
+      json_fields :width, :height, :sizeMode
+      # , :region, :emulationInfo
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'oj'
+module Applitools
+  module Selenium
+    class RenderRequest
+      include Applitools::Jsonable
+      json_fields :renderId, :webhook, :url, :dom, :resources, :scriptHooks,
+                  :selectorsToFindRegionsFor, :send_dom
+
+      json_fields :renderInfo, :browser
+
+      def initialize(*args)
+        #String webHook, String url, RGridDom dom, Map<String, RGridResource> resources, RenderInfo renderInfo, String platform, String browserName, Object scriptHooks, String[] selectorsToFindRegionsFor, boolean sendDom, Task task
+        options = Applitools::Utils.extract_options! args
+        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

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

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

@@ -0,0 +1,171 @@
+require 'base64'
+require 'applitools/selenium/visual_grid/vg_task'
+
+module Applitools
+  module Selenium
+    class RenderTask < VGTask
+      include Applitools::Jsonable
+      MAX_FAILS_COUNT = 5
+      MAX_ITERATIONS = 100
+
+      attr_accessor :script, :running_test, :all_blobs, :resource_urls, :resource_cache, :put_cache, :server_connector,
+                    :rendering_info, :request_resources, :dom_url_mod, :result
+      def initialize(name, script, running_test, resource_cache, put_cache, rendering_info, server_connector, mod = nil)
+        self.result = nil
+        self.script = script
+        self.running_test = running_test
+        self.resource_cache = resource_cache
+        self.put_cache = put_cache
+        self.server_connector = server_connector
+        self.rendering_info = rendering_info
+        self.dom_url_mod = mod
+        super(name) do
+          perform
+        end
+      end
+
+      def perform
+        requests = Applitools::Selenium::RenderRequests.new
+        rq = prepare_data_for_rg(script_data)
+        requests << rq
+        fetch_fails = 0
+        # still_running = false
+        # need_more_dom = false
+        begin
+          response = nil
+          begin
+            response = server_connector.render(rendering_info['serviceUrl'], rendering_info['accessToken'], requests)
+          # rescue StandardError => _e
+          #   response = server_connector.render(rendering_info['serviceUrl'], rendering_info['accessToken'], requests)
+          rescue StandardError => e
+            fetch_fails += 1
+            sleep 2
+          end
+          next unless response
+          running_render = response.first
+          rq.render_id = running_render['renderId']
+          need_more_dom = running_render['needMoreDom']
+          need_more_resources = running_render['renderStatus'] == 'need-more-resources'
+          still_running = need_more_resources || need_more_dom || fetch_fails > MAX_FAILS_COUNT
+
+          dom_resource = rq.dom.resource
+
+          cache_key = URI(dom_resource.url)
+          cache_key.query = "modifier=#{dom_url_mod}" if dom_url_mod
+
+          running_render['needMoreResources'].each do |resource_url|
+            put_cache.fetch_and_store(URI(resource_url)) do |_s|
+              server_connector.render_put_resource(
+                  rendering_info['serviceUrl'],
+                  rendering_info['accessToken'],
+                  request_resources[URI(resource_url)],
+                  running_render
+              )
+            end
+          end if need_more_resources
+
+          if need_more_dom
+            put_cache.fetch_and_store(cache_key) do |_s|
+              server_connector.render_put_resource(
+                  rendering_info['serviceUrl'],
+                  rendering_info['accessToken'],
+                  dom_resource,
+                  running_render
+              )
+            end
+            put_cache[cache_key]
+          end
+
+        end while(still_running)
+        statuses = poll_render_status(rq)
+        raise Applitools::EyesError, "Render failed for #{statuses.first['renderId']} with the message: " \
+          "#{statuses.first['error']}" if statuses.first['status'] == 'error'
+        self.result = statuses.first
+        statuses
+      end
+
+      def poll_render_status(rq)
+        iterations = 0
+        statuses = []
+        begin
+          fails_count = 0
+          proc = proc do
+            server_connector.render_status_by_id(
+                rendering_info['serviceUrl'],
+                rendering_info['accessToken'],
+                Oj.dump(json_value([rq.render_id]))
+            )
+          end
+          begin
+            statuses = proc.call
+            fails_count = 0
+          rescue StandardError => _e
+            sleep 1
+            fails_count = fails_count + 1
+          ensure
+            iterations+=1
+            sleep 0.5
+          end while(fails_count > 0 and fails_count < 3)
+          finished = statuses.first.is_a?(Hash) && (statuses.first['status'] == 'error' || statuses.first['status'] == 'rendered' || iterations > MAX_ITERATIONS || false)
+        end while(!finished)
+        statuses
+      end
+
+      def script_data
+        @script_data ||= Oj.load script
+      end
+
+      def prepare_data_for_rg(data)
+        self.all_blobs = data["blobs"]
+        self.resource_urls = data["resourceUrls"]
+        self.request_resources = Applitools::Selenium::Concerns::RenderResources.new
+        # self.request_resources = {}
+        all_blobs.map {|blob| Applitools::Selenium::VGResource.parse_blob_from_script(blob)}.each do |blob|
+          request_resources[blob.url] = blob
+        end
+        resource_urls.each do |url|
+          resource_cache.fetch_and_store(URI(url)) do |s|
+            resp_proc = proc { |u| server_connector.download_resource(u) }
+            retry_count = 3
+            begin
+              retry_count -= 1
+              response = resp_proc.call(url)
+            end while response.status != 200 && retry_count > 0
+            s.synchronize do
+              Applitools::Selenium::VGResource.parse_response(url, response)
+            end
+          end
+        end
+
+        resource_urls.each do |u|
+          key = URI(u)
+          request_resources[key] = resource_cache[key]
+        end
+
+        r_info = Applitools::Selenium::RenderInfo.new.tap do |r|
+          r.width = running_test.browser_info.viewport_size.width
+          r.height = running_test.browser_info.viewport_size.height
+          r.size_mode = running_test.browser_info.size_mode
+        end
+
+        dom = Applitools::Selenium::Concerns::RGridDom.new(
+          url: script_data["url"], dom_nodes: script_data['cdt'], resources: request_resources
+        )
+
+        Applitools::Selenium::RenderRequest.new(
+          webhook: rendering_info["resultsUrl"],
+          url: script_data["url"],
+          dom: dom,
+          resources: request_resources,
+          render_info: r_info,
+          browser: {name: running_test.browser_info.browser_type, platform: running_test.browser_info.platform},
+          script_hooks: nil,
+          selectors_to_find_region_for: nil,
+          send_dom: running_test.eyes.config.send_dom,
+          task: nil
+        )
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+require 'thread'
+module Applitools
+  module Selenium
+    class ResourceCache
+      attr_accessor :cache_map, :semaphore
+
+      def initialize
+        self.cache_map = {}
+        self.semaphore = Mutex.new
+      end
+
+      def contains?(url)
+        semaphore.synchronize do
+          cache_map.keys.include?(url) && !cache_map[url].nil?
+        end
+      end
+
+      def [](key)
+        current_value = semaphore.synchronize do
+          cache_map[key]
+        end
+        return current_value unless cache_map[key].is_a? Applitools::Future
+        update_cache_map(key, cache_map[key].get)
+      end
+
+      def []=(key, value)
+        Applitools::ArgumentGuard.is_a?(key, 'key', URI)
+        Applitools::ArgumentGuard.one_of?(value, 'value', [Applitools::Future, Applitools::Selenium::VGResource])
+        update_cache_map(key, value)
+      end
+
+      def fetch_and_store(key, &block)
+        return self[key] if self.contains? key
+        return unless block_given?
+        self[key] = Applitools::Future.new(semaphore) do |semaphore|
+          block.call(semaphore)
+        end
+        return true if cache_map[key].is_a? Applitools::Future
+        false
+      end
+
+      private
+
+      def update_cache_map(key, value)
+        semaphore.synchronize do
+          cache_map[key] = value
+        end
+      end
+    end
+  end
+end