eyes_selenium 3.14.3 → 3.14.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: a85a4fbc19f3a4c5fd8e57fbd839ae3d92cbbd76
-  data.tar.gz: c345ecf5f123efdefe2ebb083b67f92ba0d6234d
+SHA256:
+  metadata.gz: eed17b1ab4d0917d2cb7f0048435f2b8b5b5a41c29607bfc82caa0da521e071e
+  data.tar.gz: d8398e29b30ba60e8d033608d0e70193413866e5509c057206357840b58ca0e9
 SHA512:
-  metadata.gz: 9f7877bb8325b148309618f5ee68c8bd5ea396eecdfdc2cd48a0d23fbff3549189793883dacc6c15a438c71f36389cc0ba08c68070d2035c21f6d184df74b303
-  data.tar.gz: ef3229dc823585a9d62904d1c8bbac5fd90359826e61634811c84d9808eddff0eb84f34b6a551748ed44d6d41201d42e0cd7a3a26a5281a6ffe92334ddfef641
+  metadata.gz: 214c9dd3f2085254d46241980ca5a416a4b4f70cda46f54a65adf36b85198d53db267fb9d8275c5d98f1f9543e06343dcbe36938d80eab7c1b1fe2e4e013bc20
+  data.tar.gz: 824ea45b22311de40906cd2a2e19b8652d7eff6b778e6f43379acc7f600397e7d5ad0a49ee55909e29303d585241200c16771e976e346546dbe8c51f8e680064

data/lib/applitools/selenium/border_aware_element_content_location_provider.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Applitools::Selenium
   # @!visibility private
   class BorderAwareElementContentLocationProvider

data/lib/applitools/selenium/browser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: false
+
 module Applitools::Selenium
   # @!visibility private
   class Browser
@@ -69,7 +71,15 @@ module Applitools::Selenium
     end
 
     def chrome?
-      @driver.browser == :chrome
+      running_browser_name == :chrome
+    end
+
+    def firefox?
+      running_browser_name == :firefox
+    end
+
+    def running_browser_name
+      @driver.__getobj__.browser
     end
 
     def user_agent
@@ -149,62 +159,62 @@ module Applitools::Selenium
       set_transform("translate(-#{point.left}px, -#{point.top}px)")
     end
 
-    # Takes a full page screenshot.
+    # # Takes a full page screenshot.
+    # #
+    # # @return [ChunkyPNG::Canvas] image The result of the screenshot.
+    # 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
     #
-    # @return [ChunkyPNG::Canvas] image The result of the screenshot.
-    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
-
-      # 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 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)
-
-        sub_regions = Applitools::Base::Region.new(0, 0, page_size.width,
-          page_size.height).subregions(screenshot_part_size)
-        parts = sub_regions.map do |screenshot_part|
-          # Skip (0,0), as we already got the screenshot.
-          if screenshot_part.left.zero? && screenshot_part.top.zero?
-            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_transform(original_transform) if @eyes.use_css_transition
-      scroll_to(original_scroll_position)
-      screenshot
-    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
+    #
+    #   # 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 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)
+    #
+    #     sub_regions = Applitools::Base::Region.new(0, 0, page_size.width,
+    #       page_size.height).subregions(screenshot_part_size)
+    #     parts = sub_regions.map do |screenshot_part|
+    #       # Skip (0,0), as we already got the screenshot.
+    #       if screenshot_part.left.zero? && screenshot_part.top.zero?
+    #         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_transform(original_transform) if @eyes.use_css_transition
+    #   scroll_to(original_scroll_position)
+    #   screenshot
+    # end
 
     private
 

data/lib/applitools/selenium/context_based_scale_provider.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Applitools::Selenium
   # @!visibility private
   class ContextBasedScaleProvider

data/lib/applitools/selenium/css_transform/css_transform.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Applitools
+  module CssTransform
+    private
+
+    def get_position_from_transform(transform)
+      regexp = /^translate\(\s*(\-?)([\d, \.]+)px,\s*(\-?)([\d, \.]+)px\s*\)/
+      data = regexp.match(transform)
+
+      raise Applitools::EyesError.new "Can't parse CSS transition: #{transform}!" unless data
+      x = data[2].to_f.round
+      y = data[4].to_f.round
+
+      x *= -1 unless data[1].empty?
+      y *= -1 unless data[3].empty?
+
+      Applitools::Location.new(x, y)
+    end
+  end
+end

data/lib/applitools/selenium/css_translate_element_position_provider.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative 'element_position_provider'
+require_relative 'css_transform/css_transform'
+
+module Applitools::Selenium
+  # @!visibility private
+  class CssTranslateElementPositionProvider < ElementPositionProvider
+    include Applitools::CssTransform
+
+    # Gets the current position.
+    #
+    # @return [Applitools::Location] The location.
+    def current_position
+      position = super.offset_negative transforms_offset
+      logger.info "Current position is #{position}"
+      position
+    end
+
+    def position=(location)
+      super
+      out_of_eyes = location.dup.offset_negative(current_position)
+      return if out_of_eyes == Applitools::Location::TOP_LEFT
+      logger.info "Moving element by #{out_of_eyes} to fit in the eyes region"
+
+      Applitools::Utils::EyesSeleniumUtils.element_translate_to(
+        driver,
+        element,
+        transforms_offset.offset_negative(out_of_eyes)
+      )
+      logger.info 'Done scrolling element!'
+    end
+
+    private
+
+    def transforms_offset
+      logger.info 'Getting element transforms...'
+      transforms = Applitools::Utils::EyesSeleniumUtils.current_element_transforms(driver, element)
+      logger.info "Current transforms: #{transforms}"
+      transform_positions = transforms.values.compact.select { |s| !s.empty? }
+                                      .map { |s| get_position_from_transform(s) }
+      transform_positions.each do |p|
+        raise Applitools::EyesError.new 'Got different css positions!' unless p == transform_positions[0]
+      end
+      transform_positions[0] || Applitools::Location::TOP_LEFT.dup
+    end
+  end
+end

data/lib/applitools/selenium/css_translate_position_provider.rb

@@ -1,6 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'css_transform/css_transform'
+
 module Applitools::Selenium
   class CssTranslatePositionProvider
     extend Forwardable
+    include Applitools::CssTransform
 
     def_delegators 'Applitools::EyesLogger', :logger, :log_handler, :log_handler=
 
@@ -33,7 +38,7 @@ module Applitools::Selenium
     #
     # @param [Applitools::Location] value The location.
     def restore_state(value)
-      transforms = value.values.select { |el| !el.empty? }
+      transforms = value.values.compact.select { |el| !el.empty? }
       Applitools::Utils::EyesSeleniumUtils.set_transforms(executor, value)
       if transforms.empty?
         self.last_state_position = Applitools::Location::TOP_LEFT
@@ -62,7 +67,7 @@ module Applitools::Selenium
     # Gets the entire size of the frame.
     #
     # @return [Applitools::RectangleSize] The entire size of the frame.
-    def entire_size
+    def entire_size(_image_width, _image_height)
       viewport_size = Applitools::Utils::EyesSeleniumUtils.extract_viewport_size(executor)
       result = Applitools::Utils::EyesSeleniumUtils.current_frame_content_entire_size(executor)
       logger.info "Entire size: #{result}"
@@ -73,19 +78,33 @@ module Applitools::Selenium
       result.height = [viewport_size.height, result.height].min if disable_vertical
       logger.info "Actual size to scroll: #{result}"
       result
+
+      # return result unless executor.frame_chain.empty?
+
+      # spp = Applitools::Selenium::ScrollPositionProvider.new(executor)
+      # original_scroll_position = spp.current_position
+      # spp.scroll_to_bottom_right
+      # bottom_right_position = spp.current_position
+      # spp.restore_state(original_scroll_position)
+      # Applitools::RectangleSize.new(bottom_right_position.x + image_width, bottom_right_position.y + image_height)
     end
 
     private
 
     attr_accessor :executor, :disable_horizontal, :disable_vertical, :max_width, :max_height
 
-    def get_position_from_transform(transform)
-      regexp = /^translate\(\s*(\-?)(\d+)px,\s*(\-?)(\d+)px\s*\)/
-      data = regexp.match(transform)
-      raise Applitools::EyesError.new "Can't parse CSS transition: #{transform}!" unless data
-      x = data[1].empty? ? data[2].to_i : -1 * data[2].to_i
-      y = data[3].empty? ? data[4].to_i : -1 * data[4].to_i
-      Applitools::Location.new(x, y)
-    end
+    # def get_position_from_transform(transform)
+    #   regexp = /^translate\(\s*(\-?)([\d, \.]+)px,\s*(\-?)([\d, \.]+)px\s*\)/
+    #   data = regexp.match(transform)
+    #
+    #   raise Applitools::EyesError.new "Can't parse CSS transition: #{transform}!" unless data
+    #   x = data[2].to_f.round
+    #   y = data[4].to_f.round
+    #
+    #   x *= (-1) unless data[1].empty?
+    #   y *= (-1) unless data[3].empty?
+    #
+    #   Applitools::Location.new(x, y)
+    # end
   end
 end

data/lib/applitools/selenium/dom_capture/dom_capture.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: false
+
+require 'benchmark'
+require 'timeout'
+
+require 'css_parser'
+include Benchmark
+module Applitools::Selenium
+  module DomCapture
+    CSS_DOWNLOAD_TIMEOUT = 2 # 2 seconds
+    DOM_CAPTURE_TIMEOUT = 10 # 10 seconds
+
+    extend self
+
+    def get_window_dom(driver, logger)
+      args_obj = {
+        'styleProps' => %w(
+          background-color background-image background-size color border-width
+          border-color border-style padding margin
+        ),
+        'attributeProps' => nil,
+        'rectProps' => %w(width height top left),
+        'ignoredTagNames' => %w(HEAD SCRIPT)
+      }
+      dom_tree = ''
+      if Timeout.respond_to?(:timeout)
+        Timeout.timeout(DOM_CAPTURE_TIMEOUT) do
+          dom_tree = driver.execute_script(Applitools::Selenium::DomCapture::DOM_CAPTURE_SCRIPT, args_obj)
+          get_frame_dom(driver, { 'childNodes' => [dom_tree], 'tagName' => 'OUTER_HTML' }, logger)
+        end
+      else
+        timeout(DOM_CAPTURE_TIMEOUT) do
+          dom_tree = driver.execute_script(Applitools::Selenium::DomCapture::DOM_CAPTURE_SCRIPT, args_obj)
+          get_frame_dom(driver, { 'childNodes' => [dom_tree], 'tagName' => 'OUTER_HTML' }, logger)
+        end
+      end
+      dom_tree
+    end
+
+    private
+
+    def get_frame_dom(driver, dom_tree, logger)
+      tag_name = dom_tree['tagName']
+      return unless tag_name
+      frame_index = 0
+      loop(driver, dom_tree, logger) do |dom_sub_tree|
+        # this block is called if IFRAME found
+        driver.switch_to.frame(index: frame_index)
+        get_frame_dom(driver, dom_sub_tree, logger)
+        driver.switch_to.parent_frame
+        frame_index += 1
+      end
+    end
+
+    def loop(driver, dom_tree, logger)
+      child_nodes = dom_tree['childNodes']
+      return unless child_nodes
+      iterate_child_nodes = proc do |node_childs|
+        node_childs.each do |node|
+          if node['tagName'].casecmp('IFRAME') == 0
+            yield(node) if block_given?
+          else
+            node['css'] = get_frame_bundled_css(driver, logger) if node['tagName'].casecmp('HTML') == 0
+            iterate_child_nodes.call(node['childNodes']) unless node['childNodes'].nil?
+          end
+        end
+      end
+      iterate_child_nodes.call(child_nodes)
+    end
+
+    def get_frame_bundled_css(driver, logger)
+      base_url = URI.parse(driver.current_url)
+      parser = CssParser::Parser.new import: true, absolute_paths: true
+      css_threads = []
+      css_items = []
+      driver.execute_script(Applitools::Selenium::DomCapture::CSS_CAPTURE_SCRIPT).each_with_index do |item, i|
+        if (v = item['text'])
+          css_items[i] = [v]
+        elsif (v = item['href'])
+          target_url = URI.parse(v)
+          url_to_load = target_url.absolute? ? target_url : base_url.merge(target_url)
+          css_threads << Thread.new(url_to_load) do |url|
+            if Timeout.respond_to?(:timeout)
+              Timeout.timeout(CSS_DOWNLOAD_TIMEOUT) do
+                css_string, = parser.send(:read_remote_file, url)
+                css_items[i] = [css_string, { base_uri: url }]
+              end
+            else
+              timeout(CSS_DOWNLOAD_TIMEOUT) do
+                css_string, = parser.send(:read_remote_file, url)
+                css_items[i] = [css_string, { base_uri: url }]
+              end
+            end
+          end
+        end
+      end
+      begin
+        css_threads.each(&:join)
+      rescue CssParser::CircularReferenceError => e
+        logger.respond_to?(:error) && logger.error("Got a circular reference error! #{e.message}")
+      rescue CssParser::RemoteFileError => e
+        logger.respond_to?(:error) && logger.error("File download error - #{e.message}")
+      rescue StandardError => e
+        logger.respond_to?(:error) && logger.error("#{e.class} - #{e.message}")
+      end
+
+      css_items.each { |css| parser.add_block!(*css) if css && css[0] }
+      css_result = ''
+      parser.each_rule_set { |s| css_result.concat(s.to_s) }
+      css_result
+    end
+  end
+end

data/lib/applitools/selenium/dom_capture/dom_capture_script.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+#
+module Applitools::Selenium
+  module DomCapture
+    CSS_CAPTURE_SCRIPT = <<-SCRIPT
+      function extractCssResources() {
+        return Array.from(document.querySelectorAll('link[rel="stylesheet"],style')).map(el => {
+          if (el.tagName.toUpperCase() === 'LINK') {
+              return {"href": el.getAttribute('href')};
+          } else {
+              return {"text": el.textContent};
+          }
+        });
+      }
+      return extractCssResources();
+    SCRIPT
+    DOM_CAPTURE_SCRIPT = <<-SCRIPT
+      function captureFrame({ styleProps, attributeProps, rectProps, ignoredTagNames }) {
+        const NODE_TYPES = {
+          ELEMENT: 1,
+          TEXT: 3,
+        };
+        function filter(x) {
+          return !!x;
+        }
+        function notEmptyObj(obj) {
+          return Object.keys(obj).length ? obj : undefined;
+        }
+        function iframeToJSON(el) {
+          const obj = elementToJSON(el);
+          try {
+            if (el.contentDocument) {
+              obj.childNodes = [captureNode(el.contentDocument.documentElement)];
+            }
+          } catch (ex) {
+          } finally {
+            return obj;
+          }
+        }
+        function elementToJSON(el) {
+          const tagName = el.tagName.toUpperCase();
+          if (ignoredTagNames.indexOf(tagName) > -1) return null;
+          const computedStyle = window.getComputedStyle(el);
+          const boundingClientRect = el.getBoundingClientRect();
+          const style = {};
+          for (const p of styleProps) style[p] = computedStyle.getPropertyValue(p);
+          const rect = {};
+          for (const p of rectProps) rect[p] = boundingClientRect[p];
+          const attributes = {};
+          if (!attributeProps) {
+            if (el.hasAttributes()) {
+              var attrs = el.attributes;
+              for (const p of attrs) {
+                attributes[p.name] = p.value;
+              }
+            }
+          }
+          else {
+            if (attributeProps.all) {
+              for (const p of attributeProps.all) {
+                if (el.hasAttribute(p)) attributes[p] = el.getAttribute(p);
+              }
+            }
+            if (attributeProps[tagName]) {
+              for (const p of attributeProps[tagName]) {
+                if (el.hasAttribute(p)) attributes[p] = el.getAttribute(p);
+              }
+            }
+          }
+          return {
+            tagName,
+            style: notEmptyObj(style),
+            rect: notEmptyObj(rect),
+            attributes: notEmptyObj(attributes),
+            childNodes: Array.prototype.map.call(el.childNodes, captureNode).filter(filter),
+          };
+        }
+        function captureTextNode(node) {
+          return {
+            tagName: '#text',
+            text: node.textContent,
+          };
+        }
+        function captureNode(node) {
+          switch (node.nodeType) {
+            case NODE_TYPES.TEXT:
+              return captureTextNode(node);
+            case NODE_TYPES.ELEMENT:
+              if (node.tagName.toUpperCase() === 'IFRAME') {
+                return iframeToJSON(node);
+              } else {
+                return elementToJSON(node);
+              }
+            default:
+              return null;
+          }
+        }
+        return captureNode(document.documentElement);
+      }
+      return captureFrame(arguments[0]);
+    SCRIPT
+  end
+end