@testim/testim-cli 3.213.0 → 3.214.0

package/commons/httpRequest.js

@@ -232,7 +232,10 @@ function download(url) {
     }
 
     return Promise.fromCallback((callback) => request.end(callback))
-        .tap(() => logger.info('finished to download', { url }))
+        .then(response => {
+            logger.info('finished to download', { url });
+            return response;
+        })
         .catch(logErrorAndRethrow('failed to download', { url }));
 }
 

package/npm-shrinkwrap.json

@@ -2337,9 +2337,9 @@
       "dev": true
     },
     "caniuse-lite": {
-      "version": "1.0.30001292",
-      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001292.tgz",
-      "integrity": "sha512-jnT4Tq0Q4ma+6nncYQVe7d73kmDmE9C3OGTx3MvW7lBM/eY1S1DZTMBON7dqV481RhNiS5OxD7k9JQvmDOTirw==",
+      "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.4",
-          "resolved": "https://registry.npmjs.org/@types/node/-/node-17.0.4.tgz",
-          "integrity": "sha512-6xwbrW4JJiJLgF+zNypN5wr2ykM9/jHcL7rQ8fZe2vuftggjzZeRSM4OwRc6Xk8qWjwJ99qVHo/JgOGmomWRog=="
+          "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.27",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.27.tgz",
-      "integrity": "sha512-uZ95szi3zUbzRDx1zx/xnsCG+2xgZyy57pDOeaeO4r8zx5Dqe8Jv1ti8cunvBwJHVI5LzPuw8umKwZb3WKYxSQ==",
+      "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.213.0",
+  "version": "3.214.0",
   "description": "Command line interface for running Testing on your CI",
   "author": "Oren Rubin",
   "contributors": [{

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/testRunHandler.js

@@ -18,7 +18,7 @@ const { SeleniumPerfStats } = require('./commons/SeleniumPerfStats');
 const { preloadTests } = require('./commons/preloadTests');
 
 const RETRIES_ON_TIMEOUT = 3;
-const MAX_LIGHTWEIGHT_MODE_RUN_DATA_SIZE = 50 * 1000; // max size, in characters, of stringified run data sent over URL params. Chosen arbitrarily, this value should be changed according to data.
+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) {
@@ -181,8 +181,9 @@ TestRun.prototype.getRunRequestParams = async function () {
         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 (lightweight mode). Run data size: ${JSON.stringify(runData).length} (limit: ${MAX_LIGHTWEIGHT_MODE_RUN_DATA_SIZE} characters)`);
+            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);
     }
@@ -203,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) {

package/workers/WorkerExtension.js

@@ -110,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,29 +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)
-            .catch(err => {
-                reporter.onGetBrowserFailure(workerId, projectId, ++failedAttempts);
-                throw err;
-            })
-            .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';