eyes_selenium 2.16.0 → 2.17.0

data/lib/applitools/eyes_logger.rb

@@ -3,10 +3,10 @@ require 'forwardable'
 
 module Applitools::EyesLogger
   class NullLogger < Logger
-    def initialize(*args)
+    def initialize(*_args)
     end
 
-    def add(*args, &block)
+    def add(*_args, &_block)
     end
   end
 
@@ -16,25 +16,25 @@ module Applitools::EyesLogger
   MANDATORY_METHODS = [:debug, :info, :close].freeze
   OPTIONAL_METHODS = [:warn, :error, :fatal].freeze
 
-  def_delegators :@@log_handler, *MANDATORY_METHODS
+  def_delegators :@log_handler, *MANDATORY_METHODS
 
-  @@log_handler = NullLogger.new
+  @log_handler = NullLogger.new
 
   def log_handler=(log_handler)
     raise Applitools::EyesError.new('log_handler must implement Logger!') unless valid?(log_handler)
 
-    @@log_handler = log_handler
+    @log_handler = log_handler
   end
 
   OPTIONAL_METHODS.each do |method|
     define_singleton_method(method) do |msg|
-      @@log_handler.respond_to?(method) ? @@log_handler.send(method, msg) : @@log_handler.info(msg)
+      @log_handler.respond_to?(method) ? @log_handler.send(method, msg) : @log_handler.info(msg)
     end
   end
 
   private
 
   def valid?(log_handler)
-    MANDATORY_METHODS.all? {|method| log_handler.respond_to?(method)}
+    MANDATORY_METHODS.all? { |method| log_handler.respond_to?(method) }
   end
 end

data/lib/applitools/method_tracer.rb

@@ -15,8 +15,8 @@ module Applitools::MethodTracer
         end
       end
 
-      instance_methods.each {|method_name| trace_method(base, method_name) }
-      class_methods.each {|method_name| trace_method(base, method_name, false) }
+      instance_methods.each { |method_name| trace_method(base, method_name) }
+      class_methods.each { |method_name| trace_method(base, method_name, false) }
     end
   end
 end

data/lib/applitools/selenium/browser.rb

@@ -0,0 +1,220 @@
+module Applitools::Selenium
+  class Browser
+    JS_GET_USER_AGENT = (<<-JS).freeze
+      return navigator.userAgent;
+    JS
+
+    JS_GET_DEVICE_PIXEL_RATIO = (<<-JS).freeze
+      return window.devicePixelRatio;
+    JS
+
+    JS_GET_PAGE_METRICS = (<<-JS).freeze
+      return {
+        scrollWidth: document.documentElement.scrollWidth,
+        bodyScrollWidth: document.body.scrollWidth,
+        clientHeight: document.documentElement.clientHeight,
+        bodyClientHeight: document.body.clientHeight,
+        scrollHeight: document.documentElement.scrollHeight,
+        bodyScrollHeight: document.body.scrollHeight
+      };
+    JS
+
+    JS_GET_CURRENT_SCROLL_POSITION = (<<-JS).freeze
+      return (function() {
+        var doc = document.documentElement;
+        var x = (window.scrollX || window.pageXOffset || doc.scrollLeft) - (doc.clientLeft || 0);
+        var y = (window.scrollY || window.pageYOffset || doc.scrollTop)  - (doc.clientTop || 0);
+
+        return {left: parseInt(x, 10) || 0, top: parseInt(y, 10) || 0};
+      }());
+    JS
+
+    JS_SCROLL_TO = (<<-JS).freeze
+      window.scrollTo(%{left}, %{top});
+    JS
+
+    JS_GET_CURRENT_TRANSFORM = (<<-JS).freeze
+      return document.body.style.transform;
+    JS
+
+    JS_SET_TRANSFORM = (<<-JS).freeze
+      return (function() {
+        var originalTransform = document.body.style.transform;
+        document.body.style.transform = '%{transform}';
+        return originalTransform;
+      }());
+    JS
+
+    JS_SET_OVERFLOW = (<<-JS).freeze
+      return (function() {
+        var origOF = document.documentElement.style.overflow;
+        document.documentElement.style.overflow = '%{overflow}';
+        return origOF;
+      }());
+    JS
+
+    EPSILON_WIDTH = 12.freeze
+    MIN_SCREENSHOT_PART_HEIGHT = 10.freeze
+    MAX_SCROLLBAR_SIZE = 50.freeze
+    OVERFLOW_HIDDEN = 'hidden'.freeze
+
+    def initialize(driver, eyes)
+      @driver = driver
+      @eyes = eyes
+    end
+
+    def chrome?
+      @driver.browser == :chrome
+    end
+
+    def user_agent
+      return @user_agent if defined?(@user_agent)
+
+      @user_agent = begin
+        execute_script(JS_GET_USER_AGENT).freeze
+      rescue => e
+        Applitools::EyesLogger.error "Failed to obtain user-agent: (#{e.message})"
+
+        nil
+      end
+    end
+
+    def image_normalization_factor(image)
+      if image.width == @eyes.viewport_size.extract_viewport_from_browser.width ||
+          (image.width - entire_page_size.width).abs <= EPSILON_WIDTH
+        return 1
+      end
+
+      1.to_f / device_pixel_ratio
+    end
+
+    def entire_page_size
+      max_document_element_height = [page_metrics[:client_height], page_metrics[:scroll_height]].max
+      max_body_height = [page_metrics[:body_client_height], page_metrics[:body_scroll_height]].max
+
+      total_width = [page_metrics[:scroll_width], page_metrics[:body_scroll_width]].max
+      total_height = [max_document_element_height, max_body_height].max
+
+      Applitools::Base::Dimension.new(total_width, total_height)
+    end
+
+    def current_scroll_position
+      position = Applitools::Utils.underscore_hash_keys(execute_script(JS_GET_CURRENT_SCROLL_POSITION))
+      Applitools::Base::Point.new(position[:left], position[:top])
+    end
+
+    def scroll_to(point)
+      execute_script(JS_SCROLL_TO % { left: point.left, top: point.top }, 0.25)
+    end
+
+    def current_transform
+      execute_script(JS_GET_CURRENT_TRANSFORM)
+    end
+
+    # rubocop:disable Style/AccessorMethodName
+    def set_transform(transform)
+      execute_script(JS_SET_TRANSFORM % { transform: transform }, 0.25)
+    end
+
+    def set_overflow(overflow)
+      execute_script(JS_SET_OVERFLOW % { overflow: overflow }, 0.1)
+    end
+    # rubocop:enable Style/AccessorMethodName
+
+    def translate_to(point)
+      set_transform("translate(-#{point.left}px, -#{point.top}px)")
+    end
+
+    def fullpage_screenshot
+      # Scroll to the top/left corner of the screen.
+      original_scroll_position = current_scroll_position
+      scroll_to(Applitools::Base::Point::TOP_LEFT)
+      if current_scroll_position != Applitools::Base::Point::TOP_LEFT
+        raise 'Could not scroll to the top/left corner of the screen!'
+      end
+
+      # Translate to top/left of the page (notice this is different from JavaScript scrolling).
+      if @eyes.use_css_transition
+        original_transform = current_transform
+        translate_to(Applitools::Base::Point::TOP_LEFT)
+      end
+
+      # Hide scrollbars.
+      original_overflow = set_overflow(OVERFLOW_HIDDEN) if @eyes.hide_scrollbars
+
+      # Take screenshot of the (0,0) tile.
+      screenshot = @driver.visible_screenshot
+
+      # Normalize screenshot width/height.
+      size_factor = 1
+      page_size = entire_page_size
+      factor = image_normalization_factor(screenshot)
+      if factor == 0.5
+        size_factor = 2
+        page_size.width *= size_factor
+        page_size.height *= size_factor
+        page_size.width = [page_size.width, screenshot.width].max
+      end
+
+      # NOTE: this is required! Since when calculating the screenshot parts for full size, we use a screenshot size
+      # which is a bit smaller (see comment below).
+      if @eyes.force_fullpage_screenshot && (screenshot.width < page_size.width || screenshot.height < page_size.height)
+        # We use a smaller size than the actual screenshot size in order to eliminate duplication of bottom scroll bars,
+        # as well as footer-like elements with fixed position.
+        max_scrollbar_size = @eyes.use_css_transition ? 0 : MAX_SCROLLBAR_SIZE
+        height = [screenshot.height - (max_scrollbar_size * size_factor), MIN_SCREENSHOT_PART_HEIGHT * size_factor].max
+        screenshot_part_size = Applitools::Base::Dimension.new(screenshot.width, height)
+
+        subregios = Applitools::Base::Region.new(0, 0, page_size.width,
+          page_size.height).subregions(screenshot_part_size)
+        parts = subregios.map do |screenshot_part|
+          # Skip (0,0), as we already got the screenshot.
+          if screenshot_part.left == 0 && screenshot_part.top == 0
+            next Applitools::Base::ImagePosition.new(screenshot, Applitools::Base::Point::TOP_LEFT)
+          end
+
+          process_screenshot_part(screenshot_part, size_factor)
+        end
+
+        screenshot = Applitools::Utils::ImageUtils.stitch_images(page_size, parts)
+      end
+
+      set_overflow(original_overflow) if @eyes.hide_scrollbars
+      set_transform(original_transform) if @eyes.use_css_transition
+
+      scroll_to(original_scroll_position)
+
+      screenshot
+    end
+
+    private
+
+    def execute_script(script, stabilization_time = nil)
+      @driver.execute_script(script).tap { sleep(stabilization_time) if stabilization_time }
+    end
+
+    def device_pixel_ratio
+      @device_pixel_ratio ||= execute_script(JS_GET_DEVICE_PIXEL_RATIO).freeze
+    end
+
+    def page_metrics
+      Applitools::Utils.underscore_hash_keys(execute_script(JS_GET_PAGE_METRICS))
+    end
+
+    def process_screenshot_part(part, size_factor)
+      part_coords = Applitools::Base::Point.new(part.left, part.top)
+      part_coords_normalized = Applitools::Base::Point.new(part.left.to_f / size_factor, part.top.to_f / size_factor)
+
+      if @eyes.use_css_transition
+        translate_to(part_coords_normalized)
+        current_position = part_coords
+      else
+        scroll_to(part_coords_normalized)
+        position = current_scroll_position
+        current_position = Applitools::Base::Point.new(position.left * size_factor, position.top * size_factor)
+      end
+
+      Applitools::Base::ImagePosition.new(@driver.visible_screenshot, current_position)
+    end
+  end
+end

data/lib/applitools/selenium/driver.rb

@@ -9,13 +9,10 @@ module Applitools::Selenium
     include Selenium::WebDriver::DriverExtensions::HasInputDevices
 
     RIGHT_ANGLE = 90.freeze
-    ANDROID = 'ANDROID'.freeze
     IOS = 'IOS'.freeze
+    ANDROID = 'ANDROID'.freeze
     LANDSCAPE = 'LANDSCAPE'.freeze
 
-    IE = 'ie'.freeze
-    FIREFOX = 'firefox'.freeze
-
     FINDERS = {
       class: 'class name',
       class_name: 'class name',
@@ -29,9 +26,10 @@ module Applitools::Selenium
       xpath: 'xpath'
     }.freeze
 
-    JS_GET_USER_AGENT = 'return navigator.userAgent;'.freeze
+    attr_reader :browser
 
     def_delegators :@eyes, :user_inputs, :clear_user_inputs
+    def_delegators :@browser, :user_agent
 
     # If driver is not provided, Applitools::Selenium::Driver will raise an EyesError exception.
     def initialize(eyes, options)
@@ -39,33 +37,9 @@ module Applitools::Selenium
 
       @is_mobile_device = options.fetch(:is_mobile_device, false)
       @eyes = eyes
+      @browser = Applitools::Selenium::Browser.new(self, @eyes)
 
-      raise 'Uncapable of taking screenshots!' unless capabilities.takes_screenshot?
-    end
-
-    # Rotates the image as necessary. The rotation is either manually forced by passing a value in
-    # the +rotation+ parameter, or automatically inferred if the +rotation+ parameter is +nil+.
-    #
-    # +driver+:: +Applitools::Selenium::Driver+ The driver which produced the screenshot.
-    # +image+:: +ChunkyPNG::Canvas+ The image to normalize.
-    # +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.
-    def self.normalize_rotation(driver, image, rotation)
-      return if rotation == 0
-
-      num_quadrants = 0
-      if !rotation.nil?
-        if rotation % RIGHT_ANGLE != 0
-          raise Applitools::EyesError.new("Currently only quadrant rotations are supported. Current rotation: "\
-            "#{rotation}")
-        end
-        num_quadrants = (rotation / RIGHT_ANGLE).to_i
-      elsif rotation.nil? && driver.mobile_device? && driver.landscape_orientation? && image.height > image.width
-        # For Android, we need to rotate images to the right, and for iOS to the left.
-        num_quadrants = driver.android? ? 1 : -1
-      end
-
-      Applitools::Utils::ImageUtils.quadrant_rotate!(image, num_quadrants)
+      raise 'Incapable of taking screenshots!' unless capabilities.takes_screenshot?
     end
 
     # Returns:
@@ -81,26 +55,12 @@ module Applitools::Selenium
       version.nil? ? nil : version.to_s
     end
 
-    # Returns:
-    # +true+ if the driver is an Android driver.
-    def android?
-      platform_name.to_s.upcase == ANDROID
-    end
-
-    # Returns:
-    # +true+ if the driver is an iOS driver.
-    def ios?
-      platform_name.to_s.upcase == IOS
-    end
-
     # Returns:
     # +true+ if the driver orientation is landscape.
     def landscape_orientation?
-      begin
-        driver.orientation.to_s.upcase == LANDSCAPE
-      rescue NameError
-        Applitools::EyesLogger.debug 'driver has no "orientation" attribute. Assuming: portrait.'
-      end
+      driver.orientation.to_s.upcase == LANDSCAPE
+    rescue NameError
+      Applitools::EyesLogger.debug 'driver has no "orientation" attribute. Assuming: portrait.'
     end
 
     # Returns:
@@ -119,19 +79,24 @@ module Applitools::Selenium
     #
     # Returns: +String+ A screenshot in the requested format.
     def screenshot_as(output_type, rotation = nil)
-      screenshot = Applitools::Utils::ImageUtils.png_image_from_base64(driver.screenshot_as(:base64))
-      Applitools::Selenium::Driver.normalize_rotation(self, screenshot, rotation)
+      image = mobile_device? ? visible_screenshot : @browser.fullpage_screenshot
+
+      Applitools::Selenium::Driver.normalize_image(self, image, rotation)
 
       case output_type
       when :base64
-        screenshot = Applitools::Utils::ImageUtils.base64_from_png_image(screenshot)
+        image = Applitools::Utils::ImageUtils.base64_from_png_image(image)
       when :png
-        screenshot = Applitools::Utils::ImageUtils.bytes_from_png_image(screenshot)
+        image = Applitools::Utils::ImageUtils.bytes_from_png_image(image)
       else
-        raise Applitools::EyesError.new("Unsupported screenshot output type: #{output_type.to_s}")
+        raise Applitools::EyesError.new("Unsupported screenshot output type: #{output_type}")
       end
 
-      screenshot.force_encoding('BINARY')
+      image.force_encoding('BINARY')
+    end
+
+    def visible_screenshot
+      Applitools::Utils::ImageUtils.png_image_from_base64(driver.screenshot_as(:base64))
     end
 
     def mouse
@@ -159,12 +124,12 @@ module Applitools::Selenium
       driver.find_elements(how, what).map { |el| Applitools::Selenium::Element.new(self, el) }
     end
 
-    def user_agent
-      @user_agent ||= execute_script JS_GET_USER_AGENT
-    rescue => e
-      Applitools::EyesLogger.error "Failed to obtain user-agent string (#{e.message})"
+    def android?
+      platform_name.to_s.upcase == ANDROID
+    end
 
-      nil
+    def ios?
+      platform_name.to_s.upcase == IOS
     end
 
     private
@@ -190,5 +155,42 @@ module Applitools::Selenium
         raise ArgumentError, "wrong number of arguments (#{args.size} for 2)"
       end
     end
+
+    def self.normalize_image(driver, image, rotation)
+      normalize_rotation(driver, image, rotation)
+      normalize_width(driver, image)
+    end
+
+    # Rotates the image as necessary. The rotation is either manually forced by passing a value in
+    # the +rotation+ parameter, or automatically inferred if the +rotation+ parameter is +nil+.
+    #
+    # +driver+:: +Applitools::Selenium::Driver+ The driver which produced the screenshot.
+    # +image+:: +ChunkyPNG::Canvas+ The image to normalize.
+    # +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.
+    def self.normalize_rotation(driver, image, rotation)
+      return if rotation == 0
+
+      num_quadrants = 0
+      if !rotation.nil?
+        if rotation % RIGHT_ANGLE != 0
+          raise Applitools::EyesError.new('Currently only quadrant rotations are supported. Current rotation: '\
+            "#{rotation}")
+        end
+        num_quadrants = (rotation / RIGHT_ANGLE).to_i
+      elsif rotation.nil? && driver.mobile_device? && driver.landscape_orientation? && image.height > image.width
+        # For Android, we need to rotate images to the right, and for iOS to the left.
+        num_quadrants = driver.android? ? 1 : -1
+      end
+
+      Applitools::Utils::ImageUtils.quadrant_rotate!(image, num_quadrants)
+    end
+
+    def self.normalize_width(driver, image)
+      return if driver.mobile_device?
+
+      normalization_factor = driver.browser.image_normalization_factor(image)
+      Applitools::Utils::ImageUtils.scale!(image, normalization_factor) unless normalization_factor == 1
+    end
   end
 end