onlyoffice_webdriver_wrapper 0.6.0

data/lib/onlyoffice_webdriver_wrapper/webdriver/click_methods.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module OnlyofficeWebdriverWrapper
+  # Method to perform different clicks
+  module ClickMethods
+    # Click on specified element
+    # @param element [Selenium::WebDriver::Element] element to click
+    # @return [nil] nothing
+    def click(element)
+      element.click
+    end
+
+    # Click on locator
+    # @param xpath_name [String] xpath to click
+    # @param by_javascript [True, False] should be clicked by javascript
+    # @param count [Integer] count of clicks
+    def click_on_locator(xpath_name, by_javascript = false, count: 1)
+      element = get_element(xpath_name)
+      return webdriver_error("Element with xpath: #{xpath_name} not found") if element.nil?
+
+      if by_javascript
+        execute_javascript("document.evaluate(\"#{xpath_name}\", document, null, XPathResult.ANY_TYPE, null).iterateNext().click();")
+      else
+        begin
+          count.times { element.click }
+        rescue Selenium::WebDriver::Error::ElementNotVisibleError => e
+          webdriver_error(e.class, "Selenium::WebDriver::Error::ElementNotVisibleError: element not visible for xpath: #{xpath_name}")
+        rescue Exception => e
+          webdriver_error(e.class, "UnknownError #{e.message} #{xpath_name}")
+        end
+      end
+    end
+
+    # Click on one of several which displayed
+    # @param xpath_name [String] xpath to find element
+    # @return [nil]
+    def click_on_displayed(xpath_name)
+      element = get_element_by_display(xpath_name)
+      begin
+        element.is_a?(Array) ? element.first.click : element.click
+      rescue Exception => e
+        webdriver_error(e.class, "Exception #{e} in click_on_displayed(#{xpath_name})")
+      end
+    end
+
+    # Click on locator by coordinates
+    # @param xpath_name [String] xpath to click
+    # @param right_by [Integer] shift to right
+    # @param down_by [Integer] shift to bottom
+    # @return [nil]
+    def click_on_locator_coordinates(xpath_name, right_by, down_by)
+      wait_until_element_visible(xpath_name)
+      element = @driver.find_element(:xpath, xpath_name)
+      @driver.action.move_to(element, right_by.to_i, down_by.to_i).perform
+      @driver.action.move_to(element, right_by.to_i, down_by.to_i).click.perform
+    end
+
+    # Click on one of several which displayed
+    # @param xpath_several_elements [String] xpath to find element
+    # @return [True, False] true if click successful, false if not found
+    def click_on_one_of_several_by_display(xpath_several_elements)
+      @driver.find_elements(:xpath, xpath_several_elements).each do |current_element|
+        if current_element.displayed?
+          current_element.click
+          return true
+        end
+      end
+      false
+    end
+
+    # Click on one of several xpath filtered by parameter and value
+    # @param xpath_several_elements [String] xpath to select
+    # @param parameter_name [String] parameter name
+    # @param parameter_value [String] parameter value
+    # @return [True, False] true if click successful, false if not found
+    def click_on_one_of_several_by_parameter(xpath_several_elements, parameter_name, parameter_value)
+      @driver.find_elements(:xpath, xpath_several_elements).each do |current_element|
+        if current_element.attribute(parameter_name).include? parameter_value
+          current_element.click
+          return true
+        end
+      end
+      false
+    end
+
+    # Perform right click on xpath
+    # @param xpath_name [String] xpath to click
+    # @return [nil]
+    def right_click(xpath_name)
+      wait_until_element_visible(xpath_name)
+
+      @driver.action.context_click(@driver.find_element(:xpath, xpath_name)).perform
+    end
+
+    # Perform right click on locator with specified coordinates
+    # @param xpath_name [String] xpath to click
+    # @param right_by [Integer] shift to right
+    # @param down_by [Integer] shift to bottom
+    # @return [nil]
+    def right_click_on_locator_coordinates(xpath_name, right_by = nil, down_by = nil)
+      wait_until_element_visible(xpath_name)
+      element = @driver.find_element(:xpath, xpath_name)
+      @driver.action.move_to(element, right_by.to_i, down_by.to_i).perform
+      @driver.action.move_to(element, right_by.to_i, down_by.to_i).context_click.perform
+    end
+
+    # Perform double_click on element
+    # @param xpath_name [String] xpath to click
+    # @return [nil]
+    def double_click(xpath_name)
+      wait_until_element_visible(xpath_name)
+      @driver.action.move_to(@driver.find_element(:xpath, xpath_name)).double_click.perform
+    end
+
+    # Perform double_click on specified coordinates
+    # @param xpath_name [String] xpath to click
+    # @param right_by [Integer] shift to right
+    # @param down_by [Integer] shift to bottom
+    # @return [nil]
+    def double_click_on_locator_coordinates(xpath_name, right_by, down_by)
+      wait_until_element_visible(xpath_name)
+      @driver.action.move_to(@driver.find_element(:xpath, xpath_name), right_by.to_i, down_by.to_i).double_click.perform
+    end
+  end
+end

data/lib/onlyoffice_webdriver_wrapper/webdriver/wait_until_methods.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module OnlyofficeWebdriverWrapper
+  # Method to different wait_until methods
+  module WaitUntilMethods
+    # @return [Integer] default timeout for wait element
+    TIMEOUT_WAIT_ELEMENT = 15
+
+    def wait_until(timeout = ::PageObject.default_page_wait, message = nil, wait_js: true, &block)
+      tries ||= 3
+      wait = Object::Selenium::WebDriver::Wait.new(timeout: timeout, message: message)
+      wait.until(&block)
+      if wait_js
+        wait.until { document_ready? }
+        wait.until { jquery_finished? }
+      end
+    rescue Selenium::WebDriver::Error::TimeOutError
+      webdriver_error("Wait until timeout: #{timeout} seconds in")
+    rescue Selenium::WebDriver::Error::StaleElementReferenceError
+      OnlyofficeLoggerHelper.log("Wait until: rescuing from Stale Element error, #{tries} attempts remaining")
+      retry unless (tries -= 1).zero?
+      webdriver_error('Wait until: rescuing from Stale Element error failed after 3 tries')
+    end
+
+    def wait_until_element_visible(xpath_name, timeout = 15)
+      wait_until_element_present(xpath_name)
+      time = 0
+      while !element_visible?(xpath_name) && time < timeout
+        sleep(1)
+        time += 1
+      end
+      return unless time >= timeout
+
+      webdriver_error("Element #{xpath_name} not visible for #{timeout} seconds")
+    end
+
+    # Wait until some element present
+    # If timeout exceeded - raise an error
+    # @param xpath_name [String] xpath of element
+    # @param timeout [Integer] timeout to wait
+    # @return [Void]
+    def wait_until_element_present(xpath_name, timeout: TIMEOUT_WAIT_ELEMENT)
+      wait = Selenium::WebDriver::Wait.new(timeout: timeout) # seconds
+      begin
+        wait.until { get_element(xpath_name) }
+      rescue Selenium::WebDriver::Error::TimeOutError => e
+        timeout_message = "wait_until_element_present(#{xpath_name}) "\
+                            'Selenium::WebDriver::Error::TimeOutError: '\
+                            "timed out after #{timeout} seconds"
+        webdriver_error(e.class, timeout_message)
+      end
+    end
+
+    # Wait until some element disappear
+    # If timeout exceeded - raise an error
+    # @param xpath_name [String] xpath of element
+    # @param timeout [Integer] timeout to wait
+    # @return [Void]
+    def wait_until_element_disappear(xpath_name, timeout: TIMEOUT_WAIT_ELEMENT)
+      wait = Selenium::WebDriver::Wait.new(timeout: timeout) # seconds
+      begin
+        wait.until { get_element(xpath_name) ? false : true }
+      rescue Selenium::WebDriver::Error::TimeOutError => e
+        timeout_message = "wait_until_element_present(#{xpath_name}) "\
+                            'Selenium::WebDriver::Error::TimeOutError: '\
+                            "timed out after #{timeout} seconds"
+        webdriver_error(e.class, timeout_message)
+      end
+    end
+  end
+end

data/lib/onlyoffice_webdriver_wrapper/webdriver/webdriver_alert_helper.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module OnlyofficeWebdriverWrapper
+  # Methods for working with alerts
+  module WebdriverAlertHelper
+    def alert_confirm
+      @driver.switch_to.alert.accept if alert_exists?
+    end
+
+    # Check if alert exists
+    # @return [True, false]
+    def alert_exists?
+      @driver.switch_to.alert.text
+      true
+    rescue Selenium::WebDriver::Error::NoSuchAlertError, Errno::ECONNREFUSED
+      false
+    end
+
+    # Get alert text
+    # @return [String] text inside alert
+    def alert_text
+      @driver.switch_to.alert.text
+    end
+  end
+end

data/lib/onlyoffice_webdriver_wrapper/webdriver/webdriver_attributes_helper.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module OnlyofficeWebdriverWrapper
+  # Module with methods to work with attributes
+  module WebdriverAttributesHelper
+    def attribute_exist?(xpath_name, attribute)
+      exist = false
+
+      element = xpath_name.is_a?(String) ? get_element(xpath_name) : xpath_name
+      begin
+        attribute_value = element.attribute(attribute)
+        exist = attribute_value.empty? || attribute_value.nil? ? false : true
+      rescue Exception
+        exist = false
+      end
+      exist
+    end
+
+    def get_attribute(xpath_name, attribute)
+      element = xpath_name.is_a?(Selenium::WebDriver::Element) ? xpath_name : get_element(xpath_name)
+
+      if element.nil?
+        webdriver_error("Webdriver.get_attribute(#{xpath_name}, #{attribute}) failed because element not found")
+      else
+        element.attribute(attribute)
+      end
+    end
+
+    def get_attributes_of_several_elements(xpath_several_elements, attribute)
+      elements = @driver.find_elements(:xpath, xpath_several_elements)
+
+      elements.map do |element|
+        element.attribute(attribute)
+      end
+    end
+
+    def get_index_of_elements_with_attribute(xpath, attribute, value, only_visible = true)
+      get_elements(xpath, only_visible).each_with_index do |element, index|
+        return (index + 1) if get_attribute(element, attribute).include?(value)
+      end
+      0
+    end
+
+    # Set element attribute
+    # @param xpath [String] element to select
+    # @param attribute [String] attribute to set
+    # @param attribute_value [String] value of attribute
+    # @return [String] result of execution
+    def set_attribute(xpath, attribute, attribute_value)
+      execute_javascript("#{dom_element_by_xpath(xpath)}.#{attribute}=\"#{attribute_value}\";")
+    end
+
+    alias set_parameter set_attribute
+
+    # Remove attribute of element
+    # @param xpath [String] xpath of element
+    # @param attribute [String] attribute to remove
+    # @return [String] result of execution
+    def remove_attribute(xpath, attribute)
+      execute_javascript("#{dom_element_by_xpath(xpath)}.removeAttribute('#{attribute}');")
+    end
+  end
+end

data/lib/onlyoffice_webdriver_wrapper/webdriver/webdriver_browser_info_helper.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module OnlyofficeWebdriverWrapper
+  # Module for working with browser metadata
+  module WebdriverBrowserInfo
+    # @return [Dimensions] Size of browser window
+    def browser_size
+      size_struct = @driver.manage.window.size
+      size = Dimensions.new(size_struct.width, size_struct.height)
+      OnlyofficeLoggerHelper.log("browser_size: #{size}")
+      size
+    end
+
+    # @return [String] info about platform
+    def browser_metadata
+      caps = @driver.capabilities
+      platform = caps[:platform_name] || caps[:platform]
+      version = caps[:browser_version] || caps[:version]
+      "Platform: #{platform}, Browser: #{caps[:browser_name]}, Version: #{version}"
+    end
+  end
+end

data/lib/onlyoffice_webdriver_wrapper/webdriver/webdriver_browser_log_helper.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module OnlyofficeWebdriverWrapper
+  # Methods for working with browser console logs
+  module WebdriverBrowserLogHelper
+    def browser_logs
+      return [] if browser == :firefox # not implemented, see https://github.com/mozilla/geckodriver/issues/284
+
+      @driver.manage.logs.get(:browser)
+    end
+  end
+end

data/lib/onlyoffice_webdriver_wrapper/webdriver/webdriver_exceptions.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module OnlyofficeWebdriverWrapper
+  class WebdriverSystemNotSupported < StandardError; end
+end

data/lib/onlyoffice_webdriver_wrapper/webdriver/webdriver_helper.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'open-uri'
+require 'tempfile'
+
+module OnlyofficeWebdriverWrapper
+  # Some additional methods for webdriver
+  module WebdriverHelper
+    def system_screenshot(file_name)
+      `import -window root #{file_name}`
+    end
+
+    # Download temp file and return it location
+    # @param file [String] url
+    # @return [String] path to file
+    def download(file_url)
+      data = Kernel.open(file_url, &:read)
+      file = Tempfile.new('onlyoffice-downloaded-file')
+      file.write(data.force_encoding('UTF-8'))
+      file.close
+      file.path
+    end
+
+    # Perform safe cleanup of download folder
+    # @return [Nothing]
+    def cleanup_download_folder
+      return unless Dir.exist?(@download_directory)
+
+      if @download_directory.start_with?(Dir.tmpdir)
+        FileUtils.remove_dir(@download_directory)
+      else
+        OnlyofficeLoggerHelper.log("Download directory #{@download_directory} is not at tmp dir. "\
+                                   'It will be not deleted')
+      end
+    end
+  end
+end

data/lib/onlyoffice_webdriver_wrapper/webdriver/webdriver_js_methods.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module OnlyofficeWebdriverWrapper
+  # Methods for webdriver for calling Javascript
+  module WebdriverJsMethods
+    # Execute javascript
+    # @param script [String] code to execute
+    # @param wait_timeout [Integer] wait after JS is executed.
+    #   Some code require some time to execute
+    def execute_javascript(script, wait_timeout: 0)
+      result = @driver.execute_script(script)
+      OnlyofficeLoggerHelper.log("Executed js: `#{script}` with result: `#{result}`")
+      sleep(wait_timeout)
+      result
+    rescue Exception => e
+      webdriver_error("Exception #{e} in execute_javascript: #{script}")
+    end
+
+    # @param [String] xpath element to select
+    # @return [String] string to select dom by xpath
+    def dom_element_by_xpath(xpath)
+      escaped_xpath = xpath.tr('"', "'")
+      "document.evaluate(\"#{escaped_xpath}\", document, null, XPathResult.ANY_TYPE, null).iterateNext()"
+    end
+
+    def type_to_locator_by_javascript(xpath_name, text)
+      escaped_text = text.gsub('\\', '\\\\\\\\').gsub('"', '\\"').gsub("\n", '\\n')
+      execute_javascript("document.evaluate('#{xpath_name}', document, null, XPathResult.ANY_TYPE, null).iterateNext().value=\"#{escaped_text}\";")
+    end
+
+    # Get text in object by xpath
+    # @param xpath [String] xpath to get text
+    # @return [String] text in xpath
+    def get_text_by_js(xpath)
+      text = execute_javascript("return #{dom_element_by_xpath(xpath)}.textContent")
+      text = execute_javascript("return #{dom_element_by_xpath(xpath)}.value") if text.empty?
+      text
+    end
+
+    # Calculate object size using Javascript
+    # @param xpath [Sting] xpath of object
+    # @return [Dimensions] size of element
+    def element_size_by_js(xpath)
+      width = execute_javascript("return #{dom_element_by_xpath(xpath)}.offsetWidth")
+      height = execute_javascript("return #{dom_element_by_xpath(xpath)}.offsetHeight")
+      Dimensions.new(width, height)
+    end
+
+    # Get object absolute postion from top left edge of screen
+    # @param xpath [Sting] xpath of object
+    # @return [CursorPoint] position of element
+    def object_absolute_position(xpath)
+      bounding = "#{dom_element_by_xpath(xpath)}.getBoundingClientRect()"
+      left = execute_javascript("return #{bounding}.left")
+      top = execute_javascript("return #{bounding}.top")
+      Dimensions.new(left, top)
+    end
+
+    # @return [True, False] is page have jquery loaded
+    def jquery_loaded?
+      loaded = execute_javascript('return !!window.jQuery')
+      OnlyofficeLoggerHelper.log("jquery_loaded? # #{loaded}")
+      loaded
+    end
+
+    # Checks for jQuery finished its job or not present
+    def jquery_finished?
+      return true unless jquery_loaded?
+
+      execute_javascript('return window.jQuery.active;').zero?
+    end
+
+    def document_ready?
+      execute_javascript('return document.readyState;') == 'complete'
+    end
+
+    # Get ComputedStyle property value
+    # @param xpath [String] xpath of element
+    # @param pseudo_element [String] pseudo element to compute
+    # @param property [String] property to get
+    # @return [String] value of property
+    def computed_style(xpath, pseudo_element = 'null', property = nil)
+      element_by_xpath = "document.evaluate(\"#{xpath.tr('"', "'")}\",document, null, XPathResult.ANY_TYPE, null ).iterateNext()"
+      style = "window.getComputedStyle(#{element_by_xpath}, '#{pseudo_element}')"
+      full_command = "#{style}.getPropertyValue('#{property}')"
+      result = execute_javascript("return #{full_command}")
+      result.delete('"')
+    end
+
+    # Remove element by its xpath
+    # @param [String] xpath of element to remove
+    # @return [String] result of javascript execution
+    def remove_element(xpath)
+      script = "element = #{dom_element_by_xpath(xpath)};"\
+               'if (element !== null) '\
+               '{element.parentNode.removeChild(element);};'
+      execute_javascript(script)
+    end
+  end
+end