eyes_selenium 3.16.6 → 3.16.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9163861cda50303431e9f57bc562a157ced563ce197d5a0140cc603d40dd82d
-  data.tar.gz: d0c61e4ea52a442fb38454954166131da5cccc8932d09dc03bac464d9e4698c3
+  metadata.gz: 609b82f065fd2d1d3be7369ca993472bb279d9747dd307659e2c556d517210c7
+  data.tar.gz: 903b99fd75708e28296cec9183431e999cba2ff12e963476e6363bb9d00658d0
 SHA512:
-  metadata.gz: 95fa86b494f42a2f184cc545f0cff725256807bbb5e6ec91e27375030d11d96faa445960d954250e6e013a91b88023eee135773c23819005d3227a834b5e270b
-  data.tar.gz: 682478b3b88a435d1114a479d006eece679245928fa3cdcf5241bd3bd6af31ebba493de5809cd5176113ffc68b07eb49d2a0c7f82ad04e796f4ca80699ec3e47
+  metadata.gz: d7728155e30d8d63bd0ecfd9eab3190b6dcc015d31158c92cb31b55cf541905368d745816154a074497e4b8a69251ecc6826ca95778fd7b421edf6849116fac2
+  data.tar.gz: b99d3f6e4d4275c93eaf52512a08b7811452be7f49cb222ac3c152911e8e6ac10c3449c3bfd3f10e71997acb5eb7013bce7a7c3f038fdc6ea913be3e6badb050

data/lib/applitools/selenium/css_translate_element_position_provider.rb

@@ -31,6 +31,8 @@ module Applitools::Selenium
       logger.info 'Done scrolling element!'
     end
 
+    alias scroll_to position=
+
     private
 
     def transforms_offset

data/lib/applitools/selenium/css_translate_position_provider.rb

@@ -59,6 +59,8 @@ module Applitools::Selenium
       self.last_state_position = value
     end
 
+    alias scroll_to position=
+
     def force_offset
       Applitools::Location.from_any_attribute last_state_position
       # Applitools::Location::TOP_LEFT

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

@@ -4,7 +4,7 @@ module Applitools
   module Selenium
     module DomCapture
       CAPTURE_FRAME_SCRIPT = <<'SCRIPT'
-/* @applitools/dom-capture@7.0.14 */
+/* @applitools/dom-capture@7.1.3 */
 
 function __captureDomAndPoll() {
   var captureDomAndPoll = (function () {
@@ -56,19 +56,21 @@ function __captureDomAndPoll() {
     });
 
   async function getImageSizes({bgImages, timeout = 5000, Image = window.Image}) {
-    return (await Promise.all(
-      Array.from(bgImages).map(url =>
-        Promise.race([
-          new Promise(resolve => {
-            const img = new Image();
-            img.onload = () => resolve({url, width: img.naturalWidth, height: img.naturalHeight});
-            img.onerror = () => resolve();
-            img.src = url;
-          }),
-          psetTimeout(timeout),
-        ]),
-      ),
-    )).reduce((images, curr) => {
+    return (
+      await Promise.all(
+        Array.from(bgImages).map(url =>
+          Promise.race([
+            new Promise(resolve => {
+              const img = new Image();
+              img.onload = () => resolve({url, width: img.naturalWidth, height: img.naturalHeight});
+              img.onerror = () => resolve();
+              img.src = url;
+            }),
+            psetTimeout(timeout),
+          ]),
+        ),
+      )
+    ).reduce((images, curr) => {
       if (curr) {
         images[curr.url] = {width: curr.width, height: curr.height};
       }
@@ -115,10 +117,10 @@ function __captureDomAndPoll() {
     parseCss,
     CSSImportRule,
     absolutizeUrl,
-    fetchCss,
+    getCssFromCache,
     unfetchedToken,
   }) {
-    return async function getBundledCssFromCssText(cssText, resourceUrl) {
+    return function getBundledCssFromCssText(cssText, styleBaseUrl) {
       let unfetchedResources;
       let bundledCss = '';
 
@@ -126,13 +128,13 @@ function __captureDomAndPoll() {
         const styleSheet = parseCss(cssText);
         for (const rule of Array.from(styleSheet.cssRules)) {
           if (rule instanceof CSSImportRule) {
-            const nestedUrl = absolutizeUrl(rule.href, resourceUrl);
-            const nestedResource = await fetchCss(nestedUrl);
+            const nestedUrl = absolutizeUrl(rule.href, styleBaseUrl);
+            const nestedResource = getCssFromCache(nestedUrl);
             if (nestedResource !== undefined) {
               const {
                 bundledCss: nestedCssText,
                 unfetchedResources: nestedUnfetchedResources,
-              } = await getBundledCssFromCssText(nestedResource, nestedUrl);
+              } = getBundledCssFromCssText(nestedResource, nestedUrl);
 
               nestedUnfetchedResources && (unfetchedResources = new Set(nestedUnfetchedResources));
               bundledCss = `${nestedCssText}${bundledCss}`;
@@ -143,10 +145,10 @@ function __captureDomAndPoll() {
           }
         }
       } catch (ex) {
-        console.log(`error during getBundledCssFromCssText, resourceUrl=${resourceUrl}`, ex);
+        console.log(`error during getBundledCssFromCssText, styleBaseUrl=${styleBaseUrl}`, ex);
       }
 
-      bundledCss = `${bundledCss}${getCss(cssText, resourceUrl)}`;
+      bundledCss = `${bundledCss}${getCss(cssText, styleBaseUrl)}`;
 
       return {
         bundledCss,
@@ -189,22 +191,48 @@ function __captureDomAndPoll() {
 
   var fetchCss = makeFetchCss;
 
-  function makeExtractCssFromNode({fetchCss, absolutizeUrl}) {
-    return async function extractCssFromNode(node, baseUrl) {
-      let cssText, resourceUrl, isUnfetched;
+  var getHrefAttr = function getHrefAttr(node) {
+    const attr = Array.from(node.attributes).find(attr => attr.name.toLowerCase() === 'href');
+    return attr && attr.value;
+  };
+
+  var isLinkToStyleSheet = function isLinkToStyleSheet(node) {
+    return (
+      node.nodeName &&
+      node.nodeName.toUpperCase() === 'LINK' &&
+      node.attributes &&
+      Array.from(node.attributes).find(
+        attr => attr.name.toLowerCase() === 'rel' && attr.value.toLowerCase() === 'stylesheet',
+      )
+    );
+  };
+
+  function isDataUrl(url) {
+    return url && url.startsWith('data:');
+  }
+
+  var isDataUrl_1 = isDataUrl;
+
+  function makeExtractCssFromNode({getCssFromCache, absolutizeUrl}) {
+    return function extractCssFromNode(node, baseUrl) {
+      let cssText, styleBaseUrl, isUnfetched;
       if (isStyleElement(node)) {
         cssText = Array.from(node.childNodes)
           .map(node => node.nodeValue)
           .join('');
-        resourceUrl = baseUrl;
+        styleBaseUrl = baseUrl;
       } else if (isLinkToStyleSheet(node)) {
-        resourceUrl = absolutizeUrl(getHrefAttr(node), baseUrl);
-        cssText = await fetchCss(resourceUrl);
-        if (cssText === undefined) {
-          isUnfetched = true;
+        const href = getHrefAttr(node);
+        if (!isDataUrl_1(href)) {
+          styleBaseUrl = absolutizeUrl(href, baseUrl);
+          cssText = getCssFromCache(styleBaseUrl);
+        } else {
+          styleBaseUrl = baseUrl;
+          cssText = href.match(/,(.+)/)[1];
         }
+        isUnfetched = cssText === undefined;
       }
-      return {cssText, resourceUrl, isUnfetched};
+      return {cssText, styleBaseUrl, isUnfetched};
     };
   }
 
@@ -212,41 +240,25 @@ function __captureDomAndPoll() {
     return node.nodeName && node.nodeName.toUpperCase() === 'STYLE';
   }
 
-  function getHrefAttr(node) {
-    const attr = Array.from(node.attributes).find(attr => attr.name.toLowerCase() === 'href');
-    return attr && attr.value;
-  }
-
-  function isLinkToStyleSheet(node) {
-    return (
-      node.nodeName &&
-      node.nodeName.toUpperCase() === 'LINK' &&
-      node.attributes &&
-      Array.from(node.attributes).find(
-        attr => attr.name.toLowerCase() === 'rel' && attr.value.toLowerCase() === 'stylesheet',
-      )
-    );
-  }
-
   var extractCssFromNode = makeExtractCssFromNode;
 
   function makeCaptureNodeCss({extractCssFromNode, getBundledCssFromCssText, unfetchedToken}) {
-    return async function captureNodeCss(node, baseUrl) {
-      const {resourceUrl, cssText, isUnfetched} = await extractCssFromNode(node, baseUrl);
+    return function captureNodeCss(node, baseUrl) {
+      const {styleBaseUrl, cssText, isUnfetched} = extractCssFromNode(node, baseUrl);
 
       let unfetchedResources;
       let bundledCss = '';
       if (cssText) {
-        const {
-          bundledCss: nestedCss,
-          unfetchedResources: nestedUnfetched,
-        } = await getBundledCssFromCssText(cssText, resourceUrl);
+        const {bundledCss: nestedCss, unfetchedResources: nestedUnfetched} = getBundledCssFromCssText(
+          cssText,
+          styleBaseUrl,
+        );
 
         bundledCss += nestedCss;
         unfetchedResources = new Set(nestedUnfetched);
       } else if (isUnfetched) {
-        bundledCss += `${unfetchedToken}${resourceUrl}${unfetchedToken}`;
-        unfetchedResources = new Set([resourceUrl]);
+        bundledCss += `${unfetchedToken}${styleBaseUrl}${unfetchedToken}`;
+        unfetchedResources = new Set([styleBaseUrl]);
       }
       return {bundledCss, unfetchedResources};
     };
@@ -258,37 +270,157 @@ function __captureDomAndPoll() {
     ELEMENT: 1,
     TEXT: 3,
   };
-  const API_VERSION = '1.0.0';
+
+  var nodeTypes = {NODE_TYPES};
+
+  const {NODE_TYPES: NODE_TYPES$1} = nodeTypes;
+
+
+
+
+
+  function makePrefetchAllCss(fetchCss) {
+    return async function prefetchAllCss(doc = document) {
+      const cssMap = {};
+      const start = Date.now();
+      const promises = [];
+      doFetchAllCssFromFrame(doc, cssMap, promises);
+      await Promise.all(promises);
+      console.log('[prefetchAllCss]', Date.now() - start);
+
+      return function fetchCssSync(url) {
+        return cssMap[url];
+      };
+
+      async function fetchNodeCss(node, baseUrl, cssMap) {
+        let cssText, resourceUrl;
+        if (isLinkToStyleSheet(node)) {
+          resourceUrl = absolutizeUrl_1(getHrefAttr(node), baseUrl);
+          cssText = await fetchCss(resourceUrl);
+          if (cssText !== undefined) {
+            cssMap[resourceUrl] = cssText;
+          }
+        }
+        if (cssText) {
+          await fetchBundledCss(cssText, resourceUrl, cssMap);
+        }
+      }
+
+      async function fetchBundledCss(cssText, resourceUrl, cssMap) {
+        try {
+          const styleSheet = parseCss_1(cssText);
+          const promises = [];
+          for (const rule of Array.from(styleSheet.cssRules)) {
+            if (rule instanceof CSSImportRule) {
+              promises.push(
+                (async () => {
+                  const nestedUrl = absolutizeUrl_1(rule.href, resourceUrl);
+                  const cssText = await fetchCss(nestedUrl);
+                  cssMap[nestedUrl] = cssText;
+                  if (cssText !== undefined) {
+                    await fetchBundledCss(cssText, nestedUrl, cssMap);
+                  }
+                })(),
+              );
+            }
+          }
+          await Promise.all(promises);
+        } catch (ex) {
+          console.log(`error during fetchBundledCss, resourceUrl=${resourceUrl}`, ex);
+        }
+      }
+
+      function doFetchAllCssFromFrame(frameDoc, cssMap, promises) {
+        fetchAllCssFromNode(frameDoc.documentElement);
+
+        function fetchAllCssFromNode(node) {
+          promises.push(fetchNodeCss(node, frameDoc.location.href, cssMap));
+
+          switch (node.nodeType) {
+            case NODE_TYPES$1.ELEMENT: {
+              const tagName = node.tagName.toUpperCase();
+              if (tagName === 'IFRAME') {
+                return fetchAllCssFromIframe(node);
+              } else {
+                return fetchAllCssFromElement(node);
+              }
+            }
+          }
+        }
+
+        async function fetchAllCssFromElement(el) {
+          Array.prototype.map.call(el.childNodes, fetchAllCssFromNode);
+        }
+
+        async function fetchAllCssFromIframe(el) {
+          fetchAllCssFromElement(el);
+          try {
+            doFetchAllCssFromFrame(el.contentDocument, cssMap, promises);
+          } catch (ex) {
+            console.log(ex);
+          }
+        }
+      }
+    };
+  }
+
+  var prefetchAllCss = makePrefetchAllCss;
+
+  const {NODE_TYPES: NODE_TYPES$2} = nodeTypes;
+
+  const API_VERSION = '1.1.0';
 
   async function captureFrame(
     {styleProps, rectProps, ignoredTagNames} = defaultDomProps,
     doc = document,
+    addStats = false,
   ) {
-    const start = Date.now();
+    const performance = {total: {}, prefetchCss: {}, doCaptureFrame: {}, waitForImages: {}};
+    function startTime(obj) {
+      obj.startTime = Date.now();
+    }
+    function endTime(obj) {
+      obj.endTime = Date.now();
+      obj.ellapsedTime = obj.endTime - obj.startTime;
+    }
+    const promises = [];
+    startTime(performance.total);
     const unfetchedResources = new Set();
     const iframeCors = [];
     const iframeToken = '@@@@@';
     const unfetchedToken = '#####';
     const separator = '-----';
 
-    const fetchCss$$1 = fetchCss(fetch);
+    startTime(performance.prefetchCss);
+    const prefetchAllCss$$1 = prefetchAllCss(fetchCss(fetch));
+    const getCssFromCache = await prefetchAllCss$$1(doc);
+    endTime(performance.prefetchCss);
+
     const getBundledCssFromCssText$$1 = getBundledCssFromCssText({
       parseCss: parseCss_1,
       CSSImportRule,
-      fetchCss: fetchCss$$1,
+      getCssFromCache,
       absolutizeUrl: absolutizeUrl_1,
       unfetchedToken,
     });
-    const extractCssFromNode$$1 = extractCssFromNode({fetchCss: fetchCss$$1, absolutizeUrl: absolutizeUrl_1});
+    const extractCssFromNode$$1 = extractCssFromNode({getCssFromCache, absolutizeUrl: absolutizeUrl_1});
     const captureNodeCss$$1 = captureNodeCss({
       extractCssFromNode: extractCssFromNode$$1,
       getBundledCssFromCssText: getBundledCssFromCssText$$1,
       unfetchedToken,
     });
 
+    startTime(performance.doCaptureFrame);
+    const capturedFrame = doCaptureFrame(doc);
+    endTime(performance.doCaptureFrame);
+
+    startTime(performance.waitForImages);
+    await Promise.all(promises);
+    endTime(performance.waitForImages);
+
     // Note: Change the API_VERSION when changing json structure.
-    const capturedFrame = await doCaptureFrame(doc);
     capturedFrame.version = API_VERSION;
+    capturedFrame.scriptVersion = '7.1.3';
 
     const iframePrefix = iframeCors.length ? `${iframeCors.join('\n')}\n` : '';
     const unfetchedPrefix = unfetchedResources.size
@@ -301,10 +433,20 @@ function __captureDomAndPoll() {
       iframeStartToken: `"${iframeToken}`,
       iframeEndToken: `${iframeToken}"`,
     });
+
+    endTime(performance.total);
+
+    function stats() {
+      if (!addStats) {
+        return '';
+      }
+      return `\n${separator}\n${JSON.stringify(performance)}`;
+    }
+
     const ret = `${metaPrefix}\n${unfetchedPrefix}${separator}\n${iframePrefix}${separator}\n${JSON.stringify(
     capturedFrame,
-  )}`;
-    console.log('[captureFrame]', Date.now() - start);
+  )}${stats()}`;
+    console.log('[captureFrame]', JSON.stringify(performance));
     return ret;
 
     function filter(x) {
@@ -322,16 +464,16 @@ function __captureDomAndPoll() {
       };
     }
 
-    async function doCaptureFrame(frameDoc) {
+    function doCaptureFrame(frameDoc) {
       const bgImages = new Set();
       let bundledCss = '';
-      const ret = await captureNode(frameDoc.documentElement);
+      const ret = captureNode(frameDoc.documentElement);
       ret.css = bundledCss;
-      ret.images = await getImageSizes_1({bgImages});
+      promises.push(getImageSizes_1({bgImages}).then(images => (ret.images = images)));
       return ret;
 
-      async function captureNode(node) {
-        const {bundledCss: nodeCss, unfetchedResources: nodeUnfetched} = await captureNodeCss$$1(
+      function captureNode(node) {
+        const {bundledCss: nodeCss, unfetchedResources: nodeUnfetched} = captureNodeCss$$1(
           node,
           frameDoc.location.href,
         );
@@ -339,15 +481,15 @@ function __captureDomAndPoll() {
         if (nodeUnfetched) for (const elem of nodeUnfetched) unfetchedResources.add(elem);
 
         switch (node.nodeType) {
-          case NODE_TYPES.TEXT: {
+          case NODE_TYPES$2.TEXT: {
             return captureTextNode(node);
           }
-          case NODE_TYPES.ELEMENT: {
+          case NODE_TYPES$2.ELEMENT: {
             const tagName = node.tagName.toUpperCase();
             if (tagName === 'IFRAME') {
-              return await iframeToJSON(node);
+              return iframeToJSON(node);
             } else {
-              return await await elementToJSON(node);
+              return elementToJSON(node);
             }
           }
           default: {
@@ -356,10 +498,8 @@ function __captureDomAndPoll() {
         }
       }
 
-      async function elementToJSON(el) {
-        const childNodes = (await Promise.all(
-          Array.prototype.map.call(el.childNodes, captureNode),
-        )).filter(filter);
+      function elementToJSON(el) {
+        const childNodes = Array.prototype.map.call(el.childNodes, captureNode).filter(filter);
 
         const tagName = el.tagName.toUpperCase();
         if (ignoredTagNames.indexOf(tagName) > -1) return null;
@@ -369,6 +509,13 @@ function __captureDomAndPoll() {
 
         const style = {};
         for (const p of styleProps) style[p] = computedStyle.getPropertyValue(p);
+        if (!style['border-width']) {
+          style['border-width'] = `${computedStyle.getPropertyValue(
+          'border-top-width',
+        )} ${computedStyle.getPropertyValue('border-right-width')} ${computedStyle.getPropertyValue(
+          'border-bottom-width',
+        )} ${computedStyle.getPropertyValue('border-left-width')}`;
+        }
 
         const rect = {};
         for (const p of rectProps) rect[p] = boundingClientRect[p];
@@ -394,8 +541,8 @@ function __captureDomAndPoll() {
         };
       }
 
-      async function iframeToJSON(el) {
-        const obj = await elementToJSON(el);
+      function iframeToJSON(el) {
+        const obj = elementToJSON(el);
         let doc;
         try {
           doc = el.contentDocument;
@@ -405,7 +552,7 @@ function __captureDomAndPoll() {
         }
         try {
           if (doc) {
-            obj.childNodes = [await doCaptureFrame(el.contentDocument)];
+            obj.childNodes = [doCaptureFrame(el.contentDocument)];
           } else {
             markFrameAsCors();
           }

data/lib/applitools/selenium/target.rb

@@ -31,7 +31,7 @@ module Applitools
         self.options = {
           ignore_caret: true,
           ignore_mismatch: false,
-          send_dom: nil,
+          send_dom: true,
           script_hooks: { beforeCaptureScreenshot: '' }
         }
         self.regions = {}

data/lib/applitools/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: false
 
 module Applitools
-  VERSION = '3.16.6'.freeze
+  VERSION = '3.16.7'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eyes_selenium
 version: !ruby/object:Gem::Version
-  version: 3.16.6
+  version: 3.16.7
 platform: ruby
 authors:
 - Applitools Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-05 00:00:00.000000000 Z
+date: 2020-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eyes_core
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.16.6
+        version: 3.16.7
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.16.6
+        version: 3.16.7
 - !ruby/object:Gem::Dependency
   name: selenium-webdriver
   requirement: !ruby/object:Gem::Requirement