@testim/testim-cli 3.260.0 → 3.262.0

package/commons/testimServicesApi.js

@@ -183,6 +183,14 @@ function reportExecutionFinished(status, executionId, projectId, success, tmsOpt
     }), { retries: DEFAULT_REQUEST_RETRY });
 }
 
+/**
+ * @param {string} projectId
+ * @param {string[]} names
+ * @param {string[]} planIds
+ * @param {string} branch
+ * @param {import('../runOptions').RunnerOptions['intersections']} intersections
+ * @returns {ReturnType<import('services/src/test-plan/service')['testPlan']['getTestPlanTestList']>}
+ */
 async function getTestPlanTestList(projectId, names, planIds, branch, intersections) {
     return pRetry(() => postAuth({
         url: '/testPlan/list',
@@ -206,12 +214,7 @@ async function getTestPlanTestList(projectId, names, planIds, branch, intersecti
  *   testConfigIds?: string[];
  *   intersections: import('../runOptions').RunnerOptions['intersections'];
  * }} param0
- * @returns {globalThis.Promise<{
- *   tests: any[][];
- *   branch?: string;
- *   runName?: string;
- *   runExists?: boolean;
- * }>}
+ * @returns {import('services/src/suite/service').RunListResult}
  */
 function getSuiteTestList({
     projectId, labels, testIds, testNames, testConfigNames, suiteNames, suiteIds, branch, rerunFailedByRunId, testConfigIds, intersections,
@@ -247,7 +250,7 @@ function isTestResultCompleted(resultId, projectId, testRetryKey) {
 }
 
 function getTestResults(testId, resultId, projectId, branch) {
-    return pRetry(() => getWithAuth(`/test/v2/${testId}/result/${resultId}`, { projectId, branch }), { retries: DEFAULT_REQUEST_RETRY });
+    return pRetry(() => getWithAuth(`/test/v2/${testId}/result/${resultId}`, { projectId, branch }), { retries: DEFAULT_REQUEST_RETRY, factor: 1 });
 }
 
 function keepAliveGrid(projectId, slots) {

package/executionQueue.js

@@ -1,8 +1,16 @@
 'use strict';
 
-const TestRun = require('./testRunHandler.js');
+const TestRun = require('./testRunHandler');
 
 class ExecutionQueue {
+    /**
+     * @param {string} executionId
+     * @param {string} executionName
+     * @param {any[]} testList
+     * @param {import('./runOptions').RunnerOptions} options
+     * @param {string} branchToUse
+     * @param {import('./testRunStatus')} testRunStatus
+     */
     constructor(executionId, executionName, testList, options, branchToUse, testStatus) {
         this._waitingTests = testList.map(testInfo => new TestRun(executionId, executionName, testInfo, options, branchToUse, testStatus));
     }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@testim/testim-cli",
-  "version": "3.260.0",
+  "version": "3.262.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@testim/testim-cli",
-      "version": "3.260.0",
+      "version": "3.262.0",
       "license": "Proprietary",
       "dependencies": {
         "@applitools/eyes-sdk-core": "13.6.23",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testim/testim-cli",
-  "version": "3.260.0",
+  "version": "3.262.0",
   "description": "Command line interface for running Testing on your CI",
   "author": "Oren Rubin",
   "contributors": [{

package/player/stepActions/RefreshStepAction.js

@@ -4,10 +4,13 @@ const StepAction = require('./stepAction');
 require('bluebird');
 
 class RefreshStepAction extends StepAction {
-    execute() {
-        return this.driver.reloadTab()
-            .then(() => ({ success: true }))
-            .catch(error => ({ success: false, reason: error.message }));
+    async execute() {
+        try {
+            await this.driver.reloadTab();
+            return { success: true };
+        } catch (error) {
+            return { success: false, reason: error.message };
+        }
     }
 }
 

package/player/stepActions/baseJsStepAction.js

@@ -15,6 +15,7 @@ const constants = commonConstants.stepResult;
 const logger = require('../../commons/logger').getLogger('base-js-step-action');
 
 const _ = require('lodash');
+const utils = require('../../utils');
 
 function constructWithArguments(constructor, args) {
     function F() {
@@ -98,46 +99,43 @@ class BaseJsStepAction extends StepAction {
         const that = this;
         const retryInterval = that.context.config.retryTimeout;
         let timeToPlayStep = that.context.data.timeToPlayStep - retryInterval;
-        return new Promise(resolve => {
-            function checkScriptStatus() {
-                return that.executeGetStatus(transactionId)
-                    .catch(err => {
-                        logger.warn('failed to get js status', { err });
-                        return { value: { status: 'exception' } };
-                    })
-                    .then(selRes => {
-                        let res;
-                        try {
-                            res = JSON.parse(selRes ? selRes.value : '{}');
-                        } catch (e) {
-                            logger.warn('non object value', { selRes });
-                            res = { status: 'exception' };
-                        }
-                        const abortReason = that.stepActionUtils.abortedSteps.find(abortedStep => abortedStep.id === that.step.id);
-                        if (abortReason) {
-                            return resolve(abortReason);
-                        }
-                        if (!res) {
-                            return resolve({ success: true });
-                        }
-                        if (res.status && res.status === 'done') {
-                            return resolve(res);
-                        }
-                        if (res.status && res.status === 'failed') {
-                            return resolve({ success: false, shouldRetry: true, result: res.result });
-                        }
-                        if (timeToPlayStep - retryInterval > 0) {
-                            timeToPlayStep -= retryInterval;
-                            setTimeout(checkScriptStatus, retryInterval);
-                        } else {
-                            return resolve(Object.assign({}, res, { success: false, shouldRetry: true }));
-                        }
-                        return undefined;
-                    });
+        async function checkScriptStatus() {
+            let selRes;
+            try {
+                selRes = await that.executeGetStatus(transactionId);
+            } catch (err) {
+                logger.warn('failed to get js status', { err });
+                selRes = { value: { status: 'exception' } };
+            }
+            let res;
+            try {
+                res = JSON.parse(selRes ? selRes.value : '{}');
+            } catch (e) {
+                logger.warn('non object value', { selRes });
+                res = { status: 'exception' };
+            }
+            const abortReason = that.stepActionUtils.abortedSteps.find(abortedStep => abortedStep.id === that.step.id);
+            if (abortReason) {
+                return abortReason;
+            }
+            if (!res) {
+                return { success: true };
+            }
+            if (res.status && res.status === 'done') {
+                return res;
             }
+            if (res.status && res.status === 'failed') {
+                return { success: false, shouldRetry: true, result: res.result };
+            }
+            if (timeToPlayStep - retryInterval <= 0) {
+                return Object.assign(res, { success: false, shouldRetry: true });
+            }
+            timeToPlayStep -= retryInterval;
+            await utils.delay(retryInterval);
+            return checkScriptStatus();
+        }
 
-            checkScriptStatus();
-        });
+        return checkScriptStatus();
     }
 
     executeInAut(eventMessage) {
@@ -241,7 +239,7 @@ class BaseJsStepAction extends StepAction {
         return resp?.success ? this.codeExecDone(resp) : this.codeExecFailed(resp);
     }
 
-    performAction() {
+    async performAction() {
         const step = this.step;
         const context = this.context;
 
@@ -262,14 +260,15 @@ class BaseJsStepAction extends StepAction {
             testResultId: context.testResultId,
         };
 
+        const browserAndOS = await this.driver.getBrowserAndOS();
+        Object.assign(eventMessage, { browser: browserAndOS.browser, browserMajor: browserAndOS.browserMajor });
+
+        if (!this.context.isPendingPromise) {
+            await this.executeInAut(eventMessage);
+        }
 
-        return this.driver.getBrowserAndOS()
-            .then(browserAndOS => {
-                Object.assign(eventMessage, { browser: browserAndOS.browser, browserMajor: browserAndOS.browserMajor });
-                return this.context.isPendingPromise ? undefined : this.executeInAut(eventMessage);
-            })
-            .then(() => this.checkStatus(eventMessage.transactionId))
-            .then(resp => this.checkCodeResponse(resp));
+        const resp = await this.checkStatus(eventMessage.transactionId);
+        return await this.checkCodeResponse(resp);
     }
 
     handleExecutionError(err) {

package/player/stepActions/dropFileStepAction.js

@@ -8,26 +8,25 @@ const { codeSnippets, utils } = require('../../commons/getSessionPlayerRequire')
 const featureFlagService = require('../../commons/featureFlags');
 
 class DropFileStepAction extends StepAction {
-    performAction() {
+    async performAction() {
         const target = this.context.data[this.step.targetId || 'targetId'];
         const overrideAzureStorageUrl = featureFlagService.flags.overrideAzureStorageUrl.isEnabled();
-        //TODO remove if after release session player
-        return (utils.addTokenToFileUrl ? utils.addTokenToFileUrl(
+        const fileUrls = await utils.addTokenToFileUrl(
             this.context.project.id,
             this.step.fileUrls,
             this.stepActionUtils.testimServicesApi,
             overrideAzureStorageUrl,
             logger,
-        ) : Promise.resolve(this.step.fileUrls)).then((fileUrls) => {
-            const dropFileCode = `
-            var getLocatedElement = ${codeSnippets.getLocatedElementCode};
-            var createDropEvent = ${(codeSnippets.createDropEvent ? codeSnippets.createDropEvent : createDropEventLegacy).toString()};
-            var downloadFileAndFireDropEvent = ${downloadFileAndFireDropEvent.toString()};
-            return downloadFileAndFireDropEvent.apply(null, arguments)
-        `;
+        );
 
-            return this.driver.executeJSWithArray(dropFileCode, [target.locatedElement, fileUrls]).then(() => {});
-        });
+        const dropFileCode = `
+        var getLocatedElement = ${codeSnippets.getLocatedElementCode};
+        var createDropEvent = ${(codeSnippets.createDropEvent ? codeSnippets.createDropEvent : createDropEventLegacy).toString()};
+        var downloadFileAndFireDropEvent = ${downloadFileAndFireDropEvent.toString()};
+        return downloadFileAndFireDropEvent.apply(null, arguments)
+    `;
+
+        return await this.driver.executeJSWithArray(dropFileCode, [target.locatedElement, fileUrls]);
     }
 }
 

package/player/stepActions/evaluateExpressionStepAction.js

@@ -1,6 +1,5 @@
 'use strict';
 
-const Promise = require('bluebird');
 const sessionPlayer = require('../../commons/getSessionPlayerRequire');
 const StepAction = require('./stepAction');
 
@@ -10,44 +9,44 @@ const logger = require('../../commons/logger').getLogger('evaluate-expression-st
 const _ = require('lodash');
 
 class EvaluateExpressionStepAction extends StepAction {
-    execute() {
+    async execute() {
         const step = this.step;
         const context = this.context;
         const exportsGlobal = this.exportsGlobal;
         const exportsTest = this.exportsTest;
 
-        return new Promise((resolve, reject) => {
-            try {
-                logger.info('runner running incoming params evaluation');
-                let incomingParams = context.incomingParams || {};
-                if (_.isEmpty(incomingParams)) {
-                    incomingParams = stepParamBuilder.getStepInputs(step, context, exportsGlobal, exportsTest);
-                }
-
-                const params = ['context', ...incomingParams.as.functionParameters];
-                const args = [context, ...incomingParams.as.functionArguments];
-                const expressionToEvaluate = step.subType === 'text' ? `'${step.expression.replace(/'/g, "\\\'")}'` : step.expression;
-                const code = (`return ${expressionToEvaluate}`).replace(/\n/g, '\\n');
-                const textEvaluateFunction = Function.apply(Function, params.concat([code]));
-                const evaluatedText = textEvaluateFunction.apply(null, args);
-
-                context.data[step.targetName] = evaluatedText;
-                context.data[step.targetId] = evaluatedText;
-                if (context.internalParams) {
-                    context.internalParams.add(step.targetId);
-                }
-
-                const result = {
-                    success: true,
-                    evaluatedText,
-                    data: context.data,
-                };
-
-                resolve(result);
-            } catch (e) {
-                reject({ errorType: constants.EVALUATE_EXPRESSION_EXCEPTION, resultInfo: { exception: e.toString() }, success: false });
+        try {
+            logger.info('runner running incoming params evaluation');
+            let incomingParams = context.incomingParams || {};
+            if (_.isEmpty(incomingParams)) {
+                incomingParams = stepParamBuilder.getStepInputs(step, context, exportsGlobal, exportsTest);
             }
-        });
+
+            const params = ['context', ...incomingParams.as.functionParameters];
+            const args = [context, ...incomingParams.as.functionArguments];
+            const expressionToEvaluate = step.subType === 'text' ? `'${step.expression.replace(/'/g, "\\\'")}'` : step.expression;
+            const code = `return ${expressionToEvaluate}`.replace(/\n/g, '\\n');
+            const textEvaluateFunction = Function.apply(Function, params.concat([code]));
+            const evaluatedText = textEvaluateFunction.apply(null, args);
+
+            context.data[step.targetName] = evaluatedText;
+            context.data[step.targetId] = evaluatedText;
+            if (context.internalParams) {
+                context.internalParams.add(step.targetId);
+            }
+
+            const result = {
+                success: true,
+                evaluatedText,
+                data: context.data,
+            };
+
+            return result;
+        } catch (e) {
+            // TODO: Fix throwing non-error
+            // eslint-disable-next-line no-throw-literal
+            throw { errorType: constants.EVALUATE_EXPRESSION_EXCEPTION, resultInfo: { exception: e.toString() }, success: false };
+        }
     }
 }
 

package/player/stepActions/extensionOnlyStepAction.js

@@ -1,12 +1,11 @@
 const StepAction = require('./stepAction');
-const Promise = require('bluebird');
 
 class ExtensionOnlyStepAction extends StepAction {
-    performAction() {
-        return Promise.resolve({
+    async performAction() {
+        return {
             success: 'skipped',
             reason: 'This step can run only on Chrome',
-        });
+        };
     }
 }
 

package/player/stepActions/extractTextStepAction.js

@@ -3,18 +3,16 @@
 const StepAction = require('./stepAction');
 
 class ExtractTextStepAction extends StepAction {
-    performAction() {
+    async performAction() {
         const paramName = this.step.extractTextParamName;
 
-        return this.stepActionUtils.extractTargetText(this.getTarget())
-            .then(extractedText => {
-                this.context.data.exports = this.context.data.exports || {};
-                this.context.data.exports[paramName] = extractedText;
-                return {
-                    success: true,
-                    data: this.context.data,
-                };
-            });
+        const extractedText = await this.stepActionUtils.extractTargetText(this.getTarget());
+        this.context.data.exports = this.context.data.exports || {};
+        this.context.data.exports[paramName] = extractedText;
+        return {
+            success: true,
+            data: this.context.data,
+        };
     }
 }
 

package/player/stepActions/hoverStepAction.js

@@ -21,7 +21,7 @@ class HoverStepAction extends StepAction {
             this.getTarget().rect;
     }
 
-    performAction() {
+    async performAction() {
         const target = this.getTarget();
         const { seleniumElement, rectWithoutFrameOffset, rect } = target;
 
@@ -49,8 +49,8 @@ class HoverStepAction extends StepAction {
             clickOffset: { x: Math.floor(clickOffsetX), y: Math.floor(clickOffsetY) },
         };
 
-        return this.driver.hover(seleniumElement, offsets)
-            .then(() => ({ success: true }));
+        await this.driver.hover(seleniumElement, offsets);
+        return { success: true };
     }
 }
 

package/player/stepActions/locateStepAction.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 'use strict';
 
 const StepAction = require('./stepAction');
@@ -14,15 +16,16 @@ const {
 
 const DEFAULT_VISIBILITY_RESULT = { opacity: 1, clientRects: {} };
 
+/**
+ * @param {import('../webdriver')} driver
+*/
 function createUtils(driver) {
     return {
         getFrameIdByTestimFrameId() { },
 
-        setElementResultDataOnContext(target) {
-            return driver.getElement(target.locatedElement)
-                .then(seleniumResponse => {
-                    target.seleniumElement = seleniumResponse.value;
-                });
+        async setElementResultDataOnContext(target) {
+            const seleniumResponse = await driver.getElement(target.locatedElement);
+            target.seleniumElement = seleniumResponse.value;
         },
 
         getElementRectangle(target) {
@@ -76,14 +79,18 @@ function createUtils(driver) {
         },
 
         /** @type {typeof import('clickim/src/background/stepActions/locateStepAction').LocateStepAction['isVisible']} */
-        isVisible(target, targetElement, rect, locateStep, frameHandler, allOffsets, dom) {
-            const skipVisibilityCheck =
-                featureFlags.flags.disableEdgeVisibilityChecks.isEnabled() && driver.isEdge();
+        async isVisible(target, targetElement, rect, locateStep, frameHandler, allOffsets, dom) {
+            const skipVisibilityCheck = featureFlags.flags.disableEdgeVisibilityChecks.isEnabled() && driver.isEdge();
 
             if (skipVisibilityCheck) {
                 logger.info('bypassed visibility check because of feature flag');
                 target.visibilityCheckSkipped = skipVisibilityCheck;
-                return driver.isVisible(target.seleniumElement).catch(() => { }).then(() => true);
+                try {
+                    await driver.isVisible(target.seleniumElement);
+                } catch {
+                    /* ignored */
+                }
+                return true;
             }
 
             const useNativeVisibilityCheck = this.shouldUseNativeVisibilityCheck(locateStep, driver, visibilityUtils, positionUtils);
@@ -91,35 +98,33 @@ function createUtils(driver) {
                 return driver.isVisible(target.seleniumElement);
             }
 
-            const handler = res => {
-                if (!targetElement || locatorBuilderUtils.isEmptyResult(targetElement)) {
-                    return Promise.resolve({ visible: false, invisibleReason: 'element not found' });
-                }
-                const middlePosition = positionUtils.calculateElementMiddlePoint(rect);
-                const points = [middlePosition, positionUtils.calculateClickPoint(locateStep.clickOffset, rect)].filter(Boolean);
-                const code = codeSnippets.getVisibilityCode.getCompoundVisibilityInfoCode(target.locatedElement, points, false, locateStep);
-                return driver.execute(`return ${code}`)
-                    .catch(err => {
-                        logger.error('failed to execute getVisibilityCode', { err });
-                        throw err;
-                    })
-                    .then((response = {}) => {
-                        const { value: result } = response;
-                        const elementVisibilityInfo = result.elementVisibilityInfo || DEFAULT_VISIBILITY_RESULT;
-                        const [middleElementFromPoint, clickElementFromPoint] = result.elementsFromPointResults || [null, null];
-
-                        return visibilityUtils.checkElementVisibility(elementVisibilityInfo, locateStep, clickElementFromPoint, middleElementFromPoint, dom, targetElement);
-                    });
-            };
-
             if (!target.seleniumElement) {
-                return Promise.resolve({ visible: false, invisibleReason: 'element not found' });
+                return { visible: false, invisibleReason: 'element not found' };
             }
 
             // this is here for the side effects.
-            return driver.isVisible(target.seleniumElement)
-                .catch(() => { })
-                .then(handler);
+            try {
+                await driver.isVisible(target.seleniumElement);
+            } catch {
+                /* ignored */
+            }
+            if (!targetElement || locatorBuilderUtils.isEmptyResult(targetElement)) {
+                return { visible: false, invisibleReason: 'element not found' };
+            }
+            const middlePosition = positionUtils.calculateElementMiddlePoint(rect);
+            const points = [middlePosition, positionUtils.calculateClickPoint(locateStep.clickOffset, rect)].filter(Boolean);
+            const code = codeSnippets.getVisibilityCode.getCompoundVisibilityInfoCode(target.locatedElement, points, false, locateStep);
+            let response;
+            try {
+                response = await driver.execute(`return ${code}`);
+            } catch (err) {
+                logger.error('failed to execute getVisibilityCode', { err });
+                throw err;
+            }
+            const { value } = response || {};
+            const elementVisibilityInfo = value.elementVisibilityInfo || DEFAULT_VISIBILITY_RESULT;
+            const [middleElementFromPoint, clickElementFromPoint] = value.elementsFromPointResults || [null, null];
+            return visibilityUtils.checkElementVisibility(elementVisibilityInfo, locateStep, clickElementFromPoint, middleElementFromPoint, dom, targetElement);
         },
 
         scrollToElement(frameHandler, locatedElement) {

package/player/stepActions/mouseStepAction.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 const StepAction = require('./stepAction');
 const html5dndAction = require('./scripts/html5dragAction');
 const html5dndActionV2 = require('./scripts/html5dragActionV2');
@@ -22,7 +24,7 @@ class MouseStepAction extends StepAction {
         };
     }
 
-    clickJs() {
+    async clickJs() {
         const step = this.step;
         const context = this.context;
         const target = context.data[step.targetId || 'targetId'];
@@ -30,7 +32,7 @@ class MouseStepAction extends StepAction {
         const events = step.events;
 
         if (!events?.length) {
-            return Promise.resolve();
+            return undefined;
         }
 
         const eventMessage = {
@@ -55,18 +57,19 @@ class MouseStepAction extends StepAction {
         // values between 0 and -1 -_-.
         const eventParam = this.driver.isEdge() ? JSON.stringify(eventMessage) : eventMessage;
 
-        return this.driver.executeCodeAsync(doClickCode, timeout, eventParam)
-            .then(result => {
-                if (result.value?.success) {
-                    return { success: true };
-                }
-                return { success: false };
-            })
-            .catch(err => ({
+        try {
+            const result = await this.driver.executeCodeAsync(doClickCode, timeout, eventParam);
+            if (result.value?.success) {
+                return { success: true };
+            }
+            return { success: false };
+        } catch (err) {
+            return {
                 success: false,
                 reason: err.message,
                 exception: err,
-            }));
+            };
+        }
     }
 
     isWithinBounds(start, end, point) {
@@ -126,14 +129,14 @@ class MouseStepAction extends StepAction {
         this.addOffsetToEvents(this.getEventSequenceOffset());
     }
 
-    dragPathJs() {
+    async dragPathJs() {
         const step = this.step;
         const context = this.context;
         const target = context.data[step.targetId || 'targetId'];
         const timeout = context.data.timeToPlayStep + 3000;
 
         if (!this.step.events || !this.step.events.length) {
-            return Promise.resolve();
+            return undefined;
         }
 
         this.fixAbsoluteDragEventSequence();
@@ -158,18 +161,19 @@ class MouseStepAction extends StepAction {
             return doDragPath.apply(null, arguments);
         `;
 
-        return this.driver.executeCodeAsync(doDragPathCode, timeout, eventMessage)
-            .then(result => {
-                if (result.value?.success) {
-                    return { success: true };
-                }
-                return { success: false };
-            })
-            .catch(err => ({
+        try {
+            const result = await this.driver.executeCodeAsync(doDragPathCode, timeout, eventMessage);
+            if (result.value?.success) {
+                return { success: true };
+            }
+            return { success: false };
+        } catch (err) {
+            return {
                 success: false,
                 reason: err.message,
                 exception: err,
-            }));
+            };
+        }
     }
 
     chooseAndRunAction() {
@@ -295,18 +299,16 @@ class MouseStepAction extends StepAction {
         return this.driver.leftClick(seleniumElement, offsets);
     }
 
-    performAction() {
-        return this.chooseAndRunAction()
-            .then(res => {
-                if (!res.status && res.value && res.value.keep) {
-                    res = res.value;
-                }
-                if (res.keep) {
-                    delete res.keep;
-                    return res;
-                }
-                return undefined;
-            });
+    async performAction() {
+        let res = await this.chooseAndRunAction();
+        if (!res.status && res.value && res.value.keep) {
+            res = res.value;
+        }
+        if (res.keep) {
+            delete res.keep;
+            return res;
+        }
+        return undefined;
     }
 
     addDragendIfNeeded(events) {