eyes_selenium 2.39.1 → 3.0.6

data/lib/applitools/base/image_position.rb

@@ -1,10 +0,0 @@
-module Applitools::Base
-  class ImagePosition
-    attr_accessor :image, :position
-
-    def initialize(image, position)
-      @image = image
-      @position = position
-    end
-  end
-end

data/lib/applitools/base/mouse_trigger.rb

@@ -1,33 +0,0 @@
-module Applitools::Base
-  class MouseTrigger
-    MOUSE_ACTION = {
-      click: 'Click',
-      right_click: 'RightClick',
-      double_click: 'DoubleClick',
-      move: 'Move',
-      down: 'Down',
-      up: 'Up'
-    }.freeze
-
-    attr_reader :mouse_action, :control, :location
-
-    def initialize(mouse_action, control, location)
-      @mouse_action = mouse_action
-      @control = control
-      @location = location
-    end
-
-    def to_hash
-      {
-        trigget_type: 'Mouse',
-        mouse_action: MOUSE_ACTION[mouse_action],
-        control: control.to_hash,
-        location: location.to_hash
-      }
-    end
-
-    def to_s
-      "#{mouse_action} [#{control}] #{location.x}, #{location.y}"
-    end
-  end
-end

data/lib/applitools/base/point.rb

@@ -1,34 +0,0 @@
-module Applitools::Base
-  class Point
-    attr_accessor :x, :y
-
-    alias_attribute :left, :x
-    alias_attribute :top, :y
-
-    def initialize(x, y)
-      @x = x
-      @y = y
-    end
-
-    TOP_LEFT = Point.new(0, 0)
-
-    def ==(other)
-      return super.==(other) unless other.is_a?(Point)
-      @x == other.x && @y == other.y
-    end
-
-    alias eql? ==
-
-    def hash
-      @x.hash & @y.hash
-    end
-
-    def to_hash(options = {})
-      options[:region] ? { left: left, top: top } : { x: x, y: y }
-    end
-
-    def values
-      [x, y]
-    end
-  end
-end

data/lib/applitools/base/region.rb

@@ -1,112 +0,0 @@
-module Applitools::Base
-  class Region
-    attr_accessor :left, :top, :width, :height
-
-    def initialize(left, top, width, height)
-      @left = left.round
-      @top = top.round
-      @width = width.round
-      @height = height.round
-    end
-
-    EMPTY = Region.new(0, 0, 0, 0)
-
-    def make_empty
-      @left = EMPTY.left
-      @top = EMPTY.top
-      @width = EMPTY.width
-      @height = EMPTY.height
-    end
-
-    def empty?
-      @left == EMPTY.left && @top == EMPTY.top && @width == EMPTY.width && @height == EMPTY.height
-    end
-
-    def right
-      left + width
-    end
-
-    def bottom
-      top + height
-    end
-
-    def intersecting?(other)
-      ((left <= other.left && other.left <= right) || (other.left <= left && left <= other.right)) &&
-        ((top <= other.top && other.top <= bottom) || (other.top <= top && top <= other.bottom))
-    end
-
-    def intersect(other)
-      unless intersecting?(other)
-        make_empty
-
-        return
-      end
-
-      i_left = left >= other.left ? left : other.left
-      i_right = right <= other.right ? right : other.right
-      i_top = top >= other.top ? top : other.top
-      i_bottom = bottom <= other.bottom ? bottom : other.bottom
-
-      @left = i_left
-      @top = i_top
-      @width = i_right - i_left
-      @height = i_bottom - i_top
-    end
-
-    def contains?(other_left, other_top)
-      other_left >= left && other_left <= right && other_top >= top && other_top <= bottom
-    end
-
-    def middle_offset
-      mid_x = width / 2
-      mid_y = height / 2
-      Point.new(mid_x.round, mid_y.round)
-    end
-
-    def subregions(subregion_size)
-      [].tap do |subregions|
-        current_top = @top
-        bottom = @top + @height
-        right = @left + @width
-        subregion_width = [@width, subregion_size.width].min
-        subregion_height = [@height, subregion_size.height].min
-
-        while current_top < bottom
-          current_bottom = current_top + subregion_height
-          if current_bottom > bottom
-            current_bottom = bottom
-            current_top = current_bottom - subregion_height
-          end
-
-          current_left = @left
-          while current_left < right
-            current_right = current_left + subregion_width
-            if current_right > right
-              current_right = right
-              current_left = current_right - subregion_width
-            end
-
-            subregions << Region.new(current_left, current_top, subregion_width, subregion_height)
-
-            current_left += subregion_width
-          end
-
-          current_top += subregion_height
-        end
-      end
-    end
-
-    def to_hash
-      {
-        left: left,
-        top: top,
-        height: height,
-        width: width
-      }
-    end
-
-    def to_s
-      "(#{left}, #{top}), #{width} x #{height}"
-    end
-  end
-end

data/lib/applitools/base/server_connector.rb

@@ -1,120 +0,0 @@
-require 'faraday'
-
-require 'oj'
-Oj.default_options = { :mode => :compat }
-
-require 'uri'
-
-module Applitools::Base::ServerConnector
-  extend self
-
-  DEFAULT_SERVER_URL = 'https://eyessdk.applitools.com'.freeze
-
-  SSL_CERT = File.join(File.dirname(File.expand_path(__FILE__)), '../../../certs/cacert.pem').to_s.freeze
-  DEFAULT_TIMEOUT = 300
-
-  API_SESSIONS_RUNNING = '/api/sessions/running/'.freeze
-
-  HTTP_STATUS_CODES = {
-    created: 201,
-    accepted: 202
-  }.freeze
-
-  attr_accessor :server_url, :api_key
-  attr_reader :endpoint_url
-
-  def server_url=(url)
-    @server_url = url.nil? ? DEFAULT_SERVER_URL : url
-    @endpoint_url = URI.join(@server_url, API_SESSIONS_RUNNING).to_s
-  end
-
-  def set_proxy(uri, user = nil, password = nil)
-    @proxy = {
-      uri: uri,
-      user: user,
-      password: password
-    }
-  end
-
-  def match_window(session, data)
-    # Notice that this does not include the screenshot.
-    json_data = Oj.dump(Applitools::Utils.camelcase_hash_keys(data.to_hash)).force_encoding('BINARY')
-    body = [json_data.length].pack('L>') + json_data + data.screenshot
-    Applitools::EyesLogger.debug 'Sending match data...'
-
-    res = post(URI.join(endpoint_url, session.id.to_s), content_type: 'application/octet-stream', body: body)
-    raise Applitools::EyesError.new("Request failed: #{res.status}") unless res.success?
-
-    Oj.load(res.body)['asExpected'].tap do |as_expected|
-      Applitools::EyesLogger.debug "Got response! #{as_expected}"
-    end
-  end
-
-  def start_session(session_start_info)
-    res = post(endpoint_url, body: Oj.dump(startInfo:
-      Applitools::Utils.camelcase_hash_keys(session_start_info.to_hash)))
-    raise Applitools::EyesError.new("Request failed: #{res.status}") unless res.success?
-
-    response = Oj.load(res.body)
-    Applitools::Base::Session.new(response['id'], response['url'], res.status == HTTP_STATUS_CODES[:created])
-  end
-
-  def stop_session(session, aborted = nil, save = false)
-    res = long_delete(URI.join(endpoint_url, session.id.to_s), query: { aborted: aborted, updateBaseline: save })
-    raise Applitools::EyesError.new("Request failed: #{res.status}") unless res.success?
-
-    response = Oj.load(res.body)
-    Applitools::Base::TestResults.new(response)
-  end
-
-  private
-
-  DEFAULT_HEADERS = {
-    'Accept' => 'application/json',
-    'Content-Type' => 'application/json'
-  }.freeze
-
-  LONG_REQUEST_DELAY = 2 # seconds
-  MAX_LONG_REQUEST_DELAY = 10 # seconds
-  LONG_REQUEST_DELAY_MULTIPLICATIVE_INCREASE_FACTOR = 1.5
-
-  [:get, :post, :delete].each do |method|
-    define_method method do |url, options = {}|
-      request(url, method, options)
-    end
-
-    define_method "long_#{method}" do |url, options = {}|
-      long_request(url, method, options)
-    end
-  end
-
-  def request(url, method, options = {})
-    Faraday::Connection.new(url, ssl: { ca_file: SSL_CERT }, proxy: @proxy || nil).send(method) do |req|
-      req.options.timeout = DEFAULT_TIMEOUT
-      req.headers = DEFAULT_HEADERS.merge(options[:headers] || {})
-      req.headers['Content-Type'] = options[:content_type] if options.key?(:content_type)
-      req.params = { apiKey: api_key }.merge(options[:query] || {})
-      req.body = options[:body]
-    end
-  end
-
-  def long_request(url, method, options = {})
-    delay = LONG_REQUEST_DELAY
-    (options[:headers] ||= {})['Eyes-Expect'] = '202-accepted'
-
-    loop do
-      # Date should be in RFC 1123 format.
-      options[:headers]['Eyes-Date'] = Time.now.utc.strftime('%a, %d %b %Y %H:%M:%S GMT')
-
-      res = request(url, method, options)
-      return res unless res.status == HTTP_STATUS_CODES[:accepted]
-
-      Applitools::EyesLogger.debug "Still running... retrying in #{delay}s"
-      sleep delay
-
-      delay = [MAX_LONG_REQUEST_DELAY, (delay * LONG_REQUEST_DELAY_MULTIPLICATIVE_INCREASE_FACTOR).round].min
-    end
-  end
-
-  include Applitools::MethodTracer
-end

data/lib/applitools/base/session.rb

@@ -1,15 +0,0 @@
-module Applitools::Base
-  class Session
-    attr_reader :id, :url
-
-    def initialize(session_id, session_url, new_session)
-      @id = session_id
-      @url = session_url
-      @new_session = new_session
-    end
-
-    def new_session?
-      @new_session
-    end
-  end
-end

data/lib/applitools/base/start_info.rb

@@ -1,34 +0,0 @@
-module Applitools::Base
-  class StartInfo
-    attr_accessor :app_id_or_name, :scenario_id_or_name
-
-    def initialize(agent_id, app_id_or_name, scenario_id_or_name, batch_info, env_name, environment, match_level,
-      ver_id = nil, branch_name = nil, parent_branch_name = nil)
-      @agent_id = agent_id
-      @app_id_or_name = app_id_or_name
-      @ver_id = ver_id
-      @scenario_id_or_name = scenario_id_or_name
-      @batch_info = batch_info
-      @env_name = env_name
-      @environment = environment
-      @match_level = match_level
-      @branch_name = branch_name
-      @parent_branch_name = parent_branch_name
-    end
-
-    def to_hash
-      {
-        agent_id: @agent_id,
-        app_id_or_name: @app_id_or_name,
-        ver_id: @ver_id,
-        scenario_id_or_name: @scenario_id_or_name,
-        batch_info: @batch_info.to_hash,
-        env_name: @env_name,
-        environment: @environment.to_hash,
-        match_level: @match_level,
-        branch_name: @branch_name,
-        parent_branch_name: @parent_branch_name
-      }
-    end
-  end
-end

data/lib/applitools/base/test_results.rb

@@ -1,28 +0,0 @@
-module Applitools::Base
-  class TestResults
-    attr_accessor :is_new, :url
-    attr_reader :steps, :matches, :mismatches, :missing
-
-    def initialize(results = {})
-      @steps = results.fetch('steps', 0)
-      @matches = results.fetch('matches', 0)
-      @mismatches = results.fetch('mismatches', 0)
-      @missing = results.fetch('missing', 0)
-      @is_new = nil
-      @url = nil
-    end
-
-    def passed?
-      !is_new && !(mismatches > 0) && !(missing > 0)
-    end
-    alias is_passed passed?
-
-    def to_s
-      is_new_str = ''
-      is_new_str = is_new ? 'New test' : 'Existing test' unless is_new.nil?
-
-      "#{is_new_str} [ steps: #{steps}, matches: #{matches}, mismatches: #{mismatches}, missing: #{missing} ], "\
-        "URL: #{url}"
-    end
-  end
-end

data/lib/applitools/base/text_trigger.rb

@@ -1,22 +0,0 @@
-module Applitools::Base
-  class TextTrigger
-    attr_reader :text, :control
-
-    def initialize(text, control)
-      @text = text
-      @control = control
-    end
-
-    def to_hash
-      {
-        trigget_type: 'Text',
-        text: text,
-        control: control.to_hash
-      }
-    end
-
-    def to_s
-      "Text [#{@control}] #{@text}"
-    end
-  end
-end

data/lib/applitools/extensions.rb

@@ -1,17 +0,0 @@
-class Module
-  def alias_attribute(new_name, old_name)
-    module_eval <<-STR, __FILE__, __LINE__ + 1
-      def #{new_name}
-        self.#{old_name}
-      end
-
-      def #{new_name}?
-        self.#{old_name}?
-      end
-
-      def #{new_name}=(v)
-        self.#{old_name}
-      end
-    STR
-  end
-end

data/lib/applitools/eyes.rb

@@ -1,460 +0,0 @@
-require 'capybara/poltergeist'
-
-require_relative 'version'
-require_relative 'eyes_logger'
-
-require 'forwardable'
-
-class Applitools::Eyes
-  extend Forwardable
-
-  FAILURE_REPORTS = {
-    immediate: 'Immediate',
-    on_close: 'OnClose'
-  }.freeze
-
-  MATCH_LEVEL = {
-    none: 'None',
-    layout: 'Layout',
-    layout2: 'Layout2',
-    content: 'Content',
-    strict: 'Strict',
-    exact: 'Exact'
-  }.freeze
-
-  DEFAULT_MATCH_TIMEOUT = 2.0 # Seconds
-  # noinspection RubyConstantNamingConvention
-  DEFAULT_WAIT_BEFORE_SCREENSHOTS = 0.1 # Seconds
-  BASE_AGENT_ID = ('eyes.selenium.ruby/' + Applitools::VERSION).freeze
-
-  ANDROID = 'Android'.freeze
-  IOS = 'iOS'.freeze
-
-  # Attributes:
-  #
-  # +app_name+:: +String+ The application name which was provided as an argument to +open+.
-  # +test_name+:: +String+ The test name which was provided as an argument to +open+.
-  # +is_open+:: +boolean+ Is there an open session.
-  # +viewport_size+:: +Hash+ The viewport size which was provided as an argument to +open+. Should include +width+
-  #   and +height+.
-  # +driver+:: +Applitools::Selenium::Driver+ The driver instance wrapping the driver which was provided as an argument
-  #   to +open+.
-  # +api_key+:: +String+ The user's API key.
-  # +match_timeout+:: +Float+ The default timeout for check_XXXX operations. (Seconds)
-  # +batch+:: +BatchInfo+ The current tests grouping, if any.
-  # +host_os+:: +String+ A string identifying the OS running the AUT. Set this if you wish to override Eyes' automatic
-  #   inference.
-  # +host_app+:: +String+ A string identifying the container application running the AUT (e.g., Firefox). Set this if
-  #   you wish to override Eyes' automatic inference.
-  # +branch_name+:: +String+ If set, names the branch in which the test should run.
-  # +parent_branch_name+:: +String+ If set, names the parent branch of the branch in which the test should run.
-  # +user_inputs+:: +Applitools::Base::MouseTrigger+/+Applitools::Selenium::KeyboardTrigger+ Mouse/Keyboard events which
-  #   happened after the last visual validation.
-  # +save_new_tests+:: +boolean+ Whether or not new tests should be automatically accepted as baseline.
-  # +save_failed_tests+:: +boolean+ Whether or not failed tests should be automatically accepted as baseline.
-  # +match_level+:: +String+ The default match level for the entire session. See +Applitools::Eyes::MATCH_LEVEL+.
-  # +baseline_name+:: +String+ A string identifying the baseline which the test will be compared against. Set this if
-  #   you wish to override Eyes' automatic baseline inference.
-  # +is_disabled+:: +boolean+ Set to +true+ if you wish to disable Eyes without deleting code (Eyes' methods act as a
-  #   mock, and will do nothing).
-  # +server_url+:: +String+ The Eyes' server. Set this if you wish to override the default Eyes server URL.
-  # +agent_id+:: +String+ An optional string identifying the current library using the SDK.
-  # +log_handler+:: +Logger+ The logger to which Eyes will send info/debug messages.
-  # +failure_reports+:: +String+ Whether the current test will report mismatches immediately or when it is finished.
-  #   See +Applitools::Eyes::FAILURE_REPORTS+.
-  # +rotation+:: +Integer+|+nil+ The degrees by which to rotate the screenshots received from the driver. Set this to
-  #   override Eyes' automatic rotation inference. Positive values = clockwise rotation, negative
-  #   values = counter-clockwise, 0 = force no rotation, +nil+ = use Eyes' automatic rotation inference.
-  # +scale_ratio+:: +Float+|+nil+ The ratio by which to scale the screenshots received from the driver. Set this to
-  #   override Eyes' automatic scaling inference. Values must be >=0 or +nil+. 1 = Don't scale, +nil+ = use Eyes'
-  #   automatic scaling inference.
-  # +force_fullpage_screenshot+:: +boolean+ Whether or not to force fullpage screenshot taking, if the browser doesn't
-  #                               support it explicitly.
-  # +hide_scrollbars+:: +boolean+ Whether or not hide scrollbars.
-  # +use_css_transition+:: +boolean+ Whether or not to perform CSS transition.
-  # +wait_before_screenshot+:: +Integer+ The number of milliseconds to wait before each screenshot. Use -1 to reset to
-  #                            the default value.
-  # +debug_screenshot+:: +boolean+ If true saves every taken screenshot in current folder. File name has following
-  #                      format: +TAG_YYYY_MM_DD_HH_MI__N.png+, where +TAG+ - the tag specified for the test,
-  #                      +YYYY_MM_DD_HH_MI+ - date && time, +N+ - screenshot number (makes sense only when
-  #                      +force_fullpage_screenshot+ is true). Default value is false
-
-  attr_reader :app_name, :test_name, :is_open, :viewport_size, :driver, :passed_driver
-  attr_accessor :match_timeout, :batch, :host_os, :host_app, :branch_name, :parent_branch_name, :user_inputs,
-    :save_new_tests, :save_failed_tests, :is_disabled, :server_url, :agent_id, :failure_reports,
-    :match_level, :baseline_name, :rotation, :force_fullpage_screenshot, :hide_scrollbars,
-    :use_css_transition, :scale_ratio, :wait_before_screenshots, :debug_screenshot
-
-  def_delegators 'Applitools::EyesLogger', :log_handler, :log_handler=
-  def_delegators 'Applitools::Base::ServerConnector', :api_key, :api_key=, :server_url, :server_url=, :set_proxy
-
-  def wait_before_screenshots=(ms)
-    @wait_before_screenshots = ms > 0 ? (ms / 1000.0) : DEFAULT_WAIT_BEFORE_SCREENSHOTS
-  end
-
-  def full_agent_id
-    @full_agent_id ||= agent_id.nil? ? BASE_AGENT_ID : "#{agent_id} [#{BASE_AGENT_ID}]"
-  end
-
-  def title
-    unless @dont_get_title
-      begin
-        return driver.title
-      rescue
-        @dont_get_title = true
-      end
-    end
-
-    ''
-  end
-
-  def initialize(options = {})
-    @is_disabled = false
-    @debug_screenshot = options[:debug_screenshot].nil? ? false : true
-    return if disabled?
-
-    @api_key = nil
-    @user_inputs = []
-
-    Applitools::Base::ServerConnector.server_url = options[:server_url]
-
-    @match_timeout = DEFAULT_MATCH_TIMEOUT
-    @match_level = Applitools::Eyes::MATCH_LEVEL[:exact]
-    @failure_reports = Applitools::Eyes::FAILURE_REPORTS[:on_close]
-    @save_new_tests = true
-    @save_failed_tests = false
-    @dont_get_title = false
-    @force_fullpage_screenshot = false
-    @hide_scrollbars = false
-    @use_css_transition = false
-    @wait_before_screenshots = DEFAULT_WAIT_BEFORE_SCREENSHOTS
-  end
-
-  def open(options = {})
-    @passed_driver = @driver = get_driver(options.merge(debug_screenshot: debug_screenshot))
-    return driver if disabled?
-
-    if api_key.nil?
-      raise Applitools::EyesError.new('API key not set! Log in to https://applitools.com to obtain your API Key and '\
-        "use 'api_key' to set it.")
-    end
-
-    if driver.respond_to? :driver_for_eyes
-      @driver = driver.driver_for_eyes self
-    else
-      unless driver.is_a?(Applitools::Selenium::Driver)
-        is_mobile_device = driver.respond_to?(:capabilities) && driver.capabilities['platformName']
-
-        @driver =
-          case driver
-          when Selenium::WebDriver
-            Applitools::Selenium::Driver.new(self, driver: driver, is_mobile_device: is_mobile_device)
-          when Capybara::Poltergeist::Driver # driver for PhantomJS
-            Applitools::Poltergeist::Driver.new(self, driver: driver, is_mobile_device: is_mobile_device)
-          else
-            Applitools::EyesLogger.warn("Unrecognized driver type: (#{driver.class.name})!")
-            Applitools::Selenium::Driver.new(self, driver: driver, is_mobile_device: is_mobile_device)
-          end
-
-      end
-    end
-
-    @driver.wait_before_screenshots = wait_before_screenshots
-
-    if open?
-      abort_if_not_closed
-      msg = 'a test is already running'
-      Applitools::EyesLogger.warn(msg)
-
-      raise Applitools::EyesError.new(msg)
-    end
-
-    @user_inputs = []
-    @app_name = options.fetch(:app_name)
-    if @app_name.nil? || @app_name.empty?
-      raise Applitools::EyesError.new('App name must be a non empty string.')
-    end
-    @test_name = options.fetch(:test_name)
-    if @test_name.nil? || @test_name.empty?
-      raise Applitools::EyesError.new('Test name must be a non empty string.')
-    end
-    @viewport_size = options.fetch(:viewport_size, nil)
-
-    @is_open = true
-
-    driver
-  end
-
-  def open?
-    is_open
-  end
-
-  def clear_user_inputs
-    user_inputs.clear
-  end
-
-  def check_region(how, what, tag = nil, specific_timeout = -1)
-    Applitools::EyesLogger.debug 'check_region called'
-    return if disabled?
-
-    # We have to start the session if it's not started, since we want the viewport size to be set before getting the
-    # element's position and size
-    raise Applitools::EyesError.new('Eyes not open') unless open?
-
-    unless @session
-      Applitools::EyesLogger.debug 'Starting session...'
-      start_session
-      Applitools::EyesLogger.debug 'Done! Creating match window task...'
-      @match_window_task = Applitools::Selenium::MatchWindowTask.new(self, @session, driver, match_timeout)
-      Applitools::EyesLogger.debug 'Done!'
-    end
-
-    original_overflow = driver.hide_scrollbars if hide_scrollbars
-    begin
-      if how == :element
-        Applitools::EyesLogger.debug 'Element given as an argument...'
-        raise Applitools::EyesError.new('Element does not exist') if what.nil?
-        element_to_check = what
-      elsif how == :region && what.is_a?(Applitools::Base::Region)
-        return check_region_(what, tag, specific_timeout)
-      else
-        Applitools::EyesLogger.debug 'Finding element...'
-        element_to_check = driver.find_element(how, what)
-      end
-
-      Applitools::EyesLogger.debug 'Done! Getting element location...'
-      location = element_to_check.location
-      Applitools::EyesLogger.debug 'Done! Getting element size...'
-      size = element_to_check.size
-      raise Applitools::EyesError.new("Invalid region size: #{size}") if size.width <= 0 || size.height <= 0
-      Applitools::EyesLogger.debug 'Done! Creating region...'
-      region = Applitools::Base::Region.new(location.x, location.y, size.width, size.height)
-      Applitools::EyesLogger.debug "Done! Checking region... #{region}"
-      check_region_(region, tag, specific_timeout)
-      Applitools::EyesLogger.debug 'Done!'
-    ensure
-      driver.set_overflow(original_overflow) if hide_scrollbars
-    end
-  end
-
-  def check_window(tag = nil, specific_timeout = -1)
-    original_overflow = driver.hide_scrollbars if hide_scrollbars
-    begin
-      check_region_(Applitools::Base::Region::EMPTY, tag, specific_timeout)
-    ensure
-      driver.set_overflow(original_overflow) if hide_scrollbars
-    end
-  end
-
-  def close(raise_ex = true)
-    return if disabled?
-    @is_open = false
-    passed_driver.use_native_browser if passed_driver.respond_to? :use_native_browser
-
-    # If there's no running session, the test was never started (never reached check_window).
-    unless @session
-      Applitools::EyesLogger.debug 'Server session was not started'
-      Applitools::EyesLogger.info '--- Empty test ended.'
-
-      return Applitools::Base::TestResults.new
-    end
-
-    session_results_url = @session.url
-    new_session = @session.new_session?
-    Applitools::EyesLogger.debug 'Ending server session...'
-    save = (new_session && save_new_tests) || (!new_session && save_failed_tests)
-    results = Applitools::Base::ServerConnector.stop_session(@session, false, save)
-    results.is_new = new_session
-    results.url = session_results_url
-    Applitools::EyesLogger.debug "Results: #{results}"
-
-    @session = nil
-
-    if new_session
-      instructions = "Please approve the new baseline at #{session_results_url}"
-      Applitools::EyesLogger.info "--- New test ended. #{instructions}"
-
-      if raise_ex
-        message = "'#{@session_start_info.scenario_id_or_name}' of '#{@session_start_info.app_id_or_name}'. "\
-          "#{instructions}"
-
-        raise Applitools::NewTestError.new(message, results)
-      end
-
-      return results
-    end
-
-    unless results.passed?
-      # Test failed
-      Applitools::EyesLogger.info "--- Failed test ended. See details at #{session_results_url}"
-
-      if raise_ex
-        message = "'#{@session_start_info.scenario_id_or_name}' of '#{@session_start_info.app_id_or_name}'. see "\
-          "details at #{session_results_url}"
-
-        raise Applitools::TestFailedError.new(message, results)
-      end
-
-      return results
-    end
-
-    # Test passed
-    Applitools::EyesLogger.info "--- Test passed. See details at #{session_results_url}"
-
-    results
-  end
-
-  ## Use this method to perform seamless testing with selenium through eyes driver.
-  ## Using Selenium methods inside the 'test' block will send the messages to Selenium
-  ## after creating the Eyes triggers for them.
-  ##
-  ## Example:
-  #    eyes.test(app_name: 'my app1', test_name: 'my test') do |d|
-  #      get "http://www.google.com"
-  #      check_window("initial")
-  #    end
-  # noinspection RubyUnusedLocalVariable
-  def test(options = {}, &_block)
-    open(options)
-    yield(driver)
-    close
-  ensure
-    abort_if_not_closed
-  end
-
-  def abort_if_not_closed
-    return if disabled?
-
-    @is_open = false
-    passed_driver.use_native_browser if passed_driver.respond_to? :use_native_browser
-
-    return unless @session
-
-    begin
-      Applitools::Base::ServerConnector.stop_session(@session, true, false)
-    rescue => e
-      Applitools::EyesLogger.error "Failed to abort server session: #{e.message}!"
-    ensure
-      @session = nil
-    end
-  end
-
-  private
-
-  def disabled?
-    is_disabled
-  end
-
-  def get_driver(options)
-    # TODO: remove the "browser" related block when possible. It's for backward compatibility.
-    if options.key?(:browser)
-      Applitools::EyesLogger.warn('"browser" key is deprecated, please use "driver" instead.')
-
-      return options[:browser]
-    end
-
-    options.fetch(:driver, nil)
-  end
-
-  def inferred_environment
-    user_agent = driver.user_agent
-    "useragent:#{user_agent}" if user_agent
-  end
-
-  # Application environment is the environment (e.g., the host OS) which runs the application under test.
-  #
-  # Returns:
-  # +Applitools::Base::Environment+ The application environment.
-  def app_environment
-    os = host_os
-    if os.nil?
-      Applitools::EyesLogger.info 'No OS set, checking for mobile OS...'
-      if driver.mobile_device?
-        platform_name = nil
-        Applitools::EyesLogger.info 'Mobile device detected! Checking device type..'
-        if driver.android?
-          Applitools::EyesLogger.info 'Android detected.'
-          platform_name = ANDROID
-        elsif driver.ios?
-          Applitools::EyesLogger.info 'iOS detected.'
-          platform_name = IOS
-        else
-          Applitools::EyesLogger.warn 'Unknown device type.'
-        end
-        # We only set the OS if we identified the device type.
-        unless platform_name.nil?
-          platform_version = driver.platform_version
-          if platform_version.nil?
-            os = platform_name
-          else
-            # Notice that Ruby's +split+ function's +limit+ is the number of elements, whereas in Python it is the
-            # maximum splits performed (which is why they are set differently).
-            major_version = platform_version.split('.', 2)[0]
-            os = "#{platform_name} #{major_version}"
-          end
-          Applitools::EyesLogger.info "Setting OS: #{os}"
-        end
-      else
-        Applitools::EyesLogger.info 'No mobile OS detected.'
-      end
-    end
-
-    # Create and return the environment object.
-    Applitools::Base::Environment.new(os, host_app, viewport_size, inferred_environment)
-  end
-
-  def start_session
-    assign_viewport_size
-    @batch ||= Applitools::Base::BatchInfo.new
-    app_env = app_environment
-
-    @session_start_info = Applitools::Base::StartInfo.new(full_agent_id, app_name, test_name, batch, baseline_name,
-      app_env, match_level, nil, branch_name, parent_branch_name)
-    @session = Applitools::Base::ServerConnector.start_session(@session_start_info)
-    @should_match_window_run_once_on_timeout = @session.new_session?
-  end
-
-  def viewport_size?
-    viewport_size
-  end
-
-  def assign_viewport_size
-    if viewport_size?
-      @viewport_size = Applitools::Selenium::ViewportSize.new(driver, viewport_size)
-      @viewport_size.set
-    else
-      @viewport_size = Applitools::Selenium::ViewportSize.new(driver)
-      @viewport_size.extract_viewport_from_browser!
-    end
-  end
-
-  def check_region_(region, tag = nil, specific_timeout = -1)
-    return if disabled?
-    Applitools::EyesLogger.info "check_region_('#{tag}', #{specific_timeout})"
-    raise Applitools::EyesError.new('region cannot be nil!') if region.nil?
-    raise Applitools::EyesError.new('Eyes not open') unless open?
-
-    unless @session
-      Applitools::EyesLogger.debug 'Starting session...'
-      start_session
-      Applitools::EyesLogger.debug 'Done! Creating match window task...'
-      @match_window_task = Applitools::Selenium::MatchWindowTask.new(self, @session, driver, match_timeout)
-      Applitools::EyesLogger.debug 'Done!'
-    end
-
-    Applitools::EyesLogger.debug 'Starting match task...'
-    as_expected = @match_window_task.match_window(region, specific_timeout, tag, rotation,
-      @should_match_window_run_once_on_timeout)
-    Applitools::EyesLogger.debug 'Match window done!'
-    return if as_expected
-
-    @should_match_window_run_once_on_timeout = true
-    return if @session.new_session?
-
-    Applitools::EyesLogger.info %(mismatch #{tag ? '' : "(#{tag})"})
-    return unless failure_reports.to_i == Applitools::Eyes::FAILURE_REPORTS[:immediate]
-
-    raise Applitools::TestFailedError.new("Mismatch found in '#{@session_start_info.scenario_id_or_name}' "\
-      "of '#{@session_start_info.app_id_or_name}'")
-  end
-end