eyes_core 4.4.1 → 4.5.0.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b270e9777509fbff56836132e7c946acc6f131aff903e8205836dd7742e1df1
-  data.tar.gz: 57843ac7683e28309baf66857d49b3c2127891aabbc9043a568f121c5c701d21
+  metadata.gz: fb4470a9e790799f337bf3649c9d1d815b78933e1cdd394e14f02c1fcb1e9707
+  data.tar.gz: 8a54d18a05cafc611d51b689dcf3b47db26e7ee8c7be1fec3ff2e77b007ed2f2
 SHA512:
-  metadata.gz: cc448938f1fca93ba339854ab3570a758f389b6c48e207781e10cc18a726b0c889391b04a0ba24354ebaeefe9050744d09a47bf660aa44c75e2d5b3fea5de760
-  data.tar.gz: acbd8ac4994b80b804a39a7f7ab0c400531b1558d2541785cb49b7d5c64a98f7e10bd1dd78efa7b979f1ac4b243d31036c521f8b8c8304e27a3d2f9be7b9c5cf
+  metadata.gz: 9bbb9b54179c3d535a981e26d5ddfde2bc88be6e378074b635ff7796c2cf1ffa1b176b5d74a35e9b03b0d6d9e9ce6241149e92ccaf2b81e33ac59bb81f7e9568
+  data.tar.gz: 7052cf337483264abfaf9d495c3f6a6c83381266ae17cde752c589c193df264afd72f82178077400bbd67ac1b72f58e446a741046c793f06dbcf83c48e8f67fe

data/lib/applitools/connectivity/server_connector.rb

@@ -21,7 +21,7 @@ module Applitools::Connectivity
     DEFAULT_SERVER_URL = 'https://eyesapi.applitools.com'.freeze
 
     SSL_CERT = File.join(File.dirname(File.expand_path(__FILE__)), '../../../certs/cacert.pem').to_s.freeze
-    DEFAULT_TIMEOUT = 300
+    DEFAULT_TIMEOUT = 300_000
     API_SESSIONS = '/api/sessions'.freeze
     API_SESSIONS_RUNNING = API_SESSIONS + '/running/'.freeze
     API_SINGLE_TEST = API_SESSIONS + '/'.freeze

data/lib/applitools/core/floating_region.rb

@@ -93,14 +93,16 @@ module Applitools
 
     def to_hash
       {
-        'top' => top,
-        'left' => left,
-        'width' => width,
-        'height' => height,
-        'maxUpOffset' => max_top_offset + padding_top,
-        'maxLeftOffset' => max_left_offset + padding_left,
-        'maxRightOffset' => max_right_offset + padding_right,
-        'maxDownOffset' => max_bottom_offset + padding_bottom
+        x: left,
+        y: top,
+        width: width,
+        height: height,
+        offset: {
+          top: max_top_offset + padding_top,
+          bottom: max_bottom_offset + padding_bottom,
+          left: max_left_offset + padding_left,
+          right: max_right_offset + padding_right
+        }
       }
     end
   end
@@ -126,10 +128,12 @@ module Applitools
 
     def to_hash
       {
-        maxUpOffset: max_top_offset,
-        maxDownOffset: max_bottom_offset,
-        maxLeftOffset: max_left_offset,
-        maxRightOffset: max_right_offset
+        offset: {
+          top: max_top_offset,
+          bottom: max_bottom_offset,
+          left: max_left_offset,
+          right: max_right_offset
+        }
       }
     end
   end

data/lib/applitools/core/match_level.rb

@@ -8,11 +8,12 @@ module Applitools
     LAYOUT1 = 'Layout1'.freeze
     LAYOUT2 = 'Layout2'.freeze
     CONTENT = 'Content'.freeze
+    IGNORE_COLORS = 'IgnoreColors'.freeze
     STRICT = 'Strict'.freeze
     EXACT = 'Exact'.freeze
 
     def enum_values
-      [NONE, LAYOUT, LAYOUT1, LAYOUT2, CONTENT, STRICT, EXACT]
+      [NONE, LAYOUT, LAYOUT1, LAYOUT2, CONTENT, IGNORE_COLORS, STRICT, EXACT]
     end
   end
 end

data/lib/applitools/core/test_result_summary.rb

@@ -18,7 +18,7 @@ module Applitools
 
     def old_style_results_array
       Applitools::Utils.deep_stringify_keys(results).map do |e|
-        r = e['testResults'] ? e['testResults'] : {}
+        r = e['result'] ? e['result'] : {}
         Applitools::TestResults.new(r)
       end
     end

data/lib/applitools/core/universal_eyes_checks.rb

@@ -13,9 +13,11 @@ module Applitools
 
       raise Applitools::EyesNotOpenException.new('Eyes not open!') if @universal_eyes.nil?
       Applitools::EyesLogger.logger.info "#{test_name} : check(#{name}) started  ..."
+      settings = get_universal_check_settings(name, target)
+      image_target = settings[:image].nil? ? {} : { image: settings.delete(:image) }
       # require 'pry'
       # binding.pry
-      check_result = @universal_eyes.check(get_universal_check_settings(name, target))
+      check_result = @universal_eyes.check(settings, image_target)
       if server_error?(check_result)
         # require 'pry'
         # binding.pry
@@ -23,12 +25,13 @@ module Applitools
       end
 
       if check_result != {}
-        result = Applitools::MatchResult.new(Applitools::Utils.deep_stringify_keys(check_result))
+        result = Applitools::MatchResult.new(Applitools::Utils.deep_stringify_keys(check_result[0]))
 
         check_fail_result_processing(name) unless result.as_expected?
       end
 
       logger.info 'Done!'
+      result
     end
 
     private

data/lib/applitools/core/universal_eyes_open.rb

@@ -18,17 +18,19 @@ module Applitools
     #   trigger recording and frame handling
     def universal_open(options = {})
       original_driver = options.delete(:driver)
-      Applitools::ArgumentGuard.not_nil original_driver, 'options[:driver]'
+      if self.class.name != 'Applitools::Images::Eyes'
+        Applitools::ArgumentGuard.not_nil original_driver, 'options[:driver]'
 
-      if respond_to?(:disabled?) && disabled?
-        logger.info('Ignored')
-        return original_driver
-      end
+        if respond_to?(:disabled?) && disabled?
+          logger.info('Ignored')
+          return original_driver
+        end
 
-      self.driver = Applitools::Selenium::SeleniumEyes.eyes_driver(original_driver, self)
+        self.driver = Applitools::Selenium::SeleniumEyes.eyes_driver(original_driver, self)
+      end
 
       update_config_from_options(options)
-      universal_driver_config = driver.universal_driver_config
+      universal_driver_config = driver.universal_driver_config if self.class.name != 'Applitools::Images::Eyes'
       universal_eyes_manager = runner.get_universal_eyes_manager
 
       universal_eyes_config = Applitools::UniversalEyesConfig.new
@@ -42,7 +44,11 @@ module Applitools
 
       self.open = true if respond_to?(:open=, true)
       self.running_session = true if respond_to?(:running_session=, true)
-      driver
+      if self.class.name != 'Applitools::Images::Eyes'
+        driver
+      else
+        self.open?
+      end
     rescue Applitools::EyesError => e
       logger.error e.message
       raise e

data/lib/applitools/core/universal_new_api.rb

@@ -9,12 +9,18 @@ module Applitools
     #   minMatch?: number
     #   language?: string
     # }
-    def extract_text(targets_array)
+    def extract_text(*args)
+      image_target = args[0].is_a?(Hash) ? args[0] : nil
+      targets_array = args[0].is_a?(Hash) ? args[1].to_a : args[0]
       targets_array.map do |target|
         target['target'] = { elementId: target['target'].ref } if target['target'].is_a?(::Selenium::WebDriver::Element)
+        target['target']['x'] = target['target'].delete('left') if target['target']['left']
+        target['target']['y'] = target['target'].delete('top') if target['target']['top']
+        target[:region] = target.delete('target')
         target
       end
-      universal_eyes.extract_text(targets_array)
+      driver_target = respond_to?(:driver) ? driver.universal_driver_config : image_target
+      universal_eyes.extract_text(targets_array, driver_target)
     end
 
 
@@ -25,7 +31,8 @@ module Applitools
     #   language?: string
     # }
     def extract_text_regions(patterns_array)
-      results = universal_eyes.extract_text_regions(patterns_array)
+      driver_target = respond_to?(:driver) ? driver.universal_driver_config : { image: patterns_array.delete('image') }
+      results = universal_eyes.extract_text_regions(patterns_array, driver_target)
       Applitools::Utils.deep_stringify_keys(results)
     end
 
@@ -35,7 +42,8 @@ module Applitools
         locatorNames: locate_settings[:locator_names],
         firstOnly: !!locate_settings[:first_only]
       }
-      results = universal_eyes.locate(settings)
+      driver_target = driver.universal_driver_config
+      results = universal_eyes.locate(settings, driver_target)
       Applitools::Utils.deep_stringify_keys(results)
     end
 

data/lib/applitools/universal_sdk/universal_check_settings.rb

@@ -80,6 +80,19 @@ module Applitools
       :scrollRootElement,
       :fully
 
+    # v3
+    json_fields :ufgOptions,
+                :userCommandId
+
+    # ImageTarget
+    json_fields :image
+                # :name,
+                # :source,
+                # :dom,
+                # :locationInViewport,
+                # :locationInView,
+                # :fullViewSize
+
     def initialize(*args)
       options = Applitools::Utils.extract_options! args
       options.keys.select {|k| options[k] && respond_to?("#{k}=") }.each {|k| send("#{k}=", options[k]) }
@@ -100,6 +113,7 @@ module Applitools
     def from_original_target(target, eyes)
       # require('pry')
       # binding.pry
+      return from_eyes_images(target, eyes) if eyes.class.name === 'Applitools::Images::Eyes'
 
       self.accessibility_settings = eyes.accessibility_validation
       self.disable_browser_fetching = eyes.dont_fetch_resources
@@ -160,11 +174,39 @@ module Applitools
       self.send_dom = from_target_options_or_eyes(:send_dom, target.options, eyes)
       self.use_dom = from_target_options_or_eyes(:use_dom, target.options, eyes)
       self.visual_grid_options = from_target_options_or_eyes(:visual_grid_options, target.options, eyes)
+      self.ufg_options = self.visual_grid_options
+      self.user_command_id = self.variation_group_id
+
+      self.image = target.image if target.respond_to?(:image)
     # rescue => e
     #   require('pry')
     #   binding.pry
     end
 
+    def from_eyes_images(target, eyes)
+      self.accessibility_settings = eyes.accessibility_validation
+      self.disable_browser_fetching = eyes.dont_fetch_resources
+      self.accessibility_regions = target.accessibility_regions
+      self.floating_regions = target.floating_regions
+
+      self.ignore_regions = target.ignored_regions.map do |ir|
+        ir.is_a?(Proc) ? normalize_element_selector(ir.call(eyes.driver)) : ir
+      end
+
+      if target.region_to_check.is_a?(Hash)
+        self.region = target.region_to_check
+      elsif target.region_to_check.is_a?(String)
+        self.region = target.region_to_check
+      elsif target.region_to_check.is_a?(Proc)
+        el = target.region_to_check.call(eyes.driver)
+        self.region = normalize_element_selector(el) unless el.respond_to?(:empty?) && el.empty?
+      end
+
+      self.exact = (target.options[:exact] && target.options[:exact].to_hash) || (eyes.exact && eyes.exact.to_hash)
+
+      self.image = target.image
+    end
+
     def to_hash
       json_data.compact.reject do |_, v|
         case v

data/lib/applitools/universal_sdk/universal_client.rb

@@ -16,29 +16,37 @@ module Applitools::Connectivity
     extend Forwardable
     def_delegators 'Applitools::EyesLogger', :logger
 
-    SESSION_INIT = 'Core.makeSDK'
+    SESSION_INIT = 'Core.makeCore'
 
     CORE_MAKE_MANAGER = 'Core.makeManager'
     CORE_GET_VIEWPORT_SIZE = 'Core.getViewportSize'
     CORE_SET_VIEWPORT_SIZE = 'Core.setViewportSize'
-    CORE_CLOSE_BATCHES = 'Core.closeBatches'
+    CORE_CLOSE_BATCHES = 'Core.closeBatch'
     CORE_DELETE_TEST = 'Core.deleteTest'
 
     EYES_MANAGER_MAKE_EYES = 'EyesManager.openEyes'
     EYES_MANAGER_CLOSE_ALL_EYES = 'EyesManager.closeManager'
     EYES_CHECK = 'Eyes.check'
-    EYES_LOCATE = 'Eyes.locate'
-    EYES_EXTRACT_TEXT_REGIONS = 'Eyes.extractTextRegions'
+    EYES_CHECK_AND_CLOSE = 'Eyes.checkAndClose' # ...
+    EYES_LOCATE = 'Core.locate'
+    EYES_EXTRACT_TEXT_REGIONS = 'Eyes.locateText'
     EYES_EXTRACT_TEXT = 'Eyes.extractText'
     EYES_CLOSE = 'Eyes.close'
     EYES_ABORT = 'Eyes.abort'
 
+    attr_accessor :commands_config
 
     def initialize
       # @socket = Applitools::Connectivity::UniversalClientSocket.new
       prepare_socket
       # store on open for next check calls
       @open_config = nil
+      @commands_config = {
+        open: {},
+        screenshot: {},
+        check: {},
+        close: {}
+      }
     end
 
     def make_manager(eyes_manager_config)
@@ -50,66 +58,207 @@ module Applitools::Connectivity
 
 
     def core_make_manager(eyes_manager_config)
-      # await(->(cb) { @socket.request(CORE_MAKE_MANAGER, eyes_manager_config, cb) })
+      # interface MakeManagerRequestPayload {
+      #   type: 'ufg' | 'classic'
+      #   concurrency?: number
+      #   legacyConcurrency?: number
+      #   agentId?: string
+      # }
+      #
+      # type MakeManagerResponsePayload = Ref<EyesManager>
       command_with_result(CORE_MAKE_MANAGER, eyes_manager_config)
     end
 
+    def config_mapping(old_config, command_config, name)
+      return if old_config[name].nil?
+      command_config[name] = old_config.delete(name)
+    end
+
+    def map_open_eyes_config_to_commands_config(config)
+      [
+        :serverUrl, :apiKey, :proxy, :connectionTimeout, :removeSession, :agentId, :appName, :testName, :displayName,
+        :userTestId, :sessionType, :properties, :batch, :keepBatchOpen, :environmentName, :environment, :branchName,
+        :parentBranchName, :baselineEnvName, :baselineBranchName, :compareWithParentBranch, :ignoreBaseline,
+        :ignoreGitBranching, :saveDiffs, :abortIdleTestTimeout
+      ].each do |k|
+        config_mapping(config, commands_config[:open], k)
+      end
+
+      commands_config[:open][:keepBatchOpen] = config.delete(:dontCloseBatches) unless config[:dontCloseBatches].nil?
+
+      [:hideCaret, :hideScrollbars, :disableBrowserFetching, :sendDom, :stitchMode,
+       :layoutBreakpoints, :waitBeforeCapture].each do |k|
+        config_mapping(config, commands_config[:check], k)
+      end
+
+      commands_config[:check][:renderers] = config.delete(:browsersInfo) unless config[:browsersInfo].nil?
+
+      unless config[:defaultMatchSettings].nil?
+        if config[:defaultMatchSettings][:accessibilitySettings]
+          commands_config[:check][:accessibilitySettings] = {}
+          commands_config[:check][:accessibilitySettings][:level] = config[:defaultMatchSettings][:accessibilitySettings].delete(:level) unless config[:defaultMatchSettings][:accessibilitySettings][:level].nil?
+          commands_config[:check][:accessibilitySettings][:version] = config[:defaultMatchSettings][:accessibilitySettings].delete(:guidelinesVersion) unless config[:defaultMatchSettings][:accessibilitySettings][:guidelinesVersion].nil?
+          config[:defaultMatchSettings].delete(:accessibilitySettings) if config[:defaultMatchSettings][:accessibilitySettings].empty?
+        end
+        commands_config[:check][:ignoreCaret] = config[:defaultMatchSettings].delete(:ignoreCaret) unless config[:defaultMatchSettings][:ignoreCaret].nil?
+        commands_config[:check][:matchLevel] = config[:defaultMatchSettings].delete(:matchLevel) unless config[:defaultMatchSettings][:matchLevel].nil?
+        config.delete(:defaultMatchSettings) if config[:defaultMatchSettings].empty?
+      end
+
+      if commands_config[:check][:fully].nil?
+        commands_config[:check][:fully] = config.delete(:forceFullPageScreenshot) unless config[:forceFullPageScreenshot].nil?
+      end
+
+      commands_config[:close][:updateBaselineIfNew] = config.delete(:saveNewTests) unless config[:saveNewTests].nil?
+      commands_config[:close][:updateBaselineIfDifferent] = config.delete(:saveFailedTests) unless config[:saveFailedTests].nil?
+
+      commands_config[:screenshot] = commands_config[:check]
+    end
+
+
+
+
     def eyes_manager_make_eyes(manager, driver_config, config)
       @open_config = config
 
-      # await(->(cb) {
-      #   @socket.request(EYES_MANAGER_MAKE_EYES, {manager: manager, driver: driver_config, config: config}, cb)
-      # })
-      command_with_result(EYES_MANAGER_MAKE_EYES, {manager: manager, driver: driver_config, config: config})
+      map_open_eyes_config_to_commands_config(config)
+      # interface OpenEyesRequestPayload {
+      #   manager: Ref<EyesManager>
+      #   target?: DriverTarget
+      #   settings?: OpenSettings
+      #   config?: Config
+      # }
+      #
+      # type OpenEyesResponsePayload = Ref<Eyes>
+      command_with_result(EYES_MANAGER_MAKE_EYES, {manager: manager, target: driver_config, settings: commands_config[:open], config: commands_config})
     end
 
     def eyes_manager_close_all_eyes(manager)
-      # await(->(cb) { @socket.request(EYES_MANAGER_CLOSE_ALL_EYES, {manager: manager}, cb) })
-      command_with_result(EYES_MANAGER_CLOSE_ALL_EYES, {manager: manager})
+      # interface CloseManagerRequestPayload {
+      #   manager: Ref<EyesManager>
+      #   settings?: {throwErr?: boolean}
+      # }
+      #
+      # interface CloseManagerResponsePayload {
+      #   results: Array<{
+      #     error?: Error
+      #     result?: TestResult
+      #     renderer?: TType extends 'ufg' ? Renderer : never
+      #     userTestId: string
+      #   }>
+      #   passed: number
+      #   unresolved: number
+      #   failed: number
+      #   exceptions: number
+      #   mismatches: number
+      #   missing: number
+      #   matches: number
+      # }
+      command_with_result(EYES_MANAGER_CLOSE_ALL_EYES, {manager: manager, config: commands_config})
     end
 
-    def eyes_check(eyes, settings)
-      # await(->(cb) { @socket.request(EYES_CHECK, {eyes: eyes, settings: settings, config: @open_config}, cb) })
-      command_with_result(EYES_CHECK, {eyes: eyes, settings: settings, config: @open_config})
+    def eyes_check(eyes, settings, image_target = {})
+      # interface CheckRequestPayload {
+      #   eyes: Ref<Eyes>
+      #   target?: ImageTarget | DriverTarget
+      #   settings?: CheckSettings
+      #   config?: Config
+      # }
+      #
+      # type CheckResponsePayload = CheckResult[]
+      payload = {eyes: eyes, settings: settings, config: commands_config}
+      payload[:target] = image_target unless image_target.empty?
+      command_with_result(EYES_CHECK, payload)
     end
 
-    def eyes_locate(eyes, settings)
-      # await(->(cb) { @socket.request(EYES_LOCATE, {eyes: eyes, settings: settings, config: @open_config}, cb) })
-      command_with_result(EYES_LOCATE, {eyes: eyes, settings: settings, config: @open_config})
+    def eyes_locate(eyes, settings, driver_target)
+      # interface LocateRequestPayload {
+      #   target?: ImageTarget | DriverTarget
+      #   settings?: LocateSettings
+      #   config?: Config
+      # }
+      #
+      # interface LocateResponsePayload {
+      #   [key: string]: Array<{x: number, y: number, width: number, height: number}>
+      # }
+
+      command_with_result(EYES_LOCATE, {target: driver_target, settings: settings, config: commands_config})
     end
 
-    def eyes_extract_text_regions(eyes, settings)
-      # await(->(cb) { @socket.request(EYES_EXTRACT_TEXT_REGIONS, {eyes: eyes, settings: settings, config: @open_config}, cb) })
-      command_with_result(EYES_EXTRACT_TEXT_REGIONS, {eyes: eyes, settings: settings, config: @open_config})
+    def eyes_extract_text_regions(eyes, settings, driver_target)
+      # interface LocateTextRequestPayload {
+      #   eyes: Ref<Eyes>
+      #   target?: ImageTarget | DriverTarget
+      #   settings?: LocateTextSettings
+      #   config?: Config
+      # }
+      #
+      # type LocateTextResponcePayload = Record<string, Array<{text: string, x: number, y: number, width: number, hieght: number}>>
+      payload = {eyes: eyes, target: driver_target, settings: settings, config: commands_config}
+      payload.delete(:target) if driver_target.nil? || driver_target.empty?
+      command_with_result(EYES_EXTRACT_TEXT_REGIONS, payload)
     end
 
-    def eyes_extract_text(eyes, regions)
-      # await(->(cb) { @socket.request(EYES_EXTRACT_TEXT, {eyes: eyes, regions: regions, config: @open_config}, cb) })
-      command_with_result(EYES_EXTRACT_TEXT, {eyes: eyes, regions: regions, config: @open_config})
+    def eyes_extract_text(eyes, regions, driver_target)
+      # interface ExtractTextRequestPayload {
+      #   eyes: Ref<Eyes>
+      #   target?: ImageTarget | DriverTarget
+      #   settings?: ExtractTextSettings | ExtractTextSettings[]
+      #   config?: Config
+      # }
+      #
+      # type ExtractTextResponcePayload = string[]
+      payload = {eyes: eyes, target: driver_target, settings: regions, config: commands_config}
+      payload.delete(:settings) if regions.empty?
+      command_with_result(EYES_EXTRACT_TEXT, payload)
     end
 
     def eyes_close(eyes)
-      # await(->(cb) { @socket.request(EYES_CLOSE, {eyes: eyes}, cb) })
-      command_with_result(EYES_CLOSE, {eyes: eyes})
+      # interface CloseResponsePayload {
+      #   eyes: Ref<Eyes>
+      #   settings?: CloseSettings
+      #   config?: Config
+      # }
+      #
+      # type CloseResponsePayload = TestResult[]
+      settings = {throwErr: false}
+
+      command_with_result(EYES_CLOSE, {eyes: eyes, settings: settings, config: commands_config})
     end
 
     def eyes_abort(eyes)
-      # await(->(cb) { @socket.request(EYES_ABORT, {eyes: eyes}, cb) })
+      # interface AbortPayload {
+      #   eyes: Ref<Eyes>
+      # }
+      #
+      # type AbortResponsePayload = TestResult[]
       command_with_result(EYES_ABORT, {eyes: eyes})
     end
 
     def core_get_viewport_size(driver)
-      # await(->(cb) { @socket.request(CORE_GET_VIEWPORT_SIZE, {driver: driver}, cb) })
-      command_with_result(CORE_GET_VIEWPORT_SIZE, {driver: driver})
+      # interface GetViewportSizeRequestPayload {
+      #   target: DriverTarget
+      # }
+      #
+      # interface GetViewportSizeResponsePayload {
+      #   width: number
+      #   height: number
+      # }
+      command_with_result(CORE_GET_VIEWPORT_SIZE, {target: driver})
     end
 
     def core_set_viewport_size(driver, size)
-      # await(->(cb) { @socket.request(CORE_SET_VIEWPORT_SIZE, {driver: driver, size: size}, cb) })
-      command_with_result(CORE_SET_VIEWPORT_SIZE, {driver: driver, size: size})
+      # interface SetViewportSizeRequestPayload {
+      #   target: DriverTarget
+      #   size: {width: number, height: number}
+      # }
+      command_with_result(CORE_SET_VIEWPORT_SIZE, {target: driver, size: size})
     end
 
     def core_close_batches(close_batch_settings=nil)
-      # batchIds, serverUrl?, apiKey?, proxy?
+      # interface CloseBatchRequestPayload {
+      #   settings: CloseBatchSettings | CloseBatchSettings[]
+      # }
       unless close_batch_settings.is_a?(Hash)
         batch_ids = [@open_config[:batch][:id]]
         batch_ids = [close_batch_settings] if close_batch_settings.is_a?(String)
@@ -117,13 +266,13 @@ module Applitools::Connectivity
         optional = [:serverUrl, :apiKey, :proxy].map {|k| [k, @open_config[k]] }.to_h
         close_batch_settings = { settings: ({ batchIds: batch_ids }.merge(optional).compact) }
       end
-      # await(->(cb) { @socket.request(CORE_CLOSE_BATCHES, close_batch_settings, cb) })
       command_with_result(CORE_CLOSE_BATCHES, close_batch_settings)
     end
 
     def core_delete_test(delete_test_settings)
-      # testId, batchId, secretToken, serverUrl, apiKey?, proxy?
-      # await(->(cb) { @socket.request(CORE_DELETE_TEST, delete_test_settings, cb) })
+      # interface DeleteTestRequestPayload {
+      #   settings: DeleteTestSettings | DeleteTestSettings[]
+      # }
       command_with_result(CORE_DELETE_TEST, delete_test_settings)
     end
 
@@ -175,12 +324,13 @@ module Applitools::Connectivity
     end
 
     def session_init
-      command(SESSION_INIT, {
+      make_core_payload = {
         name: :rb,
         version: Applitools::VERSION,
         protocol: :webdriver,
         cwd: Dir.pwd
-      })
+      }
+      command(SESSION_INIT, make_core_payload)
       # no response
     end
 

data/lib/applitools/universal_sdk/universal_eyes.rb

@@ -11,10 +11,10 @@ module Applitools
       @universal_client = universal_client
     end
 
-    def check(settings)
+    def check(settings, image_target = {})
       elapsed_time_start = Time.now
       # Applitools::EyesLogger.logger.debug "check settings: #{settings}"
-      check_result = @universal_client.eyes_check(@eyes, settings)
+      check_result = @universal_client.eyes_check(@eyes, settings, image_target)
       # Applitools::EyesLogger.logger.debug "check_result: #{check_result}"
       Applitools::EyesLogger.logger.info "Completed in #{format('%.2f', Time.now - elapsed_time_start)} seconds"
       check_result
@@ -28,16 +28,16 @@ module Applitools
       @universal_client.eyes_abort(@eyes)
     end
 
-    def locate(settings)
-      @universal_client.eyes_locate(@eyes, settings)
+    def locate(settings, driver_target)
+      @universal_client.eyes_locate(@eyes, settings, driver_target)
     end
 
-    def extract_text_regions(patterns_array)
-      @universal_client.eyes_extract_text_regions(@eyes, patterns_array)
+    def extract_text_regions(patterns_array, driver_target)
+      @universal_client.eyes_extract_text_regions(@eyes, patterns_array, driver_target)
     end
 
-    def extract_text(targets_array)
-      @universal_client.eyes_extract_text(@eyes, targets_array)
+    def extract_text(targets_array, driver_target)
+      @universal_client.eyes_extract_text(@eyes, targets_array, driver_target)
     end
 
   end

data/lib/applitools/universal_sdk/universal_eyes_config.rb

@@ -123,6 +123,13 @@ module Applitools
       :layoutBreakpoints,
       :disableBrowserFetching
 
+    # v3
+    json_fields :environment
+    # :updateBaselineIfDifferent,
+    # :updateBaselineIfNew,
+    # :ignoreGitBranching,
+    # :abortIdleTestTimeout
+
     # 23 + 3 + 2 + 11 = 39
     FROM_ORIGINAL_EYES = [:api_key, :app_name, :batch, :browsers_info, :concurrent_sessions, :debug_screenshots,
       :force_full_page_screenshot, :hide_caret, :hide_scrollbars, :host_app, :host_os, :match_timeout, :proxy,
@@ -159,8 +166,27 @@ module Applitools
       end
     end
 
+    def from_eyes_images
+      FROM_ORIGINAL_EYES - [
+        :browsers_info,
+        :concurrent_sessions,
+        :debug_screenshots,
+        :force_full_page_screenshot,
+        :hide_caret,
+        :hide_scrollbars,
+        :send_dom,
+        :stitch_mode,
+        :visual_grid_options,
+        :wait_before_screenshots,
+        :wait_before_capture,
+        :stitching_overlap
+      ]
+
+    end
+
     def from_original_sdk(original_eyes)
-      FROM_ORIGINAL_EYES.each {|m| copy_from(m, original_eyes) }
+      from_eyes = original_eyes.class.name != 'Applitools::Images::Eyes' ? FROM_ORIGINAL_EYES : from_eyes_images
+      from_eyes.each {|m| copy_from(m, original_eyes) }
       self.agent_id = original_eyes.base_agent_id if original_eyes.respond_to?(:base_agent_id)
       self.agent_id = original_eyes.full_agent_id if original_eyes.respond_to?(:full_agent_id)
       # self.display_name = original_eyes.app_name
@@ -181,10 +207,28 @@ module Applitools
       self.default_match_settings = default_match_settings.to_hash if default_match_settings.is_a?(Applitools::ImageMatchSettings)
       self.proxy = proxy.to_hash if proxy.is_a?(Applitools::Connectivity::Proxy)
       self.viewport_size = viewport_size.to_h if viewport_size.is_a?(Applitools::RectangleSize)
+      v3api_change
       # require 'pry'
       # binding.pry
     end
 
+    def v3api_change
+      # self.updateBaselineIfDifferent = saveFailedTests unless saveFailedTests.nil?
+      # self.updateBaselineIfNew = saveNewTests unless saveNewTests.nil?
+      environment = {}
+      environment[:hostApp] = hostApp unless hostApp.nil?
+      environment[:hostAppInfo] = hostAppInfo unless hostAppInfo.nil?
+      environment[:hostOS] = hostOS unless hostOS.nil?
+      environment[:hostOSInfo] = hostOSInfo unless hostOSInfo.nil?
+      environment[:deviceInfo] = deviceInfo unless deviceInfo.nil?
+      unless viewportSize.nil?
+        environment[:viewportSize] = viewportSize
+        self.viewportSize = nil
+      end
+      self.environment = environment unless environment.empty?
+      # :ignoreGitBranching, :abortIdleTestTimeout
+    end
+
     def to_hash
       json_data.compact.reject do |_, v|
         case v

data/lib/applitools/universal_sdk/universal_eyes_manager_config.rb

@@ -18,7 +18,7 @@ module Applitools
     # }
     attr_reader :type, :concurrency, :legacy
 
-    VG = 'vg'.freeze
+    VG = 'ufg'.freeze
     CLASSIC = 'classic'.freeze
     def type_enum_values
       [VG, CLASSIC]

data/lib/applitools/version.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: false
 
 module Applitools
-  VERSION = '4.4.1'.freeze
-  UNIVERSAL_VERSION = '2.12.3'.freeze
+  VERSION = '4.5.0.beta'.freeze
+  IMAGES_VERSION = '4.0.0.alpha'.freeze
+  UNIVERSAL_VERSION = '3.0.2'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eyes_core
 version: !ruby/object:Gem::Version
-  version: 4.4.1
+  version: 4.5.0.beta
 platform: ruby
 authors:
 - Applitools Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-10-03 00:00:00.000000000 Z
+date: 2022-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -114,14 +114,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.12.3
+        version: 3.0.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.12.3
+        version: 3.0.2
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -422,9 +422,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.3.14
 signing_key: