@testim/testim-cli 3.261.0 → 3.263.0

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/polyfills/Array.prototype.at.js

@@ -0,0 +1,13 @@
+/* eslint-disable no-extend-native */
+
+Array.prototype.at = Array.prototype.at || function (index) {
+    const relativeIndex = Number.isInteger(index) ? index : 0;
+
+    const indexToRead = relativeIndex >= 0 ? relativeIndex : this.length + relativeIndex;
+
+    if (indexToRead < 0 || indexToRead >= this.length) {
+        return undefined;
+    }
+
+    return this[indexToRead];
+};

package/polyfills/index.js

@@ -0,0 +1 @@
+require('./Array.prototype.at');

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 = |

package/runOptions.js

@@ -112,6 +112,10 @@ const printUsage = () => {
         return line.includes('--high-speed'); // high speed mode was renamed to turbo mode
     }
 
+    function isUrls(line) {
+        return line.includes('--urls');
+    }
+
     function isTestStartTimeout(line) {
         return line.includes('--test-start-timeout');
     }
@@ -119,7 +123,7 @@ const printUsage = () => {
     program.help((txt) => {
         const lines = txt.split('\n');
         return lines
-            .filter(
+            .filter( // hide CLI options
                 (ln) =>
                     !isExtOnlyOption(ln) &&
                     !isParamsJsonOption(ln) &&
@@ -132,6 +136,7 @@ const printUsage = () => {
                     !isSaveRCALocally(ln) &&
                     !isExitCodeIgnoreFailingTests(ln) &&
                     !isDeprecatedHighSpeed(ln) &&
+                    !isUrls(ln) &&
                     !isTestStartTimeout(ln)
             )
             .join('\n');
@@ -172,6 +177,7 @@ program
     .option('-n, --name [test-name]', 'test name to run', collect, [])
     .option('--project [project-id]', 'project ID')
     .option('-r, --report-file [report junit xml path]', 'where to save junit xml results file')
+    .option('--urls', 'add step urls to the junit report')
     .option('--override-report-file-classname [override-report-file-classname]', 'custom junit class name for the junit reporter')
     .option('--reporters [names]', 'report types', list)
     .option('-h, --host [host-name]', 'host name or ip containing the selenium grid')
@@ -1108,6 +1114,7 @@ module.exports = {
             files: [program.files].flat(),
             webpackConfig: program.webpackConfig,
             reportFile: program.reportFile,
+            urls: program.urls,
             reportFileClassname: program.overrideReportFileClassname,
             reporters: program.reporters,
             project: program.project,

package/runner.js

@@ -310,6 +310,13 @@ async function init(options) {
     validateOptionsForCompany(options, companyByProjectId);
     await Promise.all([featureFlagsReady, socketConnected]);
 
+    if (options.browser && featureFlags.flags.dec2022eolBrowsers.isEnabled()) {
+        const browser = utils.getBrowserInfo(options.browser);
+        if (browser.eol) {
+            throw new ArgError(`Unsupported browser: ${browser.browserName}`);
+        }
+    }
+
     perf.log('after featureFlagsReady and socketConnected');
     setSystemInfo(options, editorConfig);
     setCompany(options, companyByProjectId);

package/runners/TestPlanRunner.js

@@ -1,29 +1,30 @@
 'use strict';
 
 const _ = require('lodash');
-const constants = require('../commons/constants');
-
-const TESTIM_RUN_STATUS = constants.testRunStatus;
+const utils = require('../utils');
+const Logger = require('../commons/logger');
+const config = require('../commons/config');
 const reporter = require('../reports/reporter');
-const RealDataService = require('../commons/socket/realDataService');
-const testimServicesApi = require('../commons/testimServicesApi');
-const testimCustomToken = require('../commons/testimCustomToken');
+const constants = require('../commons/constants');
 const TestRunStatus = require('../testRunStatus');
-const analyticsService = require('../services/analyticsService');
+const perf = require('../commons/performance-logger');
 const gridService = require('../services/gridService');
 const branchService = require('../services/branchService');
-const config = require('../commons/config');
 const ParallelWorkerManager = require('./ParallelWorkerManager');
-const utils = require('../utils');
-const { getSuite, calcTestResultStatus, validateConfig } = require('./runnerUtils');
+const analyticsService = require('../services/analyticsService');
+const testimServicesApi = require('../commons/testimServicesApi');
+const testimCustomToken = require('../commons/testimCustomToken');
+const RealDataService = require('../commons/socket/realDataService');
 const { StopRunOnError, ArgError } = require('../errors');
-const Logger = require('../commons/logger');
-const perf = require('../commons/performance-logger');
+const { getSuite, calcTestResultStatus, validateConfig } = require('./runnerUtils');
 
 const guid = utils.guid;
+const TESTIM_RUN_STATUS = constants.testRunStatus;
 const logger = Logger.getLogger('test-plan-runner');
 const TDK_CHILD_RESULTS_TIMEOUT = 1000 * 60 * 5;
 
+/** @typedef {Awaited<ReturnType<typeof getSuite>>['tests'][number]} ExecutionList */
+
 class TestPlanRunner {
     /**
      * @param {string=} customExtensionLocalLocation
@@ -35,9 +36,9 @@ class TestPlanRunner {
 
     /**
      * @private
-     * @param {any[]} beforeTests
-     * @param {any[]} tests
-     * @param {any[]} afterTests
+     * @param {ExecutionList} beforeTests
+     * @param {ExecutionList} tests
+     * @param {ExecutionList} afterTests
      * @param {string} branchToUse
      * @param {import('../runOptions').RunnerOptions} tpOptions
      * @param {string} executionId
@@ -213,9 +214,9 @@ class TestPlanRunner {
 
     /**
      * @private
-     * @param {any[]} beforeTests
-     * @param {any[]} tests
-     * @param {any[]} afterTests
+     * @param {ExecutionList} beforeTests
+     * @param {ExecutionList} tests
+     * @param {ExecutionList} afterTests
      * @param {import('../runOptions').RunnerOptions} tpOptions
      * @param {string} testPlanName
      * @param {string | null} testPlanId
@@ -285,7 +286,7 @@ class TestPlanRunner {
         });
 
         function flattenTestListData(testPlansData) {
-            return _.flattenDeep(Object.keys(testPlansData).map(tpId => testPlansData[tpId])).reduce((all, testRun) => _.concat(all, testRun.beforeTests, testRun.tests, testRun.afterTests), []);
+            return _.flattenDeep(Object.values(testPlansData)).reduce((all, testRun) => all.concat(testRun.beforeTests, testRun.tests, testRun.afterTests), []);
         }
 
         const testPlansResults = {};

package/runners/runnerUtils.js

@@ -53,9 +53,8 @@ function calcTestResultStatus(tests) {
 
 
 /**
- * @template T
  * @param {import('../runOptions').RunnerOptions} options
- * @param {T[]} testList
+ * @param {import('./TestPlanRunner').ExecutionList} testList
  */
 async function validateConfig(options, testList) {
     const supportedBrowsers = options.mode === 'extension' ? [

package/testRunHandler.js

@@ -23,6 +23,14 @@ const MAX_LIGHTWEIGHT_MODE_RUN_DATA_SIZE = 20 * 1000; // max size, in characters
 const canSendRunDataOverUrl = (runData) => JSON.stringify(runData).length < MAX_LIGHTWEIGHT_MODE_RUN_DATA_SIZE;
 
 class TestRun {
+    /**
+     * @param {string} executionId
+     * @param {string} executionName
+     * @param {*} test
+     * @param {import('./runOptions').RunnerOptions} options
+     * @param {string} branchToUse
+     * @param {import('./testRunStatus')} testRunStatus
+     */
     constructor(executionId, executionName, test, options, branchToUse, testRunStatus) {
         this._executionId = executionId;
         this._executionName = executionName;
@@ -33,7 +41,7 @@ class TestRun {
         this._code = test.code;
         this._baseUrl = options.baseUrl || test.baseUrl || test.testConfig.baseUrl;
         this._nativeApp = test.nativeApp;
-        this._overrideTestConfigId = test.overrideTestConfig && test.overrideTestConfig.id;
+        this._overrideTestConfigId = test.overrideTestConfig?.id;
         this._options = options;
         this._branch = branchToUse;
         this._maxRetryCount = options.retries;
@@ -43,7 +51,7 @@ class TestRun {
         this._totalRetryCount = 1;
 
         this._testRunStatus = testRunStatus;
-        const shouldUpdateConfig = !(test.runConfig && test.runConfig.isMobileWeb) && options.browser;
+        const shouldUpdateConfig = !test.runConfig?.isMobileWeb && options.browser;
         this._runConfig = shouldUpdateConfig ? utils.getRunConfigByBrowserName(options.browser, options.saucelabs, options.browserstack) : test.runConfig;
         this.clearTestResultFinished = Promise.resolve();
 
@@ -181,20 +189,22 @@ class TestRun {
             runRequestParams.lightweightMode = this._options.lightweightMode;
         }
 
-        if (this._options.lightweightMode && this._options.lightweightMode.general) {
+        if (this._options.lightweightMode?.general) {
             runRequestParams.company = this._options.company;
             const runData = this.getRunData();
             runRequestParams.lightweightMode.isRunDataSentInUrl = canSendRunDataOverUrl(runData);
+            const stringifiedLength = JSON.stringify(runData).length;
+            const testId = this.getTestId();
             if (runRequestParams.lightweightMode.isRunDataSentInUrl) {
                 runRequestParams.runData = runData;
-                logger.info(`Run data sent as URL param, test id: ${this.getTestId()} run data length: ${JSON.stringify(runData).length}`);
+                logger.info(`Run data sent as URL param, test id: ${testId} run data length: ${stringifiedLength}`);
             } else {
-                logger.warn(`Run data is too big to be sent as a URL param. Test id: ${this.getTestId()}, run data size: ${JSON.stringify(runData).length} (limit: ${MAX_LIGHTWEIGHT_MODE_RUN_DATA_SIZE} characters)`);
+                logger.warn(`Run data is too big to be sent as a URL param. Test id: ${testId}, run data size: ${stringifiedLength} (limit: ${MAX_LIGHTWEIGHT_MODE_RUN_DATA_SIZE} characters)`);
             }
             runRequestParams.isLocalRun = Boolean(this._options.useLocalChromeDriver || this._options.useChromeLauncher);
         }
 
-        if (this._options.lightweightMode && this._options.lightweightMode.preloadTests && this._options.useChromeLauncher) {
+        if (this._options.lightweightMode?.preloadTests && this._options.useChromeLauncher) {
             const preloadedTests = await preloadTests(this._options);
             runRequestParams.preloadedTest = preloadedTests[runRequestParams.testId];
         }
@@ -259,8 +269,7 @@ class TestRun {
         }
         const mustClearPreviousStepResults = (this._timeoutRetryCount > 1 || this._retryCount > 1);
 
-        if (this._options.lightweightMode && this._options.lightweightMode.disableResults &&
-            !mustClearPreviousStepResults && canSendRunDataOverUrl(runData)) {
+        if (this._options.lightweightMode?.disableResults && !mustClearPreviousStepResults && canSendRunDataOverUrl(runData)) {
             return Promise.resolve();
         }
 
@@ -574,7 +583,7 @@ class TestRun {
         this._originalTestResultId = this._originalTestResultId || this._previousTestResultId;
         this._testResultId = utils.guid();
 
-        if (this._options.lightweightMode && this._options.lightweightMode.onlyTestIdsNoSuite) {
+        if (this._options.lightweightMode?.onlyTestIdsNoSuite) {
             return;
         }