onlyoffice_webdriver_wrapper 0.6.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 01e7c8a03fdec74828c4f660d287be5729f56f29ce49b91f74005e29a666942e
+  data.tar.gz: bd3f969c07b3c5043b6329c07fff8e02d9576dfa373eef527af6738db1be9acd
+SHA512:
+  metadata.gz: e5a02e944fd3b617209598f54274dcec25776695ed050576e9f7b92371de8c8bb72632ef8460c1bf0390a338f0e910f8610d590b59b449f29c08a93618440e99
+  data.tar.gz: dd7151ef729280ba654f37a5c4842f62b10c3d6c4b47f64df0e02e9a0d9658ad1a8c7c6c8ad4e44b2b9a87ea2a1e4092913ee290165006dd5ad00745f7bbd755

data/lib/onlyoffice_webdriver_wrapper.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'onlyoffice_logger_helper'
+require_relative 'onlyoffice_webdriver_wrapper/helpers/headless_helper'
+require_relative 'onlyoffice_webdriver_wrapper/helpers/os_helper'
+require_relative 'onlyoffice_webdriver_wrapper/dimensions'
+require_relative 'onlyoffice_webdriver_wrapper/webdriver'

data/lib/onlyoffice_webdriver_wrapper/dimensions.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module OnlyofficeWebdriverWrapper
+  # Class for working with cursor coordinates
+  class Dimensions
+    attr_accessor :left, :top
+
+    def initialize(left, top)
+      @left = left
+      @top = top
+    end
+
+    alias width left
+    alias height top
+    alias x left
+    alias y top
+
+    def to_s
+      "Dimensions(left: #{@left}, top: #{@top})"
+    end
+  end
+end

data/lib/onlyoffice_webdriver_wrapper/helpers/chrome_helper.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module OnlyofficeWebdriverWrapper
+  # Class for working with Chrome
+  module ChromeHelper
+    DEFAULT_CHROME_SWITCHES = %w[--kiosk-printing
+                                 --disable-popup-blocking
+                                 --disable-infobars
+                                 --no-sandbox
+                                 test-type].freeze
+
+    # @return [String] path to chromedriver
+    def chromedriver_path
+      driver_name = 'bin/chromedriver'
+      driver_name = 'bin/chromedriver_mac' if OSHelper.mac?
+      File.join(File.dirname(__FILE__), driver_name)
+    end
+
+    def chrome_service
+      @chrome_service ||= Selenium::WebDriver::Chrome::Service.new(path: chromedriver_path)
+    end
+
+    # @return [Webdriver::Chrome] Chrome webdriver
+    def start_chrome_driver
+      prefs = {
+        download: {
+          'prompt_for_download' => false,
+          'default_directory' => download_directory
+        },
+        profile: {
+          'default_content_setting_values' => {
+            'automatic_downloads' => 1
+          }
+        },
+        credentials_enable_service: false
+      }
+      caps = Selenium::WebDriver::Remote::Capabilities.chrome
+      caps[:logging_prefs] = { browser: 'ALL' }
+      caps[:proxy] = Selenium::WebDriver::Proxy.new(ssl: "#{@proxy.proxy_address}:#{@proxy.proxy_port}") if @proxy
+      switches = add_useragent_to_switches(DEFAULT_CHROME_SWITCHES)
+      options = Selenium::WebDriver::Chrome::Options.new(args: switches,
+                                                         prefs: prefs)
+      webdriver_options = { options: options,
+                            desired_capabilities: caps,
+                            service: chrome_service }
+      driver = Selenium::WebDriver.for :chrome, webdriver_options
+      maximize_chrome(driver)
+      driver
+    end
+
+    private
+
+    # Maximize chrome
+    # @param driver [Selenium::WebDriver] driver to use
+    # @return [Void]
+    def maximize_chrome(driver)
+      if headless.running?
+        # Cannot use `driver.manage.window.maximize` in xvfb session
+        # according to https://bugs.chromium.org/p/chromedriver/issues/detail?id=1901#c16
+        driver.manage.window.size = Selenium::WebDriver::Dimension.new(headless.resolution_x, headless.resolution_y)
+      else
+        driver.manage.window.maximize
+      end
+    end
+  end
+end

data/lib/onlyoffice_webdriver_wrapper/helpers/firefox_helper.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module OnlyofficeWebdriverWrapper
+  # Module for working with firefox
+  module FirefoxHelper
+    def firefox_service
+      geckodriver = File.join(File.dirname(__FILE__), 'bin/geckodriver')
+      @firefox_service ||= Selenium::WebDriver::Firefox::Service.new(path: geckodriver)
+    end
+
+    # @return [Webdriver::Firefox] firefox webdriver
+    def start_firefox_driver
+      profile = Selenium::WebDriver::Firefox::Profile.new
+      profile['browser.download.folderList'] = 2
+      profile['browser.helperApps.neverAsk.saveToDisk'] = read_firefox_files_to_save
+      profile['browser.download.dir'] = @download_directory
+      profile['browser.download.manager.showWhenStarting'] = false
+      profile['dom.disable_window_move_resize'] = false
+      options = Selenium::WebDriver::Firefox::Options.new(profile: profile)
+      caps = Selenium::WebDriver::Remote::Capabilities.firefox
+      caps[:proxy] = Selenium::WebDriver::Proxy.new(ssl: "#{@proxy.proxy_address}:#{@proxy.proxy_port}") if @proxy
+      driver = Selenium::WebDriver.for :firefox, options: options, service: firefox_service, desired_capabilities: caps
+      driver.manage.window.size = Selenium::WebDriver::Dimension.new(headless.resolution_x, headless.resolution_y) if headless.running?
+      driver
+    end
+
+    private
+
+    # @return [Array<String>] list of formats to save
+    def read_firefox_files_to_save
+      path_to_file = "#{Dir.pwd}/lib/onlyoffice_webdriver_wrapper/"\
+                     'helpers/firefox_helper/save_to_disk_files.list'
+      OnlyofficeFileHelper::FileHelper.read_array_from_file(path_to_file)
+                                      .join(', ')
+    end
+  end
+end

data/lib/onlyoffice_webdriver_wrapper/helpers/firefox_helper/save_to_disk_files.list

@@ -0,0 +1,35 @@
+application/doct
+application/mspowerpoint
+application/msword
+application/octet-stream
+application/oleobject
+application/pdf
+application/powerpoint
+application/pptt
+application/rtf
+application/vnd.ms-excel
+application/vnd.ms-powerpoint
+application/vnd.oasis.opendocument.spreadsheet
+application/vnd.oasis.opendocument.text
+application/vnd.openxmlformats-officedocument.presentationml.presentation
+application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
+application/vnd.openxmlformats-officedocument.wordprocessingml.document
+application/x-compressed
+application/x-excel
+application/xlst
+application/x-msexcel
+application/x-mspowerpoint
+application/x-rtf
+application/x-zip-compressed
+application/zip
+image/jpeg
+image/pjpeg
+image/pjpeg
+image/x-jps
+message/rfc822
+multipart/x-zip
+text/csv
+text/html
+text/html
+text/plain
+text/richtext

data/lib/onlyoffice_webdriver_wrapper/helpers/headless_helper.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative 'headless_helper/real_display_tools'
+require_relative 'headless_helper/ruby_helper'
+require 'headless'
+require_relative 'headless_helper/headless_screenshot_patch'
+require_relative 'headless_helper/headless_video_recorder'
+
+module OnlyofficeWebdriverWrapper
+  # Class for using headless gem
+  class HeadlessHelper
+    include HeadlessVideoRecorder
+    include RealDisplayTools
+    include RubyHelper
+    # @return [Headless] instance of headless object
+    attr_accessor :headless_instance
+    # @return [Integer] x resolution of virtual screen
+    attr_accessor :resolution_x
+    # @return [Integer] y resolution of virtual screen
+    attr_accessor :resolution_y
+    # @return [True, False] is video should be recorded
+    attr_reader :record_video
+
+    def initialize(resolution_x = 1680,
+                   resolution_y = 1050,
+                   record_video: true)
+      @resolution_x = resolution_x
+      @resolution_y = resolution_y
+      @record_video = record_video
+    end
+
+    # Check if should start headless
+    # @return [True, False] result
+    def should_start?
+      return false if debug?
+      return false if OSHelper.mac?
+
+      true
+    end
+
+    def start
+      create_session = if real_display_connected?
+                         should_start?
+                       else
+                         true
+                       end
+      return unless create_session
+
+      OnlyofficeLoggerHelper.log('Starting Headless Session')
+      begin
+        @headless_instance = Headless.new(reuse: false,
+                                          destroy_at_exit: true,
+                                          dimensions: "#{@resolution_x + 1}x#{@resolution_y + 1}x24",
+                                          video: { provider: :ffmpeg })
+      rescue Exception => e
+        OnlyofficeLoggerHelper.log("xvfb not started with problem #{e}")
+        WebDriver.clean_up(true)
+        @headless_instance = Headless.new(reuse: false,
+                                          destroy_at_exit: true,
+                                          dimensions: "#{@resolution_x + 1}x#{@resolution_y + 1}x24",
+                                          video: { provider: :ffmpeg })
+      end
+      headless_instance.start
+      start_capture
+    end
+
+    def stop
+      return unless running?
+
+      OnlyofficeLoggerHelper.log('Stopping Headless Session')
+      stop_capture
+      headless_instance.destroy
+    end
+
+    def running?
+      !headless_instance.nil?
+    end
+
+    def take_screenshot(scr_path = '/tmp/screenshot.png')
+      return unless running?
+
+      headless_instance.take_screenshot(scr_path)
+      OnlyofficeLoggerHelper.log("Took Screenshot to file: #{scr_path}")
+    end
+  end
+end

data/lib/onlyoffice_webdriver_wrapper/helpers/headless_helper/headless_screenshot_patch.rb

@@ -0,0 +1,18 @@
+class Headless
+  def take_screenshot(file_path, options={})
+    using = options.fetch(:using, :imagemagick)
+    case using
+    when :imagemagick
+      CliUtil.ensure_application_exists!('import', "imagemagick is not found on your system. Please install it using sudo apt-get install imagemagick")
+      system "#{CliUtil.path_to('import')} -display :#{display} -window root #{file_path}"
+    when :xwd
+      CliUtil.ensure_application_exists!('xwd', "xwd is not found on your system. Please install it using sudo apt-get install X11-apps")
+      system "#{CliUtil.path_to('xwd')} -display localhost:#{display} -silent -root -out #{file_path}"
+    when :graphicsmagick, :gm
+      CliUtil.ensure_application_exists!('gm', "graphicsmagick is not found on your system. Please install it.")
+      system "#{CliUtil.path_to('gm')} import -display localhost:#{display} -window root #{file_path}"
+    else
+      raise Headless::Exception.new('Unknown :using option value')
+    end
+  end
+end

data/lib/onlyoffice_webdriver_wrapper/helpers/headless_helper/headless_video_recorder.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module OnlyofficeWebdriverWrapper
+  # Methods to record video
+  module HeadlessVideoRecorder
+    # @return [String] uniq file path to recorded file
+    def recorded_video_file
+      return @recorded_video_file if @recorded_video_file
+
+      file_pattern = 'onlyoffice_webdriver_wrapper_video_file'
+      temp_file = Tempfile.new([file_pattern, '.mp4'])
+      @recorded_video_file = temp_file.path
+      temp_file.unlink
+      @recorded_video_file
+    end
+
+    # @return [nil] start capture of file
+    def start_capture
+      headless_instance.video.start_capture if record_video
+    rescue Headless::Exception => e
+      OnlyofficeLoggerHelper.log("Cannot start video capture: #{e}")
+      @record_video = false
+    end
+
+    # @return [nil] stop catpure of file
+    def stop_capture
+      return unless record_video
+
+      headless_instance.video.stop_and_save(recorded_video_file)
+      OnlyofficeLoggerHelper.log("Video is saved to #{recorded_video_file}")
+    rescue Headless::Exception => e
+      OnlyofficeLoggerHelper.log("Saving recorded video failed: #{e}")
+      @record_video = false
+    end
+  end
+end

data/lib/onlyoffice_webdriver_wrapper/helpers/headless_helper/real_display_tools.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module OnlyofficeWebdriverWrapper
+  # module for getting info about real display
+  module RealDisplayTools
+    def xrandr_result
+      result = `xrandr 2>&1`
+      OnlyofficeLoggerHelper.log("xrandr answer: #{result}".delete("\n"))
+      result
+    end
+
+    def real_display_connected?
+      return true if OSHelper.mac?
+
+      result = xrandr_result
+      exists = result.include?(' connected') && !result.include?('Failed')
+      OnlyofficeLoggerHelper.log("Real Display Exists: #{exists}")
+      exists
+    end
+  end
+end

data/lib/onlyoffice_webdriver_wrapper/helpers/headless_helper/ruby_helper.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module OnlyofficeWebdriverWrapper
+  # Module for check ruby info
+  module RubyHelper
+    def debug?
+      ENV['RUBYLIB'].to_s.include?('ruby-debug')
+    end
+
+    # Check if current os is 64 bit
+    # @return [True, False] result of comparision
+    def os_64_bit?
+      RUBY_PLATFORM.include?('_64')
+    end
+  end
+end

data/lib/onlyoffice_webdriver_wrapper/helpers/os_helper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module OnlyofficeWebdriverWrapper
+  # Stuff for working with OS families
+  class OSHelper
+    # @return [True, False] Check if current platform is mac
+    def self.mac?
+      RUBY_PLATFORM.include?('darwin')
+    end
+  end
+end

data/lib/onlyoffice_webdriver_wrapper/name.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module OnlyofficeWebdriverWrapper
+  module Name
+    STRING = 'onlyoffice_webdriver_wrapper'
+  end
+end

data/lib/onlyoffice_webdriver_wrapper/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module OnlyofficeWebdriverWrapper
+  module Version
+    STRING = '0.6.0'
+  end
+end

data/lib/onlyoffice_webdriver_wrapper/webdriver.rb

@@ -0,0 +1,424 @@
+# frozen_string_literal: true
+
+require 'onlyoffice_file_helper'
+require 'page-object'
+require 'securerandom'
+require 'selenium-webdriver'
+require 'uri'
+require_relative 'helpers/chrome_helper'
+require_relative 'helpers/firefox_helper'
+require_relative 'webdriver/click_methods'
+require_relative 'webdriver/wait_until_methods'
+require_relative 'webdriver/webdriver_alert_helper'
+require_relative 'webdriver/webdriver_attributes_helper'
+require_relative 'webdriver/webdriver_browser_info_helper'
+require_relative 'webdriver/webdriver_type_helper'
+require_relative 'webdriver/webdriver_exceptions'
+require_relative 'webdriver/webdriver_helper'
+require_relative 'webdriver/webdriver_js_methods'
+require_relative 'webdriver/webdriver_screenshot_helper'
+require_relative 'webdriver/webdriver_style_helper'
+require_relative 'webdriver/webdriver_tab_helper'
+require_relative 'webdriver/webdriver_user_agent_helper'
+require_relative 'webdriver/webdriver_browser_log_helper'
+
+module OnlyofficeWebdriverWrapper
+  # noinspection RubyTooManyMethodsInspection, RubyInstanceMethodNamingConvention, RubyParameterNamingConvention
+  class WebDriver
+    include ChromeHelper
+    include ClickMethods
+    include FirefoxHelper
+    include RubyHelper
+    include WaitUntilMethods
+    include WebdriverAlertHelper
+    include WebdriverAttributesHelper
+    include WebdriverBrowserInfo
+    include WebdriverTypeHelper
+    include WebdriverHelper
+    include WebdriverJsMethods
+    include WebdriverScreenshotHelper
+    include WebdriverStyleHelper
+    include WebdriverTabHelper
+    include WebdriverUserAgentHelper
+    include WebdriverBrowserLogHelper
+    TIMEOUT_FILE_DOWNLOAD = 100
+    # @return [Array, String] default switches for chrome
+    attr_accessor :driver
+    # @return [Symbol] browser to use
+    attr_accessor :browser
+    # @return [True, False] is browser currently running
+    attr_reader :browser_running
+    # @return [Symbol] device of which we try to simulate, default - :desktop_linux
+    attr_accessor :device
+    # @return [String] directory to which file is downloaded
+    attr_accessor :download_directory
+    # @return [HeadlessHelper] headless wrapper
+    attr_accessor :headless
+    # @return [Net::HTTP::Proxy] connection proxy
+    attr_accessor :proxy
+
+    def initialize(browser = :firefox,
+                   _remote_server = nil,
+                   device: :desktop_linux,
+                   proxy: nil)
+      raise WebdriverSystemNotSupported, 'Your OS is not 64 bit. It is not supported' unless os_64_bit?
+
+      @device = device
+      @headless = HeadlessHelper.new
+      @headless.start
+
+      @download_directory = Dir.mktmpdir('webdriver-download')
+      @browser = browser
+      @proxy = proxy
+      case browser
+      when :firefox
+        @driver = start_firefox_driver
+      when :chrome
+        @driver = start_chrome_driver
+      else
+        raise("Unknown Browser: #{browser}")
+      end
+      @browser_running = true
+    end
+
+    def open(url)
+      url = "http://#{url}" unless url.include?('http') || url.include?('file://')
+      loop do
+        @driver.navigate.to url
+        break
+      rescue Timeout::Error
+        @driver.navigate.refresh
+      end
+      sleep(1) # Correct wait for Page to init focus
+      OnlyofficeLoggerHelper.log("Opened page: #{url}")
+    end
+
+    def quit
+      return unless browser_running
+
+      begin
+        @driver.execute_script('window.onbeforeunload = null') # off popup window
+      rescue StandardError
+        Exception
+      end
+      begin
+        @driver.quit
+      rescue Exception => e
+        OnlyofficeLoggerHelper.log("Some error happened on webdriver.quit #{e.backtrace}")
+      end
+      alert_confirm
+      @headless.stop
+      cleanup_download_folder
+      @browser_running = false
+    end
+
+    def get_element(object_identification)
+      return object_identification unless object_identification.is_a?(String)
+
+      @driver.find_element(:xpath, object_identification)
+    rescue StandardError
+      nil
+    end
+
+    # Get text from all elements with specified xpath
+    # @param array_elements [String] xpath of elements
+    # @return [Array<String>] values of elements
+    def get_text_array(array_elements)
+      get_elements(array_elements).map { |current_element| get_text(current_element) }
+    end
+
+    def select_from_list_elements(value, elements_value)
+      index = get_element_index(value, elements_value)
+      elements_value[index].click
+    end
+
+    def get_element_index(title, list_elements)
+      list_elements.each_with_index do |current, i|
+        return i if get_text(current) == title
+      end
+      nil
+    end
+
+    def get_all_combo_box_values(xpath_name)
+      @driver.find_element(:xpath, xpath_name).find_elements(tag_name: 'option').map { |el| el.attribute('value') }
+    end
+
+    # @return [String] url of current frame, or browser url if
+    # it is a root frame
+    def get_url
+      execute_javascript('return window.location.href')
+    rescue Selenium::WebDriver::Error::NoSuchDriverError
+      raise 'Browser is crushed or hangup'
+    end
+
+    def refresh
+      @driver.navigate.refresh
+      OnlyofficeLoggerHelper.log('Refresh page')
+    end
+
+    def go_back
+      @driver.navigate.back
+      OnlyofficeLoggerHelper.log('Go back to previous page')
+    end
+
+    # Perform drag'n'drop action in one element (for example on big canvas area)
+    # for drag'n'drop one whole element use 'drag_and_drop_by'
+    # ==== Attributes
+    #
+    # * +xpath+ - xpath of element on which drag and drop performed
+    # * +x1+ - x coordinate on element to start drag'n'drop
+    # * +y1+ - y coordinate on element to start drag'n'drop
+    # * +x2+ - shift vector x coordinate
+    # * +y2+ - shift vector y coordinate
+    # * +mouse_release+ - release mouse after move
+    def drag_and_drop(xpath, x1, y1, x2, y2, mouse_release: true)
+      canvas = get_element(xpath)
+
+      move_action = @driver.action
+                           .move_to(canvas, x1.to_i, y1.to_i)
+                           .click_and_hold
+                           .move_by(x2, y2)
+      move_action = move_action.release if mouse_release
+
+      move_action.perform
+    end
+
+    # Perform drag'n'drop one whole element
+    # for drag'n'drop inside one element (f.e. canvas) use drag_and_drop
+    # ==== Attributes
+    #
+    # * +source+ - xpath of element on which drag and drop performed
+    # * +right_by+ - shift vector x coordinate
+    # * +down_by+ - shift vector y coordinate
+    def drag_and_drop_by(source, right_by, down_by = 0)
+      @driver.action.drag_and_drop_by(get_element(source), right_by, down_by).perform
+    end
+
+    def scroll_list_to_element(list_xpath, element_xpath)
+      execute_javascript("$(document.evaluate(\"#{list_xpath}\", document, null, XPathResult.ANY_TYPE, null).
+          iterateNext()).jScrollPane().data('jsp').scrollToElement(document.evaluate(\"#{element_xpath}\",
+          document, null, XPathResult.ANY_TYPE, null).iterateNext());")
+    end
+
+    def scroll_list_by_pixels(list_xpath, pixels)
+      execute_javascript("$(document.evaluate(\"#{list_xpath.tr('"', "'")}\", document, null, XPathResult.ANY_TYPE, null).iterateNext()).scrollTop(#{pixels})")
+    end
+
+    # Open dropdown selector, like 'Color Selector', which has no element id
+    # @param [String] xpath_name name of dropdown list
+    def open_dropdown_selector(xpath_name, horizontal_shift = 30, vertical_shift = 0)
+      element = get_element(xpath_name)
+      if @browser == :firefox || @browser == :safari
+        set_style_attribute("#{xpath_name}/button", 'display', 'none')
+        set_style_attribute(xpath_name, 'display', 'inline')
+        element.click
+        set_style_attribute("#{xpath_name}/button", 'display', 'inline-block')
+        set_style_attribute(xpath_name, 'display', 'block')
+      else
+        @driver.action.move_to(element, horizontal_shift, vertical_shift).click.perform
+      end
+    end
+
+    def action_on_locator_coordinates(xpath_name, right_by, down_by, action = :click, times = 1)
+      wait_until_element_visible(xpath_name)
+      element = @driver.find_element(:xpath, xpath_name)
+      (0...times).inject(@driver.action.move_to(element, right_by.to_i, down_by.to_i)) { |acc, _elem| acc.send(action) }.perform
+    end
+
+    def move_to_element(element)
+      element = get_element(element) if element.is_a?(String)
+      @driver.action.move_to(element).perform
+    end
+
+    def move_to_element_by_locator(xpath_name)
+      element = get_element(xpath_name)
+      @driver.action.move_to(element).perform
+      OnlyofficeLoggerHelper.log("Moved mouse to element: #{xpath_name}")
+    end
+
+    def mouse_over(xpath_name, x_coordinate = 0, y_coordinate = 0)
+      wait_until_element_present(xpath_name)
+      @driver.action.move_to(@driver.find_element(:xpath, xpath_name), x_coordinate.to_i, y_coordinate.to_i).perform
+    end
+
+    def element_present?(xpath_name)
+      case xpath_name
+      when PageObject::Elements::Element
+        xpath_name.present?
+      when Selenium::WebDriver::Element
+        xpath_name.displayed?
+      else
+        @driver.find_element(:xpath, xpath_name)
+        true
+      end
+    rescue Exception
+      false
+    end
+
+    def get_element_by_display(xpath_name)
+      @driver.find_elements(:xpath, xpath_name).each do |element|
+        return element if element.displayed?
+      end
+    rescue Selenium::WebDriver::Error::InvalidSelectorError
+      webdriver_error("get_element_by_display(#{xpath_name}): invalid selector: Unable to locate an element with the xpath expression")
+    end
+
+    # Return count of elements (visible and not visible)
+    # @param xpath_name [String] xpath to find
+    # @param only_visible [True, False] count only visible elements?
+    # @return [Integer] element count
+    def get_element_count(xpath_name, only_visible = true)
+      if element_present?(xpath_name)
+        elements = @driver.find_elements(:xpath, xpath_name)
+        only_visible ? elements.delete_if { |element| !element.displayed? }.length : elements.length
+      else
+        0
+      end
+    end
+
+    def get_elements(objects_identification, only_visible = true)
+      return objects_identification if objects_identification.is_a?(Array)
+
+      elements = @driver.find_elements(:xpath, objects_identification)
+      if only_visible
+        elements.each do |current|
+          elements.delete(current) unless @browser == :firefox || current.displayed?
+        end
+      end
+      elements
+    end
+
+    def element_visible?(xpath_name)
+      if xpath_name.is_a?(PageObject::Elements::Element) # PageObject always visible
+        true
+      elsif element_present?(xpath_name)
+        element = get_element(xpath_name)
+        return false if element.nil?
+
+        begin
+          visible = element.displayed?
+        rescue Exception
+          visible = false
+        end
+        visible
+      else
+        false
+      end
+    end
+
+    # Check if any element of xpath is displayed
+    # @param xpath_several_elements [String] xpath to check
+    # @return [True, False] result of visibility
+    def one_of_several_elements_displayed?(xpath_several_elements)
+      @driver.find_elements(:xpath, xpath_several_elements).each do |current_element|
+        return true if current_element.displayed?
+      end
+      false
+    rescue Exception => e
+      webdriver_error("Raise unkwnown exception: #{e}")
+    end
+
+    def wait_element(xpath_name, period_of_wait = 1, critical_time = 3)
+      wait_until_element_present(xpath_name)
+      time = 0
+      until element_visible?(xpath_name)
+        sleep(period_of_wait)
+        time += 1
+        return if time == critical_time
+      end
+    end
+
+    # Select frame as current
+    # @param [String] xpath_name name of current xpath
+    def select_frame(xpath_name = '//iframe', count_of_frames = 1)
+      (0...count_of_frames).each do
+        frame = @driver.find_element(:xpath, xpath_name)
+        @driver.switch_to.frame frame
+      rescue Selenium::WebDriver::Error::NoSuchElementError
+        OnlyofficeLoggerHelper.log('Raise NoSuchElementError in the select_frame method')
+      rescue Exception => e
+        webdriver_error("Raise unkwnown exception: #{e}")
+      end
+    end
+
+    # Select top frame of browser (even if several subframes exists)
+    def select_top_frame
+      @driver.switch_to.default_content
+    rescue Timeout::Error
+      OnlyofficeLoggerHelper.log('Raise TimeoutError in the select_top_frame method')
+    rescue Exception => e
+      raise "Browser is crushed or hangup with error: #{e}"
+    end
+
+    # Get text of current element
+    # @param [String] xpath_name name of xpath
+    # @param [true, false] wait_until_visible wait until element visible [@default = true]
+    def get_text(xpath_name, wait_until_visible = true)
+      wait_until_element_visible(xpath_name) if wait_until_visible
+
+      element = get_element(xpath_name)
+      webdriver_error("get_text(#{xpath_name}, #{wait_until_visible}) not found element by xpath") if element.nil?
+      if element.tag_name == 'input' || element.tag_name == 'textarea'
+        element.attribute('value')
+      else
+        element.text
+      end
+    end
+
+    def get_text_of_several_elements(xpath_several_elements)
+      @driver.find_elements(:xpath, xpath_several_elements).map { |element| element.text unless element.text == '' }.compact
+    end
+
+    def select_combo_box(xpath_name, select_value, select_by = :value)
+      wait_until_element_visible(xpath_name)
+      option = Selenium::WebDriver::Support::Select.new(get_element(xpath_name))
+      begin
+        option.select_by(select_by, select_value)
+      rescue StandardError
+        option.select_by(:text, select_value)
+      end
+    end
+
+    # Get page source
+    # @return [String] all page source
+    def get_page_source
+      @driver.execute_script('return document.documentElement.innerHTML;')
+    end
+
+    def webdriver_error(exception, error_message = nil)
+      if exception.is_a?(String) # If there is no error_message
+        error_message = exception
+        exception = RuntimeError
+      end
+      select_top_frame
+      current_url = get_url
+      raise exception, "#{error_message}\n\nPage address: #{current_url}\n\nError #{webdriver_screenshot}"
+    end
+
+    def wait_file_for_download(file_name, timeout = TIMEOUT_FILE_DOWNLOAD)
+      full_file_name = "#{@download_directory}/#{file_name}"
+      full_file_name = file_name if file_name[0] == '/'
+      counter = 0
+      while !File.exist?(full_file_name) && counter < timeout
+        OnlyofficeLoggerHelper.log("Waiting for download file #{full_file_name} for #{counter} of #{timeout}")
+        sleep 1
+        counter += 1
+      end
+      webdriver_error("File #{full_file_name} not download for #{timeout} seconds") if counter >= timeout
+      full_file_name
+    end
+
+    # Perform cleanup if something went wrong during tests
+    # @param forced [True, False] should cleanup run in all cases
+    def self.clean_up(forced = false)
+      return unless OnlyofficeFileHelper::LinuxHelper.user_name.include?('nct-at') ||
+                    OnlyofficeFileHelper::LinuxHelper.user_name.include?('ubuntu') ||
+                    forced == true
+
+      OnlyofficeFileHelper::LinuxHelper.kill_all('chromedriver')
+      OnlyofficeFileHelper::LinuxHelper.kill_all('geckodriver')
+      OnlyofficeFileHelper::LinuxHelper.kill_all('Xvfb')
+      OnlyofficeFileHelper::LinuxHelper.kill_all_browsers
+    end
+  end
+end