@testim/testim-cli 3.254.0 → 3.256.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testim/testim-cli",
-  "version": "3.254.0",
+  "version": "3.256.0",
   "description": "Command line interface for running Testing on your CI",
   "author": "Oren Rubin",
   "contributors": [{
@@ -83,6 +83,7 @@
     "npm": "8.19.2",
     "object-hash": "3.0.0",
     "ora": "5.4.1",
+    "p-limit": "4.0.0",
     "p-retry": "4.6.2",
     "pako": "1.0.11",
     "portfinder": "1.0.28",
@@ -111,8 +112,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": "yarn test:pattern './src/**/*.test.js'",
+    "test:pattern": "IS_UNIT_TEST=1 ../../node_modules/mocha/bin/_mocha --timeout 2000 --exit --recursive --exclude ./src/codim/template.js/tests/examples/**/*.test.js --watch-files 'src'",
     "test:cov": "nyc --reporter=lcov --reporter=text yarn test",
     "upload-bundle-s3": "ts-node-transpile-only scripts/upload.js",
     "prepare-version": "rm -rf ./deploy && mkdir -p deploy && gulp prepare-version-on-prem",

package/player/services/tabService.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 'use strict';
 
 const sessionPlayer = require('../../commons/getSessionPlayerRequire');
@@ -36,8 +38,20 @@ const logger = require('../../commons/logger').getLogger('tab-service');
  *     from: any;
  *     isMain: any;
  *     openerStepId: any;
+ *     openerOriginalStepId?: any;
+ *     isClosed?: boolean;
+ *     currentUrl?: any;
+ *     lastUpdatedUrl?: any;
  * }} TabInfo
  */
+/**
+ * @typedef {{
+ *     tabCount: number;
+ *     tabInfos: Record<string, TabInfo>;
+ *     lastActiveTabInfo?: any;
+ *     currentTab?: any;
+ * }} SessionTab
+ */
 
 class TabService {
     /** @param {import('../webdriver')} driver */
@@ -45,7 +59,7 @@ class TabService {
         this.driver = driver;
         /** @type {Record<string, TabUtil>} */
         this._utils = {};
-        /** @type {Record<string, { tabCount: number; tabInfos: Record<string, TabInfo> }>} */
+        /** @type {Record<string, SessionTab>} */
         this.sessionTabs = {};
         /** @type {Record<string, string>} */
         this.pendingTabs = {};

package/player/stepActions/apiStepAction.js

@@ -1,6 +1,7 @@
+// @ts-check
+
 'use strict';
 
-const Promise = require('bluebird');
 const StepAction = require('./stepAction');
 
 const sessionPlayer = require('../../commons/getSessionPlayerRequire');
@@ -9,23 +10,28 @@ const constants = sessionPlayer.commonConstants.stepResult;
 const apiCall = sessionPlayer.apiCall;
 
 class ApiStepAction extends StepAction {
-    runApiInAut(eventData) {
+    async runApiInAut(eventData) {
         eventData.withCredentials = true;
         const timeout = this.context.data.timeToPlayStep + 3000;
-        return this.driver.executeCodeAsync(apiCall, timeout, eventData)
-            .then(autRes => {
-                const resp = autRes && autRes.value;
-                return resp || {};
-            }).catch(err => err && err.message && err.message.includes('Javascript execution context no longer exists'), err => {
-                throw new Error('The page refreshed or changed while executing this step. Please consider unchecking "Send via web page" if this is expected.');
-            });
+        try {
+            const autRes = await this.driver.executeCodeAsync(apiCall, timeout, eventData);
+            const resp = autRes?.value;
+            return resp || {};
+        } catch (err) {
+            if (err?.message?.includes('Javascript execution context no longer exists')) {
+                throw new Error(
+                    'The page refreshed or changed while executing this step. Please consider unchecking "Send via web page" if this is expected.');
+            }
+            throw err;
+        }
     }
 
     runApiInBg(eventData) {
-        return new Promise(resolve => apiCall(eventData, resolve));
+        return new Promise(resolve => { apiCall(eventData, resolve); });
     }
 
-    performAction() {
+    async performAction() {
+        /** @type {import('clickim/src/common/models/apiStep').ApiStep} */
         const step = this.step;
         const context = this.context;
 
@@ -41,44 +47,44 @@ class ApiStepAction extends StepAction {
             fileUrls: context.fileUrls,
         };
 
-        return (step.sendViaWebApp ? this.runApiInAut(eventData) : this.runApiInBg(eventData))
-            .then(resp => {
-                const result = resp.result || {};
-
-                const resultInfo = {
-                    method: step.method,
-                    status: result.status,
-                    url: step.url,
-                };
-
-                if (resp.success) {
-                    if (result.status === 0) {
-                        return {
-                            result,
-                            resultInfo,
-                            shouldRetry: false,
-                            success: false,
-                            reason: 'Connection problem',
-                            errorType: constants.API_REQUEST_NETWORK_ERROR,
-                        };
-                    }
-                    return {
-                        result,
-                        resultInfo,
-                        shouldRetry: false,
-                        success: true,
-                    };
-                }
-
+        let resp;
+        if (step.sendViaWebApp) {
+            resp = await this.runApiInAut(eventData);
+        } else {
+            resp = await this.runApiInBg(eventData);
+        }
+        const result = resp.result || {};
+        const resultInfo = {
+            method: step.method,
+            status: result.status,
+            url: step.url,
+        };
+        if (resp.success) {
+            if (result.status === 0) {
                 return {
                     result,
                     resultInfo,
                     shouldRetry: false,
                     success: false,
-                    reason: result.error || sessionPlayer.commonConstants.error.REQUEST_TIMED_OUT,
-                    errorType: result.error ? constants.API_FAILURE : constants.API_REQUEST_NETWORK_ERROR,
+                    reason: 'Connection problem',
+                    errorType: constants.API_REQUEST_NETWORK_ERROR,
                 };
-            });
+            }
+            return {
+                result,
+                resultInfo,
+                shouldRetry: false,
+                success: true,
+            };
+        }
+        return {
+            result,
+            resultInfo,
+            shouldRetry: false,
+            success: false,
+            reason: result.error || sessionPlayer.commonConstants.error.REQUEST_TIMED_OUT,
+            errorType: result.error ? constants.API_FAILURE : constants.API_REQUEST_NETWORK_ERROR,
+        };
     }
 }
 

package/player/stepActions/baseCliJsStepAction.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const BaseJsStepAction = require('./baseJsStepAction');
-const Promise = require('bluebird');
+const Bluebird = require('bluebird');
 const service = require('../../agent/routers/cliJsCode/service');
 const sessionPlayer = require('../../commons/getSessionPlayerRequire');
 const _ = require('lodash');
@@ -9,16 +9,16 @@ const _ = require('lodash');
 const constants = sessionPlayer.commonConstants.stepResult;
 
 class BaseCliJsStepAction extends BaseJsStepAction {
-    executeCliCode() {
+    async executeCliCode() {
         const { step, context } = this;
         const isMobile = this.stepActionUtils.driver.isMobile;
         const hasCliAction = _(context).get('company.activePlan.premiumFeatures.cliAction');
 
         if (!hasCliAction && !isMobile) {
-            return Promise.resolve({
+            return {
                 success: 'skipped',
                 reason: 'CLI action is not enabled in your current plan',
-            });
+            };
         }
 
         const { code, id } = step;
@@ -28,21 +28,26 @@ class BaseCliJsStepAction extends BaseJsStepAction {
             data: context.data,
         };
         const runTimeout = context.data.timeToPlayStep;
-        return service.runCodeWithPackages(code, id, incomingParams, contextData, testResultId, retryIndex, stepResultId, runTimeout)
-            .then(data => this.checkCodeResponse(data));
+        const data = await service.runCodeWithPackages(code, id, incomingParams, contextData, testResultId, retryIndex, stepResultId, runTimeout);
+        return await this.checkCodeResponse(data);
     }
 
-    performAction() {
-        return this.executeCliCode()
-            .catch(Promise.TimeoutError, () => Promise.resolve({
-                success: false,
-                errorType: constants.ACTION_TIMEOUT,
-            }))
-            .catch(err => Promise.resolve({
+    async performAction() {
+        try {
+            return await this.executeCliCode();
+        } catch (err) {
+            if (err instanceof Bluebird.TimeoutError) {
+                return {
+                    success: false,
+                    errorType: constants.ACTION_TIMEOUT,
+                };
+            }
+            return {
                 success: false,
                 reason: err.message,
                 exception: err,
-            }));
+            };
+        }
     }
 }
 

package/player/stepActions/baseJsStepAction.js

@@ -44,7 +44,8 @@ class BaseJsStepAction extends StepAction {
     }
 
     executeGetStatus(transactionId) {
-        // eslint-disable-next-line prefer-arrow-callback
+        // TODO: Cleanup after dropping IE11/Edge support
+        /* eslint-disable prefer-arrow-callback,  no-undef,  unicorn/prefer-includes */
         return this.driver.executeJS(function (transactionId) {
             const sessionItem = 'data-testim-' + transactionId;
             try {
@@ -62,14 +63,15 @@ class BaseJsStepAction extends StepAction {
                 throw err;
             }
         }, transactionId);
+        /* eslint-enable prefer-arrow-callback,  no-undef,  unicorn/prefer-includes */
     }
 
     constructJSFunParams(eventData) {
         const incomingParams = eventData.incomingParams;
 
         const params = [
-            ...['context', ...incomingParams.as.functionParameters],
-            ...['exports', 'exportsTest', 'exportsGlobal'],
+            'context', ...incomingParams.as.functionParameters,
+            'exports', 'exportsTest', 'exportsGlobal',
         ];
 
         const args = [eventData.context, ...incomingParams.as.functionArguments];
@@ -142,7 +144,7 @@ class BaseJsStepAction extends StepAction {
         const useExperimentalPreCompilation = featureFlags.flags.experimentalPreCodeCompilation.isEnabled();
         const experimentalAsyncCustomCode = featureFlags.flags.experimentalAsyncCustomCode.isEnabled();
         const rawParams = this.constructJSFunParams(eventMessage);
-        const hasLocateParams = rawParams.function.args.some(x => Boolean(x && x.locatedElement));
+        const hasLocateParams = rawParams.function.args.some(x => Boolean(x?.locatedElement));
         let funcToRunString = 'undefined';
         if (useExperimentalPreCompilation) {
             const paramNames = rawParams.function.params.slice(0, -1);
@@ -236,7 +238,7 @@ class BaseJsStepAction extends StepAction {
     }
 
     checkCodeResponse(resp) {
-        return resp && resp.success ? this.codeExecDone(resp) : this.codeExecFailed(resp);
+        return resp?.success ? this.codeExecDone(resp) : this.codeExecFailed(resp);
     }
 
     performAction() {
@@ -264,15 +266,14 @@ class BaseJsStepAction extends StepAction {
         return this.driver.getBrowserAndOS()
             .then(browserAndOS => {
                 Object.assign(eventMessage, { browser: browserAndOS.browser, browserMajor: browserAndOS.browserMajor });
-                return Promise.resolve();
+                return this.context.isPendingPromise ? undefined : this.executeInAut(eventMessage);
             })
-            .then(() => (this.context.isPendingPromise ? Promise.resolve() : this.executeInAut(eventMessage)))
             .then(() => this.checkStatus(eventMessage.transactionId))
             .then(resp => this.checkCodeResponse(resp));
     }
 
     handleExecutionError(err) {
-        const canExtractError = err && err.seleniumStack && err.seleniumStack.type === 'JavaScriptError' &&
+        const canExtractError = err?.seleniumStack && err.seleniumStack.type === 'JavaScriptError' &&
             err.seleniumStack.orgStatusMessage;
 
         if (canExtractError) {

package/player/stepActions/dropFileStepAction.js

@@ -1,6 +1,5 @@
 'use strict';
 
-const Promise = require('bluebird');
 const StepAction = require('./stepAction');
 const logger = require('../../commons/logger').getLogger('drop-file-step-action');
 const downloadFileAndFireDropEvent = require('./scripts/dropEvent');
@@ -27,8 +26,7 @@ class DropFileStepAction extends StepAction {
             return downloadFileAndFireDropEvent.apply(null, arguments)
         `;
 
-            return this.driver.executeJSWithArray(dropFileCode, [target.locatedElement, fileUrls])
-                .then(() => Promise.resolve());
+            return this.driver.executeJSWithArray(dropFileCode, [target.locatedElement, fileUrls]).then(() => {});
         });
     }
 }

package/player/stepActions/inputFileStepAction.js

@@ -55,16 +55,18 @@ class InputFileStepAction extends StepAction {
             const invalidStateMsg = 'invalid element state: Element is not currently interactable and may not be manipulated';
             const mustBeVisibleMsg = 'Element must not be hidden, disabled or read-only';
             const notReachableByKeyboard = 'is not reachable by keyboard';
+            /** @type {string} */
             const errorMsg = err ? err.message : '';
             // Workaround move element if element is not visible or disabled
-            if (_.isEqual(errorMsg, invalidStateMsg) ||
-                _.startsWith(errorMsg, mustBeVisibleMsg) ||
-                _.startsWith(errorMsg, edgeErrorEditableMessage) ||
-                _.startsWith(errorMsg, edgeErrorFocusableMessage) ||
-                _.startsWith(errorMsg, safariErrorVisibleMessage) ||
-                _.includes(errorMsg, notReachableByKeyboard) ||
-                _.includes(errorMsg, elementNotInteractable) ||
-                _.includes(errorMsg, elementNotPointerOrKeyboardInteractable)
+            if (
+                errorMsg === invalidStateMsg ||
+                errorMsg.startsWith(mustBeVisibleMsg) ||
+                errorMsg.startsWith(edgeErrorEditableMessage) ||
+                errorMsg.startsWith(edgeErrorFocusableMessage) ||
+                errorMsg.startsWith(safariErrorVisibleMessage) ||
+                errorMsg.includes(notReachableByKeyboard) ||
+                errorMsg.includes(elementNotInteractable) ||
+                errorMsg.includes(elementNotPointerOrKeyboardInteractable)
             ) {
                 await this.forceInputToBeVisible(target);
                 await this.uploadFiles(gridLocalFiles, target);

package/player/stepActions/locateStepAction.js

@@ -33,6 +33,7 @@ function createUtils(driver) {
             return Promise.resolve([frameHandler.frameOffset || {}]);
         }
 
+        /** @type {typeof import('clickim/src/background/stepActions/locateStepAction').LocateStepAction['htmlStringToDom']} */
         static htmlStringToDom(htmlString, url, nonBodyElements, bodyTagName, setDomTimeout = true) {
             const virtualConsole = new VirtualConsole();
             const jsdom = new JSDOM(htmlString, {
@@ -74,6 +75,7 @@ function createUtils(driver) {
             return true;
         }
 
+        /** @type {typeof import('clickim/src/background/stepActions/locateStepAction').LocateStepAction['isVisible']} */
         static isVisible(target, targetElement, rect, locateStep, frameHandler, allOffsets, dom) {
             const skipVisibilityCheck =
                 featureFlags.flags.disableEdgeVisibilityChecks.isEnabled() && driver.isEdge();

package/player/stepActions/mouseStepAction.js

@@ -1,5 +1,4 @@
 const StepAction = require('./stepAction');
-const Promise = require('bluebird');
 const html5dndAction = require('./scripts/html5dragAction');
 const html5dndActionV2 = require('./scripts/html5dragActionV2');
 const doClickScript = require('./scripts/doClick');
@@ -30,7 +29,7 @@ class MouseStepAction extends StepAction {
         const timeout = context.data.timeToPlayStep + 3000;
         const events = step.events;
 
-        if (!events || !events.length) {
+        if (!events?.length) {
             return Promise.resolve();
         }
 
@@ -58,12 +57,12 @@ class MouseStepAction extends StepAction {
 
         return this.driver.executeCodeAsync(doClickCode, timeout, eventParam)
             .then(result => {
-                if (result.value && result.value.success) {
-                    return Promise.resolve({ success: true });
+                if (result.value?.success) {
+                    return { success: true };
                 }
-                return Promise.resolve({ success: false });
+                return { success: false };
             })
-            .catch(err => Promise.resolve({
+            .catch(err => ({
                 success: false,
                 reason: err.message,
                 exception: err,
@@ -75,7 +74,7 @@ class MouseStepAction extends StepAction {
     }
 
     getEventSequenceOffset() {
-        const initialPosition = (this.step.events[0] || {}).pointerPosition;
+        const initialPosition = this.step.events[0]?.pointerPosition;
         if (!initialPosition) {
             return { xOffset: 0, yOffset: 0 };
         }
@@ -91,7 +90,7 @@ class MouseStepAction extends StepAction {
 
     addOffsetToEvents(offsetFromElement) {
         this.step.events.forEach(event => {
-            if (event && event.pointerPosition) {
+            if (event?.pointerPosition) {
                 event.pointerPosition.originX += offsetFromElement.xOffset;
                 event.pointerPosition.originY += offsetFromElement.yOffset;
             }
@@ -113,7 +112,9 @@ class MouseStepAction extends StepAction {
 
         const { recordPointerMoveEvents = false } = this.context.project.defaults || {};
         const mouseUpEvent = this.step.events.find(event => event.event === 'mouseup') || (recordPointerMoveEvents && this.step.events.find(event => event.event === 'pointerup'));
-        const lastMouseMoveEventIndex = _.findLastIndex(this.step.events, event => event.event === 'mousemove') || (recordPointerMoveEvents && _.findLastIndex(this.step.events, event => event.event === 'pointermove'));
+        const lastMouseMoveEventIndex =
+            _.findLastIndex(this.step.events, event => event.event === 'mousemove') ||
+            (recordPointerMoveEvents && _.findLastIndex(this.step.events, event => event.event === 'pointermove'));
         if (mouseUpEvent && lastMouseMoveEventIndex > 0 && !this.step.allEventsOnSameElement) {
             this.step.events.splice(lastMouseMoveEventIndex + 1, 0, this.generateEventOfType(mouseUpEvent, 'mouseover'));
         }
@@ -159,12 +160,12 @@ class MouseStepAction extends StepAction {
 
         return this.driver.executeCodeAsync(doDragPathCode, timeout, eventMessage)
             .then(result => {
-                if (result.value && result.value.success) {
-                    return Promise.resolve({ success: true });
+                if (result.value?.success) {
+                    return { success: true };
                 }
-                return Promise.resolve({ success: false });
+                return { success: false };
             })
-            .catch(err => Promise.resolve({
+            .catch(err => ({
                 success: false,
                 reason: err.message,
                 exception: err,
@@ -173,9 +174,7 @@ class MouseStepAction extends StepAction {
 
     chooseAndRunAction() {
         const target = this.getTarget();
-        const {
-            locatedElement, seleniumElement, rectWithoutFrameOffset, rect,
-        } = target;
+        const { locatedElement, seleniumElement, rectWithoutFrameOffset, rect } = target;
         const { xOffset, yOffset } = this.stepActionUtils.getClickOffset(this.step.element.clickOffset, rectWithoutFrameOffset);
 
         // used for fallback native click
@@ -220,7 +219,7 @@ class MouseStepAction extends StepAction {
                     if (!isIE && featureFlagService.flags.usePortedHtml5DragDrop.isEnabled()) {
                         const events = this.generateHTML5DragEventSequence();
                         const timeout = this.context.data.timeToPlayStep + 3000;
-                        const target = this.context.data[this.step.targetId || 'targetId'];
+                        const contextTarget = this.context.data[this.step.targetId || 'targetId'];
                         const eventMessage = {
                             transactionId: `${this.context.testResultId}:${this.step.id}`,
                             id: this.step.id,
@@ -235,10 +234,10 @@ class MouseStepAction extends StepAction {
                             isDrag: this.step.isDrag,
                             useRecordedMousedown: this.step.useRecordedMousedown,
                             allEventsOnSameElement: this.step.allEventsOnSameElement,
-                            elementToFocusLocatedElement: target.elementToFocusLocatedElement,
+                            elementToFocusLocatedElement: contextTarget.elementToFocusLocatedElement,
                             trackActiveElement: this.step.trackActiveElement,
-                            locatedElement: target.locatedElement,
-                            isRoot: target.isRoot,
+                            locatedElement: contextTarget.locatedElement,
+                            isRoot: contextTarget.isRoot,
                         };
                         // hack for Edge (17/18) which does not accept properties with negative (throws Unknown Error)
                         // values between 0 and -1 -_-.
@@ -311,7 +310,7 @@ class MouseStepAction extends StepAction {
     }
 
     addDragendIfNeeded(events) {
-        if (events.find(event => event.event === 'dragend')) {
+        if (events.some(event => event.event === 'dragend')) {
             return events;
         }
         const dragendDefaultEvent = {
@@ -325,7 +324,7 @@ class MouseStepAction extends StepAction {
     }
 
     getToElementPosition() {
-        if (!(this.context.data && this.context.data.toElement && this.context.data.toElement.rect)) {
+        if (!(this.context.data?.toElement?.rect)) {
             return undefined;
         }
         const { rect } = this.context.data.toElement;

package/player/stepActions/nodePackageStepAction.js

@@ -1,47 +1,46 @@
-"use strict";
+'use strict';
 
 const StepAction = require('./stepAction');
-const Promise = require('bluebird');
-const {NpmPackageError} = require('../../errors');
+const Bluebird = require('bluebird');
+const { NpmPackageError } = require('../../errors');
 
 const service = require('../../agent/routers/cliJsCode/service');
 
 class NodePackageStepAction extends StepAction {
+    async performAction() {
+        const { context } = this;
+        const { stepId, packageData, resultId, retryIndex, stepResultId, timeToPlayBeforeExec } = context;
 
-    performAction() {
-        const {context} = this;
-        const {
-            stepId,
-            packageData,
-            resultId,
-            retryIndex,
-            stepResultId,
-            timeToPlayBeforeExec
-        } = context;
-
-        return service.installPackage(stepId, resultId, retryIndex, packageData, stepResultId, timeToPlayBeforeExec)
-            .then(data => ({data, success: true}))
-            .catch(NpmPackageError, err => {
-                return Promise.resolve({
-                    success: false,
-                    code: "invalid-node-package",
-                    message: err.message
-                })
-            })
-            .catch(Promise.TimeoutError, () => {
-                return Promise.resolve({
+        try {
+            const data = await service.installPackage(
+                stepId,
+                resultId,
+                retryIndex,
+                packageData,
+                stepResultId,
+                timeToPlayBeforeExec,
+            );
+            return ({ data, success: true });
+        } catch (err) {
+            if (err instanceof NpmPackageError) {
+                return {
                     success: false,
-                    code: "timeout"
-                });
-            })
-            .catch(err =>
-                Promise.resolve({
+                    code: 'invalid-node-package',
+                    message: err.message,
+                };
+            }
+            if (err instanceof Bluebird.TimeoutError) {
+                return {
                     success: false,
-                    reason: err.message,
-                    exception: err
-                })
-            );
-
+                    code: 'timeout',
+                };
+            }
+            return {
+                success: false,
+                reason: err.message,
+                exception: err,
+            };
+        }
     }
 }
 

package/player/stepActions/stepAction.js

@@ -22,6 +22,7 @@ class StepAction {
         this.context = context;
         this.frameHandler = frameHandler;
         this.frameId = 0;
+        /** @type {import('../utils/stepActionUtils'))} */
         this.stepActionUtils = stepActionUtils;
         this.locateElementPlayer = locateElementPlayer;
         this.exportsGlobal = exportsGlobal;