@testim/testim-cli 3.270.0 → 3.271.0

package/player/services/frameLocator.js

@@ -1,6 +1,7 @@
+// @ts-check
+
 'use strict';
 
-const Promise = require('bluebird');
 const logger = require('../../commons/logger').getLogger('frame-locator');
 const { locatorBuilderUtils } = require('../../commons/getSessionPlayerRequire');
 const featureFlags = require('../../commons/featureFlags');
@@ -16,13 +17,23 @@ const _getGuidFromSeleniumElement = (seleniumElement) => {
     return seleniumElement[SELENIUM_ELEMENT_KEY] || seleniumElement[SELENIUM_GUID_KEY];
 };
 
+/** @typedef {import('clickim/src/background/frameLocator').FrameLocator} FrameLocator */
+/** @typedef {import("clickim/src/locators/dynamicParentUtils").FrameHandler} FrameHandler */
+/** @typedef {import("clickim/src/background/playbackContext").PlaybackContext} PlaybackContext */
+/** @typedef {import("clickim/src/background/frameTree").FrameTree} FrameTree */
+/** @typedef {import("clickim/src/common/models/locateStep").LocateStep} LocateStep */
+/** @typedef {import("clickim/src/common/models/step").Step} Step */
+/** @typedef {FrameLocator['findFrame']} findFrameFn */
+/** @typedef {ConstructorParameters<typeof import('clickim/src/background/frameLocator').FrameLocator>} ClickimFrameLocatorCtorArgs */
+
 /** @param {import('../webdriver')} driver*/
 module.exports = function frameLocatorFactory(driver) {
     class FrameLocator {
-        /** @type {(...args: ConstructorParameters<typeof import('clickim/src/background/frameLocator').FrameLocator>) => this} */
+        /** @type {(...args: ClickimFrameLocatorCtorArgs) => this}} */
         constructor(frameManager, locateElementPlayer) {
             this.frameManager = frameManager;
             this.locateElementPlayer = locateElementPlayer;
+            /** @type {Record<string, string>} */
             this._cache = {};
         }
 
@@ -43,30 +54,43 @@ module.exports = function frameLocatorFactory(driver) {
             }
         }
 
-        foundFrameCallback(result, frameTree, testimFrameId) {
+        /**
+         * @param {FrameTree} frameTree
+         * @param {string | number} testimFrameId
+         * @returns {Promise<FrameHandler>}
+        */
+        async foundFrameCallback(result, frameTree, testimFrameId) {
             const { frameOffset, locatedElement } = result;
             if (locatorBuilderUtils.isEmptyResult(locatedElement)) {
-                logger.error('got empty result in frame result, not rejected from locate element player');
-                return Promise.reject();
+                const errorMsg = 'got empty result in frame result, not rejected from locate element player';
+                logger.error(errorMsg);
+                throw new Error(errorMsg);
             }
-            return driver.switchToLocatedFrame(locatedElement)
-                .then(el => {
-                    const guid = _getGuidFromSeleniumElement(el.value);
-                    const frameLocateResultUrl = this.getResultsFromCache(guid);
-
-                    return {
-                        frameId: -1,
-                        frameOffset,
-                        tabInfo: frameTree.tabInfo,
-                        tabId: frameTree.tabId,
-                        testimFrameId,
-                        testimFullFrameId: `${this.currentFrameHandler.testimFullFrameId}-${testimFrameId}`,
-                        seleniumFrameElement: el.value,
-                        frameLocateResultUrl,
-                    };
-                });
+            const el = await driver.switchToLocatedFrame(locatedElement);
+            const guid = _getGuidFromSeleniumElement(el.value);
+            const frameLocateResultUrl = this.getResultsFromCache(guid);
+
+            return {
+                frameId: -1,
+                frameOffset,
+                tabInfo: frameTree.tabInfo,
+                tabId: frameTree.tabId,
+                testimFrameId,
+                testimFullFrameId: `${this.currentFrameHandler.testimFullFrameId}-${testimFrameId}`,
+                // @ts-ignore
+                seleniumFrameElement: el.value,
+                frameLocateResultUrl,
+            };
         }
 
+        /**
+         * @param {LocateStep & { targetId: NonNullable<LocateStep['targetId']>}} frameLocator
+         * @param {number} frameDepth
+         * @param {FrameHandler & { frameOffset: NonNullable<FrameHandler['frameOffset']> }} currentFrame
+         * @param {PlaybackContext} context
+         * @param {FrameTree} frameTree
+         * @param {Step} stepData
+         */
         locate(frameLocator, frameDepth, currentFrame, context, frameTree, stepData) {
             // eslint-disable-next-line new-cap
             const locateElementPlayer = new this.locateElementPlayer(context);
@@ -101,7 +125,8 @@ module.exports = function frameLocatorFactory(driver) {
                 });
         }
 
-        findFrame(stepData, frameLocators, context, frameTree) {
+        /** @type {findFrameFn} */
+        async findFrame(stepData, frameLocators, context, frameTree) {
             const allowNoFrameSwitch = featureFlags.flags.enableFrameSwitchOptimization.isEnabled();
             const chronologicalResults = context.playback.resultsHandler.resultsByChronologicOrder;
             const lastResult = chronologicalResults[chronologicalResults.length - 1];
@@ -111,23 +136,31 @@ module.exports = function frameLocatorFactory(driver) {
                 const currentFramePos = frameLocators.findIndex(x => x.testimFrameId === this.currentFrameHandler.testimFrameId);
                 if (currentFramePos > -1) {
                     const shorterPath = frameLocators.slice(currentFramePos + 1);
-                    return Promise.reduce(shorterPath, (currentFrame, frameLocator, index) => this.locate(frameLocator, index, currentFrame, context, frameTree, stepData), this.currentFrameHandler);
+                    let frameIndex = 0;
+                    // Changes to the deepest frame
+                    for (const frameLocator of shorterPath) {
+                        frameIndex++;
+                        this.currentFrameHandler = await this.locate(frameLocator, frameIndex, this.currentFrameHandler, context, frameTree, stepData);
+                    }
+                    return this.currentFrameHandler;
                 }
             }
 
-            return frameTree.getTopFrameHandler()
-                .then(topFrameHandler => {
-                    topFrameHandler.frameOffset = { top: 0, left: 0 };
-                    const switchToTop = (allowNoFrameSwitch && this.currentFrameHandler === topFrameHandler) ?
-                        Promise.resolve(this.currentFrameHandler) :
-                        driver.switchToTopFrame();
-                    return switchToTop.then(() => {
-                        this.cacheFrameLocateResults(this.currentFrameHandler);
-                        this.currentFrameHandler = topFrameHandler;
-                        return Promise.reduce(frameLocators, (currentFrame, frameLocator, index) =>
-                            this.locate(frameLocator, index, currentFrame, context, frameTree, stepData), topFrameHandler);
-                    });
-                });
+            const topFrameHandler = await frameTree.getTopFrameHandler();
+            topFrameHandler.frameOffset = { top: 0, left: 0 };
+            const switchToTop = (allowNoFrameSwitch && this.currentFrameHandler === topFrameHandler) ?
+                this.currentFrameHandler :
+                driver.switchToTopFrame();
+            await switchToTop;
+            this.cacheFrameLocateResults(this.currentFrameHandler);
+            this.currentFrameHandler = topFrameHandler;
+            let frameIndex = 0;
+            let currentFrame = topFrameHandler;
+            for (const frameLocator of frameLocators) {
+                frameIndex++;
+                currentFrame = await this.locate(frameLocator, frameIndex, currentFrame, context, frameTree, stepData);
+            }
+            return currentFrame;
         }
     }
 

package/player/services/portSelector.js

@@ -1,7 +1,5 @@
 'use strict';
 
-const Promise = require('bluebird');
-
 // Legacy code not supported in selenium mode
 class PortSelector {
     // eslint-disable-next-line no-useless-constructor, no-empty-function

package/player/services/tabService.js

@@ -4,7 +4,6 @@
 
 const sessionPlayer = require('../../commons/getSessionPlayerRequire');
 
-const Promise = require('bluebird');
 const WindowUtils = require('../utils/windowUtils');
 const ScreenshotUtils = require('../utils/screenshotUtils');
 const ImageCaptureUtils = require('../utils/imageCaptureUtils');
@@ -158,6 +157,7 @@ class TabService {
     }
 
     async buildTabInfo(sessionId, tabId, order, openerStepId, options = {}) {
+        /** @type {{ title: any; url: any; isMainTab: string; favIconUrl?: any, openerTabId?: any }} */
         const tab = await this.getTabDetails(tabId, sessionId, options);
         const infoId = guid();
         function isMainTab(tabService) {
@@ -507,7 +507,9 @@ class TabService {
             .then(() => {
                 let tabId;
                 if (tabMatcher) {
-                    const allTabInfos = this.getAllTabIds(sessionId).map(tabId => Object.assign({}, this.getTabInfo(sessionId, tabId), { tabId })).filter(tabInfo => !tabInfo.isClosed);
+                    const allTabInfos = this.getAllTabIds(sessionId)
+                        .map((tabId) => Object.assign({}, this.getTabInfo(sessionId, tabId), { tabId }))
+                        .filter((tabInfo) => !tabInfo.isClosed);
                     tabId = tabMatcher.matchTabs(step, allTabInfos);
                 } else {
                     // old session player (clickim) version - remove once enough time passed

package/player/stepActions/RefreshStepAction.js

@@ -1,7 +1,6 @@
 'use strict';
 
 const StepAction = require('./stepAction');
-require('bluebird');
 
 class RefreshStepAction extends StepAction {
     async execute() {

package/player/stepActions/baseJsStepAction.js

@@ -1,6 +1,5 @@
 'use strict';
 
-const Promise = require('bluebird');
 const sessionPlayer = require('../../commons/getSessionPlayerRequire');
 
 const featureFlags = require('../../commons/featureFlags');

package/player/stepActions/locateStepAction.js

@@ -3,7 +3,6 @@
 'use strict';
 
 const StepAction = require('./stepAction');
-const Promise = require('bluebird');
 const sessionPlayer = require('../../commons/getSessionPlayerRequire');
 const featureFlags = require('../../commons/featureFlags');
 const logger = require('../../commons/logger').getLogger('locate-step-action');

package/player/stepActions/specialKeyStepAction.js

@@ -2,7 +2,6 @@
 
 const { extractElementId } = require('../../utils');
 const StepAction = require('./stepAction');
-const Promise = require('bluebird');
 
 const keyMap = {
     8: '\uE008', // (Backspace)

package/player/utils/screenshotUtils.js

@@ -2,7 +2,6 @@
 
 'use strict';
 
-const Promise = require('bluebird');
 const pRetry = require('p-retry');
 
 class ScreenshotUtils {

package/player/utils/windowUtils.js

@@ -2,7 +2,6 @@
 
 'use strict';
 
-const Promise = require('bluebird');
 const pRetry = require('p-retry');
 const { delay } = require('../../utils');
 const { PageNotAvailableError } = require('../../errors');

package/runners/buildCodeTests.js

@@ -2,7 +2,6 @@
 
 const _ = require('lodash');
 const path = require('path');
-const Promise = require('bluebird');
 const MemoryFS = require('memory-fs');
 const utils = require('../utils');
 const lazyRequire = require('../commons/lazyRequire');

package/services/gridService.js

@@ -1,7 +1,8 @@
+// @ts-check
+
 'use strict';
 
 const _ = require('lodash');
-const Promise = require('bluebird');
 
 const { GridError, ArgError } = require('../errors');
 const { hasTestPlanFlag, promiseMap } = require('../utils');
@@ -9,6 +10,7 @@ const { gridMessages, gridTypes } = require('../commons/constants');
 const logger = require('../commons/logger').getLogger('grid-service');
 const servicesApi = require('../commons/testimServicesApi');
 
+/** @type {Record<string, { gridId: string; companyId: string; slotId: string; browser: string }>} */
 const gridCache = {};
 const urlExtractRegex = /(^(https?):\/{2})?(.*)/;
 let keepAliveTimer = null;
@@ -145,37 +147,40 @@ async function getGridDataByGridName(companyId, gridName, allGrids) {
     return getSerializableObject(grid);
 }
 
-function releaseGridSlot(workerId, projectId) {
+async function releaseGridSlot(workerId, projectId) {
     const gridData = gridCache[workerId];
     if (!gridData) {
-        return Promise.resolve();
+        return;
     }
 
     const { slotId, gridId, browser, companyId } = gridData;
     delete gridCache[workerId];
     if (!slotId) {
         logger.warn('failed to find grid slot id', { projectId });
-        return Promise.resolve();
+        return;
     }
 
     logger.info('release slot id', { projectId, companyId, slotId, gridId, browser });
-    return servicesApi.releaseGridSlot(companyId, projectId, slotId, gridId, browser)
-        .catch(err => logger.error('failed to release slot', { projectId, err }));
+    try {
+        await servicesApi.releaseGridSlot(companyId, projectId, slotId, gridId, browser);
+    } catch (err) {
+        logger.error('failed to release slot', { projectId, err });
+    }
 }
 
-function keepAlive(projectId) {
-    const slots = Object.keys(gridCache).reduce((slots, workerId) => {
-        slots.push(gridCache[workerId]);
-        return slots;
-    }, []).filter(Boolean);
+async function keepAlive(projectId) {
+    const slots = Object.values(gridCache).filter(Boolean);
 
-    if (_.isEmpty(slots)) {
-        return Promise.resolve();
+    if (slots.length === 0) {
+        return;
     }
 
     logger.info('keep alive worker slots', { projectId, slots });
-    return servicesApi.keepAliveGrid(projectId, slots)
-        .catch(err => logger.error('failed to update grid keep alive', { err, slots, projectId }));
+    try {
+        await servicesApi.keepAliveGrid(projectId, slots);
+    } catch (err) {
+        logger.error('failed to update grid keep alive', { err, slots, projectId });
+    }
 }
 
 function startKeepAlive(projectId) {
@@ -183,21 +188,24 @@ function startKeepAlive(projectId) {
     keepAliveTimer = setInterval(keepAlive, KEEP_ALIVE_INTERVAL, projectId);
 }
 
-function releaseAllSlots(projectId) {
+async function releaseAllSlots(projectId) {
     const workerIds = Object.keys(gridCache);
 
     if (_.isEmpty(workerIds)) {
-        return Promise.resolve();
+        return;
     }
 
     logger.warn('not all slots released before end runner flow', { projectId });
-    return promiseMap(workerIds, workerId => releaseGridSlot(workerId, projectId))
-        .catch(err => logger.error('failed to release all slots', { err, projectId }));
+    try {
+        await promiseMap(workerIds, workerId => releaseGridSlot(workerId, projectId));
+    } catch (err) {
+        logger.error('failed to release all slots', { err, projectId });
+    }
 }
 
-function endKeepAlive(projectId) {
-    return releaseAllSlots(projectId)
-        .then(() => clearInterval(keepAliveTimer));
+async function endKeepAlive(projectId) {
+    await releaseAllSlots(projectId);
+    clearInterval(keepAliveTimer);
 }
 
 function getVendorKeyFromOptions(type, options) {
@@ -276,13 +284,13 @@ async function getGridData(options) {
 /**
  * @param {string} browser
  * @param {string} executionId
- * @param {import('../runOptions')} options
+ * @param {import('../runOptions').RunnerOptions} options
  * @param {number} workerId
  */
 async function getGridSlot(browser, executionId, options, workerId) {
     const getGridDataFromServer = async () => {
-        const { host, project, grid, gridId, useLocalChromeDriver, useChromeLauncher, company = {} } = options;
-        const companyId = company.companyId;
+        const { host, project, grid, gridId, useLocalChromeDriver, useChromeLauncher, company } = options;
+        const companyId = company?.companyId;
         if (useLocalChromeDriver || useChromeLauncher) {
             return { mode: 'local' };
         }

package/testRunHandler.js

@@ -99,7 +99,11 @@ class TestRun {
     }
 
     get androidActivityWait() {
-        const activity = 'appMetadata' in this._nativeApp ? this._nativeApp.appMetadata.activity : this._nativeApp.activity;
+        const appData = 'appMetadata' in this._nativeApp ? this._nativeApp.appMetadata : this._nativeApp;
+        if (appData.activity.includes(appData.id)) {
+            return `${appData.id}.*`;
+        }
+        const { activity } = appData;
         const lastValue = activity.split('.').pop();
         return activity.replace(lastValue, '*');
     }

package/workers/WorkerSelenium.js

@@ -1,6 +1,5 @@
 'use strict';
 
-const Promise = require('bluebird');
 const BaseWorker = require('./BaseWorker');
 const logger = require('../commons/logger').getLogger('worker-selenium');
 const reporter = require('../reports/reporter');
@@ -118,7 +117,7 @@ class WorkerSelenium extends BaseWorker {
             preloadedTest = preloadedTests[this.testId];
         }
 
-        async function runSeleniumTest() {
+        const runSeleniumTest = async () => {
             if (testRunHandler.automationMode === 'codeful') {
                 // Testim Development Kit test;
                 if (!sessionPlayer.callOrderScheduler) { // old session player
@@ -131,22 +130,32 @@ class WorkerSelenium extends BaseWorker {
                     );
                 }
                 perf.log('right before playTestByCode');
-                return new Promise((resolve, reject) => sessionPlayer.playTestByCode(
-                    this.testId,
-                    this.executionId,
-                    this.testResultId,
-                    this.baseUrl,
-                    this.userData,
-                    version,
-                    resolve,
-                    false,
-                    this.overrideTestConfigId,
-                    this.branch,
-                    testRunHandler.code,
-                    testRunHandler.testName
-                ).catch(reject))
-                    .log('right after playTestByCode')
-                    .timeout(this.testRunTimeout, timeoutMessages.TEST_COMPLETE_TIMEOUT_MSG)
+                // TODO: Fix promise constructor anti-pattern
+                const playTestByCodePromise = new Promise((resolve, reject) => {
+                    sessionPlayer.playTestByCode(
+                        this.testId,
+                        this.executionId,
+                        this.testResultId,
+                        this.baseUrl,
+                        this.userData,
+                        version,
+                        resolve,
+                        false,
+                        this.overrideTestConfigId,
+                        this.branch,
+                        testRunHandler.code,
+                        testRunHandler.testName
+                    ).catch(reject);
+                });
+                return utils
+                    .promiseTimeout(
+                        playTestByCodePromise.then((testResult) => {
+                            perf.log('right after playTestByCode');
+                            return testResult;
+                        }),
+                        this.testRunTimeout,
+                        timeoutMessages.TEST_COMPLETE_TIMEOUT_MSG
+                    )
                     .catch(err => {
                         if (err instanceof utils.TimeoutError) {
                             sessionPlayer.stopPlayingOnTestTimeout?.();
@@ -160,32 +169,37 @@ class WorkerSelenium extends BaseWorker {
             }
             const INCOGNITO = false;
 
-            return new Promise((resolve, reject) =>
-                sessionPlayer.playByTestId(
-                    this.testId,
-                    this.executionId,
-                    this.testResultId,
-                    this.baseUrl,
-                    this.userData,
-                    version,
-                    resolve,
-                    false,
-                    this.overrideTestConfigId,
-                    this.branch,
-                    INCOGNITO,
-                    testRunHandler.remoteRunId,
-                    undefined,
-                    undefined,
-                    preloadedTest
-                ).catch(reject))
-                .timeout(this.testRunTimeout, timeoutMessages.TEST_COMPLETE_TIMEOUT_MSG)
-                .catch(err => {
+            return utils.promiseTimeout(
+                // TODO: Fix promise constructor anti-pattern
+                new Promise((resolve, reject) => {
+                    sessionPlayer.playByTestId(
+                        this.testId,
+                        this.executionId,
+                        this.testResultId,
+                        this.baseUrl,
+                        this.userData,
+                        version,
+                        resolve,
+                        false,
+                        this.overrideTestConfigId,
+                        this.branch,
+                        INCOGNITO,
+                        testRunHandler.remoteRunId,
+                        undefined,
+                        undefined,
+                        preloadedTest
+                    ).catch(reject);
+                }),
+                this.testRunTimeout,
+                timeoutMessages.TEST_COMPLETE_TIMEOUT_MSG,
+            )
+                .catch((err) => {
                     if (err instanceof utils.TimeoutError) {
                         sessionPlayer.stopPlayingOnTestTimeout?.();
                     }
                     throw err;
                 })
-                .then(async testResult => {
+                .then(async (testResult) => {
                     if (sessionPlayerInit.localAssetService) {
                         await sessionPlayerInit.localAssetService.drain();
                     }
@@ -203,23 +217,24 @@ class WorkerSelenium extends BaseWorker {
                     }
                     const resultWithStats = { ...testResult, ...testRunHandler.seleniumPerfStats.getStats() };
                     if (this.lambdatestService.isLambdatestRun()) {
-                        await driver.executeJS(`lambda-status=${!resultWithStats.success ? 'failed' : 'passed'}`).catch(() => { });
+                        await driver.executeJS(`lambda-status=${!resultWithStats.success ? 'failed' : 'passed'}`).catch(() => {});
                     }
                     return resultWithStats;
                 });
-        }
+        };
 
         driver.start();
 
         perf.log('right before super.runTestOnce in workerSelenium');
-        return super.runTestOnce(testRunHandler, seleniumTestPlayer)
-            .log('right after super.runTestOnce in workerSelenium')
-            .then(runSeleniumTest.bind(this))
-            .log('right after runSeleniumTest')
-            .catch(err => {
-                logger.error('failed to run test once', { err });
-                throw err;
-            });
+        try {
+            await super.runTestOnce(testRunHandler, seleniumTestPlayer);
+            perf.log('right after super.runTestOnce in workerSelenium');
+            await runSeleniumTest();
+            perf.log('right after runSeleniumTest');
+        } catch (err) {
+            logger.error('failed to run test once', { err });
+            throw err;
+        }
     }
 }
 function setupCliPerformanceMonitoring(sessionPlayer) {

package/workers/workerUtils.js

@@ -1,18 +1,20 @@
-const Promise = require('bluebird');
 const gridService = require('../services/gridService');
 const logger = require('../commons/logger').getLogger('worker-utils');
 
-const releaseGridSlot = (workerId, releaseSlotOnTestFinished, projectId) => {
+const releaseGridSlot = async (workerId, releaseSlotOnTestFinished, projectId) => {
     if (!releaseSlotOnTestFinished) {
-        return Promise.resolve();
+        return;
     }
-    return gridService.releaseGridSlot(workerId, projectId);
+    await gridService.releaseGridSlot(workerId, projectId);
 };
 
-const releasePlayer = (workerId, releaseSlotOnTestFinished, projectId, player) => {
+const releasePlayer = async (workerId, releaseSlotOnTestFinished, projectId, player) => {
     logger.info('releasing player', { hasPlayer: Boolean(player) });
-    return (player ? player.onDone() : Promise.resolve())
-        .finally(() => releaseGridSlot(workerId, releaseSlotOnTestFinished, projectId));
+    try {
+        await player?.onDone();
+    } finally {
+        await releaseGridSlot(workerId, releaseSlotOnTestFinished, projectId);
+    }
 };
 
 module.exports.releasePlayer = releasePlayer;