eyes_selenium 3.15.25 → 3.15.26

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88093a081f4f6f894ff270f5fd485d58a5ee72a5db793b3e81611ee7e374ab4b
-  data.tar.gz: 775674e679494be0b7ff1b69f0cce61a30e3ee22926bec75550a070a7a6ee276
+  metadata.gz: d296beb9d397fda23bb4559c1bbbe0dcc62a8a517a41340048588fbdf6c911df
+  data.tar.gz: 5d6a5b7b4d6cdd32e9a51ebd36929bc57923f64402ec64bfea8e43d349106c8f
 SHA512:
-  metadata.gz: 0010be372dcb9524baa55868a0a8b2a5804b9474586b79a2ac8070daab34397884327b82470cf88bb57814983ce4fb3a027f85815309589566be966eb99fec94
-  data.tar.gz: a147aa412ffdb8309e0616536797206b587c2f7dace5c52b70628b7be199d81e26584c711266191741bb7269c61b75568f2f30b963beea545da60c06c5b6144d
+  metadata.gz: a3c793ece4f587ee303af163e6aba396e49f6a9021cb045e6e67281c3ff9a8f5cf41e473d87f0dd3e89c4aaf778ace87ca54bf5c7167ea0263e58e9e89b646ed
+  data.tar.gz: 9fef8d433b59ecbd31557be05592a7edb41d6ddec641fbc5ea63e81b52642a12c7ffe98fdd48353278a2d33dd716b8034ae8a8af0f8d9427a6ff5e5214c1d582

data/lib/applitools/selenium/configuration.rb

@@ -60,7 +60,7 @@ module Applitools
         config_keys.each do |k|
           new_config.send(
             "#{k}=", case value = self.send(k)
-                     when Symbol, FalseClass, TrueClass, Fixnum, Float
+                     when Symbol, FalseClass, TrueClass, Integer, Float
                        value
                      else
                        value.clone

data/lib/applitools/selenium/target.rb

@@ -209,6 +209,25 @@ module Applitools
         end
       end
 
+      def replace_region(original_region, new_region, key)
+        case key
+        when :content_regions
+          replace_element(original_region, new_region, content_regions)
+        when :strict_regions
+          replace_element(original_region, new_region, strict_regions)
+        when :layout_regions
+          replace_element(original_region, new_region, layout_regions)
+        when :floating
+          replace_element(original_region, new_region, floating_regions)
+        when :ignore
+          replace_element(original_region, new_region, ignored_regions)
+        end
+      end
+
+      def replace_element(original, new, array)
+        array[array.index(original)] = new
+      end
+
       def match_level(*args)
         match_level = args.shift
         exact_options = args.shift || {}

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

@@ -4,7 +4,7 @@ module Applitools
       USE_DEFAULT_MATCH_TIMEOUT = -1
 
       attr_accessor :browser_info, :test_result, :driver, :dummy_region_provider, :dont_get_title,
-                    :current_uuid, :render_statuses, :device_name
+                    :current_uuid, :render_statuses, :device_name, :driver_lock
       public :server_connector
 
       class RegionProvider
@@ -14,10 +14,12 @@ module Applitools
       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]
       end
 
       def ensure_config
@@ -44,6 +46,7 @@ module Applitools
         match_data.tag = name
         update_default_settings(match_data)
         match_data.read_target(target_to_check, driver, selector_regions)
+
         check_result = check_window_base(
             dummy_region_provider, timeout, match_data
         )
@@ -65,7 +68,7 @@ module Applitools
       end
 
       def render_status_for_task(uuid, status)
-        render_statuses[uuid] = status.first
+        render_statuses[uuid] = status
       end
 
       def render_status

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

@@ -8,86 +8,91 @@ module Applitools
       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, :region_selectors, :size_mode,
-                    :region_to_check, :script_hooks
+      attr_accessor :script, :running_tests, :all_blobs, :resource_urls, :resource_cache, :put_cache, :server_connector,
+        :rendering_info, :request_resources, :dom_url_mod, :result, :region_selectors, :size_mode,
+        :region_to_check, :script_hooks, :visual_grid_manager
+
+      def initialize(name, script_result, visual_grid_manager, server_connector, region_selectors, size_mode,
+        region, script_hooks, mod = nil)
 
-      def initialize(name, script_result, running_test, resource_cache, put_cache, rendering_info, server_connector, region_selectors, size_mode, region, script_hooks, mod = nil)
         self.result = nil
         self.script = script_result
-        self.running_test = running_test
-        self.resource_cache = resource_cache
-        self.put_cache = put_cache
+        self.visual_grid_manager = visual_grid_manager
         self.server_connector = server_connector
-        self.rendering_info = rendering_info
+        self.resource_cache = visual_grid_manager.resource_cache
+        self.put_cache = visual_grid_manager.put_cache
+        self.rendering_info = visual_grid_manager.rendering_info(server_connector)
         self.region_selectors = region_selectors
         self.size_mode = size_mode
         self.region_to_check = region
         self.script_hooks = script_hooks if script_hooks.is_a?(Hash)
 
         self.dom_url_mod = mod
+        self.running_tests = []
         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)
+            response = server_connector.render(rendering_info['serviceUrl'], rendering_info['accessToken'], rq)
           rescue StandardError => e
             Applitools::EyesLogger.error(e.message)
             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
-              )
+          need_more_dom = false
+          need_more_resources = false
+
+          response.each_with_index do |running_render, index|
+            rq[index].render_id = running_render['renderId']
+            need_more_dom = running_render['needMoreDom']
+            need_more_resources = running_render['renderStatus'] == 'need-more-resources'
+
+            dom_resource = rq[index].dom.resource
+
+            cache_key = URI(dom_resource.url)
+            cache_key.query = "modifier=#{dom_url_mod}" if dom_url_mod
+
+            if need_more_resources
+              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
             end
-          end if need_more_resources
 
-          if need_more_dom
-            put_cache.fetch_and_store(cache_key) do |_s|
-              server_connector.render_put_resource(
+            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
-            put_cache[cache_key]
           end
 
-        end while(still_running)
+          still_running = need_more_resources || need_more_dom || fetch_fails > MAX_FAILS_COUNT
+        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'
+        if statuses.first['status'] == 'error'
+          raise Applitools::EyesError, "Render failed for #{statuses.first['renderId']} with the message: " \
+          "#{statuses.first['error']}"
+        end
         self.result = statuses.first
         statuses
       end
@@ -95,14 +100,13 @@ module Applitools
       def poll_render_status(rq)
         iterations = 0
         statuses = []
-        raise Applitools::EyesError, 'RenderStatus: Got empty renderId!' unless rq.render_id.is_a?(String) && !rq.render_id.empty?
         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]))
+              rendering_info['serviceUrl'],
+              rendering_info['accessToken'],
+              Oj.dump(json_value(rq.map(&:render_id)))
             )
           end
           begin
@@ -110,12 +114,12 @@ module Applitools
             fails_count = 0
           rescue StandardError => _e
             sleep 1
-            fails_count = fails_count + 1
+            fails_count += 1
           ensure
-            iterations+=1
+            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)
+          finished = !statuses.map { |s| s['status'] }.uniq.include?('rendering') || iterations > MAX_ITERATIONS
         end while(!finished)
         statuses
       end
@@ -130,9 +134,10 @@ module Applitools
         self.resource_urls = data["resourceUrls"]
         self.request_resources = Applitools::Selenium::RenderResources.new
 
-        all_blobs.map {|blob| Applitools::Selenium::VGResource.parse_blob_from_script(blob)}.each do |blob|
+        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) }
@@ -152,31 +157,43 @@ module Applitools
           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 = size_mode
-          r.region = region_to_check
-          r.emulation_info = running_test.browser_info.emulation_info if running_test.browser_info.emulation_info
-        end
+        requests = Applitools::Selenium::RenderRequests.new
 
-        dom = Applitools::Selenium::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: script_hooks,
-          selectors_to_find_regions_for: region_selectors,
-          send_dom: running_test.eyes.config.send_dom.nil? ? false.to_s : running_test.eyes.config.send_dom.to_s
-        )
+        running_tests.each do |running_test|
+          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 = size_mode
+            r.region = region_to_check
+            r.emulation_info = running_test.browser_info.emulation_info if running_test.browser_info.emulation_info
+          end
+
+          dom = Applitools::Selenium::RGridDom.new(
+            url: script_data["url"], dom_nodes: script_data['cdt'], resources: request_resources
+          )
+
+          requests << 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: script_hooks,
+            selectors_to_find_regions_for: region_selectors,
+            send_dom: running_test.eyes.config.send_dom.nil? ? false.to_s : running_test.eyes.config.send_dom.to_s
+          )
+        end
+        requests
       end
 
+      def add_running_test(running_test)
+        if running_tests.include?(running_test)
+          raise Applitools::EyesError, "The running test #{running_test} already exists in the render task"
+        end
+        running_tests << running_test
+        running_tests.length - 1
+      end
     end
   end
 end

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

@@ -84,9 +84,11 @@ module Applitools
             end
             close_task.on_task_succeeded do |task_result|
               self.test_result = task_result
-            end.on_task_error do |e|
-              self.pending_exceptions << e
-            end.on_task_completed do
+            end
+            close_task.on_task_error do |e|
+              pending_exceptions << e
+            end
+            close_task.on_task_completed do
               watch_close[close_task] = true
               becomes_completed if all_tasks_completed?(watch_close)
             end
@@ -116,7 +118,8 @@ module Applitools
         end
       end
 
-      attr_accessor :open_queue, :task_queue, :render_queue, :close_queue, :watch_open, :watch_task, :watch_render, :watch_close
+      attr_accessor :open_queue, :task_queue, :render_queue, :close_queue, :watch_open, :watch_task,
+        :watch_render, :watch_close
 
       attr_accessor :eyes, :browser_info, :test_result, :pending_exceptions, :driver, :task_lock
 
@@ -147,27 +150,22 @@ module Applitools
       def init
         open_task = Applitools::Selenium::VGTask.new("open #{browser_info}") { eyes.open(driver, browser_info) }
 
-        open_task.on_task_succeeded { watch_open[open_task] = true; becomes_opened if all_tasks_completed?(watch_open) }.
-            on_task_error { |e| pending_exceptions << e; becomes_completed }
+        open_task.on_task_succeeded do
+          watch_open[open_task] = true
+          becomes_opened if all_tasks_completed?(watch_open)
+        end
+
+        open_task.on_task_error do |e|
+          pending_exceptions << e
+          becomes_completed
+        end
+
         open_queue << open_task
         watch_open[open_task] = false
       end
 
-      def check(tag, target, result, visual_grid_manager, region_selectors, size_mod, region_to_check, mod = nil)
-        render_task = RenderTask.new(
-          "Render #{eyes.config.short_description} - #{tag}",
-          result,
-          self,
-          visual_grid_manager.resource_cache,
-          visual_grid_manager.put_cache,
-          visual_grid_manager.rendering_info(eyes.server_connector),
-          eyes.server_connector,
-          region_selectors,
-          size_mod,
-          region_to_check,
-          target.options[:script_hooks],
-          mod
-        )
+      def check(tag, target, render_task)
+        result_index = render_task.add_running_test(self)
 
         check_task = VGTask.new("perform check #{tag} #{target}") do
           eyes.check(tag, target, render_task.uuid)
@@ -183,13 +181,18 @@ module Applitools
         watch_task[check_task] = false
 
         render_task.on_task_succeeded do |r|
-          eyes.render_status_for_task(render_task.uuid, r) if r
-          watch_render[render_task] = true
-          becomes_rendered if all_tasks_completed?(watch_render)
-        end.on_task_error do
+          if r[result_index] && r[result_index]['status'] == 'rendered'
+            eyes.render_status_for_task(render_task.uuid, r[result_index])
+            watch_render[render_task] = true
+            becomes_rendered if all_tasks_completed?(watch_render)
+          else
+            logger.error "Wrong render status! Render returned status #{r[result_index]['status']}"
+            becomes_completed
+          end
+        end
+        render_task.on_task_error do
           becomes_completed
         end
-        render_queue << render_task
         watch_render[render_task] = false
       end
 

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

@@ -22,6 +22,10 @@ module Applitools
               @ignored_regions << padding_proc.call(retrieved_region) if padding_proc.is_a? Proc
             when Applitools::Region
               @ignored_regions << r
+            when Applitools::Selenium::VGRegion
+              region = selector_regions[target.regions[r.region]]
+              retrieved_region = Applitools::Region.new(region['x'], region['y'], region['width'], region['height'])
+              @ignored_regions << r.padding_proc.call(retrieved_region)
             end
           end
         end
@@ -57,6 +61,15 @@ module Applitools
           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]]
+            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
@@ -71,6 +84,10 @@ module Applitools
             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]]
+            result << Applitools::Region.new(region['x'], region['y'], region['width'], region['height'])
           end
         end
         result

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

@@ -0,0 +1,11 @@
+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
+    end
+  end
+end

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

@@ -6,24 +6,24 @@ module Applitools
       def initialize(name, &block)
         self.name = name
         @block_to_run = block if block_given?
-        @callback = nil
-        @error_callback = nil
-        @completed_callback = nil
+        @callback = []
+        @error_callback = []
+        @completed_callback = []
         self.uuid = SecureRandom.uuid
       end
 
       def on_task_succeeded(&block)
-        @callback = block if block_given?
+        @callback.push block if block_given?
         self
       end
 
       def on_task_error(&block)
-        @error_callback = block if block_given?
+        @error_callback.push block if block_given?
         self
       end
 
       def on_task_completed(&block)
-        @completed_callback = block if block_given?
+        @completed_callback.push block if block_given?
         self
       end
 
@@ -31,14 +31,20 @@ module Applitools
         return unless @block_to_run.respond_to? :call
         begin
           res = @block_to_run.call
-          @callback.call(res) if @callback.respond_to? :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.call(e) if @error_callback.respond_to? :call
+          @error_callback.each do |ecb|
+            ecb.call(e) if ecb.respond_to? :call
+          end
         ensure
-          @completed_callback.call if @completed_callback.respond_to? :call
+          @completed_callback.each do |ccb|
+            ccb.call if ccb.respond_to? :call
+          end
         end
       end
     end

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

@@ -8,7 +8,8 @@ module Applitools
 
       def_delegators 'Applitools::EyesLogger', :logger, :log_handler, :log_handler=
 
-      attr_accessor :visual_grid_manager, :driver, :current_url, :current_config, :fetched_cache_map, :config
+      attr_accessor :visual_grid_manager, :driver, :current_url, :current_config, :fetched_cache_map,
+        :config, :driver_lock
       attr_accessor :test_list
 
       attr_accessor :api_key, :server_url, :proxy, :opened
@@ -21,10 +22,12 @@ module Applitools
 
       def initialize(visual_grid_manager, server_url = nil)
         ensure_config
+        @server_connector = Applitools::Connectivity::ServerConnector.new(server_url)
         self.server_url = server_url if server_url
         self.visual_grid_manager = visual_grid_manager
         self.test_list = Applitools::Selenium::TestList.new
         self.opened = false
+        self.driver_lock = Mutex.new
       end
 
       def ensure_config
@@ -73,7 +76,7 @@ module Applitools
 
       def eyes_connector
         logger.info("creating VisualGridEyes server connector")
-        ::Applitools::Selenium::EyesConnector.new(server_url).tap do |connector|
+        ::Applitools::Selenium::EyesConnector.new(server_url, driver_lock: driver_lock).tap do |connector|
           connector.batch = batch
           connector.config = config.deep_clone
         end
@@ -106,11 +109,22 @@ module Applitools
           mod = Digest::SHA2.hexdigest(script_result)
 
           region_x_paths = get_regions_x_paths(target)
-
+          render_task = RenderTask.new(
+            "Render #{config.short_description} - #{tag}",
+            result["value"],
+            visual_grid_manager,
+            server_connector,
+            region_x_paths,
+            size_mod,
+            region_to_check,
+            target.options[:script_hooks],
+            mod
+          )
           test_list.each do |t|
-            t.check(tag, target, result['value'].dup, visual_grid_manager, region_x_paths, size_mod, region_to_check, mod)
+            t.check(tag, target, render_task)
           end
           test_list.each { |t| t.becomes_not_rendered }
+          visual_grid_manager.enqueue_render_task render_task
         rescue StandardError => e
           Applitools::EyesLogger.error e.message
           test_list.each { |t| t.becomes_tested }
@@ -134,31 +148,31 @@ module Applitools
       def collect_selenium_regions(target)
         selenium_regions = {}
         target_element = target.region_to_check
-        setup_size_mode(target_element)
+        setup_size_mode(target_element, target, :none)
         target.ignored_regions.each do |r|
-          selenium_regions[element_or_region(r)] = :ignore
+          selenium_regions[element_or_region(r, target, :ignore)] = :ignore
         end
         target.floating_regions.each do |r|
-          selenium_regions[element_or_region(r)] = :floating
+          selenium_regions[element_or_region(r, target, :floating)] = :floating
         end
         target.layout_regions.each do |r|
-          selenium_regions[element_or_region(r)] = :layout
+          selenium_regions[element_or_region(r, target, :layout_regions)] = :layout
         end
         target.strict_regions.each do |r|
-          selenium_regions[element_or_region(r)] = :strict
+          selenium_regions[element_or_region(r, target, :strict_regions)] = :strict
         end
         target.content_regions.each do |r|
-          selenium_regions[element_or_region(r)] = :content
+          selenium_regions[element_or_region(r, target, :content_regions)] = :content
         end
         selenium_regions[region_to_check] = :target if size_mod == 'selector'
 
         selenium_regions
       end
 
-      def setup_size_mode(target_element)
+      def setup_size_mode(target_element, target, key)
         self.size_mod = 'full-page'
 
-        element_or_region = element_or_region(target_element)
+        element_or_region = element_or_region(target_element, target, key)
 
         case element_or_region
         when ::Selenium::WebDriver::Element, Applitools::Selenium::Element
@@ -172,9 +186,10 @@ module Applitools
         self.region_to_check = element_or_region
       end
 
-      def element_or_region(target_element)
+      def element_or_region(target_element, target, options_key)
         if target_element.respond_to?(:call)
-          region, _padding_proc = target_element.call(driver, true)
+          region, padding_proc = target_element.call(driver, true)
+          target.replace_region(target_element, Applitools::Selenium::VGRegion.new(region, padding_proc), options_key)
           region
         else
           target_element
@@ -248,6 +263,14 @@ module Applitools
         "Test '#{original_results['name']}' of '#{original_results['appName']}' " \
             "is failed! See details at #{original_results['appUrls']['session']}"
       end
+
+      def server_connector
+        @server_connector.server_url = config.server_url
+        @server_connector.api_key = config.api_key
+        @server_connector.proxy = config.proxy if config.proxy
+        @server_connector
+      end
+
       private :new_test_error_message, :diffs_found_error_message, :test_failed_error_message
 
       # Takes a snapshot of the application under test and matches it with the expected output.

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

@@ -2,10 +2,13 @@ module Applitools
   module Selenium
     class VisualGridRunner
       EMPTY_QUEUE = []
-      attr_accessor :all_eyes, :resource_cache, :put_cache, :rendering_info
+      attr_accessor :all_eyes, :resource_cache, :put_cache, :rendering_info, :render_queue
+
+      alias queue render_queue
 
       def initialize(concurrent_open_sessions = 10)
         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
@@ -23,6 +26,10 @@ module Applitools
         all_eyes << eyes
       end
 
+      def enqueue_render_task(render_task)
+        render_queue.push render_task if render_task.is_a? Applitools::Selenium::RenderTask
+      end
+
       def stop
         while all_running_tests.map(&:score).reduce(0, :+) > 0 do
           sleep 0.5
@@ -52,7 +59,11 @@ module Applitools
       end
 
       def get_task_queue
-        test_to_run = all_running_tests_by_score.first
+        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
     end

data/lib/applitools/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: false
 
 module Applitools
-  VERSION = '3.15.25'.freeze
+  VERSION = '3.15.26'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eyes_selenium
 version: !ruby/object:Gem::Version
-  version: 3.15.25
+  version: 3.15.26
 platform: ruby
 authors:
 - Applitools Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-24 00:00:00.000000000 Z
+date: 2019-07-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eyes_core
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.15.25
+        version: 3.15.26
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.15.25
+        version: 3.15.26
 - !ruby/object:Gem::Dependency
   name: selenium-webdriver
   requirement: !ruby/object:Gem::Requirement
@@ -131,6 +131,7 @@ files:
 - 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