eyes_selenium 3.14.3 → 3.14.4

data/lib/applitools/selenium/eyes_screenshot.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Applitools
+  module Selenium
+    class EyesScreenshot < Applitools::EyesScreenshot
+      attr_accessor :driver, :region_provider
+      def_delegators '@driver', :frame_chain
+
+      def initialize(image, options = {})
+        super image
+        self.region_provider = options[:region_provider] if options[:region_provider]
+        Applitools::ArgumentGuard.is_a?(
+          region_provider,
+          'options[:region_provider]',
+          Applitools::Selenium::RegionProvider
+        )
+        self.driver = region_provider.driver
+      end
+
+      def convert_location(location, _from, _to)
+        location.offset_negative(top_left_location)
+      end
+
+      # Returns the location in the screenshot.
+      #
+      # @param [Applitools::Location] location The location.
+      # @param [Applitools::EyesScreenshot::COORDINATE_TYPES] coordinate_type The type of the coordinate.
+      # @return [Applitools::Location] The location instance in the screenshot.
+      def location_in_screenshot(location, coordinate_type)
+        raise Applitools::Selenium::UnsupportedCoordinateType, coordinate_type unless
+            coordinate_type == Applitools::EyesScreenshot::COORDINATE_TYPES[:context_relative]
+
+        location = convert_location(
+          location, coordinate_type, Applitools::EyesScreenshot::COORDINATE_TYPES[:screenshot_as_is]
+        )
+
+        unless image_region.contains?(location.x, location.y)
+          raise Applitools::OutOfBoundsException,
+            "Location #{location} (#{coordinate_type}) is not visible in screenshot!"
+        end
+        location
+      end
+
+      def intersected_region(region, original_coordinate_types, result_coordinate_types)
+        raise Applitools::Selenium::UnsupportedCoordinateType, original_coordinate_types unless
+            original_coordinate_types == Applitools::EyesScreenshot::COORDINATE_TYPES[:context_relative]
+        raise Applitools::Selenium::UnsupportedCoordinateType, result_coordinate_types unless
+            result_coordinate_types == Applitools::EyesScreenshot::COORDINATE_TYPES[:screenshot_as_is]
+
+        return Applitools::Region::EMPTY if region.empty?
+
+        intersected_region = convert_region_location(
+          region, original_coordinate_types, Applitools::EyesScreenshot::COORDINATE_TYPES[:screenshot_as_is]
+        )
+
+        intersected_region.intersect(image_region)
+      end
+    end
+  end
+end

data/lib/applitools/selenium/eyes_target_locator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Applitools::Selenium
   class EyesTargetLocator < SimpleDelegator
     extend Forwardable
@@ -38,19 +40,11 @@ module Applitools::Selenium
         end
       when Applitools::Selenium::Element
         frame_by_frame_element(value)
+      when String
+        frame_by_name_or_id(value)
       else
-        raise Applitools::EyesError 'Unknown frame selector to switch!'
+        raise Applitools::EyesError, 'Unknown frame selector to switch!'
       end
-      # require 'pry'
-      # binding.pry
-      # raise Applitools::EyesIllegalArgument.new 'You must pass :index or :name_or_id or :frame_element option' unless
-      #     options[:index] || options[:name_or_id] || options[:frame_element]
-      # if (needed_keys = (options.keys & [:index, :name_or_id, :frame_element])).length == 1
-      #   send "frame_by_#{needed_keys.first}", options[needed_keys.first]
-      # else
-      #   raise Applitools::EyesIllegalArgument.new 'You\'ve passed some extra keys!' /
-      #     'Only :index, :name_or_id or :frame_elenent are allowed.'
-      # end
     end
 
     # Switches to parent frame.
@@ -105,7 +99,7 @@ module Applitools::Selenium
     def window(name_or_handle)
       logger.info 'EyesTargetLocator.window()'
       logger.info 'Making preparaions...'
-      on_will_switch.will_switch_to_window name_or_handle
+      # on_will_switch.will_switch_to_window name_or_handle
       logger.info 'Done! Switching to window..'
       __getobj__.window name_or_handle
       logger.info 'Done!'
@@ -170,20 +164,14 @@ module Applitools::Selenium
 
     def frame_by_name_or_id(name_or_id)
       logger.info "EyesTargetLocator.frame(#{name_or_id})"
-      # Finding the target element so we can report it.
-      # We use find elements(plural) to avoid exception when the element
-      # is not found.
-      logger.info 'Getting frames by name...'
-      frames = driver.find_elements :name, name_or_id
-      if frames.empty?
-        logger.info 'No frames found! Trying by id...'
-        frames = driver.find_elements :id, name_or_id
-        raise Applitools::EyesNoSuchFrame.new "No frame with name or id #{name_or_id} exists!" if frames.empty?
-      end
+
+      logger.info 'Getting frame by name or id...'
+      target_frame = driver.find_element(name_or_id: name_or_id)
+
       logger.info 'Done! Making preparations...'
-      on_will_switch.will_switch_to_frame(:frame, frames.first)
+      on_will_switch.will_switch_to_frame(:frame, target_frame)
       logger.info 'Done! Switching to frame...'
-      __getobj__.frame frames.first
+      __getobj__.frame target_frame
 
       logger.info 'Done!'
       driver

data/lib/applitools/selenium/fixed_cut_provider.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Applitools
+  module Selenium
+    class FixedCutProvider
+      class << self
+        def viewport(image, viewport_size, region_to_check)
+          return nil if image.square == viewport_size.square
+          current_scroll_position = region_to_check.scroll_position_provider.current_position
+          image_canvas = Applitools::Region.new(0, 0, image.width, image.height)
+          viewport_frame = image_canvas.dup.intersect(
+            Applitools::Region.from_location_size(
+              Applitools::Location.new(current_scroll_position.left, current_scroll_position.top),
+              viewport_size
+            )
+          )
+          new(
+            viewport_frame.left,
+            viewport_frame.top,
+            image_canvas.right - viewport_frame.right,
+            image_canvas.bottom - viewport_frame.bottom
+          )
+        end
+      end
+
+      def initialize(left, header, right, footer)
+        Applitools::ArgumentGuard.is_a?(left, 'left', Integer)
+        Applitools::ArgumentGuard.is_a?(header, 'header', Integer)
+        Applitools::ArgumentGuard.is_a?(right, 'right', Integer)
+        Applitools::ArgumentGuard.is_a?(footer, 'footer', Integer)
+        self.left = left
+        self.header = header
+        self.right = right
+        self.footer = footer
+      end
+
+      def cut(image)
+        crop_width = image.width - left - right
+        crop_height = image.height - header - footer
+        image.crop!(left, header, crop_width, crop_height)
+      end
+
+      private
+
+      attr_accessor :left, :header, :right, :footer
+    end
+  end
+end

data/lib/applitools/selenium/frame.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Applitools::Selenium
   # @!visibility private
   class Frame
@@ -8,7 +10,7 @@ module Applitools::Selenium
         send("#{param}=", options[param])
       end
 
-      raise 'options[:location] must be instance of Applitools::Base::Point' unless
+      raise 'options[:location] must be instance of Applitools::Base::Location' unless
           location.is_a? Applitools::Location
 
       raise 'options[:parent_scroll_position] must be instance of Applitools::Location' unless
@@ -20,5 +22,13 @@ module Applitools::Selenium
       return if reference.is_a? Applitools::Selenium::Element
       raise 'options[:reference] must be instance of Applitools::Selenium::Element'
     end
+
+    def dup
+      super.tap do |r|
+        r.location = location.dup
+        r.size = size.dup
+        r.parent_scroll_position = parent_scroll_position.dup
+      end
+    end
   end
 end

data/lib/applitools/selenium/frame_chain.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Applitools::Selenium
   # @!visibility private
   class FrameChain
@@ -15,7 +17,7 @@ module Applitools::Selenium
 
     def same_frame_chain?(other)
       return false unless size == other.size
-      all? { |my_elem| my_elem.id == other.next.id }
+      ids == other.ids
     end
 
     def push(frame)
@@ -71,5 +73,11 @@ module Applitools::Selenium
     end
 
     class NoFramesException < RuntimeError; end
+
+    protected
+
+    def ids
+      map { |i| i.reference.ref }
+    end
   end
 end

data/lib/applitools/selenium/full_page_capture_algorithm.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Applitools::Selenium
   # @!visibility private
   class FullPageCaptureAlgorithm
@@ -8,6 +10,7 @@ module Applitools::Selenium
 
     MAX_SCROLL_BAR_SIZE = 50
     MIN_SCREENSHOT_PART_HEIGHT = 10
+    MIN_SCREENSHOT_PART_WIDTH = 10
 
     def initialize(options = {})
       @debug_screenshot_provider = options[:debug_screenshot_provider] ||
@@ -37,34 +40,28 @@ module Applitools::Selenium
       wait_before_screenshot = options[:wait_before_screenshots]
       eyes_screenshot_factory = options[:eyes_screenshot_factory]
       stitching_overlap = options[:stitching_overlap] || MAX_SCROLL_BAR_SIZE
+      top_left_position = options[:top_left_position] || Applitools::Location::TOP_LEFT
 
-      logger.info "Region to check: #{region_provider.region}"
+      logger.info "Region to check: #{region_provider.region(false)}"
       logger.info "Coordinates type: #{region_provider.coordinate_type}"
 
       original_position = origin_provider.state
       current_position = nil
       set_position_retries = 3
       while current_position.nil? ||
-          (current_position.x.nonzero? || current_position.y.nonzero?) && set_position_retries > 0
-        origin_provider.position = Applitools::Location.new(0, 0)
+          (current_position == top_left_position) && set_position_retries > 0
+        origin_provider.position = top_left_position
         sleep wait_before_screenshot
         current_position = origin_provider.current_position
         set_position_retries -= 1
       end
 
-      unless current_position.x.zero? && current_position.y.zero?
+      unless current_position == top_left_position
         origin_provider.restore_state original_position
         raise Applitools::EyesError.new 'Couldn\'t set position to the top/left corner!'
       end
 
-      begin
-        entire_size = position_provider.entire_size
-        logger.info "Entire size of region context: #{entire_size}"
-      rescue Applitools::EyesDriverOperationException => e
-        logger.error "Failed to extract entire size of region context: #{e.message}"
-        logger.error "Using image size instead: #{image.width}x#{image.height}"
-        entire_size = Applitools::RectangleSize.new image.width, image.height
-      end
+      logger.info "Current position: #{current_position}"
 
       logger.info 'Getting top/left image...'
       image = image_provider.take_screenshot
@@ -76,44 +73,45 @@ module Applitools::Selenium
       logger.info 'Done! Creating screenshot object...'
       screenshot = eyes_screenshot_factory.call(image)
 
-      if region_provider.coordinate_type
-        left_top_image = screenshot.sub_screenshot(region_provider.region, region_provider.coordinate_type)
-        debug_screenshot_provider.save_subscreenshot(left_top_image, region_provider.region)
+      begin
+        entire_size = position_provider.entire_size(image.width, image.height)
+      rescue Applitools::EyesDriverOperationException => e
+        logger.error "Failed to extract entire size of region context: #{e.message}"
+        logger.error "Using image size instead: #{image.width}x#{image.height}"
+        entire_size = Applitools::RectangleSize.new image.width, image.height
+      end
+
+      if region_provider.region(false).size.square > 0
+        left_top_image = screenshot.sub_screenshot(region_provider.region(false), region_provider.coordinate_type).image
       else
-        left_top_image = screenshot.sub_screenshot(
-          Applitools::Region.from_location_size(Applitools::Location.new(0, 0), entire_size),
-          Applitools::EyesScreenshot::COORDINATE_TYPES[:context_relative]
-        )
-        debug_screenshot_provider.save_subscreenshot(
-          left_top_image,
-          Applitools::Region.from_location_size(Applitools::Location.new(0, 0), entire_size)
-        )
+        left_top_image = screenshot.image
       end
+      debug_screenshot_provider.save_subscreenshot(left_top_image, region_provider.region(false))
 
       image = left_top_image.image
 
-      # Notice that this might still happen even if we used
-      # "getImagePart", since "entirePageSize" might be that of a frame.
-
-      if image.width >= entire_size.width && image.height >= entire_size.height
-        origin_provider.restore_state original_position
-        return image
-      end
-
-      part_image_size = Applitools::RectangleSize.new image.width,
+      part_image_size = Applitools::RectangleSize.new(
+        [image.width - stitching_overlap, MIN_SCREENSHOT_PART_WIDTH].max,
         [image.height - stitching_overlap, MIN_SCREENSHOT_PART_HEIGHT].max
+      )
 
       logger.info "Total size: #{entire_size}, image_part_size: #{part_image_size}"
 
       # Getting the list of sub-regions composing the whole region (we'll
       # take screenshot for each one).
       entire_page = Applitools::Region.from_location_size Applitools::Location::TOP_LEFT, entire_size
+
+      # Notice that this might still happen even if we used
+      # "getImagePart", since "entirePageSize" might be that of a frame.
+      if image.width >= entire_size.width && image.height >= entire_size.height
+        origin_provider.restore_state original_position
+        return left_top_image
+      end
+
       image_parts = entire_page.sub_regions(part_image_size)
 
       logger.info "Creating stitchedImage container. Size: #{entire_size}"
 
-      # Notice stitched_image uses the same type of image as the screenshots.
-      # stitched_image = Applitools::Screenshot.from_region entire_size
       stitched_image = ::ChunkyPNG::Image.new(entire_size.width, entire_size.height)
       logger.info 'Done! Adding initial screenshot..'
       logger.info "Initial part:(0,0) [#{image.width} x #{image.height}]"
@@ -126,13 +124,29 @@ module Applitools::Selenium
 
       original_stitched_state = position_provider.state
 
+      stitched_image_region = Applitools::Region.new(
+        0,
+        0,
+        stitched_image.width,
+        stitched_image.height
+      )
+
       logger.info 'Getting the rest of the image parts...'
 
-      image_parts.each_with_index do |part_region, i|
+      # rubocop:disable Metrics/BlockLength
+      image_parts.each_with_index do |part_regions, i|
         next unless i > 0
+
+        part_region = part_regions.first
+        intersection = part_regions.last
+
         logger.info "Taking screenshot for #{part_region}"
 
-        position_provider.position = part_region.location
+        position_provider.position = part_region
+                                     .location
+                                     .offset(top_left_position)
+                                     .offset_negative(intersection.location)
+
         sleep wait_before_screenshot
         current_position = position_provider.current_position
         logger.info "Set position to #{current_position}"
@@ -145,30 +159,51 @@ module Applitools::Selenium
         debug_screenshot_provider.save(part_image, 'cutted')
 
         logger.info 'Done!'
-        begin
-          region_to_check = Applitools::Region.from_location_size(
-            part_region.location.offset(region_provider.region.location), part_region.size
+
+        a_screenshot = eyes_screenshot_factory.call(part_image)
+
+        if region_provider.region(false).size.square > 0
+          a_screenshot = a_screenshot.sub_screenshot(
+            region_provider.region(false),
+            Applitools::EyesScreenshot::COORDINATE_TYPES[:context_relative],
+            false
           )
-          a_screenshot = eyes_screenshot_factory.call(part_image).sub_screenshot(region_to_check,
-            Applitools::EyesScreenshot::COORDINATE_TYPES[:context_relative], false)
-          debug_screenshot_provider.save_subscreenshot(a_screenshot, region_to_check)
-        rescue Applitools::OutOfBoundsException => e
-          logger.error e.message
-          break
         end
 
+        position_to_replace = current_position.offset(intersection.location)
+
+        replacement_region = Applitools::Region.new(
+          position_to_replace.x,
+          position_to_replace.y,
+          a_screenshot.width - intersection.size.width,
+          a_screenshot.height - intersection.size.height
+        )
+
+        replacement_size = stitched_image_region.dup.intersect(replacement_region).size
+        replacement_region_in_screenshot = Applitools::Region.from_location_size(
+          Applitools::Location.from_any_attribute(intersection.location),
+          replacement_size
+        )
+
+        image_to_stitch = a_screenshot.sub_screenshot(
+          replacement_region_in_screenshot,
+          Applitools::EyesScreenshot::COORDINATE_TYPES[:context_relative],
+          false
+        ).image
+
         logger.info 'Stitching part into the image container...'
 
-        stitched_image.replace! a_screenshot.image, part_region.x, part_region.y
+        stitched_image.replace! image_to_stitch, position_to_replace.x, position_to_replace.y
         logger.info 'Done!'
 
-        last_successful_location = Applitools::Location.for part_region.x, part_region.y
-        next unless a_screenshot
+        last_successful_location = Applitools::Location.for position_to_replace.x, position_to_replace.y
+        next unless image_to_stitch.area > 0
         last_successful_part_size = Applitools::RectangleSize.new(
-          a_screenshot.image.width,
-          a_screenshot.image.height
+          image_to_stitch.width,
+          image_to_stitch.height
         )
       end
+      # rubocop:enable Metrics/BlockLength
 
       logger.info 'Stitching done!'
 

data/lib/applitools/selenium/fullpage_screenshot.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+require_relative 'eyes_screenshot'
+module Applitools::Selenium
+  class FullpageScreenshot < Applitools::Selenium::EyesScreenshot
+    def sub_screenshot(region, _coordinate_type, throw_if_clipped = false, force_nil_if_clipped = false)
+      logger.info "get_subscreenshot(#{region}, #{throw_if_clipped})"
+      Applitools::ArgumentGuard.not_nil region, 'region'
+
+      as_is_subscreenshot_region = region.intersect(image_region)
+
+      if as_is_subscreenshot_region.empty? || (throw_if_clipped && as_is_subscreenshot_region.size != region.size)
+        return nil if force_nil_if_clipped
+        raise Applitools::OutOfBoundsException.new "Region #{region} is out" \
+          ' of screenshot bounds'
+      end
+
+      sub_screenshot_image = Applitools::Screenshot.from_image(
+        image.crop(
+          as_is_subscreenshot_region.left,
+          as_is_subscreenshot_region.top,
+          as_is_subscreenshot_region.width,
+          as_is_subscreenshot_region.height
+        )
+      )
+
+      result = self.class.new(sub_screenshot_image, region_provider: region_provider).tap do |s|
+        s.top_left_location = top_left_location.dup.offset(region.location)
+      end
+      logger.info 'Done!'
+      result
+    end
+
+    def top_left_location
+      @top_left_location ||= Applitools::Location::TOP_LEFT
+    end
+  end
+end