@testim/testim-cli 3.260.0 → 3.262.0

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);
     }
 }
 

package/player/stepActions/textStepAction.js

@@ -2,7 +2,6 @@
 
 const StepAction = require('./stepAction');
 const setTextScript = require('./scripts/setText');
-const Promise = require('bluebird');
 const { codeSnippets } = require('../../commons/getSessionPlayerRequire');
 const dispatchFocus = require('./scripts/focusElement');
 const sessionPlayer = require('../../commons/getSessionPlayerRequire');
@@ -12,17 +11,18 @@ const constants = sessionPlayer.commonConstants.stepResult;
 const setTextDraftJs = codeSnippets?.setTextDraftJs;
 
 class TextStepAction extends StepAction {
-    setValueNative() {
+    async setValueNative() {
         const context = this.context;
         const target = this.getTarget();
         if (!this.step.delayBetweenChars) {
             return this.driver.setValue(target.seleniumElement, context.stepText);
         }
 
-        return this.driver.elementIdClear(extractElementId(target.seleniumElement)).then(async () => await this.setTextDelayed());
+        await this.driver.elementIdClear(extractElementId(target.seleniumElement));
+        return await this.setTextDelayed();
     }
 
-    setValueJS() {
+    async setValueJS() {
         const step = this.step;
         const context = this.context;
         const target = context.data[step.targetId || 'targetId'];
@@ -33,8 +33,8 @@ class TextStepAction extends StepAction {
             return this.driver.executeJS(setTextDraftJs(target.locatedElement, context.stepText));
         }
 
-        if (!events || !events.length) {
-            return Promise.resolve();
+        if (!events?.length) {
+            return undefined;
         }
 
         const eventMessage = {
@@ -59,8 +59,8 @@ class TextStepAction extends StepAction {
         // values between 0 and -1 -_-.
         const eventParam = this.driver.isEdge() ? JSON.stringify(eventMessage) : eventMessage;
 
-        return this.driver.executeCodeAsync(setTextCode, timeout, eventParam)
-            .then(result => ({ success: Boolean(result.value?.success) }));
+        const result = await this.driver.executeCodeAsync(setTextCode, timeout, eventParam);
+        return { success: Boolean(result.value?.success) };
     }
 
     async setTextDelayed() {
@@ -75,7 +75,7 @@ class TextStepAction extends StepAction {
         }
     }
 
-    setValueAppendNative() {
+    async setValueAppendNative() {
         const keys = [];
         const context = this.context;
         const target = this.getTarget();
@@ -86,12 +86,12 @@ class TextStepAction extends StepAction {
                 return this.driver.elementIdValue(extractElementId(target.seleniumElement), keys);
             }
 
-            return Promise.resolve(this.setTextDelayed());
+            return this.setTextDelayed();
         }
-        return Promise.reject(new Error('missing selenium element'));
+        throw new Error('missing selenium element');
     }
 
-    performAction() {
+    async performAction() {
         const target = this.getTarget();
         const forceJsEvent = this.driver.isSafari() &&
             target.locatedElement && target.locatedElement.shadowPath &&
@@ -101,11 +101,11 @@ class TextStepAction extends StepAction {
             if (this.step.nativeEvents) {
                 return this.setValueAppendNative();
             }
-            return Promise.resolve({
+            return {
                 success: false,
                 errorType: constants.TEXT_ACTION_FAILURE,
                 resultInfo: { error: "'Append Text' is only supported in Native Mode" },
-            });
+            };
         }
         if (this.step.nativeEvents && !forceJsEvent) {
             return this.setValueNative();

package/player/stepActions/textValidationStepAction.js

@@ -1,6 +1,5 @@
 'use strict';
 
-const Promise = require('bluebird');
 const sessionPlayer = require('../../commons/getSessionPlayerRequire');
 const StepAction = require('./stepAction');
 
@@ -9,49 +8,62 @@ const paramEvaluator = sessionPlayer.stepParamExpressionEvaluator;
 const utils = sessionPlayer.utils;
 
 class TextValidationStepAction extends StepAction {
-    performAction(stepActionFactory) {
+    async performAction(stepActionFactory) {
         const step = this.step;
         const context = this.context;
         const target = this.getTarget();
         const frameHandler = this.frameHandler;
 
-
-        return new Promise(resolve => {
-            const onFail = resultInfo => {
-                resolve({ errorType: constants.TEXT_COMPARE_FAILURE, resultInfo, success: false });
-            };
-            this.stepActionUtils.extractTargetText(target)
-                .then(text => {
-                    if (paramEvaluator) {
-                        const expected = paramEvaluator.computeExpression(step.expression2, context, this.exportsGlobal, this.exportsTest);
-                        return {
-                            actual: text,
-                            expected: expected.evaluatedText,
-                        };
-                    }
-                    return stepActionFactory.executeStep(step.expression2, context, frameHandler, this.exportsGlobal, this.locateElementPlayer, this.exportsTest)
-                        .then(res => ({
-                            actual: text,
-                            expected: res.evaluatedText,
-                        }));
-                })
-                .then(({ actual, expected }) => {
-                    try {
-                        const compareResult = utils.compareOrMatch(expected, actual);
-                        return compareResult ?
-                            resolve({ success: true }) :
-                            onFail({ expected: String(expected), actual });
-                    } catch (err) {
-                        return onFail({ expected: expected.toString(), actual });
-                    }
-                })
-                .catch(err => resolve({
+        try {
+            const text = await this.stepActionUtils.extractTargetText(target);
+            let actual;
+            let expected;
+            if (paramEvaluator) {
+                const evaluation = paramEvaluator.computeExpression(
+                    step.expression2,
+                    context,
+                    this.exportsGlobal,
+                    this.exportsTest,
+                );
+                actual = text;
+                expected = evaluation.evaluatedText;
+            } else {
+                const res = await stepActionFactory.executeStep(
+                    step.expression2,
+                    context,
+                    frameHandler,
+                    this.exportsGlobal,
+                    this.locateElementPlayer,
+                    this.exportsTest,
+                );
+                actual = text;
+                expected = res.evaluatedText;
+            }
+            try {
+                const compareResult = utils.compareOrMatch(expected, actual);
+                if (compareResult) {
+                    return { success: true };
+                }
+                return {
                     success: false,
-                    reason: err.message,
-                    exception: err,
-                    shouldRetry: true,
-                }));
-        });
+                    errorType: constants.TEXT_COMPARE_FAILURE,
+                    resultInfo: { expected: String(expected), actual },
+                };
+            } catch (err) {
+                return {
+                    success: false,
+                    errorType: constants.TEXT_COMPARE_FAILURE,
+                    resultInfo: { expected: expected.toString(), actual },
+                };
+            }
+        } catch (err) {
+            return {
+                success: false,
+                reason: err.message,
+                exception: err,
+                shouldRetry: true,
+            };
+        }
     }
 }
 

package/player/stepActions/wheelStepAction.js

@@ -1,18 +1,17 @@
 'use strict';
 
-const Promise = require('bluebird');
 const StepAction = require('./stepAction');
 const wheelScript = require('./scripts/wheel');
 const { codeSnippets } = require('../../commons/getSessionPlayerRequire');
 
 class WheelStepAction extends StepAction {
-    performAction() {
+    async performAction() {
         const step = this.step;
         const context = this.context;
         const events = step.events;
 
-        if (!events || !events.length) {
-            return Promise.resolve();
+        if (!events?.length) {
+            return undefined;
         }
 
         const eventMessage = {
@@ -38,13 +37,8 @@ class WheelStepAction extends StepAction {
         // values between 0 and -1 -_-.
         const eventParam = this.driver.isEdge() ? JSON.stringify(eventMessage) : eventMessage;
 
-        return this.driver.executeCodeAsync(wheelCode, timeout, eventParam)
-            .then(result => {
-                if (result.value && result.value.state === 'success') {
-                    return { success: true };
-                }
-                return { success: false };
-            });
+        const result = await this.driver.executeCodeAsync(wheelCode, timeout, eventParam);
+        return { success: result.value?.state === 'success' };
     }
 }
 

package/processHandler.js

@@ -5,6 +5,7 @@
 const { promiseTimeout, promiseMap } = require('./utils');
 const logger = require('./commons/logger').getLogger('process-handler');
 
+/** @type {Array<() => PromiseLike<void>>} */
 const exitHooks = [];
 
 /**
@@ -67,6 +68,7 @@ module.exports = function (onExit, _process = process) {
     });
 };
 
+/** @param {() => PromiseLike<void>} hook */
 module.exports.registerExitHook = function (hook) {
     exitHooks.push(hook);
 };

package/reports/junitReporter.js

@@ -52,7 +52,17 @@ function getPrintName(testResult) {
     const testDataNumber = typeof testData.total === 'number' ? ` - ${testData.index} / ${testData.total} Data set` : '';
     return `${testResult.name}${testDataNumber}`;
 }
-
+function getVisitedUrlsList(testResult) {
+    if (!testResult.visitedUrlsList) {
+        console.log('No URLs found:', 'Please contact our support team or remove the --urls flag from the CLI command');
+    }
+    const visitedUrls = testResult.visitedUrlsList || '';
+    return `${visitedUrls}`;
+}
+function getVisitedUrlsJson(testResult) {
+    const visitedUrls = testResult.visitedUrlsJson || '';
+    return `${visitedUrls}`;
+}
 async function report(editorUrl, testPlanResults, projectId, branch, classname, options) {
     function createTestCaseObject(testResult) {
         const testResultUrl = utils.getTestUrl(editorUrl, projectId, testResult.testId, testResult.resultId, branch);
@@ -79,7 +89,14 @@ async function report(editorUrl, testPlanResults, projectId, branch, classname,
         if (isSkippedTest(testResult) && utils.isQuarantineAndNotRemoteRun(testResult, options) && featureAvailabilityService.isTestStatusEnabled) {
             testResultObject.skipped = {};
         }
+
         testResultObject['system-out'] = testResultUrl;
+
+        if (options.urls) {
+            testResultObject['visited-urls-list'] = getVisitedUrlsList(testResult);
+            testResultObject['visited-urls-json'] = getVisitedUrlsJson(testResult);
+        }
+
         return testResultObject;
     }
 

package/runOptions.d.ts

@@ -281,6 +281,10 @@ interface RunnerOptions extends Partial<Omit<TunnelOptions, 'tunnelOnlyMode' | '
     // #region intersections
     intersections: { labels?: string[]; suiteNames?: string[]; suiteIds?: string[] };
     // #endregion
+
+    // #region visited URLs
+    urls?: string;
+    // #endregion
 }
 
 type Options = |