@testim/testim-cli 3.252.0 → 3.254.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testim/testim-cli",
-  "version": "3.252.0",
+  "version": "3.254.0",
   "description": "Command line interface for running Testing on your CI",
   "author": "Oren Rubin",
   "contributors": [{
@@ -32,7 +32,7 @@
   },
   "lazyDependencies": {
     "ngrok": "3.4.0",
-    "webpack": "4.43.0",
+    "webpack": "5.74.0",
     "playwright": "0.12.1",
     "puppeteer": "2.1.1",
     "selenium-webdriver": "3.6.0",
@@ -68,25 +68,26 @@
     "form-data": "3.0.0",
     "fs-extra": "10.0.1",
     "glob": "7.2.0",
+    "https-proxy-agent": "5.0.0",
     "istanbul-lib-report": "3.0.0",
     "istanbul-reports": "3.0.2",
-    "jimp": "0.16.1",
+    "jimp": "0.16.2",
     "jsdom": "19.0.0",
     "jsonwebtoken": "8.5.1",
     "lodash": "4.17.21",
     "memory-fs": "0.5.0",
     "memorystream": "0.3.1",
     "mkdirp": "1.0.4",
-    "moment": "2.25.3",
+    "moment": "2.29.4",
     "ms": "2.1.2",
-    "npm": "8.3.0",
+    "npm": "8.19.2",
     "object-hash": "3.0.0",
     "ora": "5.4.1",
     "p-retry": "4.6.2",
     "pako": "1.0.11",
     "portfinder": "1.0.28",
     "promise-queue": "2.2.5",
-    "prompts": "2.3.2",
+    "prompts": "2.4.2",
     "proxy-agent": "5.0.0",
     "rox-node": "4.9.18",
     "semver": "7.3.2",
@@ -98,6 +99,7 @@
     "threads": "0.12.0",
     "ua-parser-js": "0.7.28",
     "validate-npm-package-name": "3.0.0",
+    "webdriverio": "7.24.0",
     "winston": "3.6.0",
     "winston-transport": "4.5.0",
     "ws": "8.5.0",
@@ -119,6 +121,6 @@
     "pack-serve": "yarn pack-onprem && http-server deploy/"
   },
   "engines": {
-    "node": ">= 12.0.0"
+    "node": ">= 14.0.0"
   }
 }

package/player/WebdriverioWebDriverApi.js

@@ -5,7 +5,7 @@ const Queue = require('promise-queue');
 const Promise = require('bluebird');
 const config = require('../commons/config');
 const {
-    UNICODE_CHARACTERS, W3C_ELEMENT_ID, EDGE_LAST_VERSION, EDGE_CHROMIUM_MIN_VERSION,
+    UNICODE_CHARACTERS, W3C_ELEMENT_ID,
 } = require('./constants');
 const isElementDisplayed = require('./scripts/isElementDisplayed');
 const logger = require('../commons/logger').getLogger('WebDriverApi');
@@ -59,6 +59,7 @@ class WebdriverioWebDriverApi {
         this.queue = new Queue(maxConcurrent, maxQueue);
     }
 
+    /** @returns {Promise<any>} */
     addToQueue(func) {
         const perfId = this.seleniumPerfStats.markStart();
         return this.queue.add(func)
@@ -247,6 +248,10 @@ class WebdriverioWebDriverApi {
             .finally(() => this.seleniumPerfStats.markEnd(perfId, SELENIUM_PERF_MARKS.GET_SCREENSHOT));
     }
 
+    /**
+     * @param {string} selector
+     * @returns {Promise<{ value: HTMLElement }>}
+    */
     getElementBySelector(selector) {
         return this.addToQueue(() => this.client.element(selector));
     }
@@ -506,7 +511,7 @@ class WebdriverioWebDriverApi {
         return this.addToQueue(() => this.client.getTitle());
     }
 
-
+    // eslint-disable-next-line default-param-last
     windowHandleSize(windowHandle = 'current', size) {
         return this.addToQueue(() => {
             let data = {};

package/player/appiumTestPlayer.js

@@ -0,0 +1,102 @@
+'use strict';
+
+const webdriverio = require('webdriverio');
+const TabService = require('./services/tabServiceMock');
+const PortSelector = require('./services/portSelector');
+const windowCreationListener = require('./services/windowCreationListener');
+const frameLocatorFactory = require('./services/mobileFrameLocatorMock');
+const { isDebuggerConnected } = require('../commons/detectDebugger');
+const logger = require('../commons/logger').getLogger('appium-test-player');
+
+const sessionPlayer = require('../commons/getSessionPlayerRequire');
+
+const Player = sessionPlayer.sessionPlayer;
+// delete after https://github.com/testimio/clickim/pull/3430 release to the store
+const assetService = sessionPlayer.assetService;
+const commonConstants = sessionPlayer.commonConstants;
+const StepActionFactory = sessionPlayer.stepActionFactory;
+const mobileLocateElementPlayer = sessionPlayer.MobileLocateElementPlayer;
+const PlaybackTimeoutCalculator = require('./services/playbackTimeoutCalculator');
+const testResultService = require('../commons/socket/testResultService');
+
+// delete after https://github.com/testimio/clickim/pull/3430 release to the store
+const CryptoJS = require('crypto-js');
+const StepActionUtils = require('./utils/stepActionUtils');
+
+class AppiumTestPlayer {
+    //eslint-disable-next-line default-param-last
+    constructor(id, userParamsData, shouldMonitorPerformance, automationMode = 'code', driver = webdriverio, testRetryCount, previousTestResultId) {
+        this.driver = driver;
+        this.id = id;
+
+        const stepActionUtils = new StepActionUtils(this.driver);
+        this.stepActionFactory = new StepActionFactory(stepActionUtils);
+        require('./stepActions/stepActionRegistrar')(this.driver, this.stepActionFactory, 'selenium');
+
+        if (assetService.setMd5) {
+            // delete after https://github.com/testimio/clickim/pull/3430 release to the store
+            assetService.setMd5(CryptoJS);
+        }
+        this.tabService = new TabService(this.driver);
+        this.windowCreationListener = windowCreationListener;
+        this.playbackTimeoutCalculator = new PlaybackTimeoutCalculator(isDebuggerConnected());
+
+        this.tabService.createSesion(id);
+
+        const FrameLocator = frameLocatorFactory(this.driver);
+
+        this.sessionPlayer = new Player(
+            id,
+            this.tabService,
+            null,
+            null,
+            FrameLocator,
+            PortSelector,
+            mobileLocateElementPlayer,
+            null /* Not in use, placeholder for the order of arguments */,
+            stepActionUtils,
+            this.stepActionFactory,
+            this.playbackTimeoutCalculator,
+            testResultService.getSocket(),
+            automationMode,
+        );
+
+        if (this.sessionPlayer.setShouldMonitorPerformance) {
+            this.sessionPlayer.setShouldMonitorPerformance(shouldMonitorPerformance);
+        }
+        this.sessionPlayer.playbackManager.isRemoteSession = true;
+        this.sessionPlayer.playbackManager.isLocalRun = false;
+        this.sessionPlayer.playbackManager.testRetryCount = testRetryCount;
+        this.sessionPlayer.playbackManager.previousTestResultId = previousTestResultId;
+
+        this.sessionPlayer.playbackManager.userParamsData = userParamsData || {};
+        this.onStepCompleted = this.onStepCompleted.bind(this);
+
+        this.sessionPlayer.playbackManager.on(commonConstants.playback.RESULT, this.onStepCompleted);
+    }
+
+    onStepCompleted(result, testId, resultId, step) {
+        //do nothing for now ...
+    }
+
+
+    async onDone() {
+        try {
+            await this.driver.activeSession.deleteSession();
+        } catch (error) {
+            logger.error('error while deleting appium session', { error });
+        } finally {
+            this.sessionPlayer.playbackManager.off(commonConstants.playback.RESULT);
+            this.sessionPlayer = null;
+            this.tabService = null;
+            this.stepActionFactory = null;
+            this.driver = null;
+        }
+    }
+
+    getSessionId() {
+        return this.driver.activeSession.sessionId;
+    }
+}
+
+module.exports = AppiumTestPlayer;

package/player/chromeLauncherTestPlayer.js

@@ -3,7 +3,6 @@
 const launcher = require('chrome-launcher');
 const desiredCapabilitiesBuilder = require('../commons/testimDesiredCapabilitiesBuilder');
 const utils = require('../utils');
-const httpRequest = require('../commons/httpRequest');
 const { registerExitHook } = require('../processHandler');
 const CDPTestRunner = require('../cdpTestRunner');
 

package/player/seleniumTestPlayer.js

@@ -10,7 +10,7 @@ const { isDebuggerConnected } = require('../commons/detectDebugger');
 
 const sessionPlayer = require('../commons/getSessionPlayerRequire');
 
-const player = sessionPlayer.sessionPlayer;
+const Player = sessionPlayer.sessionPlayer;
 // delete after https://github.com/testimio/clickim/pull/3430 release to the store
 const assetService = sessionPlayer.assetService;
 const commonConstants = sessionPlayer.commonConstants;
@@ -24,6 +24,7 @@ const CryptoJS = require('crypto-js');
 const StepActionUtils = require('./utils/stepActionUtils');
 
 class SeleniumTestPlayer {
+    //eslint-disable-next-line default-param-last
     constructor(id, userParamsData, shouldMonitorPerformance, automationMode = 'code', driver = new WebDriver(), testRetryCount, previousTestResultId) {
         this.driver = driver;
         this.id = id;
@@ -47,7 +48,7 @@ class SeleniumTestPlayer {
 
         const FrameLocator = frameLocatorFactory(this.driver);
 
-        this.sessionPlayer = new player(
+        this.sessionPlayer = new Player(
             id,
             this.tabService,
             CookieUtils(this.driver),

package/player/services/frameLocator.js

@@ -19,6 +19,7 @@ const _getGuidFromSeleniumElement = (seleniumElement) => {
 /** @param {import('../webdriver')} driver*/
 module.exports = function frameLocatorFactory(driver) {
     class FrameLocator {
+        /** @type {(...args: ConstructorParameters<typeof import('clickim/src/background/frameLocator').FrameLocator>) => this} */
         constructor(frameManager, locateElementPlayer) {
             this.frameManager = frameManager;
             this.locateElementPlayer = locateElementPlayer;
@@ -34,7 +35,7 @@ module.exports = function frameLocatorFactory(driver) {
         }
 
         cacheFrameLocateResults(frameHandler) {
-            if (frameHandler && frameHandler.seleniumFrameElement && frameHandler.frameLocateResultUrl) {
+            if (frameHandler?.seleniumFrameElement && frameHandler.frameLocateResultUrl) {
                 const guid = _getGuidFromSeleniumElement(frameHandler.seleniumFrameElement);
                 if (guid) {
                     this.cacheResults(guid, frameHandler.frameLocateResultUrl);

package/player/services/mobileFrameLocatorMock.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const logger = require('../../commons/logger').getLogger('mobile-frame-locator-mock');
+
+/** @param {import('../webdriver')} driver*/
+module.exports = function frameLocatorFactory(driver) {
+    class FrameLocator {
+        /** @type {(...args: ConstructorParameters<typeof import('clickim/src/background/frameLocator').FrameLocator>) => this} */
+        constructor(frameManager, locateElementPlayer) {
+            this.frameManager = frameManager;
+            this.locateElementPlayer = locateElementPlayer;
+        }
+
+        foundFrameCallback(result, frameTree, testimFrameId) {
+            logger.info('foundFrameCallback-mock invoked');
+            return {};
+        }
+
+
+        locate(frameLocator, frameDepth, currentFrame, context, frameTree, stepData) {
+            logger.info('locate-mock invoked');
+            return {};
+        }
+
+        findFrame(stepData, frameLocators, context, frameTree) {
+            logger.info('findFrame-mock invoked');
+            return {};
+        }
+    }
+
+    return FrameLocator;
+};

package/player/services/playbackTimeoutCalculator.js

@@ -18,6 +18,7 @@ const FULL_TIMEOUT_STEP_TYPES = [
     'sfdc-step-launchapp',
     'sfdc-step-closeconsoletabs',
     'sfdc-step-sobjectedit',
+    'sfdc-step-relatedlistaction',
 ];
 
 class PlaybackTimeoutCalculator {

package/player/services/portSelector.js

@@ -1,16 +1,18 @@
-"use strict";
+'use strict';
+
 const Promise = require('bluebird');
 
 // Legacy code not supported in selenium mode
 class PortSelector {
-    constructor(){}
-    select(){
-        console.log("\n\t\t\tinternal error - cant use port selector in selenium!!!!\n");
-        return Promise.reject({
-            reason: "cant use port selector in selenium!"
-        });
+    // eslint-disable-next-line no-useless-constructor, no-empty-function
+    constructor() { }
+    select() {
+        // eslint-disable-next-line no-console
+        console.log('\n\t\t\tinternal error - cant use port selector in selenium!!!!\n');
+        // eslint-disable-next-line prefer-promise-reject-errors
+        return Promise.reject({ reason: 'cant use port selector in selenium!' });
     }
-    prepare(){}
+    prepare() {}
     handleLegacyDataCaching() {}
 }
 

package/player/services/tabService.js

@@ -15,12 +15,41 @@ const constants = sessionPlayer.commonConstants.stepResult;
 const tabMatcher = sessionPlayer.tabMatcher;
 const logger = require('../../commons/logger').getLogger('tab-service');
 
+/**
+ * @typedef {{
+ *     attachDebugger(): Promise<any>,
+ *     detachDebugger(): Promise<any>,
+ *     onDebuggerDetached(): {},
+ *     tabId: string,
+ *     domUtils: { getDOM(): Promise<any> },
+ *     windowUtils: WindowUtils,
+ *     imageCaptureUtils: ImageCaptureUtils
+ * }} TabUtil
+ * */
+/**
+ * @typedef {{
+ *     infoId: any;
+ *     url: any;
+ *     title: any;
+ *     favIconUrl: any;
+ *     order: any;
+ *     from: any;
+ *     isMain: any;
+ *     openerStepId: any;
+ * }} TabInfo
+ */
+
 class TabService {
+    /** @param {import('../webdriver')} driver */
     constructor(driver) {
         this.driver = driver;
+        /** @type {Record<string, TabUtil>} */
         this._utils = {};
+        /** @type {Record<string, { tabCount: number; tabInfos: Record<string, TabInfo> }>} */
         this.sessionTabs = {};
+        /** @type {Record<string, string>} */
         this.pendingTabs = {};
+        /** @type {Record<string, Set<any>>} */
         this.addedTabs = {};
     }
 

package/player/services/tabServiceMock.js

@@ -0,0 +1,166 @@
+'use strict';
+
+/**
+ * @typedef {{
+ *     attachDebugger(): Promise<any>,
+ *     detachDebugger(): Promise<any>,
+ *     onDebuggerDetached(): {},
+ *     tabId: string,
+ *     domUtils: { getDOM(): Promise<any> },
+ *     windowUtils: WindowUtils,
+ *     imageCaptureUtils: ImageCaptureUtils
+ * }} TabUtil
+ * */
+/**
+ * @typedef {{
+ *     infoId: any;
+ *     url: any;
+ *     title: any;
+ *     favIconUrl: any;
+ *     order: any;
+ *     from: any;
+ *     isMain: any;
+ *     openerStepId: any;
+ * }} TabInfo
+ */
+
+class TabService {
+    /** @param {import('../webdriver')} driver */
+    constructor(driver) {
+        this.driver = driver;
+        /** @type {Record<string, TabUtil>} */
+        this._utils = {};
+        /** @type {Record<string, { tabCount: number; tabInfos: Record<string, TabInfo> }>} */
+        this.sessionTabs = {};
+        /** @type {Record<string, string>} */
+        this.pendingTabs = {};
+        /** @type {Record<string, Set<any>>} */
+        this.addedTabs = {};
+    }
+
+    on() {}
+
+    tabCount(sessionId) {
+    }
+
+    getAllOpenTabIds(sessionId) {
+    }
+
+    /**
+     * Get last tab info for pixel validation
+     *
+     * @returns last tab info
+     */
+    getActiveTabInfo(sessionId) {
+    }
+
+    getAllTabIds(sessionId) {
+    }
+
+    isSessionTab(sessionId, tabId) {
+    }
+
+    createSesion(sessionId) {
+    }
+
+    setAddFrameHandlerCallBack(addFrameHandlerCb) {
+    }
+
+    getAllTabInfoStrings(sessionId) {
+    }
+
+    getAllTabInfos(sessionId) {
+    }
+
+    addNewTab(sessionId, tabId, openerStepId, options = {}) {
+    }
+
+    addOpenerStepId(sessionId, tabId, openerStepId) {
+    }
+    addOpenerStep(sessionId, tabId, openerStep) {
+    }
+
+    fixMissingMainTab(sessionId) {
+    }
+
+    buildTabInfo(sessionId, tabId, order, openerStepId, options = {}) {
+    }
+
+    addTab(sessionId, id, order, openerStepId, options = {}) {
+    }
+
+    getTabUtilsByTabIdAndSessionId(sessionId, tabId) {
+    }
+
+    getTabUtilsByTabId(tabId) {
+    }
+
+    getTabInfo(sessionId, id) {
+    }
+
+    getTabUtils(sessionId, tabInfo) {
+    }
+
+    exactUrlMatch(first, second, allUrls) {
+    }
+
+    singleExactMatchForParts(first, second, allUrls, combinePartsFunction) {
+    }
+
+    isSameTab(sessionId, first, second) {
+    }
+
+    getMainTabInfo(sessionId) {
+    }
+
+    getMainTabUtils(sessionId) {
+    }
+
+    removeTabInfo(sessionId, tabId) {
+    }
+
+    getMainTabId(sessionId) {
+    }
+
+    isMainTabExists(sessionId) {
+    }
+
+    clearAllTabs(sessionId) {
+    }
+
+    clearNonMainTabs(sessionId) {
+    }
+
+    switchTab(tabId, sessionId, { forceSwitch } = { forceSwitch: false }) {
+    }
+
+    getTabDetails(tabId, sessionId, options = {}) {
+    }
+
+    getUnregisteredTabId(sessionId) {
+    }
+
+    waitForTabToOpen(sessionId) {
+    }
+
+    tryToAddTab(sessionId, openerStepId) {
+
+    }
+
+    addNewPopup(id, openerStepId) {
+    }
+
+    waitToPendingTabs(id, openerStepId) {
+    }
+
+    isMainTabIncognito() {
+    }
+
+    isInvalidStepVersion(step) {
+    }
+
+    getTabIdByTabInfo(sessionId, step) {
+    }
+}
+
+module.exports = TabService;

package/player/stepActions/navigationStepAction.js

@@ -1,15 +1,14 @@
-"use strict";
+'use strict';
 
 const StepAction = require('./stepAction');
-const url = require('url');
+const requiredUrl = require('url');
 const Promise = require('bluebird');
 
 class NavigationStepAction extends StepAction {
-
     updateBaseUrl(location) {
-        let orgUrl = url.parse(location);
-        const baseLocation = url.parse(this.context.recordedBaseUrl);
-        const newBaseLocation = url.parse(this.context.baseUrl);
+        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;
         }
@@ -18,12 +17,14 @@ class NavigationStepAction extends StepAction {
 
     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(() => {});
+        }
         return this.updateBaseUrl(url)
-            .then(url => this.driver.url(url))
-            .then(() => Promise.resolve());
+            .then(updatedUrl => this.driver.url(updatedUrl))
+            .then(() => {});
     }
-
 }
 
 module.exports = NavigationStepAction;

package/player/stepActions/sleepStepAction.js

@@ -1,12 +1,11 @@
-"use strict";
+'use strict';
 
 const StepAction = require('./stepAction');
-const Promise = require("bluebird");
+const { delay } = require('../../utils');
 
 class SleepStepAction extends StepAction {
-
-    performAction() {
-        return Promise.delay(this.step.durationMS).then(() => Promise.resolve());
+    async performAction() {
+        await delay(this.step.durationMS);
     }
 }
 

package/player/stepActions/stepAction.js

@@ -3,8 +3,21 @@
 const { commonConstants } = require('../../commons/getSessionPlayerRequire');
 const Promise = require('bluebird');
 
+/** @typedef {typeof import('clickim/src/background/stepActions/stepAction').StepAction} ClickimStepActionCtor */
+/** @typedef {ConstructorParameters<ClickimStepActionCtor>} ClickimStepActionCtorParams */
+/** @typedef {InstanceType<ClickimStepActionCtor>} ClickimStepAction */
+
 class StepAction {
-    constructor(step, context, frameHandler, exportsGlobal = {}, stepActionUtils, locateElementPlayer, exportsTest = {}) {
+    /** @type {(...args: ClickimStepActionCtorParams) => this} */
+    constructor(
+        step,
+        context,
+        frameHandler,
+        exportsGlobal = {},
+        stepActionUtils = undefined,
+        locateElementPlayer = undefined,
+        exportsTest = {},
+    ) {
         this.step = step;
         this.context = context;
         this.frameHandler = frameHandler;
@@ -28,6 +41,7 @@ class StepAction {
         return this.context.data[targetId];
     }
 
+    /** @type {ClickimStepAction['execute']} */
     execute(stepActionFactory, step) {
         return Promise.resolve(this.performAction(stepActionFactory, step))
             .then(res => Promise.resolve(Object.assign({}, { success: true }, res)))

package/player/stepActions/textStepAction.js

@@ -6,12 +6,10 @@ const Promise = require('bluebird');
 const { codeSnippets } = require('../../commons/getSessionPlayerRequire');
 const dispatchFocus = require('./scripts/focusElement');
 const sessionPlayer = require('../../commons/getSessionPlayerRequire');
-const { extractElementId } = require('../../utils');
-const util = require('util');
+const { extractElementId, delay } = require('../../utils');
 
 const constants = sessionPlayer.commonConstants.stepResult;
-const setTextDraftJs = codeSnippets && codeSnippets.setTextDraftJs;
-const delay = util.promisify(setTimeout);
+const setTextDraftJs = codeSnippets?.setTextDraftJs;
 class TextStepAction extends StepAction {
     setValueNative() {
         const context = this.context;
@@ -61,12 +59,7 @@ class TextStepAction extends StepAction {
         const eventParam = this.driver.isEdge() ? JSON.stringify(eventMessage) : eventMessage;
 
         return this.driver.executeCodeAsync(setTextCode, timeout, eventParam)
-            .then(result => {
-                if (result.value && result.value.success) {
-                    return Promise.resolve({ success: true });
-                }
-                return Promise.resolve({ success: false });
-            });
+            .then(result => ({ success: Boolean(result.value?.success) }));
     }
 
     async setTextDelayed() {
@@ -86,7 +79,7 @@ class TextStepAction extends StepAction {
         const context = this.context;
         const target = this.getTarget();
 
-        if (target && target.seleniumElement) {
+        if (target?.seleniumElement) {
             if (!this.step.delayBetweenChars) {
                 keys.push(Array.from(context.stepText));
                 return this.driver.elementIdValue(extractElementId(target.seleniumElement), keys);

package/player/utils/stepActionUtils.js

@@ -4,6 +4,7 @@ const { locatorBuilderUtils, utils, codeSnippets } = sessionPlayer;
 const CookieUtils = require('./cookieUtils');
 
 class StepActionUtils {
+    /** @param {import('../webdriver')} driver */
     constructor(driver, cookieUtils) {
         this.driver = driver;
         this._abortedSteps = [];
@@ -63,8 +64,9 @@ class StepActionUtils {
         return this.driver.getElementTextJS(locatedElement);
     }
 
-    markDynamicParent(target, id) {
-        return this.driver.markDynamicParent(target, id);
+    /** @type {import('clickim/src/background/stepActions/stepActionUtils').StepActionUtils['markDynamicParent']} */
+    async markDynamicParent(target, id, frameHandler) {
+        return this.driver.markDynamicParent(target, id, frameHandler);
     }
 
     getCookie(name) {