eyes_selenium 3.15.16 → 3.15.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8a82e44e8cc027d291b6a6250fd00419750734b42b17946ace20ff2dac94a64
-  data.tar.gz: c2b69c1f40b8171bb599ea839b8f5a7a71ab245167bfc00713900894d2ee7968
+  metadata.gz: 639b145cb841a63e971d9a5aa43aa05b502b446399691aa3b368db0309febe0f
+  data.tar.gz: 3509ad0fd6e0b581c14fd9f054e770b48ca083434337020b665d4c51ce5cdb1e
 SHA512:
-  metadata.gz: e505b26d1619b5d19e4e2a1824116efac11c718f2251c0f564284484de584ed9c88308994fadd7a9aad978b62f603ba7f96b8a94cf512cc3d3c705ae1d397eaa
-  data.tar.gz: 6c10c2efcce51a2df5966ddc7b22c910bf850ea34a4b196bb047173697f2652b6e19ab6c7298db2d39addc2a7c61973e26e1804266d9ff1841ce323c348c4a7d
+  metadata.gz: 5119825b6662f502a0ae55b7d0cd424b2fa05c5707d4f11e40fa8b57aed082fb281bd4639c8c733bb369a612e947e06fe48b57788a9fd81cce26ef21cc1fa7f0
+  data.tar.gz: 8125963685a0efbe5081a6676e37052570b34eeca579162a6d45cb31f48124bd5cdd924c848a3163fd88f2e2106bd247d31080d046d8bda6be8a1f1589bd8c6a

data/lib/applitools/selenium/scripts/process_page_and_poll.rb

@@ -0,0 +1,588 @@
+module Applitools
+  module Selenium
+    module Scripts
+      PROCESS_PAGE_AND_POLL = <<'END'
+// @applitools/dom-snapshot@1.2.4
+function __processPageAndPoll() {
+  var processPageAndPoll = (function () {
+  'use strict';
+
+  // This code was copied and modified from https://github.com/beatgammit/base64-js/blob/bf68aaa277/index.js
+  // License: https://github.com/beatgammit/base64-js/blob/bf68aaa277d9de7007cc0c58279c411bb10670ac/LICENSE
+
+  function arrayBufferToBase64(ab) {
+    const lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');
+
+    const uint8 = new Uint8Array(ab);
+    const len = uint8.length;
+    const extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes
+    const parts = [];
+    const maxChunkLength = 16383; // must be multiple of 3
+
+    let tmp;
+
+    // go through the array every three bytes, we'll deal with trailing stuff later
+    for (let i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
+      parts.push(encodeChunk(i, i + maxChunkLength > len2 ? len2 : i + maxChunkLength));
+    }
+
+    // pad the end with zeros, but make sure to not forget the extra bytes
+    if (extraBytes === 1) {
+      tmp = uint8[len - 1];
+      parts.push(lookup[tmp >> 2] + lookup[(tmp << 4) & 0x3f] + '==');
+    } else if (extraBytes === 2) {
+      tmp = (uint8[len - 2] << 8) + uint8[len - 1];
+      parts.push(lookup[tmp >> 10] + lookup[(tmp >> 4) & 0x3f] + lookup[(tmp << 2) & 0x3f] + '=');
+    }
+
+    return parts.join('');
+
+    function tripletToBase64(num) {
+      return (
+        lookup[(num >> 18) & 0x3f] +
+        lookup[(num >> 12) & 0x3f] +
+        lookup[(num >> 6) & 0x3f] +
+        lookup[num & 0x3f]
+      );
+    }
+
+    function encodeChunk(start, end) {
+      let tmp;
+      const output = [];
+      for (let i = start; i < end; i += 3) {
+        tmp = ((uint8[i] << 16) & 0xff0000) + ((uint8[i + 1] << 8) & 0xff00) + (uint8[i + 2] & 0xff);
+        output.push(tripletToBase64(tmp));
+      }
+      return output.join('');
+    }
+  }
+
+  var arrayBufferToBase64_1 = arrayBufferToBase64;
+
+  function extractLinks(doc = document) {
+    const srcsetUrls = [...doc.querySelectorAll('img[srcset],source[srcset]')]
+      .map(srcsetEl =>
+        srcsetEl
+          .getAttribute('srcset')
+          .split(',')
+          .map(str => str.trim().split(/\s+/)[0]),
+      )
+      .reduce((acc, urls) => acc.concat(urls), []);
+
+    const srcUrls = [...doc.querySelectorAll('img[src],source[src]')].map(srcEl =>
+      srcEl.getAttribute('src'),
+    );
+
+    const hrefUrls = [...doc.querySelectorAll('image')]
+      .map(hrefEl => hrefEl.getAttribute('href') || hrefEl.getAttribute('xlink:href'))
+      .filter(Boolean);
+
+    const cssUrls = [...doc.querySelectorAll('link[rel="stylesheet"]')].map(link =>
+      link.getAttribute('href'),
+    );
+
+    const videoPosterUrls = [...doc.querySelectorAll('video[poster]')].map(videoEl =>
+      videoEl.getAttribute('poster'),
+    );
+
+    return [...srcsetUrls, ...srcUrls, ...hrefUrls, ...cssUrls, ...videoPosterUrls];
+  }
+
+  var extractLinks_1 = extractLinks;
+
+  /* eslint-disable no-use-before-define */
+
+  function domNodesToCdt(docNode) {
+    const NODE_TYPES = {
+      ELEMENT: 1,
+      TEXT: 3,
+      DOCUMENT: 9,
+      DOCUMENT_TYPE: 10,
+      DOCUMENT_FRAGMENT_NODE: 11,
+    };
+
+    const domNodes = [
+      {
+        nodeType: NODE_TYPES.DOCUMENT,
+      },
+    ];
+    domNodes[0].childNodeIndexes = childrenFactory(domNodes, docNode.childNodes);
+    return domNodes;
+
+    function childrenFactory(domNodes, elementNodes) {
+      if (!elementNodes || elementNodes.length === 0) return null;
+
+      const childIndexes = [];
+      elementNodes.forEach(elementNode => {
+        const index = elementNodeFactory(domNodes, elementNode);
+        if (index !== null) {
+          childIndexes.push(index);
+        }
+      });
+
+      return childIndexes;
+    }
+
+    function elementNodeFactory(domNodes, elementNode) {
+      let node, manualChildNodeIndexes;
+      const {nodeType} = elementNode;
+      if ([NODE_TYPES.ELEMENT, NODE_TYPES.DOCUMENT_FRAGMENT_NODE].includes(nodeType)) {
+        if (elementNode.nodeName !== 'SCRIPT') {
+          if (
+            elementNode.nodeName === 'STYLE' &&
+            elementNode.sheet &&
+            elementNode.sheet.cssRules.length
+          ) {
+            domNodes.push({
+              nodeType: NODE_TYPES.TEXT,
+              nodeValue: [...elementNode.sheet.cssRules].map(rule => rule.cssText).join(''),
+            });
+            manualChildNodeIndexes = [domNodes.length - 1];
+          }
+
+          node = {
+            nodeType: nodeType,
+            nodeName: elementNode.nodeName,
+            attributes: nodeAttributes(elementNode).map(key => {
+              let value = elementNode.attributes[key].value;
+              const name = elementNode.attributes[key].localName;
+
+              if (/^blob:/.test(value)) {
+                value = value.replace(/^blob:/, '');
+              } else if (
+                elementNode.nodeName === 'IFRAME' &&
+                name === 'src' &&
+                !elementNode.contentDocument &&
+                !value.match(/^\s*data:/)
+              ) {
+                value = '';
+              }
+              return {
+                name,
+                value,
+              };
+            }),
+            childNodeIndexes:
+              manualChildNodeIndexes ||
+              (elementNode.childNodes.length
+                ? childrenFactory(domNodes, elementNode.childNodes)
+                : []),
+          };
+
+          if (elementNode.shadowRoot) {
+            node.shadowRootIndex = elementNodeFactory(domNodes, elementNode.shadowRoot);
+          }
+
+          if (elementNode.checked && !elementNode.attributes.checked) {
+            node.attributes.push({name: 'checked', value: 'checked'});
+          }
+          if (
+            elementNode.value !== undefined &&
+            elementNode.attributes.value === undefined &&
+            elementNode.tagName === 'INPUT'
+          ) {
+            node.attributes.push({name: 'value', value: elementNode.value});
+          }
+        } else {
+          node = {
+            nodeType: NODE_TYPES.ELEMENT,
+            nodeName: 'SCRIPT',
+            attributes: nodeAttributes(elementNode)
+              .map(key => ({
+                name: elementNode.attributes[key].localName,
+                value: elementNode.attributes[key].value,
+              }))
+              .filter(attr => attr.name !== 'src'),
+            childNodeIndexes: [],
+          };
+        }
+      } else if (nodeType === NODE_TYPES.TEXT) {
+        node = {
+          nodeType: NODE_TYPES.TEXT,
+          nodeValue: elementNode.nodeValue,
+        };
+      } else if (nodeType === NODE_TYPES.DOCUMENT_TYPE) {
+        node = {
+          nodeType: NODE_TYPES.DOCUMENT_TYPE,
+          nodeName: elementNode.nodeName,
+        };
+      }
+
+      if (node) {
+        domNodes.push(node);
+        return domNodes.length - 1;
+      } else {
+        // console.log(`Unknown nodeType: ${nodeType}`);
+        return null;
+      }
+
+      function nodeAttributes({attributes = {}}) {
+        return Object.keys(attributes).filter(k => attributes[k].localName);
+      }
+    }
+  }
+
+  var domNodesToCdt_1 = domNodesToCdt;
+  var NODE_TYPES = {
+    ELEMENT: 1,
+    TEXT: 3,
+    DOCUMENT: 9,
+    DOCUMENT_TYPE: 10,
+  };
+  domNodesToCdt_1.NODE_TYPES = NODE_TYPES;
+
+  function extractFrames(doc = document) {
+    return [...doc.querySelectorAll('iframe[src]:not([src=""])')]
+      .map(srcEl => {
+        try {
+          const contentDoc = srcEl.contentDocument;
+          return (
+            contentDoc &&
+            /^https?:$/.test(contentDoc.location.protocol) &&
+            contentDoc.defaultView &&
+            contentDoc.defaultView.frameElement &&
+            contentDoc
+          );
+        } catch (err) {
+          //for CORS frames
+        }
+      })
+      .filter(x => !!x);
+  }
+
+  var extractFrames_1 = extractFrames;
+
+  function uniq(arr) {
+    const result = [];
+    new Set(arr).forEach(v => v && result.push(v));
+    return result;
+  }
+
+  var uniq_1 = uniq;
+
+  function aggregateResourceUrlsAndBlobs(resourceUrlsAndBlobsArr) {
+    return resourceUrlsAndBlobsArr.reduce(
+      ({resourceUrls: allResourceUrls, blobsObj: allBlobsObj}, {resourceUrls, blobsObj}) => ({
+        resourceUrls: uniq_1(allResourceUrls.concat(resourceUrls)),
+        blobsObj: Object.assign(allBlobsObj, blobsObj),
+      }),
+      {resourceUrls: [], blobsObj: {}},
+    );
+  }
+
+  var aggregateResourceUrlsAndBlobs_1 = aggregateResourceUrlsAndBlobs;
+
+  function makeGetResourceUrlsAndBlobs({processResource, aggregateResourceUrlsAndBlobs}) {
+    return function getResourceUrlsAndBlobs(doc, baseUrl, urls) {
+      return Promise.all(
+        urls.map(url => processResource(url, doc, baseUrl, getResourceUrlsAndBlobs.bind(null, doc))),
+      ).then(resourceUrlsAndBlobsArr => aggregateResourceUrlsAndBlobs(resourceUrlsAndBlobsArr));
+    };
+  }
+
+  var getResourceUrlsAndBlobs = makeGetResourceUrlsAndBlobs;
+
+  function filterInlineUrl(absoluteUrl) {
+    return /^(blob|https?):/.test(absoluteUrl);
+  }
+
+  var filterInlineUrl_1 = filterInlineUrl;
+
+  function absolutizeUrl(url, absoluteUrl) {
+    return new URL(url, absoluteUrl).href;
+  }
+
+  var absolutizeUrl_1 = absolutizeUrl;
+
+  function makeProcessResource({
+    fetchUrl,
+    findStyleSheetByUrl,
+    extractResourcesFromStyleSheet,
+    isSameOrigin,
+    cache = {},
+  }) {
+    return function processResource(absoluteUrl, doc, baseUrl, getResourceUrlsAndBlobs) {
+      return cache[absoluteUrl] || (cache[absoluteUrl] = doProcessResource(absoluteUrl));
+
+      function doProcessResource(url) {
+        return fetchUrl(url)
+          .catch(e => {
+            if (probablyCORS(e, url)) {
+              return {probablyCORS: true, url};
+            } else {
+              throw e;
+            }
+          })
+          .then(({url, type, value, probablyCORS}) => {
+            if (probablyCORS) {
+              return {resourceUrls: [url]};
+            }
+            const result = {blobsObj: {[url]: {type, value}}};
+            if (/text\/css/.test(type)) {
+              const styleSheet = findStyleSheetByUrl(url, doc);
+              if (!styleSheet) {
+                return result;
+              }
+              const resourceUrls = extractResourcesFromStyleSheet(styleSheet, doc.defaultView)
+                .map(resourceUrl => absolutizeUrl_1(resourceUrl, url.replace(/^blob:/, '')))
+                .filter(filterInlineUrl_1);
+              return getResourceUrlsAndBlobs(baseUrl, resourceUrls).then(
+                ({resourceUrls, blobsObj}) => ({
+                  resourceUrls,
+                  blobsObj: Object.assign(blobsObj, {[url]: {type, value}}),
+                }),
+              );
+            } else {
+              return result;
+            }
+          })
+          .catch(err => {
+            console.log('[dom-snapshot] error while fetching', url, err);
+            return {};
+          });
+      }
+
+      function probablyCORS(err, url) {
+        const msgCORS = err.message && err.message.includes('Failed to fetch');
+        const nameCORS = err.name && err.name.includes('TypeError');
+        return msgCORS && nameCORS && !isSameOrigin(url, baseUrl);
+      }
+    };
+  }
+
+  var processResource = makeProcessResource;
+
+  /* global window */
+
+  function fetchUrl(url, fetch = window.fetch) {
+    return fetch(url, {cache: 'force-cache', credentials: 'same-origin'}).then(resp =>
+      resp.arrayBuffer().then(buff => ({
+        url,
+        type: resp.headers.get('Content-Type'),
+        value: buff,
+      })),
+    );
+  }
+
+  var fetchUrl_1 = fetchUrl;
+
+  function makeFindStyleSheetByUrl({styleSheetCache}) {
+    return function findStyleSheetByUrl(url, doc) {
+      return styleSheetCache[url] || [...doc.styleSheets].find(styleSheet => styleSheet.href === url);
+    };
+  }
+
+  var findStyleSheetByUrl = makeFindStyleSheetByUrl;
+
+  function getUrlFromCssText(cssText) {
+    const re = /url\((?!['"]?:)['"]?([^'")]*)['"]?\)/g;
+    const ret = [];
+    let result;
+    while ((result = re.exec(cssText)) !== null) {
+      ret.push(result[1]);
+    }
+    return ret;
+  }
+
+  var getUrlFromCssText_1 = getUrlFromCssText;
+
+  // NOTE this code is very similar to the node part of visual-grid-client, but there is a different related to the browser's cssom with import rules
+  function makeExtractResourcesFromStyleSheet({styleSheetCache}) {
+    return function extractResourcesFromStyleSheet(styleSheet, win = window) {
+      return uniq_1(
+        [...(styleSheet.cssRules || [])].reduce((acc, rule) => {
+          if (rule instanceof win.CSSImportRule) {
+            styleSheetCache[rule.styleSheet.href] = rule.styleSheet;
+            return acc.concat(rule.href);
+          } else if (rule instanceof win.CSSFontFaceRule) {
+            return acc.concat(getUrlFromCssText_1(rule.style.getPropertyValue('src')));
+          } else if (rule instanceof win.CSSSupportsRule || rule instanceof win.CSSMediaRule) {
+            return acc.concat(extractResourcesFromStyleSheet(rule));
+          } else if (rule instanceof win.CSSStyleRule) {
+            for (let i = 0, ii = rule.style.length; i < ii; i++) {
+              const urls = getUrlFromCssText_1(rule.style.getPropertyValue(rule.style[i]));
+              urls.length && (acc = acc.concat(urls));
+            }
+          }
+          return acc;
+        }, []),
+      );
+    };
+  }
+
+  var extractResourcesFromStyleSheet = makeExtractResourcesFromStyleSheet;
+
+  function extractResourceUrlsFromStyleAttrs(cdt) {
+    return cdt.reduce((acc, node) => {
+      if (node.nodeType === 1) {
+        const styleAttr =
+          node.attributes && node.attributes.find(attr => attr.name.toUpperCase() === 'STYLE');
+
+        if (styleAttr) acc = acc.concat(getUrlFromCssText_1(styleAttr.value));
+      }
+      return acc;
+    }, []);
+  }
+
+  var extractResourceUrlsFromStyleAttrs_1 = extractResourceUrlsFromStyleAttrs;
+
+  function makeExtractResourceUrlsFromStyleTags(extractResourcesFromStyleSheet) {
+    return function extractResourceUrlsFromStyleTags(doc) {
+      return uniq_1(
+        [...doc.getElementsByTagName('style')].reduce((resourceUrls, styleEl) => {
+          const styleSheet = [...doc.styleSheets].find(
+            styleSheet => styleSheet.ownerNode === styleEl,
+          );
+          return resourceUrls.concat(extractResourcesFromStyleSheet(styleSheet, doc.defaultView));
+        }, []),
+      );
+    };
+  }
+
+  var extractResourceUrlsFromStyleTags = makeExtractResourceUrlsFromStyleTags;
+
+  function isSameOrigin(url, baseUrl) {
+    const blobOrData = /^(blob|data):/;
+    if (blobOrData.test(url)) return true;
+    if (blobOrData.test(baseUrl)) return false;
+
+    const {origin} = new URL(url, baseUrl);
+    const {origin: baseOrigin} = new URL(baseUrl);
+    return origin === baseOrigin;
+  }
+
+  var isSameOrigin_1 = isSameOrigin;
+
+  function processPage(doc = document) {
+    const styleSheetCache = {};
+    const extractResourcesFromStyleSheet$$1 = extractResourcesFromStyleSheet({styleSheetCache});
+    const findStyleSheetByUrl$$1 = findStyleSheetByUrl({styleSheetCache});
+    const processResource$$1 = processResource({
+      fetchUrl: fetchUrl_1,
+      findStyleSheetByUrl: findStyleSheetByUrl$$1,
+      extractResourcesFromStyleSheet: extractResourcesFromStyleSheet$$1,
+      absolutizeUrl: absolutizeUrl_1,
+      isSameOrigin: isSameOrigin_1,
+    });
+
+    const getResourceUrlsAndBlobs$$1 = getResourceUrlsAndBlobs({
+      processResource: processResource$$1,
+      aggregateResourceUrlsAndBlobs: aggregateResourceUrlsAndBlobs_1,
+    });
+
+    const extractResourceUrlsFromStyleTags$$1 = extractResourceUrlsFromStyleTags(
+      extractResourcesFromStyleSheet$$1,
+    );
+
+    return doProcessPage(doc);
+
+    function doProcessPage(doc) {
+      const frameElement = doc.defaultView && doc.defaultView.frameElement;
+      const url = frameElement ? frameElement.src : doc.location.href;
+
+      const cdt = domNodesToCdt_1(doc);
+
+      const links = uniq_1(
+        extractLinks_1(doc)
+          .concat(extractResourceUrlsFromStyleAttrs_1(cdt))
+          .concat(extractResourceUrlsFromStyleTags$$1(doc)),
+      )
+        .map(absolutizeThisUrl)
+        .filter(filterInlineUrlsIfExisting);
+
+      const resourceUrlsAndBlobsPromise = getResourceUrlsAndBlobs$$1(doc, url, links);
+
+      const frameDocs = extractFrames_1(doc);
+      const processFramesPromise = frameDocs.map(doProcessPage);
+
+      return Promise.all([resourceUrlsAndBlobsPromise, ...processFramesPromise]).then(
+        ([{resourceUrls, blobsObj}, ...framesResults]) => ({
+          cdt,
+          url,
+          resourceUrls,
+          blobs: blobsObjToArray(blobsObj),
+          frames: framesResults,
+          srcAttr: frameElement ? frameElement.getAttribute('src') : undefined,
+        }),
+      );
+
+      function absolutizeThisUrl(someUrl) {
+        try {
+          return absolutizeUrl_1(someUrl, url);
+        } catch (err) {
+          // can't do anything with a non-absolute url
+        }
+      }
+    }
+  }
+
+  function blobsObjToArray(blobsObj) {
+    return Object.keys(blobsObj).map(blobUrl =>
+      Object.assign(
+        {
+          url: blobUrl.replace(/^blob:/, ''),
+        },
+        blobsObj[blobUrl],
+      ),
+    );
+  }
+
+  function filterInlineUrlsIfExisting(absoluteUrl) {
+    return absoluteUrl && filterInlineUrl_1(absoluteUrl);
+  }
+
+  var processPage_1 = processPage;
+
+  function processPageAndSerialize(doc) {
+    return processPage_1(doc).then(serializeFrame);
+  }
+
+  function serializeFrame(frame) {
+    frame.blobs = frame.blobs.map(({url, type, value}) => ({
+      url,
+      type,
+      value: arrayBufferToBase64_1(value),
+    }));
+    frame.frames.forEach(serializeFrame);
+    return frame;
+  }
+
+  var processPageAndSerialize_1 = processPageAndSerialize;
+
+  const EYES_NAME_SPACE = '__EYES__APPLITOOLS__';
+
+  function processPageAndPoll(doc) {
+    if (!window[EYES_NAME_SPACE]) {
+      window[EYES_NAME_SPACE] = {};
+    }
+    if (!window[EYES_NAME_SPACE].processPageAndSerializeResult) {
+      window[EYES_NAME_SPACE].processPageAndSerializeResult = {
+        status: 'WIP',
+        value: null,
+        error: null,
+      };
+      processPageAndSerialize_1(doc)
+        .then(r => ((resultObject.status = 'SUCCESS'), (resultObject.value = r)))
+        .catch(e => ((resultObject.status = 'ERROR'), (resultObject.error = e.message)));
+    }
+
+    const resultObject = window[EYES_NAME_SPACE].processPageAndSerializeResult;
+    if (resultObject.status === 'SUCCESS') {
+      window[EYES_NAME_SPACE].processPageAndSerializeResult = null;
+    }
+
+    return JSON.stringify(resultObject);
+  }
+
+  var processPageAndPoll_1 = processPageAndPoll;
+
+  return processPageAndPoll_1;
+
+}());
+
+  return processPageAndPoll.apply(this, arguments);
+}
+END
+    end
+  end
+end

data/lib/applitools/selenium/visual_grid/render_task.rb

@@ -12,9 +12,9 @@ module Applitools
                     :rendering_info, :request_resources, :dom_url_mod, :result, :region_selectors, :size_mode,
                     :region_to_check, :script_hooks
 
-      def initialize(name, script, running_test, resource_cache, put_cache, rendering_info, server_connector, region_selectors, size_mode, region, script_hooks, mod = nil)
+      def initialize(name, script_result, running_test, resource_cache, put_cache, rendering_info, server_connector, region_selectors, size_mode, region, script_hooks, mod = nil)
         self.result = nil
-        self.script = script
+        self.script = script_result
         self.running_test = running_test
         self.resource_cache = resource_cache
         self.put_cache = put_cache
@@ -121,7 +121,8 @@ module Applitools
       end
 
       def script_data
-        @script_data ||= Oj.load script
+        # @script_data ||= Oj.load script
+        @script_data ||= script
       end
 
       def prepare_data_for_rg(data)

data/lib/applitools/selenium/visual_grid/running_test.rb

@@ -153,10 +153,10 @@ module Applitools
         watch_open[open_task] = false
       end
 
-      def check(tag, target, script_result, visual_grid_manager, region_selectors, size_mod, region_to_check, mod = nil)
+      def check(tag, target, result, visual_grid_manager, region_selectors, size_mod, region_to_check, mod = nil)
         render_task = RenderTask.new(
           "Render #{eyes.config.short_description} - #{tag}",
-          script_result,
+          result,
           self,
           visual_grid_manager.resource_cache,
           visual_grid_manager.put_cache,

data/lib/applitools/selenium/visual_grid/visual_grid_eyes.rb

@@ -2,6 +2,7 @@ require 'applitools/selenium/configuration'
 module Applitools
   module Selenium
     class VisualGridEyes
+      DOM_EXTRACTION_TIMEOUT = 300 #seconds or 5 minutes
       extend Forwardable
 
       def_delegators 'Applitools::EyesLogger', :logger, :log_handler, :log_handler=
@@ -81,16 +82,35 @@ module Applitools
         script = <<-END
           var callback = arguments[arguments.length - 1]; return (#{Applitools::Selenium::Scripts::PROCESS_RESOURCES})().then(JSON.stringify).then(callback, function(err) {callback(err.stack || err.toString())});
         END
+        script = <<-END
+          #{Applitools::Selenium::Scripts::PROCESS_PAGE_AND_POLL} return __processPageAndPoll();
+        END
         begin
           sleep wait_before_screenshots
 
-          script_result = driver.execute_async_script(script).freeze
+          # script_result = driver.execute_async_script(script).freeze
+
+          dom_snapshot_start_time = Time.now()
+          result = {}
+          script_result = nil
+          loop do
+            script_result = driver.execute_script(script)
+            begin
+              result = Oj.load(script_result)
+              break if result['status'] == 'SUCCESS'
+              dom_snapshot_time = Time.now - dom_snapshot_start_time
+              raise Applitools::EyesError, 'Timeout error while getting dom snapshot!' if dom_snapshot_time > DOM_EXTRACTION_TIMEOUT
+            rescue Oj::ParseError => e
+              Applitools::EyesLogger.warn e.message
+            end
+          end
+
           mod = Digest::SHA2.hexdigest(script_result)
 
           region_x_paths = get_regions_x_paths(target)
 
           test_list.each do |t|
-            t.check(tag, target, script_result.dup, visual_grid_manager, region_x_paths, size_mod, region_to_check, mod)
+            t.check(tag, target, result['value'].dup, visual_grid_manager, region_x_paths, size_mod, region_to_check, mod)
           end
           test_list.each { |t| t.becomes_not_rendered}
         rescue StandardError => e

data/lib/applitools/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eyes_selenium
 version: !ruby/object:Gem::Version
-  version: 3.15.16
+  version: 3.15.17
 platform: ruby
 authors:
 - Applitools Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-24 00:00:00.000000000 Z
+date: 2019-05-29 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.15.16
+        version: 3.15.17
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.15.16
+        version: 3.15.17
 - !ruby/object:Gem::Dependency
   name: selenium-webdriver
   requirement: !ruby/object:Gem::Requirement
@@ -109,6 +109,7 @@ files:
 - lib/applitools/selenium/rgrid_dom.rb
 - lib/applitools/selenium/sauce/driver.rb
 - lib/applitools/selenium/scripts/get_element_xpath.rb
+- lib/applitools/selenium/scripts/process_page_and_poll.rb
 - lib/applitools/selenium/scripts/process_page_and_serialize.rb
 - lib/applitools/selenium/scroll_position_provider.rb
 - lib/applitools/selenium/selenium_eyes.rb