@testim/testim-cli 3.261.0 → 3.263.0

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) {

package/player/stepActions/navigationStepAction.js

@@ -2,28 +2,27 @@
 
 const StepAction = require('./stepAction');
 const requiredUrl = require('url');
-const Promise = require('bluebird');
 
 class NavigationStepAction extends StepAction {
-    updateBaseUrl(location) {
+    async updateBaseUrl(location) {
         const orgUrl = requiredUrl.parse(location);
         const baseLocation = requiredUrl.parse(this.context.recordedBaseUrl);
         const newBaseLocation = requiredUrl.parse(this.context.baseUrl);
         if (orgUrl.host === baseLocation.host && baseLocation.host !== newBaseLocation.host) {
             orgUrl.host = newBaseLocation.host;
         }
-        return Promise.resolve(orgUrl.href);
+        return orgUrl.href;
     }
 
-    performAction() {
+    async performAction() {
         const url = this.context.data.testimNavigationStepDestination || this.context.data.url;
         // Opens a new tab and switches to new tab
         if (this.step.openInNewTab) {
-            return this.driver.client.newWindow(url).then(() => {});
+            await this.driver.client.newWindow(url);
+            return;
         }
-        return this.updateBaseUrl(url)
-            .then(updatedUrl => this.driver.url(updatedUrl))
-            .then(() => {});
+        const updatedUrl = await this.updateBaseUrl(url);
+        await this.driver.url(updatedUrl);
     }
 }
 

package/player/stepActions/scrollStepAction.js

@@ -21,7 +21,7 @@ class ScrollStepAction extends StepAction {
         return failureMessage;
     }
 
-    scroll(elementToScrollTo, step, elementToScrollOn) {
+    async scroll(elementToScrollTo, step, elementToScrollOn) {
         const expectedY = Math.round(Number(step.isScrollToElement ? step.marginTop : step.y));
         const expectedX = Math.round(Number(step.isScrollToElement ? step.marginLeft : step.x));
 
@@ -39,8 +39,8 @@ class ScrollStepAction extends StepAction {
             return scroll.apply(null, arguments)
         `;
 
-        return this.driver
-            .executeJSWithArray(scrollCode, [
+        try {
+            const res = await this.driver.executeJSWithArray(scrollCode, [
                 elementToScrollOn,
                 elementToScrollTo,
                 Boolean(step.isScrollToElement),
@@ -49,31 +49,31 @@ class ScrollStepAction extends StepAction {
                 expectedY,
                 step.shouldScrollLeft,
                 step.shouldScrollTop,
-            ])
-            .then(res => {
-                if (!res || !res.value) {
-                    return {
-                        errorType: constants.SCROLL_ACTION_FAILURE,
-                        success: false,
-                    };
-                }
-
-                const { success, actualX, actualY } = res.value;
-
-                if (success) {
-                    return { success: true };
-                }
-
+            ]);
+            if (!res?.value) {
                 return {
                     errorType: constants.SCROLL_ACTION_FAILURE,
                     success: false,
-                    resultInfo: { error: this.getFailureString(step, expectedX, expectedY, actualX, actualY) },
                 };
-            })
-            .catch(() => ({
+            }
+
+            const { success, actualX, actualY } = res.value;
+
+            if (success) {
+                return { success: true };
+            }
+
+            return {
+                errorType: constants.SCROLL_ACTION_FAILURE,
+                success: false,
+                resultInfo: { error: this.getFailureString(step, expectedX, expectedY, actualX, actualY) },
+            };
+        } catch (error) {
+            return {
                 errorType: constants.SCROLL_ACTION_FAILURE,
                 success: false,
-            }));
+            };
+        }
     }
 
     scrollOnDocument(step, elementToScrollTo) {

package/player/stepActions/stepAction.js

@@ -1,7 +1,6 @@
 'use strict';
 
 const { commonConstants } = require('../../commons/getSessionPlayerRequire');
-const Promise = require('bluebird');
 
 /** @typedef {typeof import('clickim/src/background/stepActions/stepAction').StepAction} ClickimStepActionCtor */
 /** @typedef {ConstructorParameters<ClickimStepActionCtor>} ClickimStepActionCtorParams */
@@ -33,7 +32,7 @@ class StepAction {
         return this.stepActionUtils.driver;
     }
 
-    performAction() {
+    async performAction() {
         throw new Error('not implemented');
     }
 
@@ -43,25 +42,26 @@ class StepAction {
     }
 
     /** @type {ClickimStepAction['execute']} */
-    execute(stepActionFactory, step) {
-        return Promise.resolve(this.performAction(stepActionFactory, step))
-            .then(res => Object.assign({ success: true }, res))
-            .catch(err => {
-                const errorMsg = err?.message || err?.seleniumStack?.message;
-                const displayMsg = err?.displayMessage;
-                return {
-                    success: false,
-                    reason: errorMsg,
-                    exception: err,
-                    errorType: commonConstants.stepResult.ACTION_EXCEPTION,
-                    resultInfo: {
-                        exception: `selenium exception: ${errorMsg}`,
-                        // clickim -> playbackStepResultHandler.js -> FAILURE_REASON_MAPPING -> ACTION_EXCEPTION
-                        // expects resultInfo.error or resultInfo.reason
-                        error: displayMsg || errorMsg,
-                    },
-                };
-            });
+    async execute(stepActionFactory, step) {
+        try {
+            const res = await this.performAction(stepActionFactory, step);
+            return { success: true, ...res };
+        } catch (err) {
+            const errorMsg = err?.message || err?.seleniumStack?.message;
+            const displayMsg = err?.displayMessage;
+            return {
+                success: false,
+                reason: errorMsg,
+                exception: err,
+                errorType: commonConstants.stepResult.ACTION_EXCEPTION,
+                resultInfo: {
+                    exception: `selenium exception: ${errorMsg}`,
+                    // clickim -> playbackStepResultHandler.js -> FAILURE_REASON_MAPPING -> ACTION_EXCEPTION
+                    // expects resultInfo.error or resultInfo.reason
+                    error: displayMsg || errorMsg,
+                },
+            };
+        }
     }
 }
 

package/player/stepActions/stepActionRegistrar.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 'use strict';
 
 const LocateStepAction = require('./locateStepAction');
@@ -22,7 +24,6 @@ const ApiStepAction = require('./apiStepAction');
 const ExtractTextStepAction = require('./extractTextStepAction');
 const TdkHybridStepAction = require('./tdkHybridStepAction');
 const PixelValidationStepAction = require('./pixelValidationStepAction');
-
 const CliJsStepAction = require('./cliJsStepAction');
 const CliConditionStepAction = require('./cliConditionStepAction');
 const NodePackageStepAction = require('./nodePackageStepAction');
@@ -36,69 +37,73 @@ function register(stepActionByType, stepActionFactory) {
     });
 }
 
-module.exports = function (driver, stepActionFactory, runMode) {
-    const STEP_ACTION_MAPPING = {
-        locate: LocateStepAction,
-        scroll: ScrollStepAction,
-        mouse: MouseStepAction,
-        submit: SubmitStepAction,
-        text: TextStepAction,
-        'special-key': SpecialKeyStepAction,
-        'user-code': JsCodeStepAction,
-        'validation-code-step': JsCodeStepAction,
-        'wait-for-code-step': JsCodeStepAction,
-        'action-code-step': JsCodeStepAction,
-        'condition-step': JsConditionStepAction,
-        'skip-code-step': JsConditionStepAction,
-        'element-code-step': JsConditionStepAction,
-        'evaluate-expression': EvaluateExpressionStepAction,
-        'text-validation': TextValidationStepAction,
-        'wait-for-text-validation': TextValidationStepAction,
-        'select-option': SelectOptionStepAction,
-        'drop-file': DropFileStepAction,
-        'input-file': InputFileStepAction,
-        hover: HoverStepAction,
-        navigation: NavigationStepAction,
-        wheel: WheelStepAction,
-        sleep: SleepStepAction,
-        refresh: RefreshStepAction,
-        'api-validation': ApiStepAction,
-        'api-action': ApiStepAction,
-        'api-code-step': JsCodeStepAction,
-        'extract-text': ExtractTextStepAction,
-        'simple-ui-verification': PixelValidationStepAction,
-        'wait-for-simple-ui-verification': PixelValidationStepAction,
+const STEP_ACTION_MAPPING = {
+    locate: LocateStepAction,
+    scroll: ScrollStepAction,
+    mouse: MouseStepAction,
+    submit: SubmitStepAction,
+    text: TextStepAction,
+    'special-key': SpecialKeyStepAction,
+    'user-code': JsCodeStepAction,
+    'validation-code-step': JsCodeStepAction,
+    'wait-for-code-step': JsCodeStepAction,
+    'action-code-step': JsCodeStepAction,
+    'condition-step': JsConditionStepAction,
+    'skip-code-step': JsConditionStepAction,
+    'element-code-step': JsConditionStepAction,
+    'evaluate-expression': EvaluateExpressionStepAction,
+    'text-validation': TextValidationStepAction,
+    'wait-for-text-validation': TextValidationStepAction,
+    'select-option': SelectOptionStepAction,
+    'drop-file': DropFileStepAction,
+    'input-file': InputFileStepAction,
+    hover: HoverStepAction,
+    navigation: NavigationStepAction,
+    wheel: WheelStepAction,
+    sleep: SleepStepAction,
+    refresh: RefreshStepAction,
+    'api-validation': ApiStepAction,
+    'api-action': ApiStepAction,
+    'api-code-step': JsCodeStepAction,
+    'extract-text': ExtractTextStepAction,
+    'simple-ui-verification': PixelValidationStepAction,
+    'wait-for-simple-ui-verification': PixelValidationStepAction,
 
-        'cli-validation-download-file': ExtensionOnlyStepAction,
-        'cli-wait-for-download-file': ExtensionOnlyStepAction,
-        'network-validation-step': ExtensionOnlyStepAction,
+    'cli-validation-download-file': ExtensionOnlyStepAction,
+    'cli-wait-for-download-file': ExtensionOnlyStepAction,
+    'network-validation-step': ExtensionOnlyStepAction,
 
-        'cli-validation-code-step': CliJsStepAction,
-        'cli-wait-for-code-step': CliJsStepAction,
-        'cli-action-code-step': CliJsStepAction,
-        'cli-api-code-step': CliJsStepAction,
+    'cli-validation-code-step': CliJsStepAction,
+    'cli-wait-for-code-step': CliJsStepAction,
+    'cli-action-code-step': CliJsStepAction,
+    'cli-api-code-step': CliJsStepAction,
 
-        'cli-condition-step': CliConditionStepAction,
-        'node-package': NodePackageStepAction,
+    'cli-condition-step': CliConditionStepAction,
+    'node-package': NodePackageStepAction,
 
-        'email-code-step': JsCodeStepAction,
-        'cli-email-code-step': CliJsStepAction,
-        'tdk-hybrid': TdkHybridStepAction,
+    'email-code-step': JsCodeStepAction,
+    'cli-email-code-step': CliJsStepAction,
+    'tdk-hybrid': TdkHybridStepAction,
 
-        'sfdc-recorded-step': SfdcRecordedStepAction,
-        'sfdc-step-login': SfdcStepAction,
-        'sfdc-step-logout': SfdcStepAction,
-        'sfdc-step-sobjectcreate': SfdcStepAction,
-        'sfdc-step-sobjectdelete': SfdcStepAction,
-        'sfdc-step-findrecord': SfdcStepAction,
-        'sfdc-step-quickaction': SfdcStepAction,
-        'sfdc-step-sobjectedit': SfdcStepAction,
-        'sfdc-step-sobjectvalidate': SfdcStepAction,
-        'sfdc-step-launchapp': SfdcStepAction,
-        'sfdc-step-closeconsoletabs': SfdcStepAction,
-        'sfdc-step-relatedlistaction': SfdcStepAction,
-    };
+    'sfdc-recorded-step': SfdcRecordedStepAction,
+    'sfdc-step-login': SfdcStepAction,
+    'sfdc-step-logout': SfdcStepAction,
+    'sfdc-step-sobjectcreate': SfdcStepAction,
+    'sfdc-step-sobjectdelete': SfdcStepAction,
+    'sfdc-step-findrecord': SfdcStepAction,
+    'sfdc-step-quickaction': SfdcStepAction,
+    'sfdc-step-sobjectedit': SfdcStepAction,
+    'sfdc-step-sobjectvalidate': SfdcStepAction,
+    'sfdc-step-launchapp': SfdcStepAction,
+    'sfdc-step-closeconsoletabs': SfdcStepAction,
+    'sfdc-step-relatedlistaction': SfdcStepAction,
+};
 
+/**
+ * @param {import('../webdriver')} driver
+ * @param {import('clickim/src/background/stepActions/stepActionFactory').StepActionFactory} stepActionFactory
+*/
+module.exports = function (driver, stepActionFactory, runMode) {
     register(STEP_ACTION_MAPPING, stepActionFactory);
     if (stepActionFactory.registerLocateStepActionUtils) {
         stepActionFactory.registerLocateStepActionUtils(LocateStepAction.getUtils(driver));

package/player/stepActions/submitStepAction.js

@@ -3,9 +3,8 @@
 const StepAction = require('./stepAction');
 
 class SubmitStepAction extends StepAction {
-    performAction() {
-        return this.driver.submitForm(this.getTarget().seleniumElement)
-            .then(() => {});
+    async performAction() {
+        await this.driver.submitForm(this.getTarget().seleniumElement);
     }
 }