@testim/testim-cli 3.213.0 → 3.217.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testim/testim-cli",
-  "version": "3.213.0",
+  "version": "3.217.0",
   "description": "Command line interface for running Testing on your CI",
   "author": "Oren Rubin",
   "contributors": [{
@@ -17,23 +17,22 @@
     "@types/node": "10.17.24",
     "@types/selenium-webdriver": "4.0.9",
     "bundle-deps": "1.0.0",
-    "chai": "4.2.0",
+    "chai": "4.3.4",
     "chai-as-promised": "7.1.1",
     "gulp": "4.0.2",
     "gulp-cli": "2.3.0",
     "gulp-json-editor": "2.5.4",
     "gulp-preprocess": "3.0.3",
-    "husky": "4.3.8",
     "merge-stream": "2.0.0",
-    "mocha": "7.2.0",
+    "mocha": "9.2.0",
     "nyc": "15.1.0",
     "proxyquire": "2.1.3",
-    "request": "2.88.2",
+    "request": "2.88.0",
     "sinon": "9.0.2",
-    "sinon-chai": "3.5.0",
-    "ts-node": "8.10.1",
-    "tsconfig-paths": "3.9.0",
-    "typescript": "3.9.3"
+    "sinon-chai": "3.7.0",
+    "ts-node": "9.1.1",
+    "tsconfig-paths": "3.12.0",
+    "typescript": "4.5.5"
   },
   "lazyDependencies": {
     "ngrok": "3.4.0",
@@ -51,15 +50,15 @@
     "@applitools/eyes-sdk-core": "12.23.12",
     "@applitools/visual-grid-client": "15.8.31",
     "@testim/coralogix-logger": "1.1.27-beta",
-    "@testim/webdriverio": "0.0.4",
+    "@testim/webdriverio": "0.0.5",
     "abort-controller": "3.0.0",
-    "ajv": "6.12.2",
+    "ajv": "6.12.6",
     "analytics-node": "5.0.0",
     "appium-dom-utils": "1.0.6",
     "archiver": "3.1.1",
     "bluebird": "3.7.2",
     "bluebird-retry": "0.11.0",
-    "body-parser": "1.19.0",
+    "body-parser": "1.19.1",
     "chalk": "4.1.0",
     "chrome-launcher": "0.13.4",
     "combine-source-map": "0.8.0",
@@ -86,7 +85,7 @@
     "mkdirp": "1.0.4",
     "moment": "2.25.3",
     "ms": "2.1.2",
-    "npm": "6.14.11",
+    "npm": "8.3.0",
     "object-hash": "2.0.3",
     "ora": "4.0.4",
     "pako": "1.0.11",
@@ -97,7 +96,7 @@
     "rox-node": "4.9.18",
     "semver": "7.3.2",
     "serialize-error": "7.0.1",
-    "socket.io-client": "2.4.0",
+    "socket.io-client": "4.4.1",
     "superagent": "3.8.3",
     "superagent-proxy": "3.0.0",
     "test-exclude": "6.0.0",
@@ -115,8 +114,8 @@
     "testim": "cli.js"
   },
   "scripts": {
-    "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": "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",
     "upload-bundle-s3": "scripts/upload.js",
     "prepare-version": "rm -rf ./deploy && mkdir -p deploy && gulp prepare-version-on-prem",
@@ -125,6 +124,6 @@
     "pack-serve": "yarn pack-onprem && http-server deploy/"
   },
   "engines": {
-    "node": ">= 10.0.0"
+    "node": ">= 12.0.0"
   }
 }

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

@@ -72,9 +72,9 @@ class TabService {
     }
 
     getAllTabInfoStrings(sessionId) {
-        var allIds = this.getAllTabIds(sessionId);
+        const allIds = this.getAllTabIds(sessionId);
         return allIds.map(tabId => {
-            var tabInfo = this.getTabInfo(sessionId, tabId);
+            const tabInfo = this.getTabInfo(sessionId, tabId);
             return `tabId=${tabId}, url=${tabInfo.url}, order=${tabInfo.order}, isMain=${tabInfo.isMain}, openerStepId=${tabInfo.openerStepId}, isClosed=${tabInfo.isClosed}, currentUrl: ${tabInfo.currentUrl}, lastUpdatedUrl: ${tabInfo.lastUpdatedUrl}`;
         });
     }
@@ -116,7 +116,7 @@ class TabService {
     buildTabInfo(sessionId, tabId, order, openerStepId, options = {}) {
         return this.getTabDetails(tabId, sessionId, options)
             .then(tab => {
-                var infoId = guid();
+                const infoId = guid();
 
                 function isMainTab(tabService) {
                     if (options.checkForMainTab) {
@@ -147,7 +147,7 @@ class TabService {
     addTab(sessionId, id, order, openerStepId, options = {}) {
         return this.buildTabInfo(sessionId, id, order, openerStepId, options)
             .then(infoId => {
-                var _windowUtils = new WindowUtils(id, this.driver);
+                const _windowUtils = new WindowUtils(id, this.driver);
                 this._utils[infoId] = {
                     attachDebugger: () => Promise.resolve(),
                     detachDebugger: () => Promise.resolve(),
@@ -191,15 +191,15 @@ class TabService {
             return this.getMainTabUtils(sessionId);
         }
 
-        var infos = this.getAllTabInfos(sessionId);
-        var nonMainTabs = Object.keys(infos)
+        const infos = this.getAllTabInfos(sessionId);
+        const nonMainTabs = Object.keys(infos)
             .map(tabId => infos[tabId])
             .filter(info => !info.isMain);
         if (nonMainTabs.length === 1) {
             return this._utils[nonMainTabs[0].infoId];
         }
 
-        var sameTabs = Object.keys(sessionId)
+        const sameTabs = Object.keys(sessionId)
             .map(key => sessionId[key])
             .filter(info => this.isSameTab(sessionId, tabInfo, info));
         if (sameTabs.length > 0) {
@@ -211,7 +211,7 @@ class TabService {
     }
 
     exactUrlMatch(first, second, allUrls) {
-        var exactUrlMatch = allUrls
+        const exactUrlMatch = allUrls
             .filter(url => url === second.url);
 
         if ((first.url === second.url || first.currentUrl === second.url || (first.currentUrl && (first.currentUrl === second.currentUrl))) && (exactUrlMatch.length === 1)) {
@@ -221,11 +221,11 @@ class TabService {
     }
 
     singleExactMatchForParts(first, second, allUrls, combinePartsFunction) {
-        var firstUrlParts = UrlUtils.urlBreaker(first.url || first.currentUrl);
-        var secondUrlParts = UrlUtils.urlBreaker(second.url || second.currentUrl);
-        var firstPartsCombined = combinePartsFunction(firstUrlParts);
-        var secondPartsCombined = combinePartsFunction(secondUrlParts);
-        var allDomainAndPathMatches = allUrls.map(url => UrlUtils.urlBreaker(url))
+        const firstUrlParts = UrlUtils.urlBreaker(first.url || first.currentUrl);
+        const secondUrlParts = UrlUtils.urlBreaker(second.url || second.currentUrl);
+        const firstPartsCombined = combinePartsFunction(firstUrlParts);
+        const secondPartsCombined = combinePartsFunction(secondUrlParts);
+        const allDomainAndPathMatches = allUrls.map(url => UrlUtils.urlBreaker(url))
             .map(urlParts => combinePartsFunction(urlParts))
             .filter(combinedParts => combinedParts === firstPartsCombined);
         if ((firstPartsCombined === secondPartsCombined) && (allDomainAndPathMatches.length === 1)) {
@@ -251,20 +251,20 @@ class TabService {
             return true;
         }
 
-        var infos = this.getAllTabInfos(sessionId);
-        var alltopFrameUrls = Object.keys(infos)
+        const infos = this.getAllTabInfos(sessionId);
+        const alltopFrameUrls = Object.keys(infos)
             .map(tabId => infos[tabId].url);
 
         if (this.exactUrlMatch(first, second, alltopFrameUrls)) {
             return true;
         }
 
-        var combineDomainAndPath = urlParts => (`${urlParts.domain}/${urlParts.path.join('/')}`);
+        const combineDomainAndPath = urlParts => (`${urlParts.domain}/${urlParts.path.join('/')}`);
         if (this.singleExactMatchForParts(first, second, alltopFrameUrls, combineDomainAndPath)) {
             return true;
         }
 
-        var combineDomainPathAndHash = urlParts => (`${urlParts.domain}/${urlParts.path.join('/')}#${urlParts.hash}`);
+        const combineDomainPathAndHash = urlParts => (`${urlParts.domain}/${urlParts.path.join('/')}#${urlParts.hash}`);
         if (this.singleExactMatchForParts(first, second, alltopFrameUrls, combineDomainPathAndHash)) {
             return true;
         }
@@ -277,14 +277,14 @@ class TabService {
     }
 
     getMainTabInfo(sessionId) {
-        var infos = this.getAllTabInfos(sessionId);
+        const infos = this.getAllTabInfos(sessionId);
         return Object.keys(infos)
             .map(id => infos[id])
             .find(tabInfo => tabInfo.isMain);
     }
 
     getMainTabUtils(sessionId) {
-        var mainTabInfo = this.getMainTabInfo(sessionId);
+        const mainTabInfo = this.getMainTabInfo(sessionId);
         if (!mainTabInfo) {
             return {};
         }
@@ -292,20 +292,20 @@ class TabService {
     }
 
     removeTabInfo(sessionId, tabId) {
-        var infos = this.getAllTabInfos(sessionId);
-        var info = infos[tabId];
+        const infos = this.getAllTabInfos(sessionId);
+        const info = infos[tabId];
         delete this.sessionTabs[sessionId].tabInfos[tabId];
         delete this._utils[info.infoId];
         this.sessionTabs[sessionId].tabCount--;
     }
 
     getMainTabId(sessionId) {
-        var infos = this.getAllTabInfos(sessionId);
+        const infos = this.getAllTabInfos(sessionId);
         return Object.keys(infos).find(id => infos[id].isMain);
     }
 
     isMainTabExists(sessionId) {
-        var mainTabId = this.getMainTabId(sessionId);
+        const mainTabId = this.getMainTabId(sessionId);
         if (!mainTabId) {
             return Promise.resolve(false);
         }
@@ -313,7 +313,7 @@ class TabService {
     }
 
     clearAllTabs(sessionId) {
-        var infos = this.getAllTabInfos(sessionId);
+        const infos = this.getAllTabInfos(sessionId);
 
         this.sessionTabs[sessionId].tabCount = 0;
         Object.keys(infos)
@@ -321,7 +321,7 @@ class TabService {
     }
 
     clearNonMainTabs(sessionId) {
-        var infos = this.getAllTabInfos(sessionId);
+        const infos = this.getAllTabInfos(sessionId);
         Object.keys(infos)
             .filter(tabId => !infos[tabId].isMain)
             .forEach(tabId => this.removeTabInfo(sessionId, tabId));
@@ -414,9 +414,9 @@ class TabService {
     }
 
     waitToPendingTabs(id, openerStepId) {
-        var retryInterval = 500;
-        var timeToWait = 3000;
-        var that = this;
+        const retryInterval = 500;
+        let timeToWait = 3000;
+        const that = this;
 
         if (!openerStepId) {
             return Promise.resolve();

package/player/utils/imageCaptureUtils.js

@@ -186,18 +186,27 @@ ImageCaptureUtils.prototype = {
     },
 
     takeAreaDataUrl(areas, format) {
+        // Future changes in clickim will pass parameters to this function as a single object
+        if (areas.areas) {
+            areas = areas.areas;
+        }
+
         return this.screenshotUtils.takeScreenshot(format)
             .then((imageInfo) => cropImageFromImageData(areas, imageInfo).then((result) => {
                 result.screenImage = imageInfo.image;
                 result.absoluteScreenHighlight = getElementAbsoluteRectangle(
                     areas.elementRect,
                     imageInfo.devicePixelRatio);
-
                 return Promise.resolve(result);
             }));
     },
 
     takeArea(areas) {
+        // Future changes in clickim will pass parameters to this function as a single object
+        if (areas.areas) {
+            areas = areas.areas;
+        }
+
         return this.screenshotUtils.takeScreenshot()
             .then((imageInfo) => {
                 const result = {};

package/player/utils/screenshotUtils.js

@@ -11,7 +11,7 @@ class ScreenshotUtils {
     }
 
     base64AddPadding(str) {
-        return str + Array((4 - str.length % 4) % 4 + 1).join('=');
+        return str + Array(((4 - (str.length % 4)) % 4) + 1).join('=');
     }
 
     shouldTakeScreenshots() {

package/runOptions.js

@@ -17,6 +17,7 @@ const utils = require('./utils');
 const runOptionsAgentFlow = require('./runOptionsAgentFlow');
 const runOptionsUtils = require('./runOptionsUtils');
 const localRunnerCache = require('./commons/runnerFileCache');
+const chalk = require('chalk');
 
 const camelizeHyphenValues = (prop) => prop.replace(/-([a-z])/g, (m, w) => w.toUpperCase());
 
@@ -109,6 +110,10 @@ const printUsage = () => {
         return line.includes('--exit-code-ignore-failing-tests');
     }
 
+    function isDeprecatedHighSpeed(line) {
+        return line.includes('--high-speed'); // high speed mode was renamed to turbo mode
+    }
+
     program.help((txt) => {
         const lines = txt.split('\n');
         return lines
@@ -123,12 +128,18 @@ const printUsage = () => {
                     !isUserId(ln) &&
                     !isWebdriverTimeout(ln) &&
                     !isSaveRCALocally(ln) &&
-                    !isExitCodeIgnoreFailingTests(ln)
+                    !isExitCodeIgnoreFailingTests(ln) &&
+                    !isDeprecatedHighSpeed(ln)
             )
             .join('\n');
     });
 };
 
+const printDeprecationWarning = (deprecatedUsage, newUsage) => {
+    const newUsageString = newUsage ? `Please use ${newUsage} instead.` : '';
+    console.log(chalk.yellow(`\nWARNING: ${deprecatedUsage} is deprecated. ${newUsageString}\n`));
+};
+
 const CODE_COVERAGE_REPORTER_OPTIONS = [
     'clover',
     'html',
@@ -323,7 +334,8 @@ program
     .option('--version [version]', 'print the current version of the Testim CLI and exit', false)
     .option('--monitor-performance', 'collect test playback performance data')
 
-    .option('--high-speed', 'run in high speed mode')
+    .option('--high-speed', 'DEPRECATED: use --turbo-mode instead') // When removing, remove from the program.help output filter
+    .option('--turbo-mode', 'run in turbo mode')
     .option('--lightweight-mode [settings]', 'run lightweight mode')
     .option('--create-prefeched-data [location]', 'prefech data into local cache file')
     .option('--use-prefeched-data [location]', 'use prefeched data from local cache file, and force using only cached data')
@@ -958,6 +970,12 @@ module.exports = {
             }
         }
 
+        /** Handling deprecation of High speed mode (renamed to Turbo mode) */
+        if (program.highSpeed) {
+            printDeprecationWarning('--high-speed', ' --turbo-mode');
+            program.turboMode = true;
+        }
+
         if (program.lightweightMode) {
             try {
                 const DEFAULTS = {
@@ -987,7 +1005,7 @@ module.exports = {
             } catch (err) {
                 return Promise.reject(new ArgError(`failed to parse lightweightMode settings error: ${err.message}`));
             }
-        } else if (program.highSpeed && program.mode === CLI_MODE.EXTENSION) {
+        } else if (program.turboMode && program.mode === CLI_MODE.EXTENSION) {
             program.lightweightMode = {
                 general: true,
                 disableLabs: false,
@@ -1007,7 +1025,7 @@ module.exports = {
                 uploadAssetsAndResultsOnFailure: true,
                 preloadTests: false,
                 disableProjectDefaults: false,
-                type: 'highSpeed',
+                type: 'turboMode',
             };
         }