@testim/testim-cli 3.289.0 → 3.290.0-beta

package/player/stepActions/scripts/setText.js

@@ -1,415 +0,0 @@
-/* globals getLocatedElement, dispatchFocus */
-
-'use strict';
-
-const setText = function (eventData, done) {
-    const eventConstructorSupported = typeof Event === 'function';
-    const element = eventData.isRoot ? document.documentElement : getLocatedElement(eventData.locatedElement);
-    const context = {
-        eventIndex: 0,
-        element,
-        events: eventData.events,
-        eventType: eventData.eventType,
-        quirks: eventData.quirks,
-    };
-
-    if (!element) {
-        throw new Error('element not found');
-    }
-
-    window.__unloadNavigator = function () {
-        resolve();
-    };
-
-    window.addEventListener('unload', window.__unloadNavigator);
-
-    const keyboardEventNames = ['keydown', 'keyup', 'keypress'];
-    const MAX_KEYBOARD_EVENT_TIMEOUT = 15; //max msec between keyboard events
-
-    function getTextInputEventObject(userEvent) {
-        try {
-            if (!eventConstructorSupported) {
-                return undefined;
-            }
-
-            const event = new CustomEvent('textInput', {
-                bubbles: true,
-                cancelable: true,
-            });
-            if (userEvent.eventData) {
-                event.data = userEvent.eventData.data;
-            }
-            return event;
-        } catch (err) { /* ignored */ }
-        return undefined;
-    }
-
-    function initTextInputEvent(userEvent) {
-        try {
-            const event = document.createEvent('TextEvent');
-            event.data = userEvent.eventData.data;
-            const method = 1; // keyboard
-            const locale = userEvent.eventData.locale || 'en-US';
-            event.initTextEvent('textInput', true, true, window, userEvent.eventData.data, method, locale);
-            return event;
-        } catch (err) { /* ignored */ }
-        return undefined;
-    }
-
-    function getTextInputEvent(userEvent) {
-        return getTextInputEventObject(userEvent) || initTextInputEvent();
-    }
-
-    function createKeyboardEventObject(eventType, eventData, modifiers) {
-        try {
-            return new KeyboardEvent(eventType, {
-                bubbles: true,
-                cancelable: true,
-                location: eventData.location || 0,
-                key: eventData.key || '',
-                ctrlKey: Boolean(modifiers.ctrl),
-                shiftKey: Boolean(modifiers.shift),
-                altKey: Boolean(modifiers.alt),
-                metaKey: Boolean(modifiers.meta),
-            });
-        } catch (err) { /* ignored */ }
-        return undefined;
-    }
-
-    function initKeyboardEvent(eventType, eventData, modifiers) {
-        try {
-            const event = document.createEvent('KeyboardEvent');
-
-            event.initKeyEvent(
-                eventType, // typeArg,
-                true, // canBubbleArg,
-                true, // cancelableArg,
-                null, // viewArg,  Specifies UIEvent.view. This value may be null.
-                Boolean(modifiers.ctrl),
-                Boolean(modifiers.alt),
-                Boolean(modifiers.shift),
-                Boolean(modifiers.meta),
-                eventData.key || '',
-                0, // charCodeArg
-            );
-
-            return event;
-        } catch (err) { /* ignored */ }
-        return undefined;
-    }
-
-    function createKeyboardEvents(eventType, eventData, modifiers) {
-        try {
-            const event = document.createEvent('Events');
-            event.initEvent(eventType, true, true);
-            event.altKey = Boolean(modifiers.alt);
-            event.ctrlKey = Boolean(modifiers.ctrl);
-            event.metaKey = Boolean(modifiers.meta);
-            event.shiftKey = Boolean(modifiers.shift);
-            event.keyCode = eventData.key || '';
-            return event;
-        } catch (err) { /* ignored */ }
-        return undefined;
-    }
-
-    function createKeyboardEvent(eventType, eventData, modifiers) {
-        return createKeyboardEventObject(eventType, eventData, modifiers) ||
-            initKeyboardEvent(eventType, eventData, modifiers) ||
-            createKeyboardEvents(eventType, eventData, modifiers);
-    }
-
-    function getKeyboardEvent(userEvent) {
-        // some apps override Array.indexOf to return undefined if element not found (like Arkia)
-        const index = keyboardEventNames.indexOf(userEvent.event);
-        if ((typeof index !== 'number') || (index < 0)) {
-            return null;
-        }
-
-        const eventData = userEvent.eventData;
-        const modifiers = eventData.modifiers || {};
-
-        const event = createKeyboardEvent(userEvent.event, eventData, modifiers);
-
-        // workaround for chromium bugs which make keycode etc readonly
-        Object.defineProperties(event, {
-            keyCode: {
-                enumerable: true,
-                get() {
-                    return this._keyCode_;
-                },
-            },
-            charCode: {
-                enumerable: true,
-                get() {
-                    return this._charCode_;
-                },
-            },
-            which: {
-                enumerable: true,
-                get() {
-                    return this._keyCode_;
-                },
-            },
-        });
-        event._keyCode_ = eventData.keyCode;
-        event._charCode_ = eventData.charCode || 0;
-        return event;
-    }
-
-    function getEvent(userEvent) {
-        return userEvent.event === 'textInput' ?
-            getTextInputEvent(userEvent) :
-            getKeyboardEvent(userEvent);
-    }
-
-    function shouldSkipEvent(currentEvent, context) {
-        const isTextInputAuth0Form = function () {
-            return currentEvent.event === 'textInput' && !context.quirks?.isAuth0Form;
-        };
-        return isTextInputAuth0Form();
-    }
-
-    function getTextEventTimeout(currentEvent, nextEvent) {
-        return ((currentEvent.event === 'keyup') && (nextEvent.event === 'keydown')) ?
-            MAX_KEYBOARD_EVENT_TIMEOUT :
-            0;
-    }
-
-    function getTimeBetweenFiringEvents(context, currentEvent, nextEvent) {
-        const maxTimeout = getTextEventTimeout(currentEvent, nextEvent);
-        return Math.min(nextEvent.timeStamp - currentEvent.timeStamp, maxTimeout);
-    }
-
-    function handleReactFormFocus(element) {
-        // solution taken partially from https://github.com/vitalyq/react-trigger-change
-        const descriptor = Object.getOwnPropertyDescriptor(element, 'value');
-        if (!descriptor) {
-            return;
-        }
-        const initialValue = element.value;
-        element.value = `${initialValue}#`;
-        if (descriptor.configurable) {
-            delete element.value;
-        }
-        element.value = initialValue;
-        const event = document.createEvent('HTMLEvents');
-        event.initEvent('input', true, false);
-        element.dispatchEvent(event);
-        Object.defineProperty(element, 'value', descriptor);
-    }
-
-    function handleChangeEventIfNeeded(context) {
-        if (!context.isInput) {
-            return;
-        }
-        try {
-            handleReactFormFocus(context.element);
-            if (eventConstructorSupported) {
-                context.element.dispatchEvent(new Event('change'));
-            } else {
-                const event = document.createEvent('HTMLEvents');
-                event.initEvent('change', false, true);
-                context.element.dispatchEvent(event);
-            }
-        } catch (e) { /* ignored */ }
-    }
-
-    function nextAsyncEvent(context, currentEvent, nextEvent) {
-        if (nextEvent) {
-            setTimeout(() => {
-                executeAsyncNext(context);
-            }, getTimeBetweenFiringEvents(context, currentEvent, nextEvent));
-        } else {
-            if (window.__unloadNavigator) {
-                window.removeEventListener('unload', window.__unloadNavigator);
-            }
-            handleChangeEventIfNeeded(context);
-            resolve();
-        }
-    }
-
-    function shouldDispatchOnParentElement(eventType, context) {
-        return (eventType === 'change' || eventType === 'blur') && context.element.tagName === 'OPTION';
-    }
-
-    function getElement(event, context, currentEvent) {
-        if (shouldDispatchOnParentElement(event.type, context)) {
-            return context.element.parentElement;
-        } if (currentEvent.locatedElement) {
-            return getLocatedElement(currentEvent.locatedElement);
-        }
-        return context.element;
-    }
-
-    function findTextNode(element, offsetData) {
-        let child = element.firstChild;
-        let innerChild;
-        while (child) {
-            if (child.nodeType === 3) {
-                if (offsetData.offset-- <= 0) {
-                    return child;
-                }
-            } else if (child.nodeType === 1) {
-                innerChild = findTextNode(child, offsetData);
-                if (innerChild) {
-                    return innerChild;
-                }
-            }
-            child = child.nextSibling;
-        }
-        return null;
-    }
-
-    function setSelection(element, selection) {
-        if (!element || !selection) {
-            return;
-        }
-        // eslint-disable-next-line no-restricted-globals
-        if (!isNaN(selection.start)) {
-            element.selectionStart = selection.start;
-            element.selectionEnd = selection.end;
-        // eslint-disable-next-line no-restricted-globals
-        } else if (!isNaN(selection.nodeOffset)) {
-            let startNode;
-            if (element.firstChild) {
-                startNode = findTextNode(element, { offset: selection.nodeOffset });
-            } else {
-                startNode = element;
-            }
-            if (startNode) {
-                const sel = window.getSelection();
-                const range = document.createRange();
-
-                try { // until we get our act together regarding contenteditable, this may throw when the numbers in the recorded data don't match the current text
-                    sel.removeAllRanges();
-                    range.setStart(startNode, selection.textOffset);
-                    range.setEnd(startNode, selection.textOffset);
-                    sel.addRange(range);
-                } catch (ignore) { /* ignored */ }
-            }
-        }
-    }
-
-    function executeAsyncEvent(event, context, currentEvent) {
-        if (context.isFocusable && context.isSelectable(event) && event.type !== 'submit') {
-            try {
-                setSelection(context.element, currentEvent.eventData.selection);
-            } catch (ignore) { /* ignored */ }
-        }
-        const element = getElement(event, context, currentEvent);
-        if (!element) {
-            throw new Error('could not find element');
-        }
-        if (event.type === 'submit' && element.action) {
-            element.submit();
-        } else {
-            element.dispatchEvent(event);
-        }
-    }
-
-    function executeAsyncNext(context) {
-        let event;
-        const currentEvent = context.events[context.eventIndex];
-        const nextEvent = context.events[++context.eventIndex];
-        try {
-            event = getEvent(currentEvent);
-        } catch (err) {
-            return reject(`exception in get event in text step:${err.message}`);
-        }
-
-        if (shouldSkipEvent(currentEvent, context)) {
-            return nextAsyncEvent(context, currentEvent, nextEvent);
-        } if (event) {
-            try {
-                executeAsyncEvent(event, context, currentEvent);
-            } catch (err) {
-                return reject(`exception in executeEvent in text step:${err.message}`);
-            }
-        } else if (context.noEventExecuter) {
-            context.noEventExecuter(context, currentEvent);
-        } else {
-            return reject(`cannot execute event ${currentEvent.event}`);
-        }
-        nextAsyncEvent(context, currentEvent, nextEvent);
-        return undefined;
-    }
-
-    function isFocusableInput(target) {
-        const tagName = target.tagName;
-        return (tagName === 'INPUT' || tagName === 'TEXTAREA');
-    }
-
-    function isContentEditable(target) {
-        return target.getAttribute ?
-            Boolean(target.getAttribute('contenteditable') === 'true') :
-            false;
-    }
-
-    function executeSetValue(context, userEvent) {
-        if (context.isInput) {
-            context.element.value = userEvent.eventData.text;
-            const inputEvent = document.createEvent('Event');
-            inputEvent.initEvent('input', true, false);
-            context.element.dispatchEvent(inputEvent);
-        } else if (context.isContentEditable) {
-            context.element.innerHTML = userEvent.eventData.text;
-        }
-    }
-
-    function findEffectiveActiveElement() {
-        let activeElement = document.activeElement;
-        while (activeElement.shadowRoot?.activeElement) {
-            activeElement = activeElement.shadowRoot.activeElement;
-        }
-        return activeElement;
-    }
-
-    function resolve(result) {
-        const status = {
-            status: 'done',
-            result,
-            success: true,
-        };
-        if (context.isNonTextableElemnet) {
-            status.reason = 'Set text on non input element';
-        }
-
-        done(status);
-    }
-
-    function reject(result) {
-        result = result || {};
-        const status = {
-            status: 'failed',
-            result,
-            success: false,
-        };
-        if (context.isNonTextableElemnet) {
-            status.reason = 'Set text on non input element';
-        }
-
-        done(status);
-    }
-
-    try {
-        context.isInput = isFocusableInput(context.element);
-        context.isContentEditable = isContentEditable(context.element);
-        if (!context.isInput && !context.isContentEditable) {
-            context.isNonTextableElemnet = true;
-        }
-        context.isFocusable = context.isInput || context.isContentEditable;
-        context.isSelectable = function (event) {
-            return event.type !== 'keyup';
-        };
-        context.noEventExecuter = executeSetValue;
-    } catch (err) {
-        reject(`exception in set text step:${err.message}`);
-        return;
-    }
-
-    const oldActiveElement = findEffectiveActiveElement();
-    dispatchFocus(eventData.elementToFocusLocatedElement, oldActiveElement);
-    executeAsyncNext(context);
-};
-
-module.exports = setText;

package/player/stepActions/scripts/wheel.js

@@ -1,61 +0,0 @@
-/* global getLocatedElement */
-
-'use strict';
-
-const wheel = function (eventData, done) {
-    const MAX_WHEEL_EVENT_TIMEOUT = 200;
-
-    function getEventPosition(userEvent, element) {
-        function isWithinBounds(start, end, point) {
-            return (point > start) && (point < end);
-        }
-        const pointerPosition = userEvent.pointerPosition || {};
-        const rect = element.getBoundingClientRect();
-        const clientX = pointerPosition.originX && isWithinBounds(rect.left, rect.left + rect.width, pointerPosition.originX) ? pointerPosition.originX : rect.left + (rect.width / 2);
-        const clientY = pointerPosition.originY && isWithinBounds(rect.top, rect.top + rect.height, pointerPosition.originY) ? pointerPosition.originY : rect.top + (rect.height / 2);
-        return { x: clientX, y: clientY };
-    }
-
-    function getWheelEvent(userEvent, eventData, element) {
-        const pos = getEventPosition(userEvent, element);
-        const modifiers = eventData?.modifiers || {};
-        const dict = {
-            deltaX: userEvent.deltaX,
-            deltaY: userEvent.deltaY,
-            deltaZ: userEvent.deltaZ,
-            deltaMode: userEvent.deltaMode,
-            clientX: pos.x,
-            clientY: pos.y,
-            bubbles: true,
-            cancelable: true,
-            ctrl: Boolean(modifiers.ctrl),
-            alt: Boolean(modifiers.alt),
-            shift: Boolean(modifiers.shift),
-            meta: Boolean(modifiers.meta),
-        };
-        return new WheelEvent('wheel', dict);
-    }
-
-    function executeEvents(events, element) {
-        if (events.length === 0) {
-            done({ state: 'success' });
-            return;
-        }
-        if (!element) {
-            throw new Error('element not found');
-        }
-
-        const event = events.shift();
-        const currentEvent = getWheelEvent(event, eventData.eventData, element);
-        const timeout = events[0] ? Math.min(events[0].timeStamp - event.timeStamp, MAX_WHEEL_EVENT_TIMEOUT) : MAX_WHEEL_EVENT_TIMEOUT;
-        element.dispatchEvent(currentEvent);
-        setTimeout(() => {
-            executeEvents(events, element);
-        }, timeout);
-    }
-
-    const element = getLocatedElement(eventData.locatedElement);
-    executeEvents(eventData.events, element);
-};
-
-module.exports = wheel;

package/player/stepActions/scrollStepAction.js

@@ -1,96 +0,0 @@
-'use strict';
-
-const scroll = require('./scripts/scroll');
-const StepAction = require('./stepAction');
-
-class ScrollStepAction extends StepAction {
-    getFailureString(step, expectedX, expectedY, actualX, actualY) {
-        if (!step.isScrollToElement) {
-            return `Scrolling limit reached. Expected:(y: ${expectedY}, x: ${expectedX}); Actual:(y:${actualY}, x: ${actualX})`;
-        }
-        let failureMessage = 'Scrolling limit reached';
-        if (step.shouldScrollTop) {
-            failureMessage += `. Expected top margin: ${expectedY}, actual: ${actualY}`;
-        }
-        if (step.shouldScrollLeft) {
-            failureMessage += `. Expected left margin: ${expectedX}, actual: ${actualX}`;
-        }
-        return failureMessage;
-    }
-
-    async scroll(elementToScrollTo, step, elementToScrollOn) {
-        const { codeSnippets, commonConstants: { stepResult } } = this.sessionPlayerInit;
-        const expectedY = Math.round(Number(step.isScrollToElement ? step.marginTop : step.y));
-        const expectedX = Math.round(Number(step.isScrollToElement ? step.marginLeft : step.x));
-
-        // in Firefox setting scrollTop and scrollLeft propeties simultaneously takes only the lates,
-        const elementScrollTo = this.driver.isFirefox() ? function (element, x, y) {
-            element.scrollTo(x, y);
-        } : function (element, x, y) {
-            element.scrollTop = y;
-            element.scrollLeft = x;
-        };
-        const scrollCode = `
-            var getLocatedElement = ${codeSnippets.getLocatedElementCode};
-            var elementScrollTo = ${elementScrollTo.toString()};
-            var scroll = ${scroll.toString()};
-            return scroll.apply(null, arguments)
-        `;
-
-        try {
-            const res = await this.driver.executeJSWithArray(scrollCode, [
-                elementToScrollOn,
-                elementToScrollTo,
-                Boolean(step.isScrollToElement),
-                Boolean(step.isDynamicScroll),
-                expectedX,
-                expectedY,
-                step.shouldScrollLeft,
-                step.shouldScrollTop,
-            ]);
-            if (!res?.value) {
-                return {
-                    errorType: stepResult.SCROLL_ACTION_FAILURE,
-                    success: false,
-                };
-            }
-
-            const { success, actualX, actualY } = res.value;
-
-            if (success) {
-                return { success: true };
-            }
-
-            return {
-                errorType: stepResult.SCROLL_ACTION_FAILURE,
-                success: false,
-                resultInfo: { error: this.getFailureString(step, expectedX, expectedY, actualX, actualY) },
-            };
-        } catch (error) {
-            return {
-                errorType: stepResult.SCROLL_ACTION_FAILURE,
-                success: false,
-            };
-        }
-    }
-
-    scrollOnDocument(step, elementToScrollTo) {
-        return this.scroll(elementToScrollTo, step);
-    }
-
-    scrollOnElement(step, elementToScrollTo) {
-        return this.scroll(elementToScrollTo, step, this.getTarget().locatedElement);
-    }
-
-    execute() {
-        const context = this.context;
-        const step = this.step;
-        const elementToScrollTo = step.isScrollToElement ? context.data.scrollToElement.locatedElement : null;
-
-        return step.element.isDocument ?
-            this.scrollOnDocument(step, elementToScrollTo) :
-            this.scrollOnElement(step, elementToScrollTo);
-    }
-}
-
-module.exports = ScrollStepAction;

package/player/stepActions/selectOptionStepAction.js

@@ -1,49 +0,0 @@
-'use strict';
-
-const StepAction = require('./stepAction');
-const selectOption = require('./scripts/selectOption');
-const featureFlags = require('../../commons/featureFlags');
-const { extractElementId } = require('../../utils');
-
-class SelectOptionStepAction extends StepAction {
-    async performAction() {
-        const target = this.context.data[this.step.targetId || 'targetId'];
-        const { seleniumElement, locatedElement } = target;
-
-        const browserAndOS = await this.driver.getBrowserAndOS();
-
-        const browserMajor = browserAndOS.browserMajor;
-        const isSafari = this.driver.isSafari();
-        const isShadowed = Boolean(this.step.element?.isShadowed);
-
-        // TODO: Remove the special handling for safari < 12 after we upgrade our grid to safari 13.
-        // force use js code when element is shadow dom
-        if (!isSafari || (isSafari && browserMajor >= 13 && !isShadowed)) {
-            try {
-                const res = await this.driver.elementIdClick(extractElementId(seleniumElement));
-                return res;
-            } catch (err) {
-                // If customer overrides the native Element prototype, this click will fail for this reason. in such a case, fallback to use js code.
-                if (!err.message.includes('Cannot check the displayedness of a non-Element argument')) {
-                    throw err;
-                }
-            }
-        }
-
-        const safariSelectOptionDispatchEventOnSelectElement = featureFlags.flags.safariSelectOptionDispatchEventOnSelectElement.isEnabled();
-        const selectOptionCode = `
-            var getLocatedElement = ${this.sessionPlayerInit.codeSnippets.getLocatedElementCode};
-            var isNativeFunction = ${this.sessionPlayerInit.utils.isNativeFunction.toString()};
-            var selectOption = ${selectOption.toString()};
-            return selectOption.apply(null, arguments);
-        `;
-
-        const result = await this.driver.executeJSWithArray(selectOptionCode, [locatedElement, safariSelectOptionDispatchEventOnSelectElement]);
-        if (result.value?.success) {
-            return { success: true };
-        }
-        return { success: false };
-    }
-}
-
-module.exports = SelectOptionStepAction;

package/player/stepActions/sfdcRecordedStepAction.js

@@ -1,24 +0,0 @@
-const StepAction = require('./stepAction');
-
-class SfdcRecordedStepAction extends StepAction {
-    async performAction() {
-        const { sfdc } = this.sessionPlayerInit;
-        const page = sfdc.sfdcNewSePage(this.driver, (level, message) => this.context.playback.sfdcAddLog(level, message));
-        page.log.info(`BEGIN STEP '${this.step.getStepPreview?.()}'`);
-        try {
-            const warnings = await sfdc.sfdcExecuteRecordedStep(page, this.step.recordedData, this.context);
-            return { success: true, reason: warnings };
-        } catch (err) {
-            return {
-                success: false,
-                reason: err.reason || err.message,
-                exception: err,
-                shouldRetry: false, // TODO - check this.  Our (bFormat) steps are probably not retryable?
-            };
-        } finally {
-            page.releaseObjects();
-        }
-    }
-}
-
-module.exports = SfdcRecordedStepAction;

package/player/stepActions/sfdcStepAction.js

@@ -1,28 +0,0 @@
-const StepAction = require('./stepAction');
-
-class SfdcStepAction extends StepAction {
-    async performAction() {
-        const { sfdc } = this.sessionPlayerInit;
-        const page = sfdc.sfdcNewSePage(this.driver, (level, message) => this.context.playback.sfdcAddLog(level, message));
-        page.log.info(`BEGIN STEP '${this.step.getStepPreview?.()}'`);
-        try {
-            const actions = this.context.sfdcTestActions;
-            if (actions === undefined) {
-                throw new Error('No test actions were compiled');
-            }
-            const warnings = await sfdc.sfdcExecute(page, actions, this.context);
-            return { success: true, reason: warnings };
-        } catch (err) {
-            return {
-                success: false,
-                reason: err.reason || err.message,
-                exception: err,
-                shouldRetry: false, // TODO - check this.  Our (bFormat) steps are probably not retryable?
-            };
-        } finally {
-            page.releaseObjects();
-        }
-    }
-}
-
-module.exports = SfdcStepAction;

package/player/stepActions/sleepStepAction.js

@@ -1,12 +0,0 @@
-'use strict';
-
-const StepAction = require('./stepAction');
-const { delay } = require('../../utils');
-
-class SleepStepAction extends StepAction {
-    async performAction() {
-        await delay(this.step.durationMS);
-    }
-}
-
-module.exports = SleepStepAction;