@testim/testim-cli 3.289.0 → 3.290.1-beta

package/player/scripts/isElementDisplayed.js

@@ -1,252 +0,0 @@
-/*
- * Copyright (C) 2017 Apple Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
- * THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-// https://github.com/webdriverio/webdriverio/blob/master/packages/webdriverio/src/scripts/isElementDisplayed.js
-
-/**
- * check if element is visible
- * @param  {HTMLElement} element  element to check
- * @return {Boolean}           true if element is within viewport
- */
-module.exports = function isElementDisplayed(element) {
-    function nodeIsElement(node) {
-        if (!node) {
-            return false
-        }
-
-        switch (node.nodeType) {
-        case Node.ELEMENT_NODE:
-        case Node.DOCUMENT_NODE:
-        case Node.DOCUMENT_FRAGMENT_NODE:
-            return true
-
-        default:
-            return false
-        }
-    }
-
-    function parentElementForElement(element) {
-        if (!element) {
-            return null
-        }
-
-        return enclosingNodeOrSelfMatchingPredicate(element.parentNode, nodeIsElement)
-    }
-
-    function enclosingNodeOrSelfMatchingPredicate(targetNode, predicate) {
-        for (let node = targetNode; node && node !== targetNode.ownerDocument; node = node.parentNode)
-            if (predicate(node)) {
-                return node
-            }
-
-        return null
-    }
-
-    function enclosingElementOrSelfMatchingPredicate(targetElement, predicate) {
-        for (let element = targetElement; element && element !== targetElement.ownerDocument; element = parentElementForElement(element))
-            if (predicate(element)) {
-                return element
-            }
-
-        return null
-    }
-
-    function cascadedStylePropertyForElement(element, property) {
-        if (!element || !property) {
-            return null
-        }
-        // if document-fragment, skip it and use element.host instead. This happens
-        // when the element is inside a shadow root.
-        // window.getComputedStyle errors on document-fragment.
-        if (element instanceof DocumentFragment) {
-            element = element.host
-        }
-
-        let computedStyle = window.getComputedStyle(element)
-        let computedStyleProperty = computedStyle.getPropertyValue(property)
-        if (computedStyleProperty && computedStyleProperty !== 'inherit') {
-            return computedStyleProperty
-        }
-
-        // Ideally getPropertyValue would return the 'used' or 'actual' value, but
-        // it doesn't for legacy reasons. So we need to do our own poor man's cascade.
-        // Fall back to the first non-'inherit' value found in an ancestor.
-        // In any case, getPropertyValue will not return 'initial'.
-
-        // FIXME: will this incorrectly inherit non-inheritable CSS properties?
-        // I think all important non-inheritable properties (width, height, etc.)
-        // for our purposes here are specially resolved, so this may not be an issue.
-        // Specification is here: https://drafts.csswg.org/cssom/#resolved-values
-        let parentElement = parentElementForElement(element)
-        return cascadedStylePropertyForElement(parentElement, property)
-    }
-
-    function elementSubtreeHasNonZeroDimensions(element) {
-        let boundingBox = element.getBoundingClientRect()
-        if (boundingBox.width > 0 && boundingBox.height > 0) {
-            return true
-        }
-
-        // Paths can have a zero width or height. Treat them as shown if the stroke width is positive.
-        if (element.tagName.toUpperCase() === 'PATH' && boundingBox.width + boundingBox.height > 0) {
-            let strokeWidth = cascadedStylePropertyForElement(element, 'stroke-width')
-            return !!strokeWidth && (parseInt(strokeWidth, 10) > 0)
-        }
-
-        let cascadedOverflow = cascadedStylePropertyForElement(element, 'overflow')
-        if (cascadedOverflow === 'hidden') {
-            return false
-        }
-
-        // If the container's overflow is not hidden and it has zero size, consider the
-        // container to have non-zero dimensions if a child node has non-zero dimensions.
-        return Array.from(element.childNodes).some((childNode) => {
-            if (childNode.nodeType === Node.TEXT_NODE) {
-                return true
-            }
-
-            if (nodeIsElement(childNode)) {
-                return elementSubtreeHasNonZeroDimensions(childNode)
-            }
-
-            return false
-        })
-    }
-
-    function elementOverflowsContainer(element) {
-        let cascadedOverflow = cascadedStylePropertyForElement(element, 'overflow')
-        if (cascadedOverflow !== 'hidden') {
-            return false
-        }
-
-        // FIXME: this needs to take into account the scroll position of the element,
-        // the display modes of it and its ancestors, and the container it overflows.
-        // See Selenium's bot.dom.getOverflowState atom for an exhaustive list of edge cases.
-        return true
-    }
-
-    function isElementSubtreeHiddenByOverflow(element) {
-        if (!element) {
-            return false
-        }
-
-        if (!elementOverflowsContainer(element)) {
-            return false
-        }
-
-        if (!element.childNodes.length) {
-            return false
-        }
-
-        // This element's subtree is hidden by overflow if all child subtrees are as well.
-        return Array.from(element.childNodes).every((childNode) => {
-            // Returns true if the child node is overflowed or otherwise hidden.
-            // Base case: not an element, has zero size, scrolled out, or doesn't overflow container.
-            // Visibility of text nodes is controlled by parent
-            if (childNode.nodeType === Node.TEXT_NODE) {
-                return false
-            }
-            if (!nodeIsElement(childNode)) {
-                return true
-            }
-
-            if (!elementSubtreeHasNonZeroDimensions(childNode)) {
-                return true
-            }
-
-            // Recurse.
-            return isElementSubtreeHiddenByOverflow(childNode)
-        })
-    }
-    // walk up the tree testing for a shadow root
-    function isElementInsideShadowRoot(element) {
-        if (!element) {
-            return false
-        }
-        if (element.parentNode && element.parentNode.host) {
-            return true
-        }
-        return isElementInsideShadowRoot(element.parentNode)
-    }
-
-    // This is a partial reimplementation of Selenium's "element is displayed" algorithm.
-    // When the W3C specification's algorithm stabilizes, we should implement that.
-    // If this command is misdirected to the wrong document (and is NOT inside a shadow root), treat it as not shown.
-    if (!isElementInsideShadowRoot(element) && !document.contains(element)) {
-        return false
-    }
-
-    // Special cases for specific tag names.
-    switch (element.tagName.toUpperCase()) {
-    case 'BODY':
-        return true
-
-    case 'SCRIPT':
-    case 'NOSCRIPT':
-        return false
-
-    case 'OPTGROUP':
-    case 'OPTION': {
-        // Option/optgroup are considered shown if the containing <select> is shown.
-        let enclosingSelectElement = enclosingNodeOrSelfMatchingPredicate(element, (e) => e.tagName.toUpperCase() === 'SELECT')
-        return isElementDisplayed(enclosingSelectElement)
-    }
-    case 'INPUT':
-        // <input type="hidden"> is considered not shown.
-        if (element.type === 'hidden') {
-            return false
-        }
-        break
-        // case 'MAP':
-        // FIXME: Selenium has special handling for <map> elements. We don't do anything now.
-
-    default:
-        break
-    }
-
-    if (cascadedStylePropertyForElement(element, 'visibility') !== 'visible') {
-        return false
-    }
-
-    let hasAncestorWithZeroOpacity = !!enclosingElementOrSelfMatchingPredicate(element, (e) => {
-        return Number(cascadedStylePropertyForElement(e, 'opacity')) === 0
-    })
-    let hasAncestorWithDisplayNone = !!enclosingElementOrSelfMatchingPredicate(element, (e) => {
-        return cascadedStylePropertyForElement(e, 'display') === 'none'
-    })
-    if (hasAncestorWithZeroOpacity || hasAncestorWithDisplayNone) {
-        return false
-    }
-
-    if (!elementSubtreeHasNonZeroDimensions(element)) {
-        return false
-    }
-
-    if (isElementSubtreeHiddenByOverflow(element)) {
-        return false
-    }
-
-    return true
-}

package/player/seleniumTestPlayer.js

@@ -1,140 +0,0 @@
-'use strict';
-
-const utils = require('../utils');
-const WebDriver = require('./webdriver');
-const CookieUtils = require('./utils/cookieUtils');
-const TabService = require('./services/tabService');
-const PortSelector = require('./services/portSelector');
-const StepActionUtils = require('./utils/stepActionUtils');
-const frameLocatorFactory = require('./services/frameLocator');
-const testResultService = require('../commons/socket/testResultService');
-const windowCreationListener = require('./services/windowCreationListener');
-const PlaybackTimeoutCalculator = require('./services/playbackTimeoutCalculator');
-const { isDebuggerConnected } = require('../commons/detectDebugger');
-const { getSessionPlayer } = require('../commons/getSessionPlayerRequire');
-
-
-class SeleniumTestPlayer {
-    //eslint-disable-next-line default-param-last
-    constructor(id, userParamsData, shouldMonitorPerformance, automationMode = 'code', driver = new WebDriver(), testRetryCount, previousTestResultId) {
-        const { sessionPlayer: Player, commonConstants, stepActionFactory: StepActionFactory } = getSessionPlayer();
-        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');
-
-        this.tabService = this.driver.tabService || new TabService(this.driver);
-        // expose the tabService on the driver so future sessions reusing the driver
-        // know the tabs (for example - a TDK Hybrid step)
-        this.driver.tabService = this.tabService;
-        this.windowCreationListener = windowCreationListener;
-        this.playbackTimeoutCalculator = new PlaybackTimeoutCalculator(isDebuggerConnected());
-
-        this.tabService.createSesion(id);
-
-        const FrameLocator = frameLocatorFactory(this.driver);
-
-        this.sessionPlayer = new Player(
-            id,
-            this.tabService,
-            CookieUtils(this.driver),
-            windowCreationListener,
-            FrameLocator,
-            PortSelector,
-            null,
-            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.tabService.setAddFrameHandlerCallBack(this.sessionPlayer.addPlaybackFrameHandler.bind(this.sessionPlayer));
-
-        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) {
-        if (step?.isTabOpener) {
-            this.tabService.addNewPopup(this.id, step.id)
-                .catch(() => { });
-        }
-    }
-
-    onDone() {
-        const { commonConstants } = getSessionPlayer();
-        const END_DRIVER_TIMEOUT = 1000 * 60 * 2;
-        return utils.promiseTimeout(this.driver.end(), END_DRIVER_TIMEOUT)
-            .catch(error => {
-                if (error instanceof utils.TimeoutError) {
-                    return this.driver.forceEnd().catch(() => null);
-                }
-                return undefined;
-            })
-            .then(() => {
-                this.sessionPlayer.playbackManager.off(commonConstants.playback.RESULT, this.onStepCompleted);
-                this.sessionPlayer = null;
-                this.tabService = null;
-                this.stepActionFactory = null;
-                this.driver = null;
-            });
-    }
-
-    clearSessionTabs() {
-        this.tabService.clearAllTabs(this.id);
-    }
-
-    async addTab(openerStepId, options = { loadInfo: true }) {
-        const ids = await this.driver.getTabIds();
-        const lastId = ids.at(-1);
-        await this.tabService.addNewTab(this.id, lastId, openerStepId, options);
-        return this.sessionPlayer.addPlaybackFrameHandler(lastId, undefined, { emptyPage: true });
-    }
-
-    async addAllTabs(openerStepId, options = { loadInfo: true, checkForMainTab: true, takeScreenshots: true }, blackList = []) {
-        const ids = await this.driver.getTabIds();
-        // the ids are reversed so we search first in the last tab opened - otherwise it starts looking from the testim editor and not the AUT
-
-        const PROHIBITED_URLS = ['app.testim.io'].concat(blackList);
-        for (const id of ids.reverse()) {
-            await this.tabService.addNewTab(this.id, id, openerStepId, { ...options, forceSwitch: true });
-            const tabInfo = this.tabService.getTabInfo(this.id, id);
-            if (PROHIBITED_URLS.some(bad => tabInfo.url.includes(bad))) {
-                await this.tabService.removeTabInfo(this.id, id);
-                continue;
-            }
-            await this.sessionPlayer.addPlaybackFrameHandler(id, undefined, { emptyPage: true });
-        }
-        if (this.tabService.tabCount(this.id) === 1) {
-            // if we only have one tab because we removed the editor tab - we have to switchTab to one of the other tabs, otherwise
-            // tabService will assume it's on a good context but it's not.
-            const tabInfo = this.tabService.getMainTabInfo(this.id);
-            const tabUtils = this.tabService.getTabUtils(this.id, tabInfo);
-            await this.tabService.switchTab(tabUtils.tabId, this.id, { forceSwitch: true });
-        }
-        // deal with checkForMainTab failing due to the page refreshing or JavaScript not responding or a similar issue
-        this.tabService.fixMissingMainTab(this.id);
-    }
-
-    getSessionId() {
-        return this.driver.getSessionId();
-    }
-}
-
-module.exports = SeleniumTestPlayer;

package/player/services/frameLocator.js

@@ -1,170 +0,0 @@
-// @ts-check
-
-'use strict';
-
-const featureFlags = require('../../commons/featureFlags');
-const { getLogger } = require('../../commons/logger');
-const { getSessionPlayer } = require('../../commons/getSessionPlayerRequire');
-
-const logger = getLogger('frame-locator');
-const SELENIUM_ELEMENT_KEY = 'ELEMENT';
-const SELENIUM_GUID_KEY = 'element-6066-11e4-a52e-4f735466cecf';
-
-const _getGuidFromSeleniumElement = (seleniumElement) => {
-    if (!seleniumElement) {
-        return null;
-    }
-
-    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: ClickimFrameLocatorCtorArgs) => this}} */
-        constructor(frameManager, locateElementPlayer) {
-            this.frameManager = frameManager;
-            this.locateElementPlayer = locateElementPlayer;
-            /** @type {Record<string, string>} */
-            this._cache = {};
-        }
-
-        cacheResults(seleniumGuid, resultsUrl) {
-            this._cache[seleniumGuid] = resultsUrl;
-        }
-
-        getResultsFromCache(seleniumGuid) {
-            return this._cache[seleniumGuid];
-        }
-
-        cacheFrameLocateResults(frameHandler) {
-            if (frameHandler?.seleniumFrameElement && frameHandler.frameLocateResultUrl) {
-                const guid = _getGuidFromSeleniumElement(frameHandler.seleniumFrameElement);
-                if (guid) {
-                    this.cacheResults(guid, frameHandler.frameLocateResultUrl);
-                }
-            }
-        }
-
-        /**
-         * @param {FrameTree} frameTree
-         * @param {string | number} testimFrameId
-         * @returns {Promise<FrameHandler>}
-        */
-        async foundFrameCallback(result, frameTree, testimFrameId) {
-            const { frameOffset, locatedElement } = result;
-            const { locatorBuilderUtils } = getSessionPlayer();
-            if (locatorBuilderUtils.isEmptyResult(locatedElement)) {
-                const errorMsg = 'got empty result in frame result, not rejected from locate element player';
-                logger.error(errorMsg);
-                throw new Error(errorMsg);
-            }
-            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);
-            frameLocator.targetId = `frameLocator_${frameDepth}`;
-            return locateElementPlayer.locate(frameLocator, currentFrame, frameLocator.targetId)
-                .then(result => {
-                    result.isVisible = true; // frame visibility check is done on the target element
-                    return locateElementPlayer.handleLocateResult(result, stepData, frameLocator)
-                        .catch(() => { throw new Error(); }); // silence [object object] errors;
-                })
-                .then(result => {
-                    const { locatedElement } = context.data[frameLocator.targetId];
-                    return driver.getElementLocationWithPadding(locatedElement)
-                        .then(location => {
-                            const value = location.value || { top: 0, left: 0 };
-                            result.frameOffset = {
-                                top: currentFrame.frameOffset.top + value.top,
-                                left: currentFrame.frameOffset.left + value.left,
-                            };
-                            return result;
-                        });
-                })
-                .then(result => {
-                    if (locateElementPlayer.addFrameDataToContext) {
-                        locateElementPlayer.addFrameDataToContext(result.targetId, result.locateResult);
-                    }
-                    return this.foundFrameCallback(result, frameTree, frameLocator.testimFrameId);
-                })
-                .then(frameHandler => {
-                    this.currentFrameHandler = frameHandler;
-                    return frameHandler;
-                });
-        }
-
-        /** @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];
-            const allowedRetries = 1;
-            const moreThanAllowedRetries = Boolean(lastResult) && lastResult.stepId === stepData.id && lastResult.results.length > allowedRetries;
-            if (allowNoFrameSwitch && !moreThanAllowedRetries && this.currentFrameHandler) {
-                const currentFramePos = frameLocators.findIndex(x => x.testimFrameId === this.currentFrameHandler.testimFrameId);
-                if (currentFramePos > -1) {
-                    const shorterPath = frameLocators.slice(currentFramePos + 1);
-                    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;
-                }
-            }
-
-            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;
-        }
-    }
-
-    return FrameLocator;
-};

package/player/services/mobileFrameLocatorMock.js

@@ -1,32 +0,0 @@
-'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;
-};