eyes_selenium 2.39.1 → 3.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ac6ebb7be4b5a18ba713a6ef6628810325979d58
-  data.tar.gz: 397ff449e9dfcf03df28c7518167b5fcae0f891c
+  metadata.gz: 298245f32bacdf8a255523b09d83c01d992750d9
+  data.tar.gz: b989742805a0c330a4c92ea11fe1703e70b415ed
 SHA512:
-  metadata.gz: a254e084da60256c59ab2a5d568ce8c4baebb362db0081f2c206361b2c21915161102351da6e925286cd9ae31068191652f7b717e89fbc8d670f74023544cc3f
-  data.tar.gz: 0a4e68c2a92f8147eeaeefa22f13b05d645be179b88d8230b231788cfa6388ff941f1f76c51debfdd74475a2811c6ecf3fab09c52d5185e9df0e8d3bbccc32d0
+  metadata.gz: 9a641c66332c48f9ed14ee0a6895d6ed5a6a824bb15092ccfd9cd981f7a60f44abe2c1deccc242884509dfba25d5c47e0f9f5dcd018a038ce59a9317d615edbc
+  data.tar.gz: cf81849b83decbedd66337779dfba74f94a057e9595bd0f908af8d9457d5f19bae6612d146fe97e69e97376151dfd51be82ce3fe1d04d6e54a018992cd5f71ba

data/lib/applitools/capybara.rb

@@ -1,6 +1,6 @@
 require 'capybara'
 
-Applitools.require_dir 'selenium/capybara'
+Applitools::Selenium.require_dir 'selenium/capybara'
 
 module Applitools
   extend Applitools::Selenium::Capybara::CapybaraSettings

data/lib/applitools/selenium/border_aware_element_content_location_provider.rb

@@ -0,0 +1,41 @@
+module Applitools::Selenium
+  # @!visibility private
+  class BorderAwareElementContentLocationProvider
+    extend Forwardable
+
+    def_delegators 'Applitools::EyesLogger', :logger, :log_handler, :log_handler=
+
+    attr_accessor :element, :location, :size
+
+    def initialize(element)
+      raise Applitools::EyesIllegalArgument.new 'Passed element is not Applitools::Selenium::Element instance!' unless
+          element.is_a? Applitools::Selenium::Element
+      self.element = element
+      self.location = Applitools::Location.for element.location
+      self.size = Applitools::RectangleSize.for element.size
+      calculate_location_size
+    end
+
+    private
+
+    def calculate_location_size
+      border_left = element.border_left_width
+      border_right = element.border_right_width
+      border_top = element.border_top_width
+      border_bottom = element.border_bottom_width
+
+      padding_left = element.padding_left_width
+      padding_right = element.padding_right_width
+      padding_top = element.padding_top_width
+      padding_bottom = element.padding_bottom_width
+
+      location.offset Applitools::Location.new(border_left + padding_left, border_top + padding_top)
+      size - Applitools::RectangleSize.new(padding_left + padding_right + border_left + border_right,
+        padding_top + padding_bottom + border_top + border_bottom)
+
+    rescue Applitools::EyesDriverOperationException
+      self.location = Applitools::Location.for element.location
+      self.size = Applitools::RectangleSize.for element.size
+    end
+  end
+end

data/lib/applitools/selenium/browser.rb

@@ -1,4 +1,5 @@
 module Applitools::Selenium
+  # @!visibility private
   class Browser
     JS_GET_USER_AGENT = <<-JS.freeze
       return navigator.userAgent;

data/lib/applitools/selenium/capybara/capybara_settings.rb

@@ -1,5 +1,13 @@
 module Applitools::Selenium::Capybara
   module CapybaraSettings
+    # Registers Capybara driver which will be used by eyes and sets it as default Capybara driver.
+    # The name of the driver is :eyes, and the driver is a descendant of class Capybara::Selenium::Driver.
+    # Options are eventually passed to drivers constructor
+    # @param [Hash] options
+    # @example
+    #   Applitools.register_capybara_driver :browser => :chrome
+    # @example
+    #   Applitools.register_capybara_driver :browser => :remote, :url => 'remote_url', :desired_capabilities => {}
     def register_capybara_driver(options = {})
       Capybara.register_driver :eyes do |app|
         Applitools::Selenium::Capybara::Driver.new app, options

data/lib/applitools/selenium/capybara/driver.rb

@@ -1,5 +1,6 @@
 if defined? Capybara::Selenium::Driver
   module Applitools::Selenium::Capybara
+    # @!visibility private
     class Driver < Capybara::Selenium::Driver
       def driver_for_eyes(eyes)
         browser eyes: eyes

data/lib/applitools/selenium/context_based_scale_provider.rb

@@ -0,0 +1,36 @@
+module Applitools::Selenium
+  # @!visibility private
+  class ContextBasedScaleProvider
+    UNKNOWN_SCALE_RATIO = 0
+    ALLOWED_VS_DEVIATION = 1
+    ALLOWED_DCES_DEVIATION = 10
+
+    attr_reader :top_level_context_entire_size, :viewport_size, :device_pixel_ratio, :scale_ratio
+
+    def initialize(top_level_context_entire_size, viewport_size, device_pixel_ratio)
+      @top_level_context_entire_size = top_level_context_entire_size
+      @viewport_size = viewport_size
+      @device_pixel_ratio = device_pixel_ratio
+      @scale_ratio = UNKNOWN_SCALE_RATIO
+    end
+
+    def scale_image(image)
+      if @scale_ratio == UNKNOWN_SCALE_RATIO
+        @scale_ratio = if ((image.width >= viewport_size.width - ALLOWED_VS_DEVIATION) &&
+            (image.width <= viewport_size.width + ALLOWED_VS_DEVIATION)) ||
+            ((image.width >= top_level_context_entire_size.width - ALLOWED_DCES_DEVIATION) &&
+            (image.width <= top_level_context_entire_size.width + ALLOWED_DCES_DEVIATION))
+                         1
+                       else
+                         1.to_f / device_pixel_ratio
+                       end
+      end
+      Applitools::Utils::ImageUtils.scale!(image, scale_ratio)
+    end
+
+    def scale_ratio
+      raise Applitools::EyesError.new 'Scale ratio is not defined yet!' if @scale_ratio == UNKNOWN_SCALE_RATIO
+      @scale_ratio
+    end
+  end
+end

data/lib/applitools/selenium/css_translate_position_provider.rb

@@ -0,0 +1,66 @@
+module Applitools::Selenium
+  class CssTranslatePositionProvider
+    extend Forwardable
+
+    def_delegators 'Applitools::EyesLogger', :logger, :log_handler, :log_handler=
+
+    attr_accessor :last_state_position
+
+    def initialize(executor)
+      self.executor = executor
+    end
+
+    def current_position
+      last_state_position
+    end
+
+    def state
+      Applitools::Utils::EyesSeleniumUtils.current_transforms(executor)
+    end
+
+    def restore_state(value)
+      transforms = value.values.select { |el| !el.empty? }
+      Applitools::Utils::EyesSeleniumUtils.set_transforms(executor, value)
+      if transforms.empty?
+        self.last_state_position = Applitools::Location::TOP_LEFT
+      else
+        positions = transforms.map { |s| get_position_from_transform(s) }
+        positions.each { |p| raise Applitools::EyesError.new 'Got different css positions!' unless p == positions[0] }
+        self.last_state_position = positions[0]
+      end
+    end
+
+    def position=(value)
+      Applitools::ArgumentGuard.not_nil(value, 'value')
+      logger.info "Setting position to: #{value}"
+      Applitools::Utils::EyesSeleniumUtils.translate_to(executor, value)
+      logger.info 'Done!'
+      self.last_state_position = value
+    end
+
+    def force_offset
+      Applitools::Location.from_any_attribute last_state_position
+    end
+
+    alias scroll_to position=
+
+    def entire_size
+      e_size = Applitools::Utils::EyesSeleniumUtils.current_frame_content_entire_size(executor)
+      logger.info "Entire size: #{e_size}"
+      e_size
+    end
+
+    private
+
+    attr_accessor :executor
+
+    def get_position_from_transform(transform)
+      regexp = /^translate\(\s*(\-?)(\d+)px,\s*(\-?)(\d+)px\s*\)/
+      data = regexp.match(transform)
+      raise Applitools::EyesError.new "Can't parse CSS transition: #{transform}!" unless data
+      x = data[1].empty? ? data[2].to_i : -1 * data[2].to_i
+      y = data[3].empty? ? data[4].to_i : -1 * data[4].to_i
+      Applitools::Location.new(x, y)
+    end
+  end
+end

data/lib/applitools/selenium/driver.rb

@@ -1,4 +1,3 @@
-require 'forwardable'
 require 'socket'
 require 'selenium-webdriver'
 
@@ -7,10 +6,14 @@ module Applitools::Selenium
     extend Forwardable
 
     RIGHT_ANGLE = 90
+    # @!visibility private
     IOS = 'IOS'.freeze
+    # @!visibility private
     ANDROID = 'ANDROID'.freeze
+    # @!visibility private
     LANDSCAPE = 'LANDSCAPE'.freeze
 
+    # Available finders
     FINDERS = {
       class: 'class name',
       class_name: 'class name',
@@ -26,9 +29,11 @@ module Applitools::Selenium
 
     attr_reader :browser
     attr_accessor :wait_before_screenshots
+    attr_accessor :rotation
 
-    def_delegators :@eyes, :user_inputs, :clear_user_inputs
+    def_delegators :@eyes, :add_mouse_trigger, :add_text_trigger
     def_delegators :@browser, :user_agent
+    def_delegators 'Applitools::EyesLogger', :logger, :log_handler, :log_handler=
 
     # If driver is not provided, Applitools::Selenium::Driver will raise an EyesError exception.
     def initialize(eyes, options)
@@ -36,82 +41,87 @@ module Applitools::Selenium
       @is_mobile_device = options.fetch(:is_mobile_device, false)
       @wait_before_screenshots = 0
       @eyes = eyes
+      @frame_chain = Applitools::Selenium::FrameChain.new
       @browser = Applitools::Selenium::Browser.new(self, @eyes)
       Applitools::EyesLogger.warn '"screenshot_as" method not found!' unless driver.respond_to? :screenshot_as
     end
 
-    # Returns:
-    # +String+ The platform name or +nil+ if it is undefined.
+    # Executes javascript in browser context
+    # @raise [Applitools::EyesDriverOperationException]
+    def execute_script(*args)
+      raises_error { __getobj__.execute_script(*args) }
+    end
+
+    # @return [String] The platform name or +nil+ if it is undefined.
     def platform_name
       capabilities['platformName']
     end
 
-    # Returns:
-    # +String+ The platform version or +nil+ if it is undefined.
+    # @return [String] The platform version or +nil+ if it is undefined.
     def platform_version
       version = capabilities['platformVersion']
       version.nil? ? nil : version.to_s
     end
 
-    # Returns:
-    # +true+ if the driver orientation is landscape.
+    # Returns +true+ if the driver orientation is landscape.
     def landscape_orientation?
       driver.orientation.to_s.upcase == LANDSCAPE
     rescue NameError
       Applitools::EyesLogger.debug 'driver has no "orientation" attribute. Assuming: portrait.'
     end
 
-    # Returns:
-    # +true+ if the platform running the test is a mobile platform. +false+ otherwise.
+    # Returns +true+ if the platform running the test is a mobile platform. +false+ otherwise.
     def mobile_device?
       # We CAN'T check if the device is an +Appium::Driver+ since it is not a RemoteWebDriver. Because of that we use a
       # flag we got as an option in the constructor.
       @is_mobile_device
     end
 
-    ## Hide the main document's scrollbars and returns the original overflow value.
+    # Hide the main document's scrollbars and returns the original overflow value.
     def hide_scrollbars
       @browser.hide_scrollbars
     end
 
-    ## Set the overflow value for document element and return the original overflow value.
+    # Set the overflow value for document element and return the original overflow value.
     def overflow=(overflow)
       @browser.set_overflow(overflow)
     end
 
-    alias set_overflow overflow=
-
-    # Return a normalized screenshot.
-    #
-    # +rotation+:: +Integer+|+nil+ The degrees by which to rotate the image: positive values = clockwise rotation,
-    #              negative values = counter-clockwise, 0 = force no rotation, +nil+ = rotate automatically when needed.
-    # +tag+:: +String|nil+ The tag specified for the test, used onle when +debug_screenshot+ is set to true
-    #
-    # Returns: +ChunkPng::Image+ A screenshot object, normalized by scale and rotation.
-    def get_screenshot(rotation = nil, tag = nil)
-      @tag_for_screenshot_debug = tag
-      @visible_screenshot_call_count = 0
-      image = mobile_device? || !@eyes.force_fullpage_screenshot ? visible_screenshot : @browser.fullpage_screenshot
-      Applitools::Selenium::Driver.normalize_image(self, image, rotation)
-      image
+    # Returns native driver
+    # @return Selenium::WebDriver
+    def remote_web_driver
+      driver
     end
 
-    def visible_screenshot
-      Applitools::EyesLogger.debug "Waiting before screenshot: #{wait_before_screenshots} seconds..."
-      sleep(wait_before_screenshots)
-      Applitools::EyesLogger.debug 'Finished waiting.'
-      screenshot = driver.screenshot_as(:png)
-      save_image(screenshot) if @eyes.debug_screenshot
-      Applitools::Utils::ImageUtils::Screenshot.new screenshot
-    end
+    alias set_overflow overflow=
 
-    def mouse
-      Applitools::Selenium::Mouse.new(self, driver.mouse)
+    # Takes a screenshot
+    # @param [:Symbol] format A format to store screenshot (one of +:base64+ or +:png+)
+    # @return [String] A byte string, representing the screenshot
+    def screenshot_as(format)
+      raise "Invalid format (#{format}) passed! Available formats: :png, :base64" unless %i(base64 png).include? format
+      png_screenshot = driver.screenshot_as(:png)
+      yield png_screenshot if block_given?
+      screenshot = Applitools::Screenshot.new(png_screenshot)
+      self.class.normalize_rotation(self, screenshot, rotation)
+      return Applitools::Utils::ImageUtils.base64_from_png_image(screenshot.restore) if format == :base64
+      screenshot.to_blob
     end
 
-    def keyboard
-      Applitools::Selenium::Keyboard.new(self, driver.keyboard)
-    end
+    # Finds an element, specified by +what+ parameter interpreting it in the way, specified in +how+ parameter
+    # @param [Symbol] how Defines the way that +what+ parameter will be interpreted (The type of selector). Can be one
+    #   of: +:class+, +:class_name+, +:css+, +:id+, +:link+, +:link_text+, +:name+, +:partial_link_text+, +:tag_name+,
+    #   +:xpath+
+    # @param [String] what The selector to find an element
+    # @example
+    #   driver.find_element :css, '.some_class'
+    # @example
+    #   driver.find_element :css => '.some_class'
+    # @example
+    #   driver.find_element :id, 'element_id'
+    # @raise [ArgumentError] if invalid finder (+how+) is passed
+    # @return [Applitools::Selenium::Element]
+    # @!parse def find_element(how, what); end
 
     def find_element(*args)
       how, what = extract_args(args)
@@ -122,6 +132,21 @@ module Applitools::Selenium
       Applitools::Selenium::Element.new(self, driver.find_element(how, what))
     end
 
+    # Finds elements, specified by +what+ parameter interpreting it in the way, specified in +how+ parameter
+    # @param [Symbol] how Defines the way that +what+ parameter will be interpreted (The type of selector). Can be one
+    #   of: +:class+, +:class_name+, +:css+, +:id+, +:link+, +:link_text+, +:name+, +:partial_link_text+, +:tag_name+,
+    #   +:xpath+
+    # @param [String] what The selector to find an element
+    # @example
+    #   driver.find_elements :css, '.some_class'
+    # @example
+    #   driver.find_elements :css => '.some_class'
+    # @example
+    #   driver.find_elements :id, 'element_id'
+    # @raise [ArgumentError] if invalid finder (+how+) is passed
+    # @return [ [Applitools::Selenium::Element] ]
+    # @!parse def find_elements(how, what); end
+
     def find_elements(*args)
       how, what = extract_args(args)
 
@@ -130,20 +155,63 @@ module Applitools::Selenium
       driver.find_elements(how, what).map { |el| Applitools::Selenium::Element.new(self, el) }
     end
 
+    # Returns +true+ if test is running on Android platform
     def android?
       platform_name.to_s.upcase == ANDROID
     end
 
+    # Returns +true+ if test is running on iOS platform
     def ios?
       platform_name.to_s.upcase == IOS
     end
 
+    # Returns a copy of current frame chain. Frame chain stores information about all parent frames,
+    #   including scroll offset an frame coordinates
+    def frame_chain
+      Applitools::Selenium::FrameChain.new other: @frame_chain
+    end
+
+    # Returns current frame chain. Frame chain stores information about all parent frames,
+    #   including scroll offset an frame coordinates
+    def frame_chain!
+      @frame_chain
+    end
+
+    # Gets +default_content_viewport_size+
+    # @param [Boolean] force_query if set to true, forces querying of viewport size from the browser,
+    #   otherwise returns cached value
+    # @return [Applitools::RectangleSize]
+    def default_content_viewport_size(force_query = false)
+      logger.info('default_content_viewport_size()')
+      if cached_default_content_viewport_size && !force_query
+        logger.info "Using cached viewport_size #{cached_default_content_viewport_size}"
+        return cached_default_content_viewport_size
+      end
+
+      current_frames = frame_chain
+      switch_to.default_content unless current_frames.empty?
+      logger.info 'Extracting viewport size...'
+      @cached_default_content_viewport_size = Applitools::Utils::EyesSeleniumUtils.extract_viewport_size(self)
+      logger.info "Done! Viewport size is #{@cached_default_content_viewport_size}"
+
+      switch_to.frames(frame_chain: current_frames) unless current_frames.empty?
+      @cached_default_content_viewport_size
+    end
+
+    def switch_to
+      @switch_to ||= Applitools::Selenium::EyesTargetLocator.new(
+        self, driver.switch_to, FrameChangeEventListener.new(self)
+      )
+    end
+
     private
 
-    def save_image(image)
-      tag = (@tag_for_screenshot_debug || 'screenshot').gsub(/\s+/, '_')
-      screenshot = ChunkyPNG::Image.from_string(image)
-      screenshot.save("#{tag}_#{Time.now.strftime('%Y_%m_%d_%H_%M')}__#{@visible_screenshot_call_count += 1}.png")
+    attr_reader :cached_default_content_viewport_size
+
+    def raises_error
+      yield if block_given?
+    rescue => e
+      raise Applitools::EyesDriverOperationException.new e.message
     end
 
     def bridge
@@ -172,6 +240,53 @@ module Applitools::Selenium
       end
     end
 
+    # @!visibility private
+    class FrameChangeEventListener
+      extend Forwardable
+
+      def_delegators 'Applitools::EyesLogger', :logger, :log_handler, :log_handler=
+
+      def initialize(parent)
+        self.parent = parent
+      end
+
+      def will_switch_to_frame(target_type, target_frame)
+        logger.info 'will_switch_to_frame()'
+        case target_type
+        when :default_content
+          logger.info 'Default content.'
+          parent.frame_chain!.clear
+          return nil
+        when :parent_frame
+          logger.info 'Parent frame.'
+          return parent.frame_chain!.pop
+        when :frame
+          logger.info 'Frame.'
+          frame_location_size = Applitools::Selenium::BorderAwareElementContentLocationProvider.new target_frame
+
+          return parent.frame_chain!.push(
+            Applitools::Selenium::Frame.new(
+              reference: target_frame, frame_id: '',
+              location: Applitools::Location.for(frame_location_size.location),
+              size: Applitools::RectangleSize.for(frame_location_size.size),
+              parent_scroll_position: Applitools::Selenium::ScrollPositionProvider.new(parent).current_position
+            )
+          )
+        else
+          raise Applitools::EyesError.new('will_switch_to_frame(): target type is not recognized!')
+        end
+        logger.info 'Done!'
+      end
+
+      # def will_switch_to_window(name_or_handle)
+      #
+      # end
+
+      private
+
+      attr_accessor :parent
+    end
+
     class << self
       def normalize_image(driver, image, rotation)
         normalize_rotation(driver, image, rotation)