eyes_selenium 3.14.10 → 3.15.0.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96e0b2d98c498cc0f8b0b196dbfc2ae3d37e1c3c6c29dc372b61e049697fd293
-  data.tar.gz: ddd642143902692e6a86d8417aa5a37ba74ab7a307f9de87d7ed2d83d79079bd
+  metadata.gz: 27cfe7cfe214411e122538c9fe51e6677fdc68741269dfa8c168b475fb54670e
+  data.tar.gz: 82fe22114714117850b1a6ca99b4863950c96465ac9d4eded6f1e9c02a613871
 SHA512:
-  metadata.gz: 58801fc423d3aa44d36ad34b66b4cae2b81321716335aaa8d49c99a8382fe90e4662d3ebb4373829722291ae2c6867af1e56c6d8ab4b2b1bb09ad24b8be463d9
-  data.tar.gz: dba14c3b600f60d4a835037781dbeaa45a32ef0a7c80a1cd62d0d790ddf6deca9a3dde83161c008f6276caddfcbc49831f3569faf15cc2356835db26a8a32a8c
+  metadata.gz: 32f774769649c2187966e03b8381a39aaff1f9c824d5266d817e44519fd315400917f160c715b55ee5d9373f2afbf2beb56c0eef495c1edde7435e89b2ba126b
+  data.tar.gz: bf8e3617978ef915b33d39bded83ba241c156e097541984dfff8d9ed4fe6d0656b9be7758bc28530613217b74ff7d62fd2ce69a3fba58560183a901f86441eb4

data/lib/applitools/selenium/concerns/browser_types.rb

@@ -0,0 +1,15 @@
+module Applitools
+  module Selenium
+    module Concerns
+      module BrowserTypes
+        extend self
+        CHROME = :chrome
+        FIREFOX = :firefox
+
+        def enum_values
+          [CHROME, FIREFOX]
+        end
+      end
+    end
+  end
+end

data/lib/applitools/selenium/concerns/browsers_info.rb

@@ -0,0 +1,16 @@
+ module Applitools
+   module Selenium
+     module Concerns
+       class BrowsersInfo < Set
+         def add(obj)
+           return super if obj.is_a? Applitools::Selenium::RenderBrowserInfo
+           raise(
+             Applitools::EyesIllegalArgument,
+             "It is expected the value to be an Applitools::Selenium::RenderBrowserInfo instance," \
+             " but got #{obj.class} instead"
+           )
+         end
+       end
+     end
+   end
+ end

data/lib/applitools/selenium/concerns/external_css_resources.rb

@@ -0,0 +1,31 @@
+require 'css_parser'
+require 'pry'
+
+module Applitools
+  module Selenium
+    module Concerns
+      class ExternalCssResources
+        include CssParser
+        def initialize(url, base_url = nil)
+          @parser = CssParser::Parser.new(absolute_paths: true)
+          @parser.load_uri!(url)
+          @parser.compact!
+        end
+
+        def flatten_rules
+          @flatten ||= flatten_hash(hash, 0)
+        end
+
+        def hash
+          @h ||= @parser.to_h
+        end
+
+        def images
+          result = []
+          @parser.each_rule_set { |s| s.expand_background_shorthand!; result.push(s) unless s.get_value('background-image').empty? }
+          result
+        end
+      end
+    end
+  end
+end

data/lib/applitools/selenium/concerns/render_browser_info_fluent.rb

@@ -0,0 +1,42 @@
+module Applitools
+  module Selenium
+    module Concerns
+      class RenderBrowserInfoFluent
+        attr_accessor :browser_info
+        def initialize(browser_info)
+          self.browser_info = browser_info
+        end
+
+        def width(value)
+          browser_info.viewport_size.width = value
+          self
+        end
+
+        def height(value)
+          browser_info.viewport_size.height = value
+          self
+        end
+
+        def type(value)
+          browser_info.browser_type = value
+          self
+        end
+
+        def platform(value)
+          browser_info.platform = value
+          self
+        end
+
+        def size_mode(value)
+          browser_info.size_mode = value
+          self
+        end
+
+        def environment(value)
+          browser_info.baseline_env_name = value
+          self
+        end
+      end
+    end
+  end
+end

data/lib/applitools/selenium/concerns/render_resources.rb

@@ -0,0 +1,15 @@
+module Applitools
+  module Selenium
+    module Concerns
+      class RenderResources < Hash
+        def []=(key, value)
+          raise Applitools::EyesIllegalArgument, "Expected key to be an instance of URI (but got #{key.class})" unless
+              key.is_a? URI
+          raise Applitools::EyesIllegalArgument, "Expected key to be an instance of Applitools::Selenium::VGResource" \
+              " (but got #{value.class})" unless value.is_a? Applitools::Selenium::VGResource
+          return super
+        end
+      end
+    end
+  end
+end

data/lib/applitools/selenium/concerns/rgrid_dom.rb

@@ -0,0 +1,46 @@
+module Applitools
+  module Selenium
+    module Concerns
+      class RGridDom
+        CONTENT_TYPE = 'x-applitools-html/cdt'.freeze
+        include Applitools::Jsonable
+        json_fields :hash, :hashFormat
+        attr_accessor :dom_nodes, :resources, :url, :data
+
+        def initialize(*args)
+          options = Applitools::Utils.extract_options! args
+          self.url = options[:url]
+          self.dom_nodes = options[:dom_nodes]
+          self.resources = options[:resources]
+          self.hash_format = 'sha256'
+          self.data = {
+              'resources' => resources,
+              'domNodes' => dom_nodes
+          }
+          self.hash = calculate_sha_256
+        end
+
+        def calculate_sha_256
+          # str = Applitools::Utils.stringify_for_hash(data)
+          Digest::SHA256.hexdigest(content)
+        end
+
+        # def hash
+        #   calculate_sha_256
+        # end
+
+        def content
+          Oj.dump(json_value(data.sort.to_h))
+        end
+
+        def resource
+          Applitools::Selenium::VGResource.new(
+            url,
+            CONTENT_TYPE,
+            content
+          )
+        end
+      end
+    end
+  end
+end

data/lib/applitools/selenium/concerns/stitch_modes.rb

@@ -0,0 +1,15 @@
+module Applitools
+  module Selenium
+    module Concerns
+      module StitchModes
+        extend self
+        CSS = :CSS
+        SCROLL = :SCROLL
+
+        def enum_values
+          [CSS, SCROLL]
+        end
+      end
+    end
+  end
+end

data/lib/applitools/selenium/concerns/test_list.rb

@@ -0,0 +1,23 @@
+module Applitools
+  module Selenium
+    class TestList < Array
+      def <<(value)
+        raise(
+          Applitools::EyesIllegalArgument,
+          "Expected value to be instance of Applitools::Selenium::RunningTest but got #{value.class} instead"
+        ) unless value.is_a? Applitools::Selenium::RunningTest
+        super
+      end
+
+      def push(*args)
+        wrong_values = args.select { |a| !a.is_a? Applitools::Selenium::RunningTest }
+        raise(
+          Applitools::EyesIllegalArgument,
+          "Expected values to contain only Applitools::Selenium::RunningTest instances, " \
+          "but got [#{wrong_values.map(&:class).join(', ')}]"
+        ) unless wrong_values.empty?
+        super
+      end
+    end
+  end
+end

data/lib/applitools/selenium/eyes.rb

@@ -1,860 +1,19 @@
-# frozen_string_literal: false
-
-module Applitools::Selenium
-  # The main API gateway for the SDK
-  class Eyes < Applitools::EyesBase
-    # @!visibility private
-    UNKNOWN_DEVICE_PIXEL_RATIO = 0
-
-    # The pixel ratio will be used if detection of device pixel ratio is failed
-    DEFAULT_DEVICE_PIXEL_RATIO = 1
-
-    DEFAULT_WAIT_BEFORE_SCREENSHOTS = 0.1 # Seconds
-
-    USE_DEFAULT_MATCH_TIMEOUT = -1
-
-    DEFAULT_STITCHING_OVERLAP = 50 # Pixels
-
-    ENTIRE_ELEMENT_SCREENSHOT = 0
-
-    FULLPAGE_SCREENSHOT = 1
-
-    VIEWPORT_SCREENSHOT = 2
-
-    extend Forwardable
-    # @!visibility public
-
-    class << self
-      def eyes_driver(driver, eyes = nil)
-        if driver.respond_to? :driver_for_eyes
-          driver.driver_for_eyes eyes
+module Applitools
+  module Selenium
+    class Eyes < SimpleDelegator
+
+      def initialize(*args)
+        options = Applitools::Utils.extract_options!(args)
+        server_url = options.delete(:server_url)
+        server_url = args.first unless server_url
+        runner = options.delete(:visual_grid_runner)
+        if runner.is_a? Applitools::Selenium::VisualGridRunner
+          super Applitools::Selenium::VisualGridEyes.new(runner, server_url)
         else
-          unless driver.is_a?(Applitools::Selenium::Driver)
-            Applitools::EyesLogger.warn("Unrecognized driver type: (#{driver.class.name})!")
-            is_mobile_device = driver.respond_to?(:capabilities) && driver.capabilities['platformName']
-            Applitools::Selenium::Driver.new(eyes, driver: driver, is_mobile_device: is_mobile_device)
-          end
-          raise Applitools::EyesError.new "Unknown driver #{driver}!"
-        end
-      end
-
-      def obtain_screenshot_type(is_element, inside_a_frame, stitch_content, force_fullpage)
-        if stitch_content || force_fullpage
-          unless inside_a_frame
-            return FULLPAGE_SCREENSHOT if force_fullpage && !stitch_content
-            return FULLPAGE_SCREENSHOT if stitch_content && !is_element
-          end
-          return ENTIRE_ELEMENT_SCREENSHOT if inside_a_frame
-          return ENTIRE_ELEMENT_SCREENSHOT if stitch_content
-        else
-          return VIEWPORT_SCREENSHOT unless stitch_content || force_fullpage
-        end
-        VIEWPORT_SCREENSHOT
-      end
-
-      # Set the viewport size.
-      #
-      # @param [Applitools::Selenium::Driver] driver The driver instance.
-      # @param [Hash] viewport_size The required browser's viewport size.
-      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)
-        begin
-          Applitools::Utils::EyesSeleniumUtils.set_viewport_size eyes_driver(driver), viewport_size
-        rescue => e
-          Applitools::EyesLogger.error e.class
-          Applitools::EyesLogger.error e.message
-          raise Applitools::EyesError.new 'Failed to set viewport size!'
-        end
-      end
-    end
-
-    # @!attribute [rw] force_full_page_screenshot
-    #   Forces a full page screenshot (by scrolling and stitching) if the
-    #   browser only supports viewport screenshots.
-    #   @return [boolean] force full page screenshot flag
-    # @!attribute [rw] wait_before_screenshots
-    #   Sets the time to wait just before taking a screenshot (e.g., to allow
-    #   positioning to stabilize when performing a full page stitching).
-    #   @return [Float] The time to wait (Seconds). Values
-    #     smaller or equal to 0, will cause the default value to be used.
-    # @!attribute [rw] hide_scrollbars
-    #   Turns on/off hiding scrollbars before taking a screenshot
-    #   @return [boolean] hide_scrollbars flag
-    # @!attribute [rw] scroll_to_region
-    #   If set to +true+ browser will scroll to specified region (even it is out of viewport window)
-    #     when check_region is called
-    #   @return [boolean] scroll_to_region flag
-    # @!attribute [rw] stitch_mode
-    #   May be set to :CSS or :SCROLL (:SCROLL is default).
-    #   When :CSS - SDK will use CSS transitions to perform scrolling, otherwise it will use Javascript
-    #   window.scroll_to() function for scrolling purposes
-    #   @return [boolean] stitch_mode (:CSS or :SCROLL)
-    # @!attribute [Applitools::RectangleSize] explicit_entire_size
-    #   May be set to an Applitools::RectangleSize instance or +nil+ (default).
-    #   @return [Applitools::RectangleSize] explicit_entire_size
-
-    attr_accessor :base_agent_id, :screenshot, :force_full_page_screenshot, :hide_scrollbars,
-      :wait_before_screenshots, :debug_screenshots, :stitch_mode, :disable_horizontal_scrolling,
-      :disable_vertical_scrolling, :explicit_entire_size, :debug_screenshot_provider, :stitching_overlap,
-      :full_page_capture_algorithm_left_top_offset, :screenshot_type, :send_dom, :use_dom, :enable_patterns
-    attr_reader :driver
-
-    def_delegators 'Applitools::EyesLogger', :logger, :log_handler, :log_handler=
-
-    # Creates a new (possibly disabled) Eyes instance that interacts with the
-    # Eyes Server at the specified url.
-    #
-    # @param server_url The Eyes Server URL.
-    def initialize(server_url = nil)
-      super
-      self.base_agent_id = "eyes.selenium.ruby/#{Applitools::VERSION}".freeze
-      self.check_frame_or_element = false
-      self.region_to_check = nil
-      self.force_full_page_screenshot = false
-      self.dont_get_title = false
-      self.hide_scrollbars = false
-      self.device_pixel_ratio = UNKNOWN_DEVICE_PIXEL_RATIO
-      self.stitch_mode = Applitools::STITCH_MODE[:scroll]
-      self.wait_before_screenshots = DEFAULT_WAIT_BEFORE_SCREENSHOTS
-      self.region_visibility_strategy = MoveToRegionVisibilityStrategy.new
-      self.debug_screenshots = false
-      self.debug_screenshot_provider = Applitools::DebugScreenshotProvider.new
-                                                                          .tag_access { tag_for_debug }
-                                                                          .debug_flag_access { debug_screenshots }
-      self.disable_horizontal_scrolling = false
-      self.disable_vertical_scrolling = false
-      self.explicit_entire_size = nil
-      self.force_driver_resolution_as_viewport_size = false
-      self.stitching_overlap = DEFAULT_STITCHING_OVERLAP
-      self.full_page_capture_algorithm_left_top_offset = Applitools::Location::TOP_LEFT
-      self.send_dom = false
-      self.use_dom = false
-      self.enable_patterns = false
-      self.prevent_dom_processing = false
-    end
-
-    # 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 open(options = {})
-      original_driver = options.delete(:driver)
-      options[:viewport_size] = Applitools::RectangleSize.from_any_argument options[:viewport_size] if
-          options[:viewport_size]
-      Applitools::ArgumentGuard.not_nil original_driver, 'options[:driver]'
-      Applitools::ArgumentGuard.hash options, 'open(options)', [:app_name, :test_name]
-
-      if disabled?
-        logger.info('Ignored')
-        return driver
-      end
-
-      @driver = self.class.eyes_driver(original_driver, self)
-      perform_driver_specific_settings(original_driver)
-
-      self.device_pixel_ratio = UNKNOWN_DEVICE_PIXEL_RATIO
-      self.position_provider = self.class.position_provider(
-        stitch_mode, driver, disable_horizontal_scrolling, disable_vertical_scrolling, explicit_entire_size
-      )
-
-      self.eyes_screenshot_factory = lambda do |image|
-        Applitools::Selenium::ViewportScreenshot.new(
-          image, driver: @driver, force_offset: position_provider.force_offset
-        )
-      end
-
-      open_base(options) do
-        self.viewport_size = nil if force_driver_resolution_as_viewport_size
-        ensure_running_session
-      end
-      @driver
-    end
-
-    def perform_driver_specific_settings(original_driver)
-      modifier = original_driver.class.to_s.downcase.gsub(/::/, '_')
-      method_name = "perform_driver_settings_for_#{modifier}"
-      send(method_name) if respond_to?(method_name, :include_private)
-    end
-
-    private :perform_driver_specific_settings
-
-    # Sets the stitch mode.
-    #
-    # @param [Hash] value The desired type of stitching (:SCROLL is default).
-    # @option value [Symbol] :css use Css to perform stitching.
-    # @option value [Symbol] :scroll Scroll to perform stitching.
-    # @return [Symbol] The type of stitching.
-    def stitch_mode=(value)
-      @stitch_mode = if value.to_s.upcase == Applitools::STITCH_MODE[:css].to_s
-                       Applitools::STITCH_MODE[:css]
-                     else
-                       Applitools::STITCH_MODE[:scroll]
-                     end
-      unless driver.nil?
-        self.position_provider = self.class.position_provider(
-          stitch_mode, driver, disable_horizontal_scrolling, disable_vertical_scrolling, explicit_entire_size
-        )
-      end
-      if stitch_mode == Applitools::STITCH_MODE[:css]
-        @css_transition_original_hide_scrollbars = hide_scrollbars
-        self.hide_scrollbars = true
-      else
-        self.hide_scrollbars = @css_transition_original_hide_scrollbars || false
-      end
-      value
-    end
-
-    # Takes a snapshot of the application under test and matches it with the expected output.
-    #
-    # @param [String] tag An optional tag to be assosiated with the snapshot.
-    # @param [Fixnum] match_timeout The amount of time to retry matching (seconds)
-    def check_window(tag = nil, match_timeout = USE_DEFAULT_MATCH_TIMEOUT)
-      target = Applitools::Selenium::Target.window.tap do |t|
-        t.timeout(match_timeout)
-        t.fully if force_full_page_screenshot
-      end
-      check(tag, target)
-    end
-
-    # @!visibility private
-    def title
-      return driver.title unless dont_get_title
-    rescue StandardError => e
-      logger.warn "failed (#{e.message})"
-      self.dont_get_title = false
-      ''
-    end
-
-    # @!visibility private
-    def get_viewport_size(web_driver = driver)
-      Applitools::ArgumentGuard.not_nil 'web_driver', web_driver
-      Applitools::Utils::EyesSeleniumUtils.extract_viewport_size(driver)
-    end
-
-    # 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 check(name, target)
-      logger.info "check(#{name}) is called"
-      self.tag_for_debug = name
-      Applitools::ArgumentGuard.is_a? target, 'target', Applitools::Selenium::Target
-      target_to_check = target.finalize
-      original_overflow = nil
-      original_position_provider = position_provider
-      original_force_full_page_screenshot = force_full_page_screenshot
-
-      eyes_element = nil
-      timeout = target_to_check.options[:timeout] || USE_DEFAULT_MATCH_TIMEOUT
-
-      self.eyes_screenshot_factory = lambda do |image|
-        Applitools::Selenium::ViewportScreenshot.new(
-          image,
-          region_provider: region_to_check
-        )
-      end
-
-      # self.prevent_dom_processing = !((!target.options[:send_dom].nil? && target.options[:send_dom]) ||
-      #     send_dom || stitch_mode == Applitools::STITCH_MODE[:css])
-
-      self.prevent_dom_processing = !((!target.options[:send_dom].nil? && target.options[:send_dom]) ||
-          send_dom)
-
-      check_in_frame target_frames: target_to_check.frames do
-        begin
-          match_data = Applitools::MatchWindowData.new
-          match_data.tag = name
-          update_default_settings(match_data)
-          eyes_element = target_to_check.region_to_check.call(driver)
-
-          unless force_full_page_screenshot
-            region_visibility_strategy.move_to_region original_position_provider,
-              Applitools::Location.new(eyes_element.location.x.to_i, eyes_element.location.y.to_i)
-            driver.find_element(:css, 'html').scroll_data_attribute = true
-          end
-
-          region_provider = Applitools::Selenium::RegionProvider.new(driver, region_for_element(eyes_element))
-
-          self.region_to_check = region_provider
-
-          match_data.read_target(target_to_check, driver)
-          match_data.use_dom = use_dom unless match_data.use_dom
-          match_data.enable_patterns = enable_patterns unless match_data.enable_patterns
-
-          is_element = eyes_element.is_a? Applitools::Selenium::Element
-          inside_a_frame = !driver.frame_chain.empty?
-
-          self.screenshot_type = self.class.obtain_screenshot_type(
-            is_element,
-            inside_a_frame,
-            target_to_check.options[:stitch_content],
-            force_full_page_screenshot
-          )
-
-          case screenshot_type
-          when ENTIRE_ELEMENT_SCREENSHOT
-            if eyes_element.is_a? Applitools::Selenium::Element
-              original_overflow = eyes_element.overflow
-              eyes_element.overflow = 'hidden'
-              eyes_element.scroll_data_attribute = true
-              eyes_element.overflow_data_attribute = original_overflow
-              self.position_provider = Applitools::Selenium::CssTranslateElementPositionProvider.new(
-                driver,
-                eyes_element
-              )
-            end
-          end
-
-          check_window_base(
-            region_provider, timeout, match_data
-          )
-        ensure
-          eyes_element.overflow = original_overflow unless original_overflow.nil?
-          self.check_frame_or_element = false
-          self.force_full_page_screenshot = original_force_full_page_screenshot
-          self.position_provider = original_position_provider
-          self.region_to_check = nil
-          self.full_page_capture_algorithm_left_top_offset = Applitools::Location::TOP_LEFT
-          region_visibility_strategy.return_to_original_position original_position_provider
-        end
-        # rubocop:enable BlockLength
-      end
-      self.prevent_dom_processing = false
-    end
-
-    # Validates the contents of an iframe and matches it with the expected output.
-    #
-    # @param [Hash] options The specific parameters of the desired screenshot.
-    # @option options [Array] :target_frames The frames to check.
-    def check_in_frame(options)
-      frames = options.delete :target_frames
-
-      Applitools::ArgumentGuard.is_a? options, 'options', Hash
-      Applitools::ArgumentGuard.is_a? frames, 'target_frames: []', Array
-
-      return yield if block_given? && frames.empty?
-
-      original_frame_chain = driver.frame_chain
-
-      logger.info 'Switching to target frame according to frames path...'
-      driver.switch_to.frames(frames_path: frames)
-      frame_chain_to_reset = driver.frame_chain
-      logger.info 'Done!'
-
-      ensure_frame_visible
-
-      yield if block_given?
-
-      reset_frames_scroll_position(frame_chain_to_reset)
-
-      logger.info 'Switching back into top level frame...'
-      driver.switch_to.default_content
-      return unless original_frame_chain
-      logger.info 'Switching back into original frame...'
-      driver.switch_to.frames frame_chain: original_frame_chain
-    end
-
-    # Creates a region instance.
-    #
-    # @param [Applitools::Element] element The element.
-    # @return [Applitools::Region] The relevant region.
-    def region_for_element(element)
-      return element if element.is_a? Applitools::Region
-
-      p = element.location
-      d = element.size
-
-      border_left_width = element.border_left_width
-      border_top_width = element.border_top_width
-      border_right_width = element.border_right_width
-      border_bottom_width = element.border_bottom_width
-
-      Applitools::Region.new(
-        p.x.round + border_left_width,
-        p.y.round + border_top_width,
-        d.width - border_left_width - border_right_width,
-        d.height - border_top_width - border_bottom_width
-      ).tap do |r|
-        border_padding = Applitools::PaddingBounds.new(
-          border_left_width,
-          border_top_width,
-          border_right_width,
-          border_bottom_width
-        )
-        r.padding(border_padding)
-      end
-    end
-
-    private :check_in_frame
-    private :region_for_element
-
-    # Takes a snapshot of the application under test and matches a region of
-    # a specific element with the expected region output.
-    #
-    # @param [Applitools::Selenium::Element] element Represents a region to check.
-    # @param [Symbol] how a finder, such :css or :id. Selects a finder will be used to find an element
-    #   See Selenium::Webdriver::Element#find_element documentation for full list of possible finders.
-    # @param [String] what The value will be passed to a specified finder. If finder is :css it must be a css selector.
-    # @param [Hash] options
-    # @option options [String] :tag An optional tag to be associated with the snapshot.
-    # @option options [Fixnum] :match_timeout The amount of time to retry matching. (Seconds)
-    # @option options [Boolean] :stitch_content If set to true, will try to get full content of the element
-    #   (including hidden content due overflow settings) by scrolling the element,
-    #   taking and stitching partial screenshots.
-    # @example Check region by element
-    #   check_region(element, tag: 'Check a region by element', match_timeout: 3, stitch_content: false)
-    # @example Check region by css selector
-    #   check_region(:css, '.form-row .input#e_mail', tag: 'Check a region by element', match_timeout: 3,
-    #   stitch_content: false)
-    # @!parse def check_region(element, how=nil, what=nil, options = {}); end
-    def check_region(*args)
-      options = { timeout: USE_DEFAULT_MATCH_TIMEOUT, tag: nil }.merge! Applitools::Utils.extract_options!(args)
-      target = Applitools::Selenium::Target.new.region(*args).timeout(options[:match_timeout])
-      target.fully if options[:stitch_content]
-      check(options[:tag], target)
-    end
-
-    # Validates the contents of an iframe and matches it with the expected output.
-    #
-    # @param [Hash] options The specific parameters of the desired screenshot.
-    # @option options [Fixnum] :timeout The amount of time to retry matching. (Seconds)
-    # @option options [String] :tag An optional tag to be associated with the snapshot.
-    # @option options [String] :frame Frame element or frame name or frame id.
-    # @option options [String] :name_or_id The name or id of the target frame (deprecated. use :frame instead).
-    # @option options [String] :frame_element The frame element (deprecated. use :frame instead).
-    # @return [Applitools::MatchResult] The match results.
-
-    def check_frame(options = {})
-      options = { timeout: USE_DEFAULT_MATCH_TIMEOUT, tag: nil }.merge!(options)
-      frame = options[:frame] || options[:frame_element] || options[:name_or_id]
-      target = Applitools::Selenium::Target.frame(frame).timeout(options[:timeout]).fully
-      check(options[:tag], target)
-    end
-
-    # Validates the contents of a region in an iframe and matches it with the expected output.
-    #
-    # @param [Hash] options The specific parameters of the desired screenshot.
-    # @option options [String] :name_or_id The name or id of the target frame (deprecated. use :frame instead).
-    # @option options [String] :frame_element The frame element (deprecated. use :frame instead).
-    # @option options [String] :frame Frame element or frame name or frame id.
-    # @option options [String] :tag An optional tag to be associated with the snapshot.
-    # @option options [Symbol] :by By which identifier to find the region (e.g :css, :id).
-    # @option options [Fixnum] :timeout The amount of time to retry matching. (Seconds)
-    # @option options [Boolean] :stitch_content Whether to stitch the content or not.
-    # @return [Applitools::MatchResult] The match results.
-    def check_region_in_frame(options = {})
-      options = { timeout: USE_DEFAULT_MATCH_TIMEOUT, tag: nil, stitch_content: false }.merge!(options)
-      Applitools::ArgumentGuard.not_nil options[:by], 'options[:by]'
-      Applitools::ArgumentGuard.is_a? options[:by], 'options[:by]', Array
-
-      how_what = options.delete(:by)
-      frame = options[:frame] || options[:frame_element] || options[:name_or_id]
-
-      target = Applitools::Selenium::Target.new.timeout(options[:timeout])
-      target.frame(frame) if frame
-      target.fully if options[:stitch_content]
-      target.region(*how_what)
-
-      check(options[:tag], target)
-    end
-
-    # Use this method to perform seamless testing with selenium through eyes driver.
-    # It yields a block and passes to it an Applitools::Selenium::Driver instance, which wraps standard driver.
-    # Using Selenium methods inside the 'test' block will send the messages to Selenium
-    # after creating the Eyes triggers for them. Options are similar to {open}
-    # @yieldparam driver [Applitools::Selenium::Driver] Gives a driver to a block, which translates calls to a native
-    #   Selemium::Driver instance
-    # @example
-    #   eyes.test(app_name: 'my app', test_name: 'my test') do |driver|
-    #      driver.get "http://www.google.com"
-    #      driver.check_window("initial")
-    #   end
-    def test(options = {}, &_block)
-      open(options)
-      yield(driver)
-      close
-    ensure
-      abort_if_not_closed
-    end
-
-    # @!visibility private
-    def scroll_to_region
-      region_visibility_strategy.is_a? Applitools::Selenium::MoveToRegionVisibilityStrategy
-    end
-
-    # @!visibility private
-    def scroll_to_region=(value)
-      if value
-        self.region_visibility_strategy = Applitools::Selenium::MoveToRegionVisibilityStrategy.new
-      else
-        self.region_visibility_strategy = Applitools::Selenium::NopRegionVisibilityStrategy.new
-      end
-    end
-
-    def dom_data
-      return {} if prevent_dom_processing
-      begin
-        Applitools::Selenium::DomCapture.get_window_dom(driver, logger)
-      rescue Applitools::EyesError => e
-        logger.error "DOM capture failed! #{e.message}"
-        return {}
-      end
-    end
-
-    private
-
-    attr_accessor :check_frame_or_element, :region_to_check, :dont_get_title,
-      :device_pixel_ratio, :position_provider, :scale_provider, :tag_for_debug,
-      :region_visibility_strategy, :eyes_screenshot_factory, :force_driver_resolution_as_viewport_size,
-      :prevent_dom_processing
-
-    def image_provider
-      Applitools::Selenium::TakesScreenshotImageProvider.new(
-        driver,
-        debug_screenshot_provider: debug_screenshot_provider
-      )
-    end
-
-    def capture_screenshot
-      logger.info 'Getting screenshot (capture_screenshot() has been invoked)'
-
-      update_scaling_params
-
-      if hide_scrollbars
-        begin
-          original_overflow = Applitools::Utils::EyesSeleniumUtils.hide_scrollbars driver
-          driver.find_element(:css, 'html').overflow_data_attribute = original_overflow
-        rescue Applitools::EyesDriverOperationException => e
-          logger.warn "Failed to hide scrollbars! Error: #{e.message}"
-        end
-      end
-
-      begin
-        algo = Applitools::Selenium::FullPageCaptureAlgorithm.new(
-          debug_screenshot_provider: debug_screenshot_provider
-        )
-        case screenshot_type
-        when ENTIRE_ELEMENT_SCREENSHOT
-          self.screenshot = entire_element_screenshot(algo)
-        when FULLPAGE_SCREENSHOT
-          self.screenshot = full_page_screenshot(algo)
-        when VIEWPORT_SCREENSHOT
-          self.screenshot = viewport_screenshot
-        end
-      ensure
-        begin
-          Applitools::Utils::EyesSeleniumUtils.set_overflow driver, original_overflow
-        rescue Applitools::EyesDriverOperationException => e
-          logger.warn "Failed to revert overflow! Error: #{e.message}"
-        end
-      end
-    end
-
-    def full_page_screenshot(algo)
-      logger.info 'Full page screenshot requested'
-      original_frame = driver.frame_chain
-      driver.switch_to.default_content
-      region_provider = Applitools::Selenium::RegionProvider.new(driver, Applitools::Region::EMPTY)
-
-      full_page_image = algo.get_stitched_region(
-        image_provider: image_provider,
-        region_to_check: region_provider,
-        origin_provider: Applitools::Selenium::ScrollPositionProvider.new(driver),
-        position_provider: position_provider,
-        scale_provider: scale_provider,
-        cut_provider: cut_provider,
-        wait_before_screenshots: wait_before_screenshots,
-        eyes_screenshot_factory: eyes_screenshot_factory,
-        stitching_overlap: stitching_overlap
-      )
-
-      # binding.pry
-      unless original_frame.empty?
-        logger.info 'Switching back to original frame...'
-        driver.switch_to.frames frame_chain: original_frame
-        logger.info 'Done switching!'
-      end
-      logger.info 'Creating EyesWebDriver screenshot instance..'
-      result = Applitools::Selenium::FullpageScreenshot.new(
-        full_page_image,
-        region_provider: region_to_check
-      )
-      logger.info 'Done creating EyesWebDriver screenshot instance!'
-      result
-    end
-
-    def entire_element_screenshot(algo)
-      logger.info 'Entire element screenshot requested'
-      entire_frame_or_element = algo.get_stitched_region(
-        image_provider: image_provider,
-        region_to_check: region_to_check,
-        origin_provider: position_provider,
-        position_provider: position_provider,
-        scale_provider: scale_provider,
-        cut_provider: cut_provider,
-        wait_before_screenshots: wait_before_screenshots,
-        eyes_screenshot_factory: eyes_screenshot_factory,
-        stitching_overlap: stitching_overlap,
-        top_left_position: full_page_capture_algorithm_left_top_offset
-      )
-
-      logger.info 'Building screenshot object (EyesStitchedElementScreenshot)...'
-      result = Applitools::Selenium::EntireElementScreenshot.new(
-        entire_frame_or_element,
-        region_provider: region_to_check
-      )
-      logger.info 'Done!'
-      result
-    end
-
-    def viewport_screenshot
-      logger.info 'Viewport screenshot requested'
-      sleep wait_before_screenshots
-      image = image_provider.take_screenshot
-      scale_provider.scale_image(image) if scale_provider
-      local_cut_provider = (
-        cut_provider || Applitools::Selenium::FixedCutProvider.viewport(image, viewport_size, region_to_check)
-      )
-      local_cut_provider.cut(image) if local_cut_provider
-      eyes_screenshot_factory.call(image)
-    end
-
-    def vp_size=(value, skip_check_if_open = false)
-      raise Applitools::EyesNotOpenException.new 'set_viewport_size: Eyes not open!' unless skip_check_if_open || open?
-      original_frame = driver.frame_chain
-      driver.switch_to.default_content
-      begin
-        Applitools::Utils::EyesSeleniumUtils.set_viewport_size driver, value
-      rescue => e
-        logger.error e.class.to_s
-        logger.error e.message
-        raise Applitools::TestFailedError.new "#{e.class} - #{e.message}"
-      ensure
-        driver.switch_to.frames(frame_chain: original_frame)
-      end
-    end
-
-    alias set_viewport_size vp_size=
-
-    def get_driver(options)
-      # TODO: remove the "browser" related block when possible. It's for backward compatibility.
-      if options.key?(:browser)
-        logger.warn('"browser" key is deprecated, please use "driver" instead.')
-        return options[:browser]
-      end
-
-      options.fetch(:driver, nil)
-    end
-
-    def update_scaling_params
-      return unless device_pixel_ratio == UNKNOWN_DEVICE_PIXEL_RATIO
-
-      logger.info 'Trying to extract device pixel ratio...'
-      begin
-        self.device_pixel_ratio = Applitools::Utils::EyesSeleniumUtils.device_pixel_ratio(driver)
-      rescue Applitools::EyesDriverOperationException
-        logger.warn 'Failed to extract device pixel ratio! Using default.'
-        self.device_pixel_ratio = DEFAULT_DEVICE_PIXEL_RATIO
-      end
-
-      logger.info "Device pixel_ratio: #{device_pixel_ratio}"
-      logger.info 'Setting scale provider...'
-
-      begin
-        self.scale_provider = Applitools::Selenium::ContextBasedScaleProvider.new(position_provider.entire_size,
-          viewport_size, device_pixel_ratio)
-      rescue StandardError
-        logger.info 'Failed to set ContextBasedScaleProvider'
-        logger.info 'Using FixedScaleProvider instead'
-        self.scale_provider = Applitools::FixedScaleProvider.new(1.to_f / device_pixel_ratio)
-      end
-      logger.info 'Done!'
-    end
-
-    def _add_text_trigger(control, text)
-      unless last_screenshot
-        logger.info "Ignoring #{text} (no screenshot)"
-        return
-      end
-
-      unless driver.frame_chain.same_frame_chain? last_screenshot.frame_chain
-        logger.info "Ignoring #{text} (different_frame)"
-        return
-      end
-
-      add_text_trigger_base(control, text)
-    end
-
-    def add_text_trigger(control, text)
-      if disabled?
-        logger.info "Ignoring #{text} (disabled)"
-        return
-      end
-
-      Applitools::ArgumentGuard.not_nil control, 'control'
-      return _add_text_trigger(control, text) if control.is_a? Applitools::Region
-
-      pl = control.location
-      ds = control.size
-
-      element_region = Applitools::Region.new(pl.x, pl.y, ds.width, ds.height)
-
-      return _add_text_trigger(element_region, text) if control.is_a? Applitools::Selenium::Element
-    end
-
-    def add_mouse_trigger(mouse_action, element)
-      if disabled?
-        logger.info "Ignoring #{mouse_action} (disabled)"
-        return
-      end
-
-      if element.is_a? Hash
-        return add_mouse_trigger_by_region_and_location(mouse_action, element[:region], element[:location]) if
-            element.key?(:location) && element.key?(:region)
-        raise Applitools::EyesIllegalArgument.new 'Element[] doesn\'t contain required keys!'
-      end
-
-      Applitools::ArgumentGuard.not_nil element, 'element'
-      Applitools::ArgumentGuard.is_a? element, 'element', Applitools::Selenium::Element
-
-      pl = element.location
-      ds = element.size
-
-      element_region = Applitools::Region.new(pl.x, pl.y, ds.width, ds.height)
-
-      unless last_screenshot
-        logger.info "Ignoring #{mouse_action} (no screenshot)"
-        return
-      end
-
-      unless driver.frame_chain.same_frame_chain? last_screenshot.frame_chain
-        logger.info "Ignoring #{mouse_action} (different_frame)"
-        return
-      end
-
-      add_mouse_trigger_base(mouse_action, element_region, element_region.middle_offset)
-    end
-
-    # control - Region
-    # cursor - Location
-    def add_mouse_trigger_by_region_and_location(mouse_action, control, cursor)
-      unless last_screenshot
-        logger.info "Ignoring #{mouse_action} (no screenshot)"
-        return
-      end
-
-      Applitools::ArgumentGuard.is_a? control, 'control', Applitools::Region
-      Applitools::ArgumentGuard.is_a? cursor, 'cursor', Applitools::Location
-
-      if driver.frame_chain.same_frame_chain? last_screenshot.frame_chain
-        logger.info "Ignoring #{mouse_action} (different_frame)"
-        return
-      end
-
-      add_mouse_trigger_base(mouse_action, control, cursor)
-    end
-
-    public :add_text_trigger, :add_mouse_trigger, :add_mouse_trigger_by_region_and_location
-
-    protected
-
-    def app_environment
-      app_env = super
-      if app_env.os.nil?
-        logger.info 'No OS set, checking for mobile OS...'
-        underlying_driver = Applitools::Utils::EyesSeleniumUtils.mobile_device?(driver)
-        unless underlying_driver.nil?
-          logger.info 'Mobile device detected! Checking device type...'
-          if Applitools::Utils::EyesSeleniumUtils.android?(underlying_driver)
-            logger.info 'Android detected...'
-            platform_name = 'Android'
-          elsif Applitools::Utils::EyesSeleniumUtils.ios?(underlying_driver)
-            logger.info 'iOS detected...'
-            platform_name = 'iOS'
-          else
-            logger.info 'Unknown device type'
-          end
-        end
-
-        if platform_name && !platform_name.empty?
-          os = platform_name
-          platform_version = Applitools::Utils::EyesSeleniumUtils.platform_version(underlying_driver).to_s
-          unless platform_version.empty?
-            major_version = platform_version.split(/\./).first
-            os << " #{major_version}"
-          end
-          logger.info "Setting OS: #{os}"
-          app_env.os = os
+          super Applitools::Selenium::SeleniumEyes.new(server_url)
         end
-      else
-        logger.info 'No mobile OS detected.'
-      end
-      app_env
-    end
-
-    def inferred_environment
-      return @inferred_environment unless @inferred_environment.nil?
-
-      user_agent = driver.user_agent
-      return "useragent: #{user_agent}" if user_agent && !user_agent.empty?
-
-      nil
-    end
-
-    def ensure_frame_visible
-      original_fc = driver.frame_chain
-      return original_fc if original_fc.empty?
-      fc = Applitools::Selenium::FrameChain.new other: original_fc
-      until fc.empty?
-        driver.switch_to.parent_frame
-        position_provider.position = fc.pop.location
-      end
-      driver.switch_to.frames(frame_chain: original_fc)
-      original_fc
-    end
-
-    def reset_frames_scroll_position(original_fc)
-      return original_fc if original_fc.empty?
-      fc = Applitools::Selenium::FrameChain.new other: original_fc
-      until fc.empty?
-        driver.switch_to.parent_frame
-        position_provider.position = fc.pop.parent_scroll_position
       end
-      driver.switch_to.frames(frame_chain: original_fc)
-      original_fc
-    end
-
-    class << self
-      def position_provider(stitch_mode, driver, disable_horizontal = false, disable_vertical = false,
-        explicit_entire_size = nil)
 
-        max_width = nil
-        max_height = nil
-        unless explicit_entire_size.nil?
-          max_width = explicit_entire_size.width
-          max_height = explicit_entire_size.height
-        end
-        case stitch_mode
-        when :SCROLL
-          Applitools::Selenium::ScrollPositionProvider.new(driver, disable_horizontal, disable_vertical,
-            max_width, max_height)
-        when :CSS
-          Applitools::Selenium::CssTranslatePositionProvider.new(driver, disable_horizontal, disable_vertical,
-            max_width, max_height)
-        end
-      end
     end
   end
-end
+end