eyes_core 3.18.4 → 4.0.3

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

data/lib/applitools/universal_sdk/universal_check_settings.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module Applitools
+  class UniversalCheckSettings
+    include Applitools::Jsonable
+
+    # export type CheckSettings<TElement, TSelector> = MatchSettings<RegionReference<TElement, TSelector>> &
+    #   ScreenshotSettings<TElement, TSelector> & {
+    #     name?: string
+    #     disableBrowserFetching?: boolean
+    #     layoutBreakpoints?: boolean | number[]
+    #     visualGridOptions?: {[key: string]: any}
+    #     hooks?: {beforeCaptureScreenshot: string}
+    #     pageId?: string
+    #     renderId?: string
+    #     variationGroupId?: string
+    #     timeout?: number
+    #     waitBeforeCapture?: number
+    #   }
+    json_fields :name,
+      :disableBrowserFetching,
+      :layoutBreakpoints,
+      :visualGridOptions,
+      :hooks,
+      :pageId,
+      :renderId,
+      :variationGroupId,
+      :timeout,
+      :waitBeforeCapture
+
+    # 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>)[]
+    # }
+    json_fields :exact,
+      :matchLevel,
+      :sendDom,
+      :useDom,
+      :enablePatterns,
+      :ignoreCaret,
+      :ignoreDisplacements,
+      :accessibilitySettings,
+      :ignoreRegions,
+      :layoutRegions,
+      :strictRegions,
+      :contentRegions,
+      :floatingRegions,
+      :accessibilityRegions
+
+    # export type ScreenshotSettings<TElement, TSelector> = {
+    #   region?: RegionReference<TElement, TSelector>
+    #   frames?: (ContextReference<TElement, TSelector> | FrameReference<TElement, TSelector>)[]
+    #   scrollRootElement?: ElementReference<TElement, TSelector>
+    #   fully?: boolean
+    # }
+    json_fields :region,
+      :frames,
+      :scrollRootElement,
+      :fully
+
+    def initialize(*args)
+      options = Applitools::Utils.extract_options! args
+      options.keys.select {|k| options[k] && respond_to?("#{k}=") }.each {|k| send("#{k}=", options[k]) }
+
+      # self.timeout = Applitools::Connectivity::ServerConnector::DEFAULT_TIMEOUT
+    end
+
+    def normalize_element_selector(element)
+      if element.is_a?(::Selenium::WebDriver::Element) || element.is_a?(Applitools::Selenium::Element)
+        ref = element.ref
+        ref = element.ref[1] if ref.is_a?(Array) && ref[0] === :element
+        return { elementId: ref }
+      else
+        element
+      end
+    end
+
+    def from_original_target(target, eyes)
+      # require('pry')
+      # binding.pry
+
+      self.accessibility_settings = eyes.accessibility_validation
+      self.disable_browser_fetching = eyes.dont_fetch_resources
+
+      self.accessibility_regions = target.accessibility_regions
+      self.content_regions = target.content_regions
+      self.floating_regions = target.floating_regions
+
+      if target.respond_to?(:frames)
+        self.frames = target.frames.map do |f|
+          f = f.call(eyes.driver) if f.is_a?(Proc)
+          normalize_element_selector(f)
+        end
+      end
+
+      self.fully = target.options[:stitch_content]
+      self.hooks = target.options[:script_hooks]
+
+      # require('pry')
+      # binding.pry
+
+      self.ignore_regions = target.ignored_regions.map do |ir|
+        ir.is_a?(Proc) ? normalize_element_selector(ir.call(eyes.driver)) : ir
+      end
+      # self.ignore_regions = target.ignored_regions
+      self.layout_regions = target.layout_regions.map do |lr|
+        lr.is_a?(Proc) ? normalize_element_selector(lr.call(eyes.driver)) : lr
+      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)
+        # require('pry')
+        # binding.pry
+        el = target.region_to_check.call(eyes.driver)
+        self.region = normalize_element_selector(el) unless el.respond_to?(:empty?) && el.empty?
+      end
+      # self.region = normalize_element_selector(target.region_to_check.call(eyes.driver))
+      # self.region = nil if region.empty?
+
+      self.strict_regions = target.strict_regions
+      self.timeout = target.options[:timeout]
+      self.variation_group_id = target.options[:variation_group_id]
+      self.wait_before_capture = target.options[:wait_before_capture]
+      self.page_id = target.options[:page_id]
+
+      self.scroll_root_element = target.options[:scroll_root_element] || eyes.scroll_root_element
+      self.layout_breakpoints = target.options[:layout_breakpoints] || eyes.layout_breakpoints
+
+      self.exact = (target.options[:exact] && target.options[:exact].to_hash) || (eyes.exact && eyes.exact.to_hash)
+      self.enable_patterns = from_target_options_or_eyes(:enable_patterns, target.options, eyes)
+      self.ignore_caret = from_target_options_or_eyes(:ignore_caret, target.options, eyes)
+      self.ignore_displacements = from_target_options_or_eyes(:ignore_displacements, target.options, eyes)
+      self.match_level = from_target_options_or_eyes(:match_level, target.options, eyes)
+      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)
+    # rescue => e
+    #   require('pry')
+    #   binding.pry
+    end
+
+    def to_hash
+      json_data.compact.reject do |_, v|
+        case v
+          when Array, Hash
+            v.empty?
+          when Numeric
+            v.zero?
+          # when FalseClass
+          #   true
+          else
+            false
+        end
+      end
+    end
+
+    private
+
+    def from_target_options_or_eyes(what, options, eyes)
+      return options[what] unless options[what].nil?
+      return eyes.send(what) if eyes.respond_to?(what)
+      nil
+    end
+
+  end
+end
+# U-Notes : Added internal Applitools::UniversalCheckSettings

data/lib/applitools/universal_sdk/universal_client.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require 'eventmachine'
+
+# require_relative 'universal_client_socket'
+# require_relative 'universal_eyes_manager'
+
+module Applitools::Connectivity
+  class UniversalClient
+
+    extend Forwardable
+    def_delegators 'Applitools::EyesLogger', :logger
+
+    SESSION_INIT = 'Core.makeSDK'
+
+    CORE_MAKE_MANAGER = 'Core.makeManager'
+    CORE_GET_VIEWPORT_SIZE = 'Core.getViewportSize'
+    CORE_SET_VIEWPORT_SIZE = 'Core.setViewportSize'
+    CORE_CLOSE_BATCHES = 'Core.closeBatches'
+    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_EXTRACT_TEXT = 'Eyes.extractText'
+    EYES_CLOSE = 'Eyes.close'
+    EYES_ABORT = 'Eyes.abort'
+
+
+    def initialize(queue = EM::Queue.new)
+      @socket = Applitools::Connectivity::UniversalClientSocket.new
+      @queue = queue
+      prepare_socket
+      # store on open for next check calls
+      @open_config = nil
+    end
+
+    def make_manager(eyes_manager_config)
+      Applitools::EyesLogger.logger.debug "EyesManager config: #{eyes_manager_config}"
+      eyes_manager = core_make_manager(eyes_manager_config)
+      Applitools::EyesLogger.logger.debug "EyesManager applitools-ref-id: #{eyes_manager[:"applitools-ref-id"]}"
+      Applitools::UniversalEyesManager.new(eyes_manager, self)
+    end
+
+
+    def core_make_manager(eyes_manager_config)
+      await(->(cb) { @socket.request(CORE_MAKE_MANAGER, eyes_manager_config, cb) })
+    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)
+      })
+    end
+
+    def eyes_manager_close_all_eyes(manager)
+      await(->(cb) { @socket.request(EYES_MANAGER_CLOSE_ALL_EYES, {manager: manager}, cb) })
+    end
+
+    def eyes_check(eyes, settings)
+      await(->(cb) { @socket.request(EYES_CHECK, {eyes: eyes, settings: settings, config: @open_config}, cb) })
+    end
+
+    def eyes_locate(eyes, settings)
+      await(->(cb) { @socket.request(EYES_LOCATE, {eyes: eyes, settings: settings, config: @open_config}, cb) })
+    end
+
+    def eyes_extract_text_regions(eyes, settings)
+      await(->(cb) { @socket.request(EYES_EXTRACT_TEXT_REGIONS, {eyes: eyes, settings: settings, config: @open_config}, cb) })
+    end
+
+    def eyes_extract_text(eyes, regions)
+      await(->(cb) { @socket.request(EYES_EXTRACT_TEXT, {eyes: eyes, regions: regions, config: @open_config}, cb) })
+    end
+
+    def eyes_close(eyes)
+      await(->(cb) { @socket.request(EYES_CLOSE, {eyes: eyes}, cb) })
+    end
+
+    def eyes_abort(eyes)
+      await(->(cb) { @socket.request(EYES_ABORT, {eyes: eyes}, cb) })
+    end
+
+    def core_get_viewport_size(driver)
+      await(->(cb) { @socket.request(CORE_GET_VIEWPORT_SIZE, {driver: driver}, cb) })
+    end
+
+    def core_set_viewport_size(driver, size)
+      await(->(cb) { @socket.request(CORE_SET_VIEWPORT_SIZE, {driver: driver, size: size}, cb) })
+    end
+
+    def core_close_batches(close_batch_settings)
+      # batchIds, serverUrl?, apiKey?, proxy?
+      await(->(cb) { @socket.request(CORE_CLOSE_BATCHES, close_batch_settings, cb) })
+    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) })
+    end
+
+
+    private
+
+
+    def prepare_socket
+      socket_uri = ::Applitools::Connectivity::UniversalServer.check_or_run
+      connect_and_configure_socket(socket_uri)
+    end
+
+    def connect_and_configure_socket(uri)
+      Thread.new do
+        EM.run do
+          @socket.connect(uri)
+          @socket.emit(SESSION_INIT, {
+            name: :rb,
+            version: ::Applitools::VERSION,
+            protocol: :webdriver,
+            cwd: Dir.pwd
+          })
+        end
+      end
+    end
+
+    def await(function)
+      resolved = false
+      cb = ->(result) {
+        resolved = result
+      }
+      @queue.push(function)
+      @queue.pop {|fn| fn.call(cb)}
+      sleep 1 until !!resolved
+      resolved
+    end
+
+  end
+end
+# U-Notes : Added internal Applitools::Connectivity::UniversalClient

data/lib/applitools/universal_sdk/universal_client_socket.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'faye/websocket'
+require 'json'
+require 'securerandom'
+require 'colorize'
+
+module Applitools::Connectivity
+  class UniversalClientSocket
+    attr_reader :listeners, :queue
+
+    def initialize
+      @listeners = {}
+      @queue = []
+    end
+
+    def connect(uri, ws = ::Faye::WebSocket::Client.new(uri))
+      @socket = ws
+
+      queue.each {|command| command.call}
+      queue.clear
+
+      ws.on :message do |event|
+        message = JSON.parse(event.data, {:symbolize_names => true})
+        params = [message[:payload], message[:key]]
+        find_and_execute_listeners(message[:name], message[:key], params)
+      end
+
+      ws.on :close do |event|
+        find_and_execute_listeners('close')
+      end
+    end
+
+    def emit(message, payload)
+      command = ->() {@socket.send(serialize(message, payload))}
+      @socket ? command.call : queue.push(command)
+    end
+
+    def command(name, fn)
+      on(name, ->(payload, key) {
+        begin
+          log("[#{'COMMAND'.yellow}] #{name}, #{key}, #{JSON.pretty_generate(payload)}")
+          result = fn.call(payload)
+          emit({name: name, key: key}, {result: result})
+        rescue => error
+          log("[#{'COMMAND ERROR'.red}] #{error}")
+          emit({name: name, key: key}, error.message || error)
+        end
+      })
+    end
+
+    def request(name, payload, cb = nil, key = SecureRandom.uuid)
+      log("[#{'REQUEST'.blue}] #{name}, #{key}, #{JSON.pretty_generate(payload)}")
+      emit({name: name, key: key}, payload)
+      once({name: name, key: key}, Proc.new {|result|
+        cb.call(result[:result] || result[:error] || true) if cb
+      })
+    end
+
+    private
+
+    def find_and_execute_listeners(name, key = nil, params = [])
+      name_with_key = "#{name}/#{key}"
+      fns = listeners[name.to_sym]
+      fns = listeners[name_with_key.to_sym] if (!fns)
+      return if (!fns)
+      fns.each {|fn| fn.call(*params)}
+    end
+
+    def serialize(type, payload)
+      message = type.is_a?(String) ?
+        {:name => type, :payload => payload} : {:name => type[:name], key: type[:key], :payload => payload}
+      JSON.generate(message)
+    end
+
+    def get_name_from_type(type)
+      type.is_a?(String) ? type : "#{type[:name]}/#{type[:key]}"
+    end
+
+    def on(type, fn)
+      name = get_name_from_type(type)
+      fns = listeners[name.to_sym]
+      if (!fns)
+        fns = []
+        listeners[name.to_sym] = fns
+      end
+      fns.push(fn)
+    end
+
+    def off(type)
+      name = get_name_from_type(type)
+      listeners.delete(name.to_sym)
+    end
+
+    def once(type, fn)
+      on(type, ->(*args) {
+        fn.call(*args)
+        off(type)
+      })
+    end
+
+    def log(message)
+      if ENV['APPLITOOLS_SHOW_UNIVERSAL_LOGS']
+        Applitools::EyesLogger.logger.debug message
+      end
+    end
+
+  end
+end
+# U-Notes : Added internal Applitools::Connectivity::UniversalClientSocket

data/lib/applitools/universal_sdk/universal_eyes.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Applitools
+  class UniversalEyes
+
+    extend Forwardable
+    def_delegators 'Applitools::EyesLogger', :logger
+
+    def initialize(eyes, universal_client)
+      @eyes = eyes
+      @universal_client = universal_client
+    end
+
+    def check(settings)
+      elapsed_time_start = Time.now
+      # Applitools::EyesLogger.logger.debug "check settings: #{settings}"
+      check_result = @universal_client.eyes_check(@eyes, settings)
+      # Applitools::EyesLogger.logger.debug "check_result: #{check_result}"
+      Applitools::EyesLogger.logger.info "Completed in #{format('%.2f', Time.now - elapsed_time_start)} seconds"
+      check_result
+    end
+
+    def close
+      @universal_client.eyes_close(@eyes)
+    end
+
+    def abort
+      @universal_client.eyes_abort(@eyes)
+    end
+
+    def locate(settings)
+      @universal_client.eyes_locate(@eyes, settings)
+    end
+
+    def extract_text_regions(patterns_array)
+      @universal_client.eyes_extract_text_regions(@eyes, patterns_array)
+    end
+
+    def extract_text(targets_array)
+      @universal_client.eyes_extract_text(@eyes, targets_array)
+    end
+
+  end
+end
+# U-Notes : Added internal Applitools::UniversalEyes