eyes_selenium 2.39.1 → 3.0.6

data/lib/applitools/selenium/eyes_target_locator.rb

@@ -0,0 +1,191 @@
+module Applitools::Selenium
+  class EyesTargetLocator < SimpleDelegator
+    extend Forwardable
+
+    def_delegators 'Applitools::EyesLogger', :logger, :log_handler, :log_handler=
+
+    attr_reader :driver, :on_will_switch, :scroll_position_provider
+
+    def initialize(driver, original_target_locator, on_will_switch)
+      super(original_target_locator)
+      @driver = driver
+      @on_will_switch = on_will_switch
+      @scroll_position_provider = Applitools::Selenium::ScrollPositionProvider.new(driver)
+    end
+
+    # @param [Hash] options
+    # @option options [Fixnum] :index
+    # @option options [String] :name_or_id
+    # @option options [WebElement] :frameElement
+    # @return [Applitools::Selenium::Driver]
+    def frame(options = {})
+      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 & %i(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
+
+    def parent_frame
+      logger.info 'EyesTargetLocator.parent_frame()'
+      unless driver.frame_chain.empty?
+        on_will_switch.will_switch_to_frame :parent_frame, nil
+        logger.info 'Done! Switching to parent_frame...'
+        __getobj__.parent_frame
+      end
+      logger.info 'Done!'
+      driver
+    end
+
+    # @param [hash] options
+    # @option options [Applitools::Selenium::FrameChain] :frame_chain
+    # @option options [String] :frames_path
+    # @return Applitools::Selenium::Driver
+    def frames(options = {})
+      raise Applitools::EyesIllegalArgument.new 'You must pass :frame_chain or :frames_path' if
+          options[:frame_chain].nil? & options[:frames_path].nil?
+
+      if (needed_keys = (options.keys & %i(frame_chain frames_path))).length == 1
+        send "frames_by_#{needed_keys.first}", options[needed_keys.first]
+      else
+        raise Applitools::EyesIllegalArgument.new 'You\'ve passed some extra keys!' /
+          'Only :frame_index or :frames_path are allowed.'
+      end
+    end
+
+    # A wrapper for the native method +default_content+
+    def default_content
+      logger.info 'EyesTargetLocator.default_content()'
+      unless driver.frame_chain.empty?
+        logger.info 'Making preparations...'
+        on_will_switch.will_switch_to_frame :default_content, nil
+        logger.info 'Done! Switching to default content...'
+        __getobj__.default_content
+        logger.info 'Done!'
+      end
+      driver
+    end
+
+    # A wrapper for the native method +window+
+    def window(name_or_handle)
+      logger.info 'EyesTargetLocator.window()'
+      logger.info 'Making preparaions...'
+      on_will_switch.will_switch_to_window name_or_handle
+      logger.info 'Done! Switching to window..'
+      __getobj__.window name_or_handle
+      logger.info 'Done!'
+      driver
+    end
+
+    # A wrapper for the native method +active_element+
+    def active_element
+      logger.info 'EyesTargetLocator.active_element()'
+      logger.info 'Switching to element...'
+      element = __getobj__.active_element
+
+      unless element.is_a? Selenium::WebDriver::Element
+        raise Applitools::EyesError.new(
+          'Not an Selenium::WebDriver::Element!'
+        )
+      end
+
+      result = Applitools::Selenium::Element.new driver, element
+
+      logger.info 'Done!'
+      result
+    end
+
+    # A wrapper for a native method +alert+
+    def alert
+      logger.info 'EyesTargetLocator.alert()'
+      logger.info 'Switching to alert...'
+      result = __getobj__.alert
+      logger.info 'Done!'
+      result
+    end
+
+    private
+
+    def frame_by_index(index)
+      raise Applitools::EyesInvalidArgument.new 'You should pass Integer as :index value!' unless index.is_a? Integer
+      logger.info "EyesTargetLocator.frame(#{index})"
+      logger.info 'Getting frames list...'
+      frames = driver.find_elements(:css, 'frame, iframe')
+      raise Applitools::EyesNoSuchFrame.new "Frame index #{index} is invalid!" if index >= frames.size
+
+      logger.info 'Done! getting the specific frame...'
+      target_frame = frames[index]
+
+      logger.info 'Done! Making preparations...'
+      on_will_switch.will_switch_to_frame :frame, target_frame
+      logger.info 'Done! Switching to frame...'
+
+      # TODO: Looks like switching to frame by index (Fixnum) doesn't work at least for Chrome browser
+      #  Is it better to use __getobj__.frame target_frame instead?
+      # __getobj__.frame index
+      __getobj__.frame target_frame
+
+      logger.info 'Done!'
+      driver
+    end
+
+    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 'Done! Making preparations...'
+      on_will_switch.will_switch_to_frame(:frame, frames.first).last
+      logger.info 'Done! Switching to frame...'
+      __getobj__.frame frames.first
+
+      logger.info 'Done!'
+      driver
+    end
+
+    def frame_by_frame_element(web_element)
+      logger.info "EyesTargetLocator.frame(element) [#{web_element}]"
+      logger.info 'Done! Making preparations...'
+      on_will_switch.will_switch_to_frame :frame, web_element
+      logger.info 'Done! Switching to frame...'
+      __getobj__.frame web_element
+
+      logger.info 'Done!'
+      driver
+    end
+
+    def frames_by_frame_chain(frame_chain)
+      logger.info "EyesTargetLocator.frames(:frame_chain => a_chain) [#{frame_chain}]"
+      frame_chain.each do |frame|
+        logger.info 'Scrolling by parent scroll position...'
+        # scroll_position_provider.scroll_to frame.parent_scroll_position
+        logger.info 'Done! Switching to frame...'
+        frame(frame_element: frame.reference)
+        logger.info 'Done!'
+        logger.info 'Done switching into nested frames!'
+        driver
+      end
+    end
+
+    def frames_by_frames_path(frames_path)
+      logger.info 'EyesTargetLocator.frames(:frames_path => a_chain)'
+      frames_path.each do |frame_name_or_id|
+        logger.info 'Switching to frame...'
+        frame(name_or_id: frame_name_or_id)
+        logger.info 'Done!'
+      end
+      logger.info 'Done switching into nested frames!'
+      driver
+    end
+  end
+end

data/lib/applitools/selenium/eyes_web_driver_screenshot.rb

@@ -0,0 +1,274 @@
+module Applitools::Selenium
+  # @!visibility private
+  class EyesWebDriverScreenshot < Applitools::EyesScreenshot
+    SCREENSHOT_TYPES = {
+      viewport: 'VIEPORT',
+      entire_frame: 'ENTIRE_FRAME'
+    }.freeze
+
+    INIT_CALLBACKS = {
+      [:driver, :screenshot_type, :frame_location_in_screenshot].sort => :initialize_main,
+      [:driver, :force_offset].sort => :initialize_main,
+      [:driver].sort => :initialize_main,
+      [:driver, :position_provider].sort => :initialize_main,
+      [:driver, :entire_frame_size].sort => :initialize_for_element,
+      [:driver, :entire_frame_size, :frame_location_in_screenshot].sort => :initialize_for_element
+    }.freeze
+
+    attr_accessor :driver
+    attr_accessor :frame_chain
+    private :frame_chain=
+
+    class << self
+      alias _new new
+
+      def new(*args)
+        image = args.shift
+        raise Applitools::EyesIllegalArgument.new 'image is expected to be Applitools::Screenshot!' unless
+            image.is_a? Applitools::Screenshot
+
+        options = args.first
+        if options.is_a? Hash
+          result = _new(image)
+          callback = INIT_CALLBACKS[options.keys.sort]
+          return result.tap { |o| o.send callback, options } if result.respond_to? callback
+          raise Applitools::EyesIllegalArgument.new 'Can\'t find an appropriate initializer!'
+        end
+        raise Applitools::EyesIllegalArgument.new "#{self.class}.initialize(): Hash is expected as an argument!"
+      end
+
+      def calc_frame_location_in_screenshot(frame_chain, screenshot_type, logger)
+        frame_chain = Applitools::Selenium::FrameChain.new other: frame_chain
+        logger.info 'Getting first frame...'
+        first_frame = frame_chain.shift
+        logger.info 'Done!'
+        location_in_screenshot = Applitools::Location.for first_frame.location
+
+        if screenshot_type == SCREENSHOT_TYPES[:viewport]
+          default_content_scroll = first_frame.parent_scroll_position
+          location_in_screenshot.offset_negative(
+            Applitools::Location.for(default_content_scroll.x, default_content_scroll.y)
+          )
+        end
+
+        logger.info 'Iterating over frames...'
+        frame_chain.each do |frame|
+          location_in_screenshot.offset(Applitools::Location.for(frame.location.x, frame.location.y))
+                                .offset_negative(
+                                  Applitools::Location.for(
+                                    frame.parent_scroll_position.x, frame.parent_scroll_position.y
+                                  )
+                                )
+        end
+        location_in_screenshot
+      end
+    end
+
+    def initialize_for_element(options = {})
+      Applitools::ArgumentGuard.not_nil options[:driver], 'options[:driver]'
+      Applitools::ArgumentGuard.not_nil options[:entire_frame_size], 'options[:entire_frame_size]'
+      entire_frame_size = options[:entire_frame_size]
+      self.driver = options[:driver]
+      self.frame_chain = driver.frame_chain
+      self.screenshot_type = SCREENSHOT_TYPES[:entire_frame]
+      self.scroll_position = Applitools::Location.new(0, 0)
+      self.scroll_position = Applitools::Location.new(0, 0).offset(options[:frame_location_in_screenshot]) if
+          options[:frame_location_in_screenshot].is_a? Applitools::Location
+      self.frame_location_in_screenshot = Applitools::Location.new(0, 0)
+      self.frame_window = Applitools::Region.new(0, 0, entire_frame_size.width, entire_frame_size.height)
+    end
+
+    def initialize_main(options = {})
+      # options = {screenshot_type: SCREENSHOT_TYPES[:viewport]}.merge options
+
+      Applitools::ArgumentGuard.hash options, 'options', [:driver]
+      Applitools::ArgumentGuard.not_nil options[:driver], 'options[:driver]'
+
+      self.driver = options[:driver]
+      self.position_provider = Applitools::Selenium::ScrollPositionProvider.new driver if
+          options[:position_provider].nil?
+
+      viewport_size = driver.default_content_viewport_size
+
+      self.frame_chain = driver.frame_chain
+      if !frame_chain.empty?
+        frame_size = frame_chain.current_frame_size
+      else
+        begin
+          frame_size = position_provider.entire_size
+        rescue
+          frame_size = viewport_size
+        end
+      end
+
+      begin
+        self.scroll_position = position_provider.current_position
+      rescue
+        self.scroll_position = Applitools::Location.new(0, 0)
+      end
+
+      if options[:screenshot_type].nil?
+        self.screenshot_type = if image.width <= viewport_size.width && image.height <= viewport_size.height
+                                 SCREENSHOT_TYPES[:viewport]
+                               else
+                                 SCREENSHOT_TYPES[:entire_frame]
+                               end
+      else
+        self.screenshot_type = options[:screenshot_type]
+      end
+
+      if options[:frame_location_in_screenshot].nil?
+        if !frame_chain.empty?
+          self.frame_location_in_screenshot = self.class.calc_frame_location_in_screenshot(
+            frame_chain, screenshot_type, logger
+          )
+        else
+          self.frame_location_in_screenshot = Applitools::Location.new(0, 0)
+        end
+      else
+        self.frame_location_in_screenshot = options[:frame_location_in_screenshot]
+      end
+
+      self.force_offset = Applitools::Location::TOP_LEFT
+      self.force_offset = options[:force_offset] if options[:force_offset]
+
+      logger.info 'Calculating frame window..'
+      self.frame_window = Applitools::Region.from_location_size(frame_location_in_screenshot, frame_size)
+      frame_window.intersect Applitools::Region.new(0, 0, image.width, image.height)
+
+      raise Applitools::EyesError.new 'Got empty frame window for screenshot!' if
+          frame_window.width <= 0 || frame_window.height <= 0
+
+      logger.info 'Done!'
+    end
+
+    # def scroll_position
+    #   begin
+    #     position_provider.state
+    #   rescue
+    #     Applitools::Location.new(0,0)
+    #   end
+    # end
+
+    def convert_location(location, from, to)
+      Applitools::ArgumentGuard.not_nil location, 'location'
+      Applitools::ArgumentGuard.not_nil from, 'from'
+      Applitools::ArgumentGuard.not_nil to, 'to'
+
+      result = Applitools::Location.for location
+      return result if from == to
+      # if frame_chain.size.zero? && screenshot_type == SCREENSHOT_TYPES[:entire_frame]
+      #   if (from == Applitools::EyesScreenshot::COORDINATE_TYPES[:context_relative] ||
+      #       from == Applitools::EyesScreenshot::COORDINATE_TYPES[:context_as_is]) &&
+      #       to == Applitools::EyesScreenshot::COORDINATE_TYPES[:screenshot_as_is]
+      #     result.offset frame_location_in_screenshot
+      #   elsif from == Applitools::EyesScreenshot::COORDINATE_TYPES[:screenshot_as_is] &&
+      #       (to == Applitools::EyesScreenshot::COORDINATE_TYPES[:context_relative] ||
+      #        to == Applitools::EyesScreenshot::COORDINATE_TYPES[:context_as_is])
+      #     result.offset_negative frame_location_in_screenshot
+      #   end
+      # end
+
+      case from
+      when Applitools::EyesScreenshot::COORDINATE_TYPES[:context_relative]
+        case to
+        when Applitools::EyesScreenshot::COORDINATE_TYPES[:screenshot_as_is]
+          result.offset_negative scroll_position
+          result.offset frame_location_in_screenshot
+        else
+          raise Applitools::EyesCoordinateTypeConversionException.new "Can't convert coordinates from #{from} to #{to}"
+        end
+      when Applitools::EyesScreenshot::COORDINATE_TYPES[:screenshot_as_is]
+        case to
+        when Applitools::EyesScreenshot::COORDINATE_TYPES[:context_relative]
+          result.offset_negative frame_location_in_screenshot
+          result.offset scroll_position
+        else
+          raise Applitools::EyesCoordinateTypeConversionException.new "Can't convert coordinates from #{from} to #{to}"
+        end
+      else
+        raise Applitools::EyesCoordinateTypeConversionException.new "Can't convert coordinates from #{from} to #{to}"
+      end
+
+      result
+    end
+
+    def frame_chain
+      Applitools::Selenium::FrameChain.new other: @frame_chain
+    end
+
+    def intersected_region(region, original_coordinate_types, result_coordinate_types)
+      return Applitools::Region::EMPTY if region.empty?
+      intersected_region = convert_region_location(
+        region, original_coordinate_types, Applitools::EyesScreenshot::COORDINATE_TYPES[:screenshot_as_is]
+      )
+      case original_coordinate_types
+      when Applitools::EyesScreenshot::COORDINATE_TYPES[:context_as_is]
+        nil
+      when Applitools::EyesScreenshot::COORDINATE_TYPES[:context_relative]
+        intersected_region.intersect frame_window
+      when Applitools::EyesScreenshot::COORDINATE_TYPES[:screenshot_as_is]
+        intersected_region.intersect Applitools::Region.new(0, 0, image.width, image.height)
+      else
+        raise Applitools::EyesCoordinateTypeConversionException.new(
+          "Unknown coordinates type: #{original_coordinate_types}"
+        )
+      end
+
+      return intersected_region if intersected_region.empty?
+      convert_region_location(
+        intersected_region,
+        Applitools::EyesScreenshot::COORDINATE_TYPES[:screenshot_as_is],
+        result_coordinate_types
+      )
+    end
+
+    def location_in_screenshot(location, coordinate_type)
+      location = convert_location(
+        location, coordinate_type, Applitools::EyesScreenshot::COORDINATE_TYPES[:screenshot_as_is]
+      )
+      unless frame_window.contains?(location.x, location.y)
+        raise Applitools::OutOfBoundsException.new(
+          "Location #{location} (#{coordinate_type}) is not visible in screenshot!"
+        )
+      end
+      location
+    end
+
+    def sub_screenshot(region, coordinate_type, throw_if_clipped = false)
+      logger.info "get_subscreenshot(#{region}, #{coordinate_type}, #{throw_if_clipped})"
+      Applitools::ArgumentGuard.not_nil region, 'region'
+      Applitools::ArgumentGuard.not_nil coordinate_type, 'coordinate_type'
+
+      region_to_check = Applitools::Region.from_location_size(
+        region.location.offset_negative(force_offset), region.size
+      )
+
+      as_is_subscreenshot_region = intersected_region region_to_check, coordinate_type,
+        Applitools::EyesScreenshot::COORDINATE_TYPES[:screenshot_as_is]
+
+      if as_is_subscreenshot_region.empty? || (throw_if_clipped && !as_is_subscreenshot_region.size == region.size)
+        raise Applitools::OutOfBoundsException.new "Region #{region} (#{coordinate_type}) is out" \
+          " of screenshot bounds [#{frame_window}]"
+      end
+
+      sub_screenshot_image = Applitools::Screenshot.new image.crop(as_is_subscreenshot_region.left,
+        as_is_subscreenshot_region.top, as_is_subscreenshot_region.width,
+        as_is_subscreenshot_region.height).to_datastream.to_blob
+
+      context_relative_region_location = convert_location as_is_subscreenshot_region.location,
+        Applitools::EyesScreenshot::COORDINATE_TYPES[:screenshot_as_is],
+        Applitools::EyesScreenshot::COORDINATE_TYPES[:context_relative]
+      result = self.class.new sub_screenshot_image, driver: driver,
+        entire_frame_size: Applitools::RectangleSize.new(sub_screenshot_image.width, sub_screenshot_image.height),
+        frame_location_in_screenshot: context_relative_region_location
+      logger.info 'Done!'
+      result
+    end
+
+    private
+
+    attr_accessor :position_provider, :scroll_position, :screenshot_type, :frame_location_in_screenshot,
+      :frame_window, :force_offset
+  end
+end