eyes_selenium 2.15.0 → 2.16.0

data/lib/applitools/selenium/mouse.rb

@@ -0,0 +1,62 @@
+module Applitools::Selenium
+  class Mouse
+    attr_reader :driver, :mouse
+
+    def initialize(driver, mouse)
+      @driver = driver
+      @mouse = mouse
+    end
+
+    def click(element = nil)
+      extract_trigger_and_perform(:click, element)
+    end
+
+    def double_click(element = nil)
+      extract_trigger_and_perform(:double_click, element)
+    end
+
+    def context_click(element = nil)
+      extract_trigger_and_perform(:right_click, element)
+    end
+
+    def down(element = nil)
+      extract_trigger_and_perform(:down, element)
+    end
+
+    def up(element = nil)
+      extract_trigger_and_perform(:up, element)
+    end
+
+    def move_to(element, right_by = nil, down_by = nil)
+      element = element.web_element if element.is_a?(Applitools::Selenium::Element)
+      location = element.location
+      location.x = [0, location.x].max.round
+      location.y = [0, location.y].max.round
+      current_control = Applitools::Base::Region.new(0, 0, *location.values)
+      driver.user_inputs << Applitools::Base::MouseTrigger.new(:move, current_control, location)
+      element = element.web_element if element.is_a?(Applitools::Selenium::Element)
+      mouse.move_to(element,right_by, down_by)
+    end
+
+    def move_by(right_by, down_by)
+      right = [0, right_by].max.round
+      down = [0, down_by].max.round
+      location = Applitools::Base::Point.new(right,down)
+      current_control = Applitools::Base::Region.new(0, 0, right, down)
+      driver.user_inputs << Applitools::Base::MouseTrigger.new(:move, current_control, location)
+      mouse.move_by(right_by,down_by)
+    end
+
+    private
+
+    def extract_trigger_and_perform(method, element = nil, *args)
+      location = element.location
+      location.x = [0, location.x].max.round
+      location.y = [0, location.y].max.round
+      current_control = Applitools::Base::Region.new(0, 0, *location.values)
+      driver.user_inputs << Applitools::Base::MouseTrigger.new(method, current_control, location)
+      element = element.web_element if element.is_a?(Applitools::Selenium::Element)
+      mouse.send(method, element, *args)
+    end
+  end
+end

data/lib/applitools/selenium/viewport_size.rb

@@ -0,0 +1,128 @@
+module Applitools::Selenium
+  class ViewportSize
+    JS_GET_VIEWPORT_HEIGHT = <<-EOF
+      var height = undefined;
+      if (window.innerHeight) {
+        height = window.innerHeight;
+      }
+      else if (document.documentElement && document.documentElement.clientHeight) {
+        height = document.documentElement.clientHeight;
+      } else {
+        var b = document.getElementsByTagName("body")[0];
+        if (b.clientHeight) {
+          height = b.clientHeight;
+        }
+      }
+
+      return height;
+    EOF
+
+    JS_GET_VIEWPORT_WIDTH  = <<-EOF
+      var width = undefined;
+      if (window.innerWidth) {
+        width = window.innerWidth
+      } else if (document.documentElement && document.documentElement.clientWidth) {
+        width = document.documentElement.clientWidth;
+      } else {
+        var b = document.getElementsByTagName("body")[0];
+        if (b.clientWidth) {
+          width = b.clientWidth;
+        }
+      }
+
+      return width;
+    EOF
+
+    VERIFY_SLEEP_PERIOD = 1.freeze
+    VERIFY_RETRIES = 3.freeze
+
+    def initialize(driver, dimension = nil)
+      @driver = driver
+      @dimension = dimension
+    end
+
+    def extract_viewport_width
+      @driver.execute_script(JS_GET_VIEWPORT_WIDTH)
+    end
+
+    def extract_viewport_height
+      @driver.execute_script(JS_GET_VIEWPORT_HEIGHT)
+    end
+
+    def extract_viewport_from_browser!
+      @dimension = extract_viewport_from_browser
+    end
+
+    def extract_viewport_from_browser
+      width, height = nil, nil
+      begin
+        width  = extract_viewport_width
+        height = extract_viewport_height
+      rescue => e
+        Applitools::EyesLogger.error "Failed extracting viewport size using JavaScript: (#{e.message})"
+      end
+
+      if width.nil? || height.nil?
+        Applitools::EyesLogger.info "Using window size as viewport size."
+
+        width, height = *browser_size.values
+        width, height = width.ceil, height.ceil
+
+        if @driver.landscape_orientation? && height > width
+          width, height = height, width
+        end
+      end
+
+      Applitools::Base::Dimension.new(width,height)
+    end
+
+    alias_method :viewport_size, :extract_viewport_from_browser
+
+    def set
+      if @dimension.is_a?(Hash) && @dimension.has_key?(:width) && @dimension.has_key?(:height)
+        # If @dimension is hash of width/height, we convert it to a struct with width/height properties.
+        @dimension = Struct.new(:width, :height).new(@dimension[:width], @dimension[:height])
+      elsif !@dimension.respond_to?(:width) || !@dimension.respond_to?(:height)
+        raise ArgumentError, "expected #{@dimension.inspect}:#{@dimension.class} to respond to #width and #height, or be "\
+          ' a hash with these keys.'
+      end
+
+      set_browser_size(@dimension)
+      verify_size(:browser_size)
+
+      cur_viewport_size = extract_viewport_from_browser
+
+      set_browser_size(Applitools::Base::Dimension.new((2 * browser_size.width) - cur_viewport_size.width,
+        (2 * browser_size.height) - cur_viewport_size.height))
+      verify_size(:viewport_size)
+    end
+
+    def verify_size(to_verify, sleep_time = VERIFY_SLEEP_PERIOD, retries = VERIFY_RETRIES)
+      cur_size = nil
+
+      retries.times do
+        sleep(sleep_time)
+        cur_size = send(to_verify)
+
+        return if cur_size.values == @dimension.values
+      end
+
+      err_msg = "Failed setting #{to_verify} to #{@dimension.values} (current size: #{cur_size.values})"
+
+      Applitools::EyesLogger.error(err_msg)
+      raise Applitools::TestFailedError.new(err_msg)
+    end
+
+    def browser_size
+      @driver.manage.window.size
+    end
+
+    def set_browser_size(other)
+      @driver.manage.window.size = other
+    end
+
+    def to_hash
+      Hash[@dimension.each_pair.to_a]
+    end
+  end
+end

data/lib/applitools/utils/image_delta_compressor.rb

@@ -0,0 +1,150 @@
+require 'oily_png'
+
+module Applitools::Utils
+  module ImageDeltaCompressor
+    extend self
+
+    BLOCK_SIZE = 10.freeze
+
+    # Compresses the target image based on the source image.
+    #
+    # +target+:: +ChunkyPNG::Canvas+ The image to compress based on the source image.
+    # +target_encoded+:: +Array+ The uncompressed image as binary string.
+    # +source+:: +ChunkyPNG::Canvas+ The source image used as a base for compressing the target image.
+    # +block_size+:: +Integer+ The width/height of each block.
+    #
+    # Returns +String+ The binary result (either the compressed image, or the uncompressed image if the compression
+    # is greater in length).
+    def compress_by_raw_blocks(target, target_encoded, source, block_size = BLOCK_SIZE)
+      # If we can't compress for any reason, return the target image as is.
+      if source.nil? || (source.height != target.height) || (source.width != target.width)
+        # Returning a COPY of the target binary string.
+        return String.new(target_encoded)
+      end
+
+      # Preparing the variables we need.
+      target_pixels = target.to_rgb_stream.unpack('C*')
+      source_pixels = source.to_rgb_stream.unpack('C*')
+      image_size = Dimension.new(target.width, target.height)
+      block_columns_count = (target.width / block_size) + ((target.width % block_size) == 0 ? 0 : 1)
+      block_rows_count = (target.height / block_size) + ((target.height % block_size) == 0 ? 0 : 1)
+
+      # IMPORTANT: The "-Zlib::MAX_WBITS" tells ZLib to create raw deflate compression, without the
+      # "Zlib headers" (this isn't documented in the Zlib page, I found this in some internet forum).
+      compressor = Zlib::Deflate.new(Zlib::BEST_COMPRESSION, -Zlib::MAX_WBITS)
+
+      compression_result = ''
+
+      # Writing the data header.
+      compression_result += PREAMBLE.encode('UTF-8')
+      compression_result += [FORMAT_RAW_BLOCKS].pack('C')
+      compression_result += [0].pack('S>') #Source id, Big Endian
+      compression_result += [block_size].pack('S>') #Big Endian
+
+      # We perform the compression for each channel.
+      3.times do |channel|
+        block_number = 0
+        block_rows_count.times do |block_row|
+          block_columns_count.times do |block_column|
+            actual_channel_index = 2 - channel # Since the image bytes are BGR and the server expects RGB...
+            compare_result = compare_and_copy_block_channel_data(source_pixels, target_pixels, image_size, 3, block_size,
+              block_column, block_row, actual_channel_index)
+
+            unless compare_result.identical
+              channel_bytes = compare_result.channel_bytes
+              string_to_compress = [channel].pack('C')
+              string_to_compress += [block_number].pack('L>')
+              string_to_compress += channel_bytes.pack('C*')
+
+              compression_result += compressor.deflate(string_to_compress)
+
+              # If the compressed data so far is greater than the uncompressed representation of the target, just return
+              # the target.
+              if compression_result.length > target_encoded.length
+  	             compressor.finish
+                compressor.close
+                # Returning a copy of the target bytes.
+                return String.new(target_encoded)
+              end
+            end
+
+            block_number += 1
+          end
+        end
+      end
+
+      # Compress and flush any remaining uncompressed data in the input buffer.
+      compression_result += compressor.finish
+      compressor.close
+
+      # Returning the compressed result as a byte array.
+      compression_result
+    end
+
+    private
+
+    PREAMBLE = 'applitools'.freeze
+    FORMAT_RAW_BLOCKS = 3.freeze
+
+    Dimension = Struct.new(:width, :height)
+    CompareAndCopyBlockChannelDataResult = Struct.new(:identical, :channel_bytes)
+
+    # Computes the width and height of the image data contained in the block at the input column and row.
+    # +image_size+:: +Dimension+ The image size in pixels.
+    # +block_size+:: The block size for which we would like to compute the image data width and height.
+    # +block_column+:: The block column index.
+    # +block_row+:: The block row index.
+    # ++
+    # Returns the width and height of the image data contained in the block are returned as a +Dimension+.
+    def get_actual_block_size(image_size, block_size, block_column, block_row)
+      actual_width = [image_size.width - (block_column * block_size), block_size].min
+      actual_height = [image_size.height - (block_row * block_size), block_size].min
+      Dimension.new(actual_width, actual_height)
+    end
+
+    # Compares a block of pixels between the source and target and copies the target's block bytes to the result.
+    # +source_pixels+:: +Array+ of bytes, representing the pixels of the source image.
+    # +target_pixels+:: +Array+ of bytes, representing the pixels of the target image.
+    # +image_size+:: +Dimension+ The size of the source/target image (remember they must be the same size).
+    # +pixel_length+:: +Integer+ The number of bytes composing a pixel
+    # +block_size+:: +Integer+ The width/height of the block (block is a square, theoretically).
+    # +block_column+:: +Integer+ The block column index (when looking at the images as a grid of blocks).
+    # +block_row+:: +Integer+ The block row index (when looking at the images as a grid of blocks).
+    # +channel+:: +Integer+ The index of the channel we're comparing.
+    # ++
+    # Returns +CompareAndCopyBlockChannelDataResult+ object containing a flag saying whether the blocks are identical
+    # and a copy of the target block's bytes.
+    def compare_and_copy_block_channel_data(source_pixels, target_pixels, image_size, pixel_length, block_size,
+        block_column, block_row, channel)
+      identical = true
+
+      actual_block_size = get_actual_block_size(image_size, block_size, block_column, block_row)
+
+      # Getting the actual amount of data in the block we wish to copy.
+      actual_block_height = actual_block_size.height
+      actual_block_width = actual_block_size.width
+
+      stride = image_size.width * pixel_length
+
+      # Iterating the block's pixels and comparing the source and target.
+      channel_bytes = []
+      actual_block_height.times do |h|
+        offset = (((block_size * block_row) + h) * stride) + (block_size * block_column * pixel_length) + channel
+        actual_block_width.times do |w|
+          source_byte = source_pixels[offset]
+          target_byte = target_pixels[offset]
+          if source_byte != target_byte
+            identical = false
+          end
+          channel_bytes << target_byte
+          offset += pixel_length
+        end
+      end
+
+      # Returning the compare-and-copy result.
+      CompareAndCopyBlockChannelDataResult.new(identical, channel_bytes)
+    end
+
+    include Applitools::MethodTracer
+  end
+end

data/lib/applitools/utils/image_utils.rb

@@ -0,0 +1,63 @@
+require 'oily_png'
+require 'base64'
+
+module Applitools::Utils
+  module ImageUtils
+    extend self
+
+    # Creates an image object from the PNG bytes.
+    # +png_bytes+:: +String+ A binary string of the PNG bytes of the image.
+    #
+    # Returns:
+    # +ChunkyPNG::Canvas+ An image object.
+    def png_image_from_bytes(png_bytes)
+      ChunkyPNG::Image.from_blob(png_bytes)
+    end
+
+    # Creates an image instance from a base64 representation of its PNG encoding.
+    #
+    # +png_bytes64+:: +String+ The Base64 representation of a PNG image.
+    #
+    # Returns:
+    # +ChunkyPNG::Canvas+ An image object.
+    def png_image_from_base64(png_bytes64)
+      png_image_from_bytes(Base64.decode64(png_bytes64))
+    end
+
+    # Get the raw PNG bytes of an image.
+    #
+    # +ChunkyPNG::Canvas+ The image object for which to get the PNG bytes.
+    #
+    # Returns:
+    # +String+ The PNG bytes of the image.
+    def bytes_from_png_image(image)
+      image.to_blob
+    end
+
+    # Get the Base64 representation of the raw PNG bytes of an image.
+    #
+    # +ChunkyPNG::Canvas+ The image object for which to get the PNG bytes.
+    #
+    # Returns:
+    # +String+ the Base64 representation of the raw PNG bytes of an image.
+    def base64_from_png_image(image)
+      Base64.encode64(bytes_from_png_image(image))
+    end
+
+    # Rotates a matrix 90 deg clockwise or counter clockwise (depending whether num_quadrants is positive or negative,
+    # respectively).
+    #
+    # +image+:: +ChunkyPNG::Canvas+ The image to rotate.
+    # +num_quadrants+:: +Integer+ The number of rotations to perform. Positive values are used for clockwise rotation
+    #   and negative values are used for counter-clockwise rotation.
+    #
+    def quadrant_rotate!(image, num_quadrants)
+      image.tap do |img|
+        rotate_method = num_quadrants > 0 ? img.method(:rotate_right!) : img.method(:rotate_left!)
+        (0..(num_quadrants.abs - 1)).each { rotate_method.call }
+      end
+    end
+
+    include Applitools::MethodTracer
+  end
+end

data/lib/applitools/utils/utils.rb

@@ -0,0 +1,52 @@
+require 'bigdecimal'
+
+module Applitools::Utils
+  extend self
+
+  def underscore(str)
+    str.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').tr('-', '_').downcase
+  end
+
+  def uncapitalize(str)
+    str[0, 1].downcase + str[1..-1]
+  end
+
+  def camelcase(str)
+    tokens = str.split('_')
+    uncapitalize(tokens.shift) + tokens.map(&:capitalize).join
+  end
+
+  def wrap(object)
+    if object.nil?
+      []
+    elsif object.respond_to?(:to_ary)
+      object.to_ary || [object]
+    else
+      [object]
+    end
+  end
+
+  def underscore_hash_keys(hash)
+    convert_hash_keys(hash, :underscore)
+  end
+
+  def camelcase_hash_keys(hash)
+    convert_hash_keys(hash, :camelcase)
+  end
+
+  private
+
+  def convert_hash_keys(value, method)
+    case value
+    when Array
+      value.map {|v| convert_hash_keys(v, method) }
+    when Hash
+      Hash[value.map {|k, v| [send(method, k.to_s).to_sym,
+        convert_hash_keys(v, method)]}]
+    else
+      value
+    end
+  end
+end
+
+