eyes_core 3.18.1 → 4.0.0

data/lib/applitools/core/eyes_base.rb

@@ -6,6 +6,11 @@ require 'applitools/core/eyes_base_configuration'
 require 'applitools/core/match_level'
 require 'zlib'
 
+require_relative 'universal_eyes_open'
+require_relative 'universal_eyes_checks'
+require_relative 'universal_new_api'
+require_relative '../universal_sdk/universal_client'
+
 require_relative 'match_level_setter'
 
 module Applitools
@@ -19,6 +24,13 @@ module Applitools
   }.freeze
 
   class EyesBase
+    # new open, with eyes-manager
+    include Applitools::UniversalEyesOpen
+    # all checks here
+    include Applitools::UniversalEyesChecks
+    # add extract_text, extract_text_regions, locate
+    include Applitools::UniversalNewApi
+
     include Applitools::MatchLevelSetter
     extend Forwardable
     extend Applitools::Helpers
@@ -28,6 +40,25 @@ module Applitools
     SCREENSHOT_AS_IS = Applitools::EyesScreenshot::COORDINATE_TYPES[:screenshot_as_is].freeze
     CONTEXT_RELATIVE = Applitools::EyesScreenshot::COORDINATE_TYPES[:context_relative].freeze
 
+    class << self
+      def set_viewport_size(driver, viewport_size)
+        Applitools::ArgumentGuard.not_nil(driver, 'Driver')
+        Applitools::ArgumentGuard.not_nil(viewport_size, 'viewport_size')
+        Applitools::ArgumentGuard.is_a?(viewport_size, 'viewport_size', Applitools::RectangleSize)
+        Applitools::EyesLogger.info "Set viewport size #{viewport_size}"
+        begin
+          driver_config_json = driver.universal_driver_config
+          required_size = Applitools::RectangleSize.from_any_argument viewport_size
+          @universal_client = Applitools::Connectivity::UniversalClient.new
+          @universal_client.core_set_viewport_size(driver_config_json, required_size.to_hash)
+        rescue => e
+          Applitools::EyesLogger.error e.class
+          Applitools::EyesLogger.error e.message
+          raise Applitools::EyesError.new 'Failed to set viewport size!'
+        end
+      end
+    end
+
     attr_accessor :config
     private :config, :config=
 
@@ -60,6 +91,9 @@ module Applitools
 
     def_delegators 'config', *Applitools::EyesBaseConfiguration.methods_to_delegate
 
+    # attr_accessor :universal_client, :universal_eyes_manager
+    attr_accessor :universal_eyes, :universal_driver
+
     def initialize(*args)
       options = Applitools::Utils.extract_options!(args)
       self.runner = options[:runner]
@@ -100,6 +134,9 @@ module Applitools
       self.server_scale = 0
       self.server_remainder = 0
       self.compare_with_parent_branch = false
+
+      self.universal_eyes = nil # eyes.open
+      self.universal_driver = nil # eyes.open
     end
 
     def ensure_config
@@ -158,15 +195,20 @@ module Applitools
       self.last_screenshot = nil
       clear_user_inputs
 
+      if !running_session && !universal_eyes
+        logger.info('Server session was not started')
+        logger.info('--- Empty test ended')
+        return Applitools::TestResults.new
+      end
+
+
       if running_session.nil?
         logger.info 'Closed'
         return false
       end
 
       logger.info 'Aborting server session...'
-      server_connector.stop_session(running_session, true, false)
-      logger.info '---Test aborted'
-
+      universal_sdk_abort
     rescue Applitools::EyesError => e
       logger.error e.message
 
@@ -207,18 +249,18 @@ module Applitools
       raise e
     end
 
-    def update_config_from_options(options)
-      # Applitools::ArgumentGuard.hash options, 'open_base parameter', [:test_name]
-      default_options = { session_type: 'SEQUENTIAL' }
-      options = default_options.merge options
-
-      self.app_name = options[:app_name] if options[:app_name]
-
-      # Applitools::ArgumentGuard.not_nil options[:test_name], 'options[:test_name]'
-      self.test_name = options[:test_name] if options[:test_name]
-      self.viewport_size = options[:viewport_size] if options[:viewport_size]
-      self.session_type = options[:session_type] if options[:session_type]
-    end
+    # def update_config_from_options(options)
+    #   # Applitools::ArgumentGuard.hash options, 'open_base parameter', [:test_name]
+    #   default_options = { session_type: 'SEQUENTIAL' }
+    #   options = default_options.merge options
+    #
+    #   self.app_name = options[:app_name] if options[:app_name]
+    #
+    #   # Applitools::ArgumentGuard.not_nil options[:test_name], 'options[:test_name]'
+    #   self.test_name = options[:test_name] if options[:test_name]
+    #   self.viewport_size = options[:viewport_size] if options[:viewport_size]
+    #   self.session_type = options[:session_type] if options[:session_type]
+    # end
 
     def merge_config(other_config)
       config.merge(other_config)
@@ -319,7 +361,7 @@ module Applitools
                                                      branch_name: branch_name, parent_branch_name: parent_branch_name,
                                                      baseline_branch_name: baseline_branch_name, save_diffs: save_diffs,
                                                      properties: properties
-
+      session_start_info.agent_run_id = agent_run_id if agent_run_id
       match_window_data.start_info = session_start_info
       match_window_data.update_baseline_if_new = save_new_tests
       match_window_data.update_baseline_if_different = save_failed_tests
@@ -393,40 +435,50 @@ module Applitools
 
       clear_user_inputs
 
-      unless running_session
+      if !running_session && !universal_eyes
         be_silent || logger.info('Server session was not started')
         be_silent || logger.info('--- Empty test ended')
         return Applitools::TestResults.new
       end
 
-      is_new_session = running_session.new_session?
-      session_results_url = running_session.url
+      # is_new_session = running_session.new_session?
+      # session_results_url = running_session.url
 
       logger.info 'Ending server session...'
 
-      save = is_new_session && save_new_tests || !is_new_session && failed && save_failed_tests
+      # save = is_new_session && save_new_tests || !is_new_session && failed && save_failed_tests
 
-      logger.info "Automatically save test? #{save}"
+      # logger.info "Automatically save test? #{save}"
 
-      results = server_connector.stop_session running_session, false, save
+      # U-Notes : universal server returns Array ; keys as sym
+      universal_results = universal_eyes.close # Array even for one test
+      # require 'pry'
+      # binding.pry
+      key_transformed_results = Applitools::Utils.deep_stringify_keys(universal_results)
+      results = key_transformed_results.map {|result| Applitools::TestResults.new(result) }
+      results = results.first if results.size == 1
+      session_results_url = results.url
+      # results = server_connector.stop_session running_session, false, save
       runner.aggregate_result(results) if runner
 
-      results.is_new = is_new_session
-      results.url = session_results_url
+      # results.is_new = is_new_session
+      # results.url = session_results_url
+      save = results.new? && save_new_tests || !results.new? && failed && save_failed_tests
+      logger.info "Automatically save test? #{save}"
 
       logger.info results.to_s(verbose_results)
 
       if results.unresolved?
         if results.new?
           logger.error "--- New test ended. see details at #{session_results_url}"
-          error_message = "New test '#{session_start_info.scenario_id_or_name}' " \
-            "of '#{session_start_info.app_id_or_name}' " \
+          error_message = "New test '#{test_name}' " \
+            "of '#{app_name}' " \
             "Please approve the baseline at #{session_results_url} "
           raise Applitools::NewTestError.new error_message, results if throw_exception
         else
           logger.error "--- Differences are found. see details at #{session_results_url}"
-          error_message = "Test '#{session_start_info.scenario_id_or_name}' " \
-            "of '#{session_start_info.app_id_or_name}' " \
+          error_message = "Test '#{test_name}' " \
+            "of '#{app_name}' " \
             "detected differences! See details at #{session_results_url}"
           raise Applitools::DiffsFoundError.new error_message, results if throw_exception
         end
@@ -435,7 +487,7 @@ module Applitools
 
       if results.failed?
         logger.error "--- Failed test ended. see details at #{session_results_url}"
-        error_message = "Test '#{session_start_info.scenario_id_or_name}' of '#{session_start_info.app_id_or_name}' " \
+        error_message = "Test '#{test_name}' of '#{app_name}' " \
             "is failed! See details at #{session_results_url}"
         raise Applitools::TestFailedError.new error_message, results if throw_exception
         return results
@@ -597,6 +649,7 @@ module Applitools
                                                 branch_name: branch_name, parent_branch_name: parent_branch_name,
                                                 baseline_branch_name: baseline_branch_name, save_diffs: save_diffs,
                                                 properties: properties
+      session_start_info.agent_run_id = agent_run_id if agent_run_id
 
       logger.info 'Starting server session...'
       self.running_session = server_connector.start_session session_start_info

data/lib/applitools/core/eyes_base_configuration.rb

@@ -11,7 +11,7 @@ require 'applitools/core/image_match_settings'
 
 module Applitools
   class EyesBaseConfiguration < AbstractConfiguration
-    DEFAULT_MATCH_TIMEOUT = 2 # seconds
+    DEFAULT_MATCH_TIMEOUT = 0 # seconds
 
     DEFAULT_CONFIG = {
       branch_name: ENV['APPLITOOLS_BRANCH'],
@@ -25,7 +25,10 @@ module Applitools
       default_match_settings: Applitools::ImageMatchSettings.new,
       accessibility_validation: nil,
       properties: [],
-      match_timeout: DEFAULT_MATCH_TIMEOUT
+      match_timeout: DEFAULT_MATCH_TIMEOUT,
+      dont_fetch_resources: true,
+      enable_cross_origin_rendering: true,
+      dont_use_cookies: false,
     }.freeze
 
     class << self
@@ -118,6 +121,10 @@ module Applitools
     object_field :accessibility_validation, Applitools::AccessibilitySettings, true
     object_field :properties, Array
     int_field :match_timeout
+    string_field :agent_run_id
+    boolean_field :dont_fetch_resources
+    boolean_field :enable_cross_origin_rendering
+    boolean_field :dont_use_cookies
 
     methods_to_delegate.delete(:batch_info)
     methods_to_delegate.delete(:batch_info=)
@@ -187,7 +194,32 @@ module Applitools
       properties << { name: name, value: value } if name && value
     end
 
+    def disable_browser_fetching=(value)
+      self.dont_fetch_resources = value
+    end
+
     methods_to_delegate.push(:set_proxy)
     methods_to_delegate.push(:add_property)
+
+    # U-Notes : Universal Add
+
+    # layoutBreakpoints?: boolean | number[]
+    def layout_breakpoints=(value)
+      config_hash[:layout_breakpoints] = (value.is_a?(Array) && value.all? {|v| v.is_a?(Numeric)}) ? value : !!value
+    end
+    def layout_breakpoints
+      config_hash[:layout_breakpoints]
+    end
+    collect_method :layout_breakpoints
+
+    # scrollRootElement?: TElement | TSelector
+    def scroll_root_element=(value)
+      config_hash[:scroll_root_element] = value
+    end
+    def scroll_root_element
+      config_hash[:scroll_root_element]
+    end
+    collect_method :scroll_root_element
+
   end
 end

data/lib/applitools/core/eyes_runner.rb

@@ -3,9 +3,12 @@
 module Applitools
   class EyesRunner
     attr_accessor :batches_server_connectors_map
+    attr_accessor :universal_client, :universal_eyes_manager
 
     def initialize
       self.batches_server_connectors_map = {}
+      self.universal_client = Applitools::Connectivity::UniversalClient.new
+      self.universal_eyes_manager = nil # eyes.open
     end
 
     def add_batch(batch_id, &block)
@@ -15,5 +18,14 @@ module Applitools
     def delete_all_batches
       batches_server_connectors_map.each_value { |v| v.call if v.respond_to? :call }
     end
+
+    def get_universal_eyes_manager
+      return universal_eyes_manager if universal_eyes_manager
+      self.universal_eyes_manager = universal_client.make_manager(universal_eyes_manager_config.to_hash)
+    end
+
+    def close_all_eyes
+      get_universal_eyes_manager.close_all_eyes
+    end
   end
 end

data/lib/applitools/core/floating_region.rb

@@ -93,14 +93,14 @@ 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
+        '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
       }
     end
   end
@@ -123,5 +123,14 @@ module Applitools
       self.max_right_offset = max_right_offset
       self.max_bottom_offset = max_bottom_offset
     end
+
+    def to_hash
+      {
+        maxUpOffset: max_top_offset,
+        maxDownOffset: max_bottom_offset,
+        maxLeftOffset: max_left_offset,
+        maxRightOffset: max_right_offset
+      }
+    end
   end
 end

data/lib/applitools/core/image_match_settings.rb

@@ -98,6 +98,60 @@ module Applitools
           min_diff_height == other.min_diff_height &&
           match_threshold == other.match_threshold
       end
+
+      def to_hash
+        {
+          minDiffIntensity: min_diff_intensity,
+          minDiffWidth: min_diff_width,
+          minDiffHeight: min_diff_height,
+          matchThreshold: match_threshold
+        }
+      end
     end
+
+    # export type MatchSettings<TRegion> = {
+    #   exact?: {
+    #     minDiffIntensity: number
+    #     minDiffWidth: number
+    #     minDiffHeight: number
+    #     matchThreshold: number
+    #   }
+    #   matchLevel?: MatchLevel
+    #   sendDom?: boolean
+    #   useDom?: boolean
+    #   enablePatterns?: boolean
+    #   ignoreCaret?: boolean
+    #   ignoreDisplacements?: boolean
+    #   accessibilitySettings?: {
+    #     level?: AccessibilityLevel
+    #     guidelinesVersion?: AccessibilityGuidelinesVersion
+    #   }
+    #   ignoreRegions?: TRegion[]
+    #   layoutRegions?: TRegion[]
+    #   strictRegions?: TRegion[]
+    #   contentRegions?: TRegion[]
+    #   floatingRegions?: (TRegion | FloatingRegion<TRegion>)[]
+    #   accessibilityRegions?: (TRegion | AccessibilityRegion<TRegion>)[]
+    # }
+    def to_hash
+      result = {}
+      result[:exact] = exact.to_hash unless exact == Exact.new # ...
+      result[:matchLevel] = match_level
+      # result[:sendDom] = nil # duplicate configuration ?
+      result[:useDom] = use_dom if use_dom
+      result[:enablePatterns] = enable_patterns if enable_patterns
+      result[:ignoreCaret] = ignore_caret if ignore_caret
+      result[:ignoreDisplacements] = ignore_displacements if ignore_displacements
+      result[:accessibilitySettings] = accessibility_settings.to_hash if accessibility_settings
+      result[:ignoreRegions] = ignore unless ignore.empty?
+      result[:layoutRegions] = layout unless layout.empty?
+      result[:strictRegions] = strict unless strict.empty?
+      result[:contentRegions] = content unless content.empty?
+      result[:floatingRegions] = floating unless floating.empty?
+      result[:accessibilityRegions] = accessibility unless accessibility.empty?
+      result.compact
+      # :SplitTopHeight, :SplitBottomHeight, :scale, :remainder - deprecated ?
+    end
+
   end
 end

data/lib/applitools/core/match_level.rb

@@ -5,13 +5,15 @@ module Applitools
     extend self
     NONE = 'None'.freeze
     LAYOUT = 'Layout'.freeze
+    LAYOUT1 = 'Layout1'.freeze
     LAYOUT2 = 'Layout2'.freeze
     CONTENT = 'Content'.freeze
     STRICT = 'Strict'.freeze
     EXACT = 'Exact'.freeze
 
     def enum_values
-      [NONE, LAYOUT, LAYOUT2, CONTENT, STRICT, EXACT]
+      [NONE, LAYOUT, LAYOUT1, LAYOUT2, CONTENT, STRICT, EXACT]
     end
   end
 end
+# U-Notes : Added Layout1 MatchLevel

data/lib/applitools/core/match_window_data.rb

@@ -87,6 +87,10 @@ module Applitools
       current_data['Options']['Name'] = value
     end
 
+    def variation_group_id=(value)
+      current_data['Options']['variantId'] = value
+    end
+
     def user_inputs=(value)
       Applitools::ArgumentGuard.is_a? value, 'value', Array
       current_data['UserInputs'] += value.select { |i| i.respond_to? :to_hash }

data/lib/applitools/core/session_start_info.rb

@@ -5,7 +5,7 @@ module Applitools
     include Applitools::Jsonable
     json_fields :batchInfo, :agentId, :appIdOrName, :verId, :environment, :environmentName, :branchName, :defaultMatchSettings,
       :scenarioIdOrName, :properties, :parentBranchName, :compareWithParentBranch, :baselineEnvName, :saveDiffs, :sessionType,
-      :baselineBranchName
+      :baselineBranchName, :agentRunId
 
     wrap_data do |value|
       { startInfo: value }
@@ -28,6 +28,7 @@ module Applitools
       self.save_diffs = options[:save_diffs]
       self.session_type = options[:session_type]
       self.baseline_branch_name = options[:baseline_branch_name]
+      self.agentRunId = options[:agent_run_id] if options[:agent_run_id]
     end
 
     def to_hash

data/lib/applitools/core/test_results.rb

@@ -26,8 +26,8 @@ module Applitools
       @mismatches = results.fetch('mismatches', 0)
       @missing = results.fetch('missing', 0)
       @status = results.fetch('status', 0)
-      @is_new = nil
-      @url = nil
+      @is_new = results.fetch('isNew', nil)
+      @url = results.fetch('url', nil)
     end
 
     def passed?

data/lib/applitools/core/universal_eyes_checks.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Applitools
+  module UniversalEyesChecks
+
+    # Takes a snapshot and matches it with the expected output.
+    #
+    # @param [String] name The name of the tag.
+    # @param [Applitools::Selenium::Target] target which area of the window to check.
+    # @return [Applitools::MatchResult] The match results.
+    def universal_check(name, target)
+      return disabled_result if respond_to?(:disabled?) && disabled?
+
+      raise Applitools::EyesNotOpenException.new('Eyes not open!') if @universal_eyes.nil?
+      Applitools::EyesLogger.logger.info "#{test_name} : check(#{name}) started  ..."
+      # require 'pry'
+      # binding.pry
+      check_result = @universal_eyes.check(get_universal_check_settings(name, target))
+      if server_error?(check_result)
+        # require 'pry'
+        # binding.pry
+        raise Applitools::EyesError.new("Request failed: #{check_result[:message]}")
+      end
+
+      if check_result != {}
+        result = Applitools::MatchResult.new(Applitools::Utils.deep_stringify_keys(check_result))
+
+        check_fail_result_processing(name) unless result.as_expected?
+      end
+
+      logger.info 'Done!'
+    end
+
+    private
+
+    def disabled_result
+      logger.info "#{__method__} Ignored"
+      result = Applitools::MatchResults.new
+      result.as_expected = true
+      result
+    end
+
+    def get_universal_check_settings(name, target)
+      universal_check_settings = Applitools::UniversalCheckSettings.new(name: name)
+      universal_check_settings.from_original_target(target, self)
+      # require 'pry'
+      # binding.pry
+      universal_check_settings.to_hash
+    end
+
+    def check_fail_result_processing(name)
+      self.failed = true
+      logger.info "Mistmatch! #{name}" #unless running_session.new_session?
+
+      if failure_reports == :immediate
+        raise Applitools::TestFailedException.new "Mistmatch found in #{test_name} of #{app_name}"
+      end
+    end
+
+    def server_error?(universal_results)
+      universal_results.is_a?(Hash) && universal_results[:message] && universal_results[:stack]
+    end
+
+  end
+end
+# U-Notes : Added internal Applitools::UniversalEyesChecks

data/lib/applitools/core/universal_eyes_open.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Applitools
+  module UniversalEyesOpen
+
+    # Starts a test
+    #
+    # @param options [Hash] options
+    # @option options :driver The driver that controls the browser hosting the application
+    #   under the test. (*Required* option)
+    # @option options [String] :app_name The name of the application under the test. (*Required* option)
+    # @option options [String] :test_name The test name (*Required* option)
+    # @option options [String | Hash] :viewport_size The required browser's viewport size
+    #   (i.e., the visible part of the document's body) or +nil+ to use the current window's viewport.
+    # @option options :session_type The type of the test (e.g., standard test / visual performance test).
+    #   Default value is 'SEQUENTAL'
+    # @return [Applitools::Selenium::Driver] A wrapped web driver which enables Eyes
+    #   trigger recording and frame handling
+    def universal_open(options = {})
+      original_driver = options.delete(:driver)
+      Applitools::ArgumentGuard.not_nil original_driver, 'options[:driver]'
+
+      if respond_to?(:disabled?) && disabled?
+        logger.info('Ignored')
+        return original_driver
+      end
+
+      self.driver = Applitools::Selenium::SeleniumEyes.eyes_driver(original_driver, self)
+
+      update_config_from_options(options)
+      universal_driver_config = driver.universal_driver_config
+      universal_eyes_manager = runner.get_universal_eyes_manager
+
+      universal_eyes_config = Applitools::UniversalEyesConfig.new
+      universal_eyes_config.from_original_sdk(self)
+
+      # require('pry')
+      # binding.pry
+
+      @universal_eyes = universal_eyes_manager.open_eyes(universal_driver_config, universal_eyes_config.to_hash)
+      raise Applitools::EyesNotOpenException.new('Eyes not open!') if @universal_eyes.nil?
+
+      self.open = true if respond_to?(:open=, true)
+      self.running_session = true if respond_to?(:running_session=, true)
+      driver
+    rescue Applitools::EyesError => e
+      logger.error e.message
+      raise e
+    end
+
+    def universal_sdk_abort
+      if respond_to?(:disabled?) && disabled?
+        logger.info "#{__method__} Ignore disabled"
+        return false
+      end
+      # raise Applitools::EyesNotOpenException.new('Eyes not open!') if @eyes.nil?
+      return if @universal_eyes.nil?
+      result = @universal_eyes.abort
+
+      if result.is_a? Hash
+        logger.info "---Test aborted" if !result[:message] && !result[:stack]
+      else
+        # TestCheckFrameInFrame_Fully_Fluent_VG\
+        # require('pry')
+        # binding.pry
+      end
+    end
+
+    private
+
+    def update_config_from_options(options)
+      default_options = { session_type: 'SEQUENTIAL' }
+
+      options = default_options.merge options
+
+      self.app_name = options[:app_name] if options[:app_name]
+      self.test_name = options[:test_name] if options[:test_name]
+      if (config.viewport_size.nil? || config.viewport_size&.empty?) && options[:viewport_size]
+        self.viewport_size = Applitools::RectangleSize.from_any_argument options[:viewport_size]
+      end
+      self.session_type = options[:session_type] if options[:session_type]
+
+      raise Applitools::EyesIllegalArgument, config.validation_errors.values.join('/n') unless config.valid?
+
+      logger.info "Agent = #{full_agent_id}"
+      logger.info "open(app_name: #{app_name}, test_name: #{test_name}," \
+          " viewport_size: #{viewport_size})"
+
+      raise Applitools::EyesError.new 'API key is missing! Please set it using api_key=' if
+        api_key.nil? || (api_key && api_key.empty?)
+
+      logger.info "Batch is #{@batch}" if @batch
+      app_env = app_environment if respond_to? :app_environment
+      logger.info "Application environment is #{app_env}"
+      test_info = "'#{test_name}' of '#{app_name}' #{app_env}"
+      logger.info "--- New test started - #{test_info}"
+    end
+
+  end
+end

data/lib/applitools/core/universal_new_api.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: false
+
+module Applitools
+  module UniversalNewApi
+
+    # export type OCRExtractSettings<TElement, TSelector> = {
+    #   target: RegionReference<TElement, TSelector>
+    #   hint?: string
+    #   minMatch?: number
+    #   language?: string
+    # }
+    def extract_text(targets_array)
+      targets_array.map do |target|
+        target['target'] = { elementId: target['target'].ref } if target['target'].is_a?(::Selenium::WebDriver::Element)
+        target
+      end
+      universal_eyes.extract_text(targets_array)
+    end
+
+
+    # export type OCRSearchSettings<TPattern extends string> = {
+    #   patterns: TPattern[]
+    #   ignoreCase?: boolean
+    #   firstOnly?: boolean
+    #   language?: string
+    # }
+    def extract_text_regions(patterns_array)
+      results = universal_eyes.extract_text_regions(patterns_array)
+      Applitools::Utils.deep_stringify_keys(results)
+    end
+
+
+    def locate(locate_settings)
+      settings = {
+        locatorNames: locate_settings[:locator_names],
+        firstOnly: !!locate_settings[:first_only]
+      }
+      results = universal_eyes.locate(settings)
+      Applitools::Utils.deep_stringify_keys(results)
+    end
+
+  end
+end