eyes_selenium 2.39.1 → 3.0.6

data/lib/applitools/selenium/frame.rb

@@ -0,0 +1,24 @@
+module Applitools::Selenium
+  # @!visibility private
+  class Frame
+    attr_accessor :reference, :frame_id, :location, :size, :parent_scroll_position
+    def initialize(options = {})
+      [:reference, :frame_id, :location, :size, :parent_scroll_position].each do |param|
+        raise "options[:#{param}] can't be nil" unless options[param]
+        send("#{param}=", options[param])
+      end
+
+      raise 'options[:location] must be instance of Applitools::Base::Point' unless
+          location.is_a? Applitools::Location
+
+      raise 'options[:parent_scroll_position] must be instance of Applitools::Location' unless
+          location.is_a? Applitools::Location
+
+      raise 'options[:size] must be instance of Applitools::RectangleSize' unless
+          size.is_a? Applitools::RectangleSize
+
+      return if reference.is_a? Applitools::Selenium::Element
+      raise 'options[:reference] must be instance of Applitools::Selenium::Element'
+    end
+  end
+end

data/lib/applitools/selenium/frame_chain.rb

@@ -0,0 +1,68 @@
+module Applitools::Selenium
+  # @!visibility private
+  class FrameChain
+    include Enumerable
+
+    def initialize(options = {})
+      @frames = []
+      @frames = options[:other].to_a if options[:other].is_a? self.class
+    end
+
+    def each(*args, &block)
+      return @frames.collect unless block_given?
+      @frames.each(*args, &block)
+    end
+
+    def same_frame_chain?(other)
+      return false unless size == other.size
+      all? { |my_elem| my_elem.id == other.next.id }
+    end
+
+    def push(frame)
+      return @frames.push(frame) if frame.is_a? Applitools::Selenium::Frame
+      raise "frame must be instance of Applitools::Selenium::Frame! (passed #{frame.class})"
+    end
+
+    def pop
+      @frames.pop
+    end
+
+    def shift
+      @frames.shift
+    end
+
+    def clear
+      @frames = []
+    end
+
+    def size
+      @frames.size
+    end
+
+    def empty?
+      @frames.empty?
+    end
+
+    def current_frame_offset
+      @frames.reduce(Applitools::Location.new(0, 0)) do |result, frame|
+        result.offset frame.location
+      end
+    end
+
+    def current_frame
+      @frames.last
+    end
+
+    def default_content_scroll_position
+      raise NoFramesException.new 'No frames!' if @frames.empty?
+      result = @frames.first.parent_scroll_position
+      Applitools::Base::Point.new result.x, result.y
+    end
+
+    def current_frame_size
+      @frames.last.size
+    end
+
+    class NoFramesException < RuntimeError; end
+  end
+end

data/lib/applitools/selenium/full_page_capture_algorithm.rb

@@ -0,0 +1,162 @@
+module Applitools::Selenium
+  # @!visibility private
+  class FullPageCaptureAlgorithm
+    extend Forwardable
+    def_delegators 'Applitools::EyesLogger', :logger, :log_handler, :log_handler=
+
+    MAX_SCROLL_BAR_SIZE = 50
+    MIN_SCREENSHOT_PART_HEIGHT = 10
+
+    def get_stiched_region(options = {})
+      logger.info 'get_stiched_region() has been invoked.'
+      image_provider = options[:image_provider]
+      region_provider = options[:region_to_check]
+      origin_provider = options[:origin_provider]
+      position_provider = options[:position_provider]
+      scale_provider = options[:scale_provider]
+      cut_provider = options[:cut_provider]
+      wait_before_screenshot = options[:wait_before_screenshots]
+      eyes_screenshot_factory = options[:eyes_screenshot_factory]
+
+      logger.info "Region to check: #{region_provider.region}"
+      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)
+        sleep wait_before_screenshot
+        current_position = origin_provider.current_position
+        set_position_retries -= 1
+      end
+
+      unless current_position.x.zero? && current_position.y.zero?
+        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 'Getting top/left image...'
+      image = image_provider.take_screenshot
+      image = scale_provider.scale_image(image) if scale_provider
+      image = cut_provider.cut(image) if cut_provider
+      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)
+      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]
+        )
+      end
+
+      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,
+        [image.height - MAX_SCROLL_BAR_SIZE, 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
+      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
+      logger.info 'Done! Adding initial screenshot..'
+      logger.info "Initial part:(0,0) [#{image.width} x #{image.height}]"
+
+      stitched_image.replace! image, 0, 0
+      logger.info 'Done!'
+
+      last_successful_location = Applitools::Location.new 0, 0
+      last_successful_part_size = Applitools::RectangleSize.new image.width, image.height
+
+      original_stitched_state = position_provider.state
+
+      logger.info 'Getting the rest of the image parts...'
+
+      image_parts.each_with_index do |part_region, i|
+        next unless i > 0
+        logger.info "Taking screenshot for #{part_region}"
+
+        position_provider.position = part_region.location
+        sleep wait_before_screenshot
+        current_position = position_provider.current_position
+        logger.info "Set position to #{current_position}"
+        logger.info 'Getting image...'
+
+        part_image = image_provider.take_screenshot
+        part_image = scale_provider.scale_image part_image if scale_provider
+        part_image = cut_provider.cut part_image if cut_provider
+
+        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).sub_screenshot(region_to_check,
+            Applitools::EyesScreenshot::COORDINATE_TYPES[:context_relative], false)
+        rescue Applitools::OutOfBoundsException => e
+          logger.error e.message
+          break
+        end
+
+        logger.info 'Stitching part into the image container...'
+
+        stitched_image.replace! a_screenshot.image, part_region.x, part_region.y
+        logger.info 'Done!'
+
+        last_successful_location = Applitools::Location.for part_region.x, part_region.y
+        next unless a_screenshot
+        last_successful_part_size = Applitools::RectangleSize.new(
+          a_screenshot.image.width,
+          a_screenshot.image.height
+        )
+      end
+
+      logger.info 'Stitching done!'
+
+      position_provider.restore_state original_stitched_state
+      origin_provider.restore_state original_position
+
+      actual_image_width = last_successful_location.x + last_successful_part_size.width
+      actual_image_height = last_successful_location.y + last_successful_part_size.height
+
+      logger.info "Extracted entire size: #{entire_size}"
+      logger.info "Actual stitched size: #{stitched_image.width} x #{stitched_image.height}"
+      logger.info "Actual stitched size: #{actual_image_width} x #{actual_image_height}"
+
+      if actual_image_width < stitched_image.width || actual_image_height < stitched_image.height
+        logger.info 'Trimming unnecessary margins...'
+        stitched_image.crop!(0, 0, actual_image_width, actual_image_height)
+        logger.info 'Done!'
+      end
+
+      stitched_image
+    end
+  end
+end

data/lib/applitools/selenium/keyboard.rb

@@ -1,4 +1,5 @@
 module Applitools::Selenium
+  # @!visibility private
   class Keyboard
     attr_reader :keyboard, :driver
 

data/lib/applitools/selenium/match_window_task.rb

@@ -1,197 +0,0 @@
-require 'base64'
-
-module Applitools::Selenium
-  class MatchWindowTask
-    MATCH_INTERVAL = 0.5
-    AppOuptut = Struct.new(:title, :screenshot64)
-
-    attr_reader :eyes, :session, :driver, :default_retry_timeout, :last_checked_window,
-      :last_screenshot_bounds
-
-    def initialize(eyes, session, driver, default_retry_timeout)
-      @eyes = eyes
-
-      @session = session
-      @driver = driver
-      @default_retry_timeout = default_retry_timeout
-      @last_checked_window = nil # +ChunkyPNG::Canvas+
-      @last_screenshot_bounds = Applitools::Base::Region::EMPTY # +Applitools::Base::Region+
-      @current_screenshot = nil # +ChunkyPNG::Canvas+
-    end
-
-    def match_window(region, retry_timeout, tag, rotation, run_once_after_wait = false)
-      retry_timeout = default_retry_timeout if retry_timeout < 0
-
-      Applitools::EyesLogger.debug "Retry timeout set to: #{retry_timeout}"
-
-      start = Time.now
-      res =
-        if retry_timeout.zero?
-          run(region, tag, rotation)
-        elsif run_once_after_wait
-          run(region, tag, rotation, retry_timeout)
-        else
-          run_with_intervals(region, tag, rotation, retry_timeout)
-        end
-      elapsed_time = Time.now - start
-
-      Applitools::EyesLogger.debug "match_window(): Completed in #{format('%.2f', elapsed_time)} seconds"
-
-      @last_checked_window = @current_screenshot
-      @last_screenshot_bounds =
-        if region.empty?
-          Applitools::Base::Region.new(0, 0, last_checked_window.width, last_checked_window.height)
-        else
-          region
-        end
-      driver.clear_user_inputs
-      GC.start
-      res
-    end
-
-    def run(region, tag, rotation, wait_before_run = nil)
-      Applitools::EyesLogger.debug 'Trying matching once...'
-
-      if wait_before_run
-        Applitools::EyesLogger.debug 'Waiting before run...'
-        sleep(wait_before_run)
-        Applitools::EyesLogger.debug 'Waiting done!'
-      end
-
-      match(region, tag, rotation)
-    end
-
-    def run_with_intervals(region, tag, rotation, retry_timeout)
-      # We intentionally take the first screenshot before starting the timer, to allow the page just a tad more time to
-      # stabilize.
-      Applitools::EyesLogger.debug 'Matching with intervals...'
-      start = Time.now
-      as_expected = match(region, tag, rotation, true)
-      Applitools::EyesLogger.debug "First call result: #{as_expected}"
-      return true if as_expected
-      Applitools::EyesLogger.debug "Not as expected, performing retry (total timeout #{retry_timeout})"
-      match_retry = Time.now - start
-      while match_retry < retry_timeout
-        Applitools::EyesLogger.debug 'Waiting before match...'
-        sleep(MATCH_INTERVAL)
-        Applitools::EyesLogger.debug 'Done! Matching...'
-        return true if match(region, tag, rotation, true)
-        match_retry = Time.now - start
-        Applitools::EyesLogger.debug "Elapsed time: #{match_retry}"
-      end
-      # Let's try one more time if we still don't have a match.
-      Applitools::EyesLogger.debug 'Last attempt to match...'
-      as_expected = match(region, tag, rotation)
-      Applitools::EyesLogger.debug "Match result: #{as_expected}"
-      as_expected
-    end
-
-    private
-
-    def get_clipped_region(region, image)
-      left = [region.left, 0].max
-      top = [region.top, 0].max
-      max_width = image.width - left
-      max_height = image.height - top
-      width = [region.width, max_width].min
-      height = [region.height, max_height].min
-      Applitools::Base::Region.new(left, top, width, height)
-    end
-
-    def prep_match_data(region, tag, rotation, ignore_mismatch)
-      Applitools::EyesLogger.debug 'Preparing match data...'
-      title = eyes.title
-      Applitools::EyesLogger.debug 'Getting screenshot...'
-      Applitools::EyesLogger.debug 'Done! Creating image object from PNG...'
-      @current_screenshot = driver.get_screenshot(rotation, tag)
-      Applitools::EyesLogger.debug 'Done!'
-      # If a region was defined, we refer to the sub-image defined by the region.
-      unless region.empty?
-        Applitools::EyesLogger.debug 'Calculating clipped region...'
-        # If the region is out of bounds, clip it
-        clipped_region = get_clipped_region(region, @current_screenshot)
-        raise Applitools::EyesError.new("Region is outside the viewport: #{region}") if clipped_region.empty?
-        Applitools::EyesLogger.debug 'Done! Cropping region...'
-        @current_screenshot.crop!(clipped_region.left, clipped_region.top, clipped_region.width, clipped_region.height)
-        Applitools::EyesLogger.debug 'Done! Creating cropped image object...'
-        Applitools::EyesLogger.debug 'Done!'
-      end
-
-      # FIXME: re-Enable screenshot compression after handling memory leaks.
-      # Applitools::EyesLogger.debug 'Compressing screenshot...'
-      # compressed_screenshot = Applitools::Utils::ImageDeltaCompressor.compress_by_raw_blocks(@current_screenshot,
-      #   current_screenshot_encoded, last_checked_window)
-
-      Applitools::EyesLogger.debug 'Done! Creating AppOuptut...'
-      app_output = AppOuptut.new(title, nil)
-      user_inputs = []
-      Applitools::EyesLogger.debug 'Handling user inputs...'
-      if !last_checked_window.nil?
-        driver.user_inputs.each do |trigger|
-          Applitools::EyesLogger.debug 'Handling trigger...'
-          if trigger.is_a?(Applitools::Base::MouseTrigger)
-            updated_trigger = nil
-            trigger_left = trigger.control.left + trigger.location.x
-            trigger_top = trigger.control.top + trigger.location.y
-            if last_screenshot_bounds.contains?(trigger_left, trigger_top)
-              trigger.control.intersect(last_screenshot_bounds)
-              if trigger.control.empty?
-                trigger_left -= - last_screenshot_bounds.left
-                trigger_top -= last_screenshot_bounds.top
-                updated_trigger = Applitools::Base::MouseTrigger.new(trigger.mouse_action, trigger.control,
-                  Applitools::Base::Point.new(trigger_left, trigger_top))
-              else
-                trigger_left -= trigger.control.left
-                trigger_top -= trigger.control.top
-                control_left = trigger.control.left - last_screenshot_bounds.left
-                control_top = trigger.control.top - last_screenshot_bounds.top
-                updated_control = Applitools::Base::Region.new(control_left, control_top, trigger.control.width,
-                  trigger.control.height)
-                updated_trigger = Applitools::Base::MouseTrigger.new(trigger.mouse_action, updated_control,
-                  Applitools::Base::Point.new(trigger_left, trigger_top))
-              end
-              Applitools::EyesLogger.debug 'Done with trigger!'
-              user_inputs << updated_trigger
-            else
-              Applitools::EyesLogger.info "Trigger ignored: #{trigger} (out of bounds)"
-            end
-          elsif trigger.is_a?(Applitools::Base::TextTrigger)
-            if !trigger.control.empty?
-              trigger.control.intersect(last_screenshot_bounds)
-              if !trigger.control.empty?
-                control_left = trigger.control.left - last_screenshot_bounds.left
-                control_top = trigger.control.top - last_screenshot_bounds.top
-                updated_control = Applitools::Base::Region.new(control_left, control_top, trigger.control.width,
-                  trigger.control.height)
-                updated_trigger = Applitools::Base::TextTrigger.new(trigger.text, updated_control)
-                Applitools::EyesLogger.debug 'Done with trigger!'
-                user_inputs << updated_trigger
-              else
-                Applitools::EyesLogger.info "Trigger ignored: #{trigger} (control out of bounds)"
-              end
-            else
-              Applitools::EyesLogger.info "Trigger ignored: #{trigger} (out of bounds)"
-            end
-          else
-            Applitools::EyesLogger.info "Trigger ignored: #{trigger} (Unrecognized trigger)"
-          end
-        end
-      else
-        Applitools::EyesLogger.info 'Triggers ignored: no previous window checked'
-      end
-      Applitools::EyesLogger.debug 'Creating MatchWindowData object..'
-      match_window_data_obj = Applitools::Selenium::MatchWindowData.new(app_output, tag, ignore_mismatch,
-        @current_screenshot, user_inputs)
-      Applitools::EyesLogger.debug 'Done creating MatchWindowData object!'
-      match_window_data_obj
-    end
-
-    def match(region, tag, rotation, ignore_mismatch = false)
-      Applitools::EyesLogger.debug 'Match called...'
-      data = prep_match_data(region, tag, rotation, ignore_mismatch)
-      match_result = Applitools::Base::ServerConnector.match_window(session, data)
-      Applitools::EyesLogger.debug 'Match done!'
-      match_result
-    end
-  end
-end