eyes_core 3.18.1 → 4.0.0

data/lib/applitools/universal_sdk/universal_check_settings.rb

@@ -0,0 +1,184 @@
+# 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}
+    #     renderId?: string
+    #     variationGroupId?: string
+    #     timeout?: number
+    #   }
+    json_fields :name,
+      :disableBrowserFetching,
+      :layoutBreakpoints,
+      :visualGridOptions,
+      :hooks,
+      :renderId,
+      :variationGroupId,
+      :timeout
+
+    # 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.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.closeAllEyes'
+    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

data/lib/applitools/universal_sdk/universal_eyes_config.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+module Applitools
+  class UniversalEyesConfig
+    include Applitools::Jsonable
+
+    # export type EyesBaseConfig = {
+    #   logs?: LogHandler
+    #   debugScreenshots?: DebugScreenshotHandler
+    #   agentId?: string
+    #   apiKey?: string
+    #   serverUrl?: string
+    #   proxy?: Proxy
+    #   isDisabled?: boolean
+    #   connectionTimeout?: number
+    #   removeSession?: boolean
+    #   remoteEvents?: {serverUrl: string; accessKey?: string; timeout?: number}
+    # }
+    json_fields :logs,
+      :debugScreenshots,
+      :agentId,
+      :apiKey,
+      :serverUrl,
+      :proxy,
+      :isDisabled,
+      :connectionTimeout,
+      :removeSession,
+      :remoteEvents
+
+    # export type EyesOpenConfig = {
+    #   appName?: string
+    #   testName?: string
+    #   displayName?: string
+    #   viewportSize?: Size
+    #   sessionType?: SessionType
+    #   properties?: CustomProperty[]
+    #   batch?: Batch
+    #   defaultMatchSettings?: MatchSettings<Region>
+    #   hostApp?: string
+    #   hostOS?: string
+    #   hostAppInfo?: string
+    #   hostOSInfo?: string
+    #   deviceInfo?: string
+    #   baselineEnvName?: string
+    #   environmentName?: string
+    #   branchName?: string
+    #   parentBranchName?: string
+    #   baselineBranchName?: string
+    #   compareWithParentBranch?: boolean
+    #   ignoreBaseline?: boolean
+    #   saveFailedTests?: boolean
+    #   saveNewTests?: boolean
+    #   saveDiffs?: boolean
+    #   dontCloseBatches?: boolean
+    # }
+    json_fields :appName,
+      :testName,
+      :displayName,
+      :viewportSize,
+      :sessionType,
+      :properties,
+      :batch,
+      :defaultMatchSettings,
+      :hostApp,
+      :hostOS,
+      :hostAppInfo,
+      :hostOSInfo,
+      :deviceInfo,
+      :baselineEnvName,
+      :environmentName,
+      :branchName,
+      :parentBranchName,
+      :baselineBranchName,
+      :compareWithParentBranch,
+      :ignoreBaseline,
+      :saveFailedTests,
+      :saveNewTests,
+      :saveDiffs,
+      :dontCloseBatches
+
+    # export type EyesCheckConfig = {
+    #   sendDom?: boolean
+    #   matchTimeout?: number
+    #   forceFullPageScreenshot?: boolean
+    # }
+    json_fields :sendDom,
+      :matchTimeout,
+      :forceFullPageScreenshot
+
+    # export type EyesClassicConfig<TElement = unknown, TSelector = unknown> = {
+    #   waitBeforeScreenshots?: number
+    #   stitchMode?: StitchMode
+    #   hideScrollbars?: boolean
+    #   hideCaret?: boolean
+    #   stitchOverlap?: number
+    #   scrollRootElement?: TElement | TSelector
+    #   cut?: ImageCropRect | ImageCropRegion
+    #   rotation?: ImageRotation
+    #   scaleRatio?: number
+    # }
+    json_fields :waitBeforeScreenshots,
+      :stitchMode,
+      :hideScrollbars,
+      :hideCaret,
+      :stitchOverlap,
+      :scrollRootElement,
+      :cut,
+      :rotation,
+      :scaleRatio
+
+    # export type EyesUFGConfig = {
+    #   concurrentSessions?: number
+    #   browsersInfo?: (DesktopBrowserRenderer | ChromeEmulationDeviceRenderer | IOSDeviceRenderer)[]
+    #   visualGridOptions?: Record<string, any>
+    #   layoutBreakpoints?: boolean | number[]
+    #   disableBrowserFetching?: boolean
+    # }
+    json_fields :concurrentSessions,
+      :browsersInfo,
+      :visualGridOptions,
+      :layoutBreakpoints,
+      :disableBrowserFetching
+
+    # 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,
+      :save_failed_tests, :save_new_tests, :scale_ratio, :send_dom, :server_url, :stitch_mode, :test_name,
+      :viewport_size, :visual_grid_options, :wait_before_screenshots] + [
+      :disabled?, # disabled? => is_disabled
+      :stitching_overlap, # SeleniumEyes.stitching_overlap => stitch_overlap
+      :dont_fetch_resources # dont_fetch_resources => disable_browser_fetching
+    ] + [
+      :layout_breakpoints,
+      :scroll_root_element,
+    ] + [
+      :environment_name, :branch_name, :default_match_settings, :properties, :parent_branch_name,
+      :compare_with_parent_branch, :baseline_env_name, :save_diffs, :session_type, :baseline_branch_name
+    ]
+
+    # 51 - 39 - 2 = 10
+    OTHER = [:logs, :remove_session, :remote_events, :display_name, :host_app_info, :host_os_info, :device_info,
+      :ignore_baseline, :cut, :rotation ]
+
+
+    alias disabled= is_disabled=
+    alias stitching_overlap= stitch_overlap=
+    alias dont_fetch_resources= disable_browser_fetching=
+
+    def initialize(*args)
+      options = Applitools::Utils.extract_options! args
+      options.keys.select {|k| options[k] && respond_to?("#{k}=") }.each {|k| send("#{k}=", options[k]) }
+      # other
+      self.connection_timeout = Applitools::Connectivity::ServerConnector::DEFAULT_TIMEOUT
+      if 'true'.casecmp(ENV['APPLITOOLS_DONT_CLOSE_BATCHES'] || '') == 0
+        self.dont_close_batches = true
+        Applitools::EyesLogger.info('APPLITOOLS_DONT_CLOSE_BATCHES environment variable set to true. Doing nothing.')
+      end
+    end
+
+    def from_original_sdk(original_eyes)
+      FROM_ORIGINAL_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
+      prepare_for_json!
+    end
+
+    def copy_from(what, from)
+      if from.respond_to?(what)
+        send("#{what.to_s.chomp('?') }=", from.send(what))
+      else
+        puts "respond_to? #{what} - fail"
+      end
+    end
+
+    def prepare_for_json!
+      self.batch = batch.to_hash if batch.is_a?(Applitools::BatchInfo)
+      self.browsers_info = browsers_info.to_hash if browsers_info.is_a?(Applitools::Selenium::BrowsersInfo)
+      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)
+      # 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
+
+  end
+end
+# U-Notes : Added internal Applitools::UniversalEyesConfig