@testim/testim-cli 3.210.0 → 3.214.0

package/agent/routers/codim/service.js

@@ -36,30 +36,45 @@ async function getLocalLocators() {
 
 async function findTests(folder = process.cwd()) {
     const testFolder = await findTestFolder(folder);
-    // note - withFileTypes requires Node 10.x so we make this in two calls.
-    const filesWithoutStat = await fs.readdirAsync(testFolder);
-    const filesWithStat = await Promise.all(filesWithoutStat.map(name => Promise.props({ stat: fs.statAsync(name).catch(e => {}), name })));
+    const filesWithStat = await fs.promises.readdir(testFolder, { withFileTypes: true });
 
     // things we know are not tests but end in js
     const excluded = ['webpack.config.js', 'tsconfig.js', '.DS_Store', 'functions.js'];
     const excludedFileTypes = ['.html', '.json'];
-    return filesWithStat.filter(x => !excluded.includes(x.name))
-        .filter(x => !excludedFileTypes.some(type => x.name.endsWith(type)))
-        .filter(x => x.stat && x.stat.isFile())
-        .filter(x => !x.name.startsWith('.'))
+    return filesWithStat
+        .filter(x =>
+            !excluded.includes(x.name) &&
+            !excludedFileTypes.some(type => x.name.endsWith(type)) &&
+            x.isFile() &&
+            !x.name.startsWith('.'),
+        )
         .map(x => x.name);
 }
 
+/**
+ * @param {Record<string, object | Promise<object>>} propsObject
+ * @returns {Promise<Record<string, object>>}
+ * */
+async function promiseFromProps(propsObject) {
+    const entries = Object.entries(propsObject);
+    const values = entries.map(([, value]) => value);
+    const resolvedValues = await Promise.all(values);
+    for (let i = 0; i < resolvedValues.length; i++) {
+        entries[i][1] = resolvedValues[i];
+    }
+    return Object.fromEntries(entries);
+}
+
 async function getLocalLocatorContents(locators, full = false, originFolder = process.cwd()) {
     const props = {};
     if (full) {
         const folder = await findTestFolder(originFolder);
         for (const key of Object.values(locators)) {
-            props[key] = fs.readFileAsync(path.join(folder, 'locators', `locator.${key}.json`)).then(JSON.parse);
+            props[key] = fs.promises.readFile(path.join(folder, 'locators', `locator.${key}.json`)).then(JSON.parse);
         }
     }
     try {
-        const contents = await Promise.props(props);
+        const contents = await promiseFromProps(props);
         return contents;
     } catch (e) {
         console.error(e);

package/commons/httpRequest.js

@@ -32,6 +32,11 @@ function getProxy() {
     return global.proxyUri;
 }
 
+const logErrorAndRethrow = (logMsg, data) => err => {
+    logger.error(logMsg, { ...data, error: err });
+    throw err;
+};
+
 function deleteMethod(url, headers, timeout) {
     return deleteFullRes(url, headers, timeout)
         .then(res => {
@@ -40,7 +45,7 @@ function deleteMethod(url, headers, timeout) {
             }
             return res.body;
         })
-        .tapCatch((err) => logger.error('failed to delete request', { url, error: { message: err.message, stack: err.stack } }));
+        .catch(logErrorAndRethrow('failed to delete request', { url }));
 }
 
 function deleteFullRes(url, headers = {}, timeout = DEFAULT_REQUEST_TIMEOUT) {
@@ -70,7 +75,7 @@ function post({
             }
             return res.body;
         })
-        .tapCatch((err) => logger.error('failed to post request', { url, error: { message: err.message, stack: err.stack } }));
+        .catch(logErrorAndRethrow('failed to post request', { url }));
 }
 
 function postFullRes(url, body, headers = {}, timeout = DEFAULT_REQUEST_TIMEOUT, retry) {
@@ -128,7 +133,7 @@ function postForm(url, fields, files, headers = {}, timeout = DEFAULT_REQUEST_TI
             }
             return res.body;
         })
-        .tapCatch((err) => logger.error('failed to post request', { url, error: { message: err.message, stack: err.stack } }));
+        .catch(logErrorAndRethrow('failed to post request', { url }));
 }
 
 function _get(url, query, headers = {}, timeout = DEFAULT_REQUEST_TIMEOUT, { isBinary = false, skipProxy = false } = {}) {
@@ -156,13 +161,16 @@ function _get(url, query, headers = {}, timeout = DEFAULT_REQUEST_TIMEOUT, { isB
 function getText(url, query, headers) {
     return _get(url, query, headers)
         .then((res) => res.text)
-        .tapCatch((err) => logger.error('failed to getText request', { url, query, error: { message: err.message, stack: err.stack } }));
+        .catch(logErrorAndRethrow('failed to getText request', { url, query }));
 }
 
 function get(url, query, headers, timeout, options) {
     return _get(url, query, headers, timeout, options)
         .then((res) => res.body)
-        .tapCatch((err) => logger.warn('failed to get request', { url, query, error: { message: err.message, stack: err.stack } }));
+        .catch(err => {
+            logger.warn('failed to get request', { url, query, error: err });
+            throw err;
+        });
 }
 
 function getFullRes(url, query, headers, timeout) {
@@ -183,7 +191,7 @@ function head(url) {
     }
 
     return Promise.fromCallback((callback) => request.end(callback))
-        .tapCatch((err) => logger.error('failed to head request', { url, error: { message: err.message, stack: err.stack } }));
+        .catch(logErrorAndRethrow('failed to head request', { url }));
 }
 
 function put(url, body, headers = {}, timeout = DEFAULT_REQUEST_TIMEOUT) {
@@ -203,7 +211,7 @@ function put(url, body, headers = {}, timeout = DEFAULT_REQUEST_TIMEOUT) {
 
     return Promise.fromCallback((callback) => request.end(callback))
         .then((res) => res.body)
-        .tapCatch((err) => logger.error('failed to put request', { url, error: { message: err.message, stack: err.stack } }));
+        .catch(logErrorAndRethrow('failed to put request', { url }));
 }
 
 function download(url) {
@@ -224,8 +232,11 @@ function download(url) {
     }
 
     return Promise.fromCallback((callback) => request.end(callback))
-        .tap(() => logger.info('finished to download', { url }))
-        .tapCatch((err) => logger.error('failed to download', { error: { message: err.message, stack: err.stack } }));
+        .then(response => {
+            logger.info('finished to download', { url });
+            return response;
+        })
+        .catch(logErrorAndRethrow('failed to download', { url }));
 }
 
 module.exports = {
@@ -241,4 +252,5 @@ module.exports = {
     head: wrapWithMonitoring(head),
     download: wrapWithMonitoring(download),
     isNetworkHealthy: wrapWithMonitoring.isNetworkHealthy,
+    didNetworkConnectivityTestFail: wrapWithMonitoring.didNetworkConnectivityTestFail,
 };

package/commons/httpRequestCounters.js

@@ -1,7 +1,36 @@
 'use strit';
 
 const { sum } = require('lodash');
-const { method } = require('bluebird');
+const Bluebird = require('bluebird');
+const dns = require('dns');
+const _ = require('lodash');
+const config = require('./config');
+
+const logger = require('./logger').getLogger('http-request-counters');
+
+let networkConnectivityTestFailed = false;
+
+/** Tests network connectivity with DNS resolution (a basic test for a 7 later stack parallel but essential to most HTTP requests) */
+const testNetworkConnectivity = async () => {
+    if (config.IS_ON_PREM) {
+        return true;
+    }
+    const hostnames = ['www.google.com', 'www.facebook.com', 'www.microsoft.com', 'testim.io'];
+    try {
+        // If any of these domains resolve we consider the connectivity to be ok
+        const result = Boolean(await Bluebird.any(hostnames.map(host => dns.promises.lookup(host))));
+        if (!result) {
+            networkConnectivityTestFailed = true;
+        }
+        return result;
+    } catch (e) {
+        logger.error('network connectivity test failed');
+        networkConnectivityTestFailed = true;
+        return false;
+    }
+};
+const throttledTestNetworkConnectivity = _.throttle(testNetworkConnectivity, 10 * 1000);
+
 // we remove entries after 15 minutes, note that this isn't accurate because
 // we remove the "fail"/"success" 10 minutes after we add them (and not the "call")
 // this is fine since these values are an estimation and not an accurate representation
@@ -24,7 +53,7 @@ module.exports.makeCounters = () => {
         }, ttl);
     }
     function wrapWithMonitoring(fn, name = fn.name) {
-        return method(async function (...args) {
+        return Bluebird.method(async function (...args) {
             update(counters.call, name);
             try {
                 const result = await fn.call(this, ...args);
@@ -32,24 +61,26 @@ module.exports.makeCounters = () => {
                 return result;
             } catch (e) {
                 update(counters.fail, name);
+                if (!networkConnectivityTestFailed) {
+                    throttledTestNetworkConnectivity();
+                }
                 throw e;
             }
         });
     }
-    wrapWithMonitoring.isNetworkHealthy = function isNetworkHealthy() {
+    wrapWithMonitoring.isNetworkHealthy = async function isNetworkHealthy() {
+        if (networkConnectivityTestFailed || !(await testNetworkConnectivity())) {
+            return false;
+        }
         const allFailed = sum([...counters.fail.values()]);
-        const allSuccess = sum([...counters.success.values()]);
         const allCalls = sum([...counters.call.values()]);
         // we declare a test unhealthy network wise if
-        // 1. more than 10 requests failed and there are fewer than 100 requests
-        // 2. more than 10% of requests (out of finished requests) failed
+        // 10% or more of requests (out of finished requests) failed
         // note that the network can be unhealthy but the test would still pass
-        if (allCalls < 100) {
-            return allFailed < 10;
-        }
-        return (allSuccess + allFailed) > allFailed * 10;
+        return allFailed < allCalls * 0.1;
     };
     wrapWithMonitoring.counters = counters; // expose the counters used to the outside
     wrapWithMonitoring.isNetworkHealthy.counters = wrapWithMonitoring.counters;
+    wrapWithMonitoring.didNetworkConnectivityTestFail = () => networkConnectivityTestFailed;
     return wrapWithMonitoring;
 };

package/commons/httpRequestCounters.test.js

@@ -9,30 +9,30 @@ describe('the http request counters', () => {
     });
 
     it('Marks an always failing network as unhealthy', async () => {
-        const fn = runWithRetries(wrapWithMonitoring(() => { throw new Error('bad network'); }), 20, 1);
+        const fn = runWithRetries(wrapWithMonitoring(() => { throw new Error('bad network'); }), 30, 1);
         await rejects(fn);
-        strictEqual(wrapWithMonitoring.isNetworkHealthy(), false);
+        strictEqual(await wrapWithMonitoring.isNetworkHealthy(), false);
     });
 
     it('Marks an unstable network as unhealthy', async () => {
-        const fn = runWithRetries(wrapWithMonitoring(() => { throw new Error('bad network'); }), 20, 1);
+        const fn = runWithRetries(wrapWithMonitoring(() => { throw new Error('bad network'); }), 30, 1);
         const fn2 = runWithRetries(wrapWithMonitoring(() => 'hello'), 20, 1);
         await rejects(fn);
         await doesNotReject(fn2);
-        strictEqual(wrapWithMonitoring.isNetworkHealthy(), false);
+        strictEqual(await wrapWithMonitoring.isNetworkHealthy(), false);
     });
 
-    it('Marks a recovering network as healthy', async () => {
-        const fn = runWithRetries(wrapWithMonitoring(() => { throw new Error('bad network'); }), 20, 1);
+    it('Marks a trivial amount of failed requests as healthy', async () => {
+        const fn = runWithRetries(wrapWithMonitoring(() => { throw new Error('bad network'); }), 30, 1);
         await rejects(fn);
         const fn2 = wrapWithMonitoring(() => 'hello');
-        await Promise.all(Array(200).fill().map(fn2));
-        strictEqual(wrapWithMonitoring.isNetworkHealthy(), true);
+        await Promise.all(Array(290).fill().map(fn2));
+        strictEqual(await wrapWithMonitoring.isNetworkHealthy(), true);
     });
 
     it('Marks a healthy network as healthy', async () => {
         const fn2 = wrapWithMonitoring(() => 'hello');
         await Promise.all(Array(200).fill().map(fn2));
-        strictEqual(wrapWithMonitoring.isNetworkHealthy(), true);
+        strictEqual(await wrapWithMonitoring.isNetworkHealthy(), true);
     });
 });

package/npm-shrinkwrap.json

@@ -2337,9 +2337,9 @@
       "dev": true
     },
     "caniuse-lite": {
-      "version": "1.0.30001291",
-      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001291.tgz",
-      "integrity": "sha512-roMV5V0HNGgJ88s42eE70sstqGW/gwFndosYrikHthw98N5tLnOTxFqMLQjZVRxTWFlJ4rn+MsgXrR7MDPY4jA==",
+      "version": "1.0.30001294",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001294.tgz",
+      "integrity": "sha512-LiMlrs1nSKZ8qkNhpUf5KD0Al1KCBE3zaT7OLOwEkagXMEDij98SiOovn9wxVGQpklk9vVC/pUSqgYmkmKOS8g==",
       "dev": true
     },
     "caseless": {
@@ -2509,9 +2509,9 @@
       },
       "dependencies": {
         "@types/node": {
-          "version": "17.0.1",
-          "resolved": "https://registry.npmjs.org/@types/node/-/node-17.0.1.tgz",
-          "integrity": "sha512-NXKvBVUzIbs6ylBwmOwHFkZS2EXCcjnqr8ZCRNaXBkHAf+3mn/rPcJxwrzuc6movh8fxQAsUUfYklJ/EG+hZqQ=="
+          "version": "17.0.5",
+          "resolved": "https://registry.npmjs.org/@types/node/-/node-17.0.5.tgz",
+          "integrity": "sha512-w3mrvNXLeDYV1GKTZorGJQivK6XLCoGwpnyJFbJVK/aTBQUxOCaa/GlFAAN3OTDFcb7h5tiFG+YXCO2By+riZw=="
         },
         "mkdirp": {
           "version": "0.5.5",
@@ -3501,9 +3501,9 @@
       "integrity": "sha512-GJCAeDBKfREgkBtgrYSf9hQy9kTb3helv0zGdzqhM7iAkW8FA/ZF97VQDbwFiwIT8MQLLOe5VlPZOEvZAqtUAQ=="
     },
     "electron-to-chromium": {
-      "version": "1.4.24",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.24.tgz",
-      "integrity": "sha512-erwx5r69B/WFfFuF2jcNN0817BfDBdC4765kQ6WltOMuwsimlQo3JTEq0Cle+wpHralwdeX3OfAtw/mHxPK0Wg==",
+      "version": "1.4.29",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.29.tgz",
+      "integrity": "sha512-N2Jbwxo5Rum8G2YXeUxycs1sv4Qme/ry71HG73bv8BvZl+I/4JtRgK/En+ST/Wh/yF1fqvVCY4jZBgMxnhjtBA==",
       "dev": true
     },
     "emoji-regex": {
@@ -5860,9 +5860,9 @@
       },
       "dependencies": {
         "acorn": {
-          "version": "8.6.0",
-          "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.6.0.tgz",
-          "integrity": "sha512-U1riIR+lBSNi3IbxtaHOIKdH8sLFv3NYfNv8sg7ZsNhcfl4HF2++BfqqrNAxoCLQW1iiylOj76ecnaUxz+z9yw=="
+          "version": "8.7.0",
+          "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.7.0.tgz",
+          "integrity": "sha512-V/LGr1APy+PXIwKebEWrkZPwoeoF+w1jiOBUmuxuiUIaOHtob8Qc9BTrYo7VuI5fR8tqsy+buA2WFooR5olqvQ=="
         },
         "acorn-globals": {
           "version": "6.0.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testim/testim-cli",
-  "version": "3.210.0",
+  "version": "3.214.0",
   "description": "Command line interface for running Testing on your CI",
   "author": "Oren Rubin",
   "contributors": [{
@@ -115,7 +115,6 @@
     "testim": "cli.js"
   },
   "scripts": {
-    "postpublish": "scripts/publish-docker.js",
     "test": "IS_UNIT_TEST=1 ./node_modules/mocha/bin/_mocha --timeout 2000  --reporter spec --exit --recursive \"./src/**/*.test.js\" --exclude ./src/codim/template.js/tests/examples/**/*.test.js",
     "test:watch": "IS_UNIT_TEST=1 ./node_modules/mocha/bin/_mocha --timeout 2000 --exit --recursive \"./src/**/*.test.js\"  --exclude ./src/codim/template.js/tests/examples/**/*.test.js --watch",
     "test:cov": "nyc --reporter=lcov --reporter=text yarn test",

package/player/seleniumTestPlayer.js

@@ -4,7 +4,7 @@ const TabService = require('./services/tabService');
 const PortSelector = require('./services/portSelector');
 const windowCreationListener = require('./services/windowCreationListener');
 const CookieUtils = require('./utils/cookieUtils');
-const FrameLocator = require('./services/frameLocator');
+const frameLocatorFactory = require('./services/frameLocator');
 const Promise = require('bluebird');
 const { isDebuggerConnected } = require('../commons/detectDebugger');
 
@@ -45,12 +45,14 @@ class SeleniumTestPlayer {
 
         this.tabService.createSesion(id);
 
+        const FrameLocator = frameLocatorFactory(this.driver);
+
         this.sessionPlayer = new player(
             id,
             this.tabService,
             CookieUtils(this.driver),
             windowCreationListener,
-            FrameLocator(this.driver),
+            FrameLocator,
             PortSelector,
             null,
             null /* Not in use, placeholder for the order of arguments */,

package/player/services/frameLocator.js

@@ -8,123 +8,127 @@ const featureFlags = require('../../commons/featureFlags');
 const SELENIUM_ELEMENT_KEY = 'ELEMENT';
 const SELENIUM_GUID_KEY = 'element-6066-11e4-a52e-4f735466cecf';
 
-module.exports = function (driver) {
-    const FrameLocator = function (frameManager, locateElementPlayer) {
-        this.frameManager = frameManager;
-        this.locateElementPlayer = locateElementPlayer;
-        this._cache = {};
-    };
+const _getGuidFromSeleniumElement = (seleniumElement) => {
+    if (!seleniumElement) {
+        return null;
+    }
 
-    const _getGuidFromSeleniumElement = (seleniumElement) => {
-        if (!seleniumElement) {
-            return null;
-        }
+    return seleniumElement[SELENIUM_ELEMENT_KEY] || seleniumElement[SELENIUM_GUID_KEY];
+};
 
-        return seleniumElement[SELENIUM_ELEMENT_KEY] || seleniumElement[SELENIUM_GUID_KEY];
-    };
+/** @param {import('../webdriver')} driver*/
+module.exports = function frameLocatorFactory(driver) {
+    class FrameLocator {
+        constructor(frameManager, locateElementPlayer) {
+            this.frameManager = frameManager;
+            this.locateElementPlayer = locateElementPlayer;
+            this._cache = {};
+        }
 
-    FrameLocator.prototype.cacheResults = function (seleniumGuid, resultsUrl) {
-        this._cache[seleniumGuid] = resultsUrl;
-    };
+        cacheResults(seleniumGuid, resultsUrl) {
+            this._cache[seleniumGuid] = resultsUrl;
+        }
 
-    FrameLocator.prototype.getResultsFromCache = function (seleniumGuid) {
-        return this._cache[seleniumGuid];
-    };
+        getResultsFromCache(seleniumGuid) {
+            return this._cache[seleniumGuid];
+        }
 
-    FrameLocator.prototype.cacheFrameLocateResults = function (frameHandler) {
-        if (frameHandler && frameHandler.seleniumFrameElement && frameHandler.frameLocateResultUrl) {
-            const guid = _getGuidFromSeleniumElement(frameHandler.seleniumFrameElement);
-            if (guid) {
-                this.cacheResults(guid, frameHandler.frameLocateResultUrl);
+        cacheFrameLocateResults(frameHandler) {
+            if (frameHandler && frameHandler.seleniumFrameElement && frameHandler.frameLocateResultUrl) {
+                const guid = _getGuidFromSeleniumElement(frameHandler.seleniumFrameElement);
+                if (guid) {
+                    this.cacheResults(guid, frameHandler.frameLocateResultUrl);
+                }
             }
         }
-    };
 
-    FrameLocator.prototype.foundFrameCallback = function (result, frameTree, testimFrameId) {
-        const { frameOffset, locatedElement } = result;
-        if (locatorBuilderUtils.isEmptyResult(locatedElement)) {
-            logger.error('got empty result in frame result, not rejected from locate element player');
-            return Promise.reject();
+        foundFrameCallback(result, frameTree, testimFrameId) {
+            const { frameOffset, locatedElement } = result;
+            if (locatorBuilderUtils.isEmptyResult(locatedElement)) {
+                logger.error('got empty result in frame result, not rejected from locate element player');
+                return Promise.reject();
+            }
+            return driver.switchToLocatedFrame(locatedElement)
+                .then(el => {
+                    const guid = _getGuidFromSeleniumElement(el.value);
+                    const frameLocateResultUrl = this.getResultsFromCache(guid);
+
+                    return {
+                        frameId: -1,
+                        frameOffset,
+                        tabInfo: frameTree.tabInfo,
+                        tabId: frameTree.tabId,
+                        testimFrameId,
+                        testimFullFrameId: `${this.currentFrameHandler.testimFullFrameId}-${testimFrameId}`,
+                        seleniumFrameElement: el.value,
+                        frameLocateResultUrl,
+                    };
+                });
         }
-        return driver.switchToLocatedFrame(locatedElement)
-            .then(el => {
-                const guid = _getGuidFromSeleniumElement(el.value);
-                const frameLocateResultUrl = this.getResultsFromCache(guid);
 
-                return {
-                    frameId: -1,
-                    frameOffset,
-                    tabInfo: frameTree.tabInfo,
-                    tabId: frameTree.tabId,
-                    testimFrameId,
-                    testimFullFrameId: `${this.currentFrameHandler.testimFullFrameId}-${testimFrameId}`,
-                    seleniumFrameElement: el.value,
-                    frameLocateResultUrl,
-                };
-            });
-    };
+        locate(frameLocator, frameDepth, currentFrame, context, frameTree, stepData) {
+            // eslint-disable-next-line new-cap
+            const locateElementPlayer = new this.locateElementPlayer(context);
+            frameLocator.targetId = `frameLocator_${frameDepth}`;
+            return locateElementPlayer.locate(frameLocator, currentFrame, frameLocator.targetId)
+                .then(result => {
+                    result.isVisible = true; // frame visibility check is done on the target element
+                    return locateElementPlayer.handleLocateResult(result, stepData, frameLocator)
+                        .catch(() => { throw new Error(); }); // silence [object object] errors;
+                })
+                .then(result => {
+                    const { locatedElement } = context.data[frameLocator.targetId];
+                    return driver.getElementLocationWithPadding(locatedElement)
+                        .then(location => {
+                            const value = location.value || { top: 0, left: 0 };
+                            result.frameOffset = {
+                                top: currentFrame.frameOffset.top + value.top,
+                                left: currentFrame.frameOffset.left + value.left,
+                            };
+                            return result;
+                        });
+                })
+                .then(result => {
+                    if (locateElementPlayer.addFrameDataToContext) {
+                        locateElementPlayer.addFrameDataToContext(result.targetId, result.locateResult);
+                    }
+                    return this.foundFrameCallback(result, frameTree, frameLocator.testimFrameId);
+                })
+                .then(frameHandler => {
+                    this.currentFrameHandler = frameHandler;
+                    return frameHandler;
+                });
+        }
 
-    FrameLocator.prototype.locate = function (frameLocator, frameDepth, currentFrame, context, frameTree, stepData) {
-        // eslint-disable-next-line
-        var locateElementPlayer = new this.locateElementPlayer(context);
-        frameLocator.targetId = `frameLocator_${frameDepth}`;
-        return locateElementPlayer.locate(frameLocator, currentFrame, frameLocator.targetId)
-            .then(result => {
-                result.isVisible = true; // frame visibility check is done on the target element
-                return locateElementPlayer.handleLocateResult(result, stepData, frameLocator)
-                    .catch(() => { throw new Error(); }); // silence [object object] errors;
-            })
-            .then(result => {
-                const { locatedElement } = context.data[frameLocator.targetId];
-                return driver.getElementLocationWithPadding(locatedElement)
-                    .then(location => {
-                        const value = location.value || { top: 0, left: 0 };
-                        result.frameOffset = {
-                            top: currentFrame.frameOffset.top + value.top,
-                            left: currentFrame.frameOffset.left + value.left,
-                        };
-                        return result;
-                    });
-            })
-            .then(result => {
-                if (locateElementPlayer.addFrameDataToContext) {
-                    locateElementPlayer.addFrameDataToContext(result.targetId, result.locateResult);
+        findFrame(stepData, frameLocators, context, frameTree) {
+            const allowNoFrameSwitch = featureFlags.flags.enableFrameSwitchOptimization.isEnabled();
+            const chronologicalResults = context.playback.resultsHandler.resultsByChronologicOrder;
+            const lastResult = chronologicalResults[chronologicalResults.length - 1];
+            const allowedRetries = 1;
+            const moreThanAllowedRetries = Boolean(lastResult) && lastResult.stepId === stepData.id && lastResult.results.length > allowedRetries;
+            if (allowNoFrameSwitch && !moreThanAllowedRetries && this.currentFrameHandler) {
+                const currentFramePos = frameLocators.findIndex(x => x.testimFrameId === this.currentFrameHandler.testimFrameId);
+                if (currentFramePos > -1) {
+                    const shorterPath = frameLocators.slice(currentFramePos + 1);
+                    return Promise.reduce(shorterPath, (currentFrame, frameLocator, index) => this.locate(frameLocator, index, currentFrame, context, frameTree, stepData), this.currentFrameHandler);
                 }
-                return this.foundFrameCallback(result, frameTree, frameLocator.testimFrameId);
-            })
-            .tap(frameHandler => {
-                this.currentFrameHandler = frameHandler;
-            });
-    };
-
-    FrameLocator.prototype.findFrame = function (stepData, frameLocators, context, frameTree) {
-        const allowNoFrameSwitch = featureFlags.flags.enableFrameSwitchOptimization.isEnabled();
-        const chronologicalResults = context.playback.resultsHandler.resultsByChronologicOrder;
-        const lastResult = chronologicalResults[chronologicalResults.length - 1];
-        const allowedRetries = 1;
-        const moreThanAllowedRetries = Boolean(lastResult) && lastResult.stepId === stepData.id && lastResult.results.length > allowedRetries;
-        if (allowNoFrameSwitch && !moreThanAllowedRetries && this.currentFrameHandler) {
-            const currentFramePos = frameLocators.findIndex(x => x.testimFrameId === this.currentFrameHandler.testimFrameId);
-            if (currentFramePos > -1) {
-                const shorterPath = frameLocators.slice(currentFramePos + 1);
-                return Promise.reduce(shorterPath, (currentFrame, frameLocator, index) => this.locate(frameLocator, index, currentFrame, context, frameTree, stepData), this.currentFrameHandler);
             }
-        }
 
-        return frameTree.getTopFrameHandler()
-            .then(topFrameHandler => {
-                topFrameHandler.frameOffset = { top: 0, left: 0 };
-                const switchToTop = (allowNoFrameSwitch && this.currentFrameHandler === topFrameHandler) ?
-                    Promise.resolve(this.currentFrameHandler) :
-                    driver.switchToTopFrame();
-                return switchToTop.then(() => {
-                    this.cacheFrameLocateResults(this.currentFrameHandler);
-                    this.currentFrameHandler = topFrameHandler;
-                    return Promise.reduce(frameLocators, (currentFrame, frameLocator, index) =>
-                        this.locate(frameLocator, index, currentFrame, context, frameTree, stepData), topFrameHandler);
+            return frameTree.getTopFrameHandler()
+                .then(topFrameHandler => {
+                    topFrameHandler.frameOffset = { top: 0, left: 0 };
+                    const switchToTop = (allowNoFrameSwitch && this.currentFrameHandler === topFrameHandler) ?
+                        Promise.resolve(this.currentFrameHandler) :
+                        driver.switchToTopFrame();
+                    return switchToTop.then(() => {
+                        this.cacheFrameLocateResults(this.currentFrameHandler);
+                        this.currentFrameHandler = topFrameHandler;
+                        return Promise.reduce(frameLocators, (currentFrame, frameLocator, index) =>
+                            this.locate(frameLocator, index, currentFrame, context, frameTree, stepData), topFrameHandler);
+                    });
                 });
-            });
-    };
+        }
+    }
 
     return FrameLocator;
 };

package/player/services/tabService.js

@@ -350,14 +350,16 @@ class TabService {
                     mainTabPromise = this.driver.executeJS('return window.__isMainTestimTab').get('value');
                 }
 
-                return Promise.props({ title: this.driver.getTitle(), url: this.driver.getUrl(), isMainTab: mainTabPromise })
-                    .catch(err => {
+                return Promise.all([this.driver.getTitle(), this.driver.getUrl(), mainTabPromise]).then(
+                    ([title, url, isMainTab]) => ({ title, url, isMainTab }),
+                    err => {
                         logger.error('failed to get url or title', { err });
                         return {
                             title: '',
                             url: '',
                         };
-                    });
+                    },
+                );
             })
             .catch(err => {
                 logger.error('failed to switch to tab', { tabId, err });

package/player/stepActions/inputFileStepAction.js

@@ -34,7 +34,10 @@ class InputFileStepAction extends StepAction {
             top: '10px',
         };
         return this.forceInputToBeVisible(target, options)
-            .tapCatch(err => logger.error('failed to set input file in Safari recovery', { err }));
+            .catch(err => {
+                logger.error('failed to set input file in Safari recovery', { err });
+                throw err;
+            });
     }
 
     uploadFilesAndForceVisibility(gridLocalFiles, target) {

package/player/stepActions/pixelValidationStepAction.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const _ = require('lodash');
 const StepAction = require('./stepAction');
 const { eyeSdkService } = require('../utils/eyeSdkService');
 const logger = require('../../commons/logger').getLogger('pixel-validation-step-action');
@@ -9,6 +10,7 @@ class PixelValidationStepAction extends StepAction {
     async performAction() {
         const { shouldUseVisualGrid, applitoolsSdkConfig: config, testResultId } = this.context;
         this.runContext = this.context.getRunContext(undefined);
+        const finalParams = (this.runContext.incomingParams && this.runContext.incomingParams.final) || {};
         const batchId = (config.batch && config.batch.id) || testResultId;
         const eyeManager = await eyeSdkService.getManager(shouldUseVisualGrid, this.context.config.applitoolsConcurrency || 5, batchId, this.runContext.applitoolsIntegrationData);
         const targetElementData = this.getTarget() || {};
@@ -16,7 +18,12 @@ class PixelValidationStepAction extends StepAction {
         try {
             const openedEye = await eyeManager.openEyes({ driver: this.driver.client, config });
             const region = (this.step.action === 'element' && targetElementData.seleniumElement) || undefined;
-            await openedEye.check({ settings: { region, fully: this.step.action === 'stitched' } });
+            const settings = { region, fully: this.step.action === 'stitched' };
+            if (finalParams.applitoolsStepSettings && _.isPlainObject(finalParams.applitoolsStepSettings)) {
+                Object.assign(settings, finalParams.applitoolsStepSettings);
+                logger.info('Applitools SDK step executed with applitoolsStepSettings parameter', { applitoolsStepSettings: finalParams.applitoolsStepSettings });
+            }
+            await openedEye.check({ settings });
             const eyesResults = await openedEye.close();
 
             result = { isApplitoolsSdkResult: true, success: true, eyesResults };

package/player/utils/imageCaptureUtils.js

@@ -290,7 +290,7 @@ ImageCaptureUtils.prototype = {
         }
 
         return Promise.all([windowUtil.getFullPageSize(), windowUtil.getViewportSize()])
-            .spread((fullPageSize, viewPortSize) => createStitchImage(fullPageSize, viewPortSize));
+            .then(([fullPageSize, viewPortSize]) => createStitchImage(fullPageSize, viewPortSize));
     },
 };
 

package/player/utils/screenshotUtils.js

@@ -1,10 +1,10 @@
-"use strict";
+'use strict';
 
 const Promise = require('bluebird');
 const utils = require('../../utils');
 
 class ScreenshotUtils {
-    constructor(tabId, driver, options = { takeScreenshots: true}){
+    constructor(tabId, driver, options = { takeScreenshots: true }) {
         this.tabId = tabId;
         this.driver = driver;
         this.options = options;
@@ -30,12 +30,12 @@ class ScreenshotUtils {
         const devicePixelRatioPromise = this.currentDevicePixelRatio ? Promise.resolve(this.currentDevicePixelRatio) : this.getDevicePixelRatio();
         const getScreenshot = () => Promise.all([devicePixelRatioPromise, this.driver.takeScreenshot()]);
         return utils.runWithRetries(getScreenshot, MAX_RETRY_COUNT, SCREENSHOT_RETRY_DELAY)
-            .spread((devicePixelRatio, image) => {
+            .then(([devicePixelRatio, image]) => {
                 const base64 = image ? image.value : '';
-                const dataUrl = "data:image/png;base64," + this.base64AddPadding(base64.replace(/[\r\n]/g, ''));
+                const dataUrl = `data:image/png;base64,${this.base64AddPadding(base64.replace(/[\r\n]/g, ''))}`;
                 return {
                     image: dataUrl,
-                    devicePixelRatio: devicePixelRatio
+                    devicePixelRatio,
                 };
             });
     }
@@ -52,7 +52,7 @@ class ScreenshotUtils {
         return this.driver.executeJS(devicePixelRatioJS).then(result => Promise.resolve(result.value));
     }
 
-    forcePixelRatio(forceRatio = 1){
+    forcePixelRatio(forceRatio = 1) {
         this.currentDevicePixelRatio = forceRatio;
         return Promise.resolve();
     }

package/runners/ParallelWorkerManager.js

@@ -63,6 +63,7 @@ class ParallelWorkerManager {
             const source = options.source || 'cli';
             const user = options.user;
             const companyPlan = options.company && options.company.planType;
+            const isStartUp = options.company && options.company.isStartUp;
             const projectName = options.projectData && options.projectData.name;
             const lightweightMode = options.lightweightMode;
             const sessionType = utils.getSessionType(options);
@@ -82,6 +83,7 @@ class ParallelWorkerManager {
                     source,
                     user,
                     lightweightMode,
+                    isStartUp,
                 });
                 return testStatus.testStartAndReport(wid, executionId, resultId, isRerun, testRetryKey);
             };
@@ -146,6 +148,7 @@ class ParallelWorkerManager {
                     user,
                     lightweightMode,
                     logger,
+                    isStartUp,
                 });
                 if (stopOnError && !testResult.success) {
                     reject(new StopRunOnError());

package/services/analyticsService.js

@@ -31,7 +31,7 @@ function setLightweightAnalytics(properties, lightweightMode) {
 }
 
 function analyticsTestStart({
-    executionId, projectId, testId, resultId, companyId, companyName, projectName, companyPlan, sessionType, source, user, lightweightMode,
+    executionId, projectId, testId, resultId, companyId, companyName, projectName, companyPlan, sessionType, source, user, lightweightMode, isStartUp,
 }) {
     const properties = setLightweightAnalytics({
         executionId,
@@ -44,13 +44,14 @@ function analyticsTestStart({
         companyPlan,
         sessionType,
         source: calcSource(source, user),
+        isStartUp,
     }, lightweightMode);
     analytics.trackWithCIUser('test-run-ci', properties);
 }
 
 function analyticsTestEnd({
     executionId, projectId, testId, resultId, result, companyId, companyName, projectName, companyPlan, sessionType, source, user, lightweightMode,
-    logger,
+    logger, isStartUp,
 }) {
     try {
         const properties = setLightweightAnalytics({
@@ -65,6 +66,7 @@ function analyticsTestEnd({
             sessionType,
             mockNetworkEnabled: result.wasMockNetworkActivated,
             source: calcSource(source, user),
+            isStartUp,
         }, lightweightMode);
 
         if (result.success) {

package/testRunHandler.js

@@ -18,6 +18,8 @@ const { SeleniumPerfStats } = require('./commons/SeleniumPerfStats');
 const { preloadTests } = require('./commons/preloadTests');
 
 const RETRIES_ON_TIMEOUT = 3;
+const MAX_LIGHTWEIGHT_MODE_RUN_DATA_SIZE = 20 * 1000; // max size, in characters, of stringified run data sent over URL params. Chosen arbitrarily, this value should be changed according to data.
+const canSendRunDataOverUrl = (runData) => JSON.stringify(runData).length < MAX_LIGHTWEIGHT_MODE_RUN_DATA_SIZE;
 
 const TestRun = function (executionId, executionName, test, options, branchToUse, testRunStatus) {
     this._executionId = executionId;
@@ -175,7 +177,14 @@ TestRun.prototype.getRunRequestParams = async function () {
 
     if (this._options.lightweightMode && this._options.lightweightMode.general) {
         runRequestParams.company = this._options.company;
-        runRequestParams.runData = this.getRunData();
+        const runData = this.getRunData();
+        runRequestParams.lightweightMode.isRunDataSentInUrl = canSendRunDataOverUrl(runData);
+        if (runRequestParams.lightweightMode.isRunDataSentInUrl) {
+            runRequestParams.runData = runData;
+            logger.info(`Run data sent as URL param, test id: ${this.getTestId()} run data length: ${JSON.stringify(runData).length}`);
+        } else {
+            logger.warn(`Run data is too big to be sent as a URL param. Test id: ${this.getTestId()}, run data size: ${JSON.stringify(runData).length} (limit: ${MAX_LIGHTWEIGHT_MODE_RUN_DATA_SIZE} characters)`);
+        }
         runRequestParams.isLocalRun = Boolean(this._options.useLocalChromeDriver || this._options.useChromeLauncher);
     }
 
@@ -195,9 +204,11 @@ TestRun.prototype.getRunRequestParams = async function () {
     return runRequestParams;
 };
 
-TestRun.prototype.getRunTestUrl = function () {
-    return this.getRunRequestParams()
-        .then(runRequestParams => `https://run.testim.io/?params=${encodeURIComponent(JSON.stringify(runRequestParams))}`);
+TestRun.prototype.getRunTestUrl = async function () {
+    const runRequestParams = await this.getRunRequestParams();
+    const url = `https://run.testim.io/?params=${encodeURIComponent(JSON.stringify(runRequestParams))}`;
+    logger.info(`Test (${this.getTestId()}) run URL length: ${url.length}`);
+    return url;
 };
 
 TestRun.prototype.setSessionId = function (sessionId) {
@@ -240,7 +251,7 @@ TestRun.prototype.clearTestResult = function () {
     const mustClearPreviousStepResults = !this.isAllowReportTestResultRetries() && (this._timeoutRetryCount > 1 || this._retryCount > 1);
 
     if (this._options.lightweightMode && this._options.lightweightMode.disableResults &&
-        !mustClearPreviousStepResults) {
+            !mustClearPreviousStepResults && canSendRunDataOverUrl(runData)) {
         return Promise.resolve();
     }
 

package/workers/BaseWorker.js

@@ -8,7 +8,7 @@ const { timeoutMessages, testRunStatus, stepResult, runnerTestStatus } = require
 const logger = require('../commons/logger').getLogger('base-worker');
 const testResultService = require('../commons/socket/testResultService');
 const remoteStepService = require('../commons/socket/remoteStepService');
-const { isNetworkHealthy } = require('../commons/httpRequest');
+const { isNetworkHealthy, didNetworkConnectivityTestFail } = require('../commons/httpRequest');
 const testimServicesApi = require('../commons/testimServicesApi');
 const gridService = require('../services/gridService');
 const LambdatestService = require('../services/lambdatestService');
@@ -264,13 +264,14 @@ class BaseWorker {
                 return undefined;
             }
         };
+        const getNetworkErrorMessage = () => 'Due to network connectivity issues, Testim CLI has been unable to connect to the grid.\n' +
+                                             `Please make sure the CLI has stable access to the internet. ${didNetworkConnectivityTestFail() ? '(Internal: network connectivity test failed)' : ''}`;
 
-        const buildError = (err) => {
-            if (!isNetworkHealthy() && featureFlags.flags.errorMessageOnBadNetwork.isEnabled()) {
+        const buildError = (err, wasNetworkHealthy) => {
+            if (!wasNetworkHealthy && featureFlags.flags.errorMessageOnBadNetwork.isEnabled()) {
                 return {
                     errorType: NETWORK_ERROR,
-                    reason: 'Due to network connectivity issues, Testim CLI has been unable to connect to the grid.' +
-                        'Please make sure the CLI has stable access to the internet.',
+                    reason: getNetworkErrorMessage(),
                 };
             }
 
@@ -324,17 +325,16 @@ class BaseWorker {
         };
 
         const onRunError = async (err, testRunHandler) => {
-            if (!isNetworkHealthy() && featureFlags.flags.warnOnBadNetwork.isEnabled()) {
+            const wasNetworkHealthy = await isNetworkHealthy();
+            if (!wasNetworkHealthy && featureFlags.flags.warnOnBadNetwork.isEnabled()) {
                 // intentional, we want to log to stderr:
                 // eslint-disable-next-line no-console
-                console.warn('Due to network connectivity issues, Testim CLI has been unable to connect to the grid.');
-                // eslint-disable-next-line no-console
-                console.warn('Please make sure the CLI has stable access to the internet.');
+                console.warn(getNetworkErrorMessage());
             }
             logger.warn('error on run', { err });
 
             const projectId = this.userData && this.userData.projectId;
-            const { errorType, reason } = buildError(err);
+            const { errorType, reason } = buildError(err, wasNetworkHealthy);
             testimServicesApi.updateTestResult(projectId, this.testResultId, this.testId, {
                 status: testRunStatus.COMPLETED,
                 success: false,

package/workers/WorkerExtension.js

@@ -87,7 +87,10 @@ class WorkerExtension extends BaseWorker {
                 .then(url => {
                     reporter.onWaitToTestStart(this.id);
                     return Promise.all([
-                        driver.url(url).tap(() => { startStausDetails.driverUrlFinished = true; }).tapCatch(err => logger.error('error from driver.url', { err, testResultId, executionId, testId })),
+                        driver.url(url).tap(() => { startStausDetails.driverUrlFinished = true; }).catch(err => {
+                            logger.error('error from driver.url', { err, testResultId, executionId, testId, url, urlLength: url.length });
+                            throw err;
+                        }),
                         testRunHandler.onStarted(TEST_START_TIMEOUT_MS).tap(() => { startStausDetails.testRunHandlerStartedFinished = true; }),
                     ])
                         .timeout(TEST_START_TIMEOUT_MS, timeoutMessages.TEST_START_TIMEOUT_MSG)
@@ -107,14 +110,11 @@ class WorkerExtension extends BaseWorker {
                     };
                     driver.registerToClosedBrowser(onBrowserClosed);
                     return testRunHandler.onCompleted().timeout(this.testRunTimeout, timeoutMessages.TEST_COMPLETE_TIMEOUT_MSG)
-                        .tap(testResult => {
+                        .then(async testResult => {
                             driver.unregisterToClosedBrowser(onBrowserClosed);
                             if (this.lambdatestService.isLambdatestRun()) {
-                                return driver.executeJS(`lambda-status=${!testResult.success ? 'failed' : 'passed'}`).catch(() => {});
+                                await driver.executeJS(`lambda-status=${!testResult.success ? 'failed' : 'passed'}`).catch(() => { });
                             }
-                            return undefined;
-                        })
-                        .then(testResult => {
                             if (!driver.isAlive()) {
                                 logger.warn(`possible grid unresponsive for test ${this.testId}, result ${this.testResultId} (execution: ${this.executionId})`);
                                 testResult.gridIssues = 'could not validate grid is alive';

package/workers/WorkerSelenium.js

@@ -168,13 +168,10 @@ class WorkerSelenium extends BaseWorker {
                     }
                     throw err;
                 })
-                .tap(() => {
+                .then(async testResult => {
                     if (sessionPlayerInit.localAssetService) {
-                        return sessionPlayerInit.localAssetService.drain();
+                        await sessionPlayerInit.localAssetService.drain();
                     }
-                    return undefined;
-                })
-                .then(testResult => {
                     testResult.stepsResults = null;
                     testResult.resultId = this.testResultId;
                     if (!driver.isAlive()) {
@@ -187,13 +184,11 @@ class WorkerSelenium extends BaseWorker {
                         logger.warn(`possible browser keep alive issue ${this.testId}, result ${this.testResultId} (execution: ${this.executionId})`);
                         testResult.keepAliveIssue = maxKeepAliveGap;
                     }
-                    return { ...testResult, ...testRunHandler.seleniumPerfStats.getStats() };
-                })
-                .tap(testResult => {
+                    const resultWithStats = { ...testResult, ...testRunHandler.seleniumPerfStats.getStats() };
                     if (this.lambdatestService.isLambdatestRun()) {
-                        return driver.executeJS(`lambda-status=${!testResult.success ? 'failed' : 'passed'}`).catch(() => { });
+                        await driver.executeJS(`lambda-status=${!resultWithStats.success ? 'failed' : 'passed'}`).catch(() => { });
                     }
-                    return Promise.resolve();
+                    return resultWithStats;
                 });
         }
 

package/workers/workerUtils.js

@@ -1,19 +1,6 @@
 const Promise = require('bluebird');
-const utils = require('../utils');
 const gridService = require('../services/gridService');
 const logger = require('../commons/logger').getLogger('worker-utils');
-const { timeoutMessages } = require('../commons/constants');
-const { GetBrowserError, PageNotAvailableError } = require('../errors');
-
-const waitUntilBrowserTimeout = (err, startTime, interval, projectId, workerId, player, releaseSlotOnTestFinished) => {
-    logger.warn('failed getting browser from grid', { err });
-    return releasePlayer(workerId, releaseSlotOnTestFinished, projectId, player)
-        .then(() => {
-            const requestTime = Date.now() - startTime;
-            const timeDiff = interval - requestTime;
-            return Promise.delay(timeDiff).then(() => Promise.reject(err));
-        });
-};
 
 const releaseGridSlot = (workerId, releaseSlotOnTestFinished, projectId) => {
     if (!releaseSlotOnTestFinished) {
@@ -29,26 +16,3 @@ const releasePlayer = (workerId, releaseSlotOnTestFinished, projectId, player) =
 };
 
 module.exports.releasePlayer = releasePlayer;
-
-module.exports.getBrowserWithRetries = ({ getBrowserOnce, testPlayerFactory, releaseSlotOnTestFinished }, { totalTimeoutDuration, singleGetBrowserDuration, projectId, workerId, reporter }) => {
-    const maxGetBrowserAttempts = totalTimeoutDuration / singleGetBrowserDuration;
-    let failedAttempts = 0;
-
-    return utils.runWithRetries(() => {
-        const startTime = Date.now();
-        const player = testPlayerFactory();
-        return getBrowserOnce(player)
-            .then((getBrowserRes) => player || getBrowserRes)
-            .timeout(singleGetBrowserDuration, timeoutMessages.GET_BROWSER_TIMEOUT_MSG)
-            .tapCatch(() => reporter.onGetBrowserFailure(workerId, projectId, ++failedAttempts))
-            .tap(() => reporter.onGetBrowserSuccess(workerId, projectId))
-            .catch(err => waitUntilBrowserTimeout(err, startTime, singleGetBrowserDuration, projectId, workerId, player, releaseSlotOnTestFinished));
-    }, maxGetBrowserAttempts).catch(err => {
-        if (err instanceof PageNotAvailableError) {
-            throw err;
-        }
-        throw new GetBrowserError(err);
-    });
-};
-
-module.exports.isGetBrowserError = err => err && err.constructor && err.constructor.name === 'GetBrowserError';