@testim/testim-cli 3.289.0 → 3.290.1-beta

package/player/stepActions/scripts/html5dragActionV2.js

@@ -1,312 +0,0 @@
-/* global getLocatedElement */
-
-'use strict';
-
-const html5dndAction = function (eventData, done) {
-    const mouseEventConstructorSupported = typeof MouseEvent === 'function';
-    const dragEventConstructorSupported = typeof DragEvent === 'function';
-    const pointerEventConstructorSupported = typeof PointerEvent === 'function';
-    const data = {};
-
-    window.__unloadNavigator = resolve;
-
-    window.addEventListener('unload', window.__unloadNavigator);
-
-    function resolve(result) {
-        const status = {
-            status: 'done',
-            result,
-            success: true,
-        };
-        done(status);
-    }
-
-    function reject(result) {
-        result = result || {};
-        const status = {
-            status: 'failed',
-            result,
-            success: false,
-            keep: true,
-        };
-
-        done(status);
-    }
-
-    function convertType(type) {
-        if (!type?.toLowerCase) {
-            return type;
-        }
-        type = type.toLowerCase();
-        if (type === 'text') {
-            return 'text/plain';
-        }
-        if (type === 'url') {
-            return 'text/uri-list';
-        }
-        return type;
-    }
-
-    function createDataTransfer() {
-        try {
-            return new DataTransfer();
-        } catch (err) {
-            return {
-                data: {},
-                setData(type, val) {
-                    data[convertType(type)] = val;
-                },
-                getData(type) {
-                    return data[convertType(type)];
-                },
-            };
-        }
-    }
-
-    const dragFromElementEvents = ['drag', 'dragstart', 'dragend'];
-    const pointerEvents = ['pointerup', 'pointerdown', 'pointermove'];
-    const dragEvents = dragFromElementEvents.concat(['drop', 'dragenter', 'dragover']);
-
-    function findClosestDraggable(element) {
-        // drag events are always fired on the closest element with draggable=true
-        // rather than on the target mouse element - so when dispatching a drag
-        // event we need to fire the correct target
-        let current = element;
-        while (current && current !== document.documentElement) {
-            if (current.draggable) {
-                return current;
-            }
-            current = current.parentElement;
-        }
-        return null;
-    }
-
-    function getElement(event, context, currentEvent) {
-        const element = context.element;
-        const dispatchDragEventsOnClosestDraggable = currentEvent.dispatchDragEventsOnClosestDraggable;
-        if (dragFromElementEvents.includes(event.type) && dispatchDragEventsOnClosestDraggable) {
-            if (!element && context.lastDraggedElement) {
-                // fallback for elements being removed from DOM, but parent draggable still being there
-                return context.lastDraggedElement;
-            }
-
-            const draggable = findClosestDraggable(element);
-            if (draggable) {
-                context.lastDraggedElement = draggable;
-                return draggable;
-            }
-        }
-        return element;
-    }
-
-    function getEventPosition(userEvent, isDrag, element) {
-        function isWithinBounds(start, end, point) {
-            return (point > start) && (point < end);
-        }
-
-        const pointerPosition = userEvent.pointerPosition || {};
-        // Technically should always be true here.
-        if (isDrag) {
-            return { x: pointerPosition.originX || 0, y: pointerPosition.originY || 0 };
-        }
-        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 getMouseEvent(userEvent, eventData, context) {
-        const modifiers = eventData?.modifiers || {};
-        const pos = getEventPosition(userEvent, context.isDrag, context.element);
-        const button = eventData?.button || 0;
-        const eventType = userEvent.event;
-        if (pointerEvents.includes(eventType)) {
-            return createPointerEvent(eventType, modifiers, pos.x, pos.y, button);
-        }
-        if (dragEvents.includes(eventType)) {
-            return createDragEvent(eventType, modifiers, pos.x, pos.y, button);
-        }
-        return createMouseEvent(eventType, modifiers, pos.x, pos.y, button);
-    }
-
-    function getEventDictionary(modifiers, clientX, clientY) {
-        return {
-            screenX: 0,
-            screenY: 0,
-            clientX,
-            clientY,
-            ctrlKey: Boolean(modifiers.ctrl),
-            altKey: Boolean(modifiers.alt),
-            shiftKey: Boolean(modifiers.shift),
-            metaKey: Boolean(modifiers.meta),
-            bubbles: true,
-            cancelable: true,
-            composed: true,
-        };
-    }
-
-    function createPointerEvent(eventType, modifiers, clientX, clientY, button) {
-        if (pointerEventConstructorSupported) {
-            const eventProperties = getEventDictionary(modifiers, clientX, clientY);
-            eventProperties.pointerType = 'mouse';
-            eventProperties.isPrimary = true;
-            return new window.PointerEvent(eventType, eventProperties);
-        }
-        const event = document.createEvent('PointerEvent');
-        event.initPointerEvent(
-            eventType,
-            true, /* bubbles */
-            true, /* cancelable */
-            document.defaultView, /* view */
-            1, /* detail */
-            0, /* screenX */
-            0, /* screenY */
-            clientX, /* clientX */
-            clientY, /* clientY */
-            Boolean(modifiers.ctrl), /* ctrl */
-            Boolean(modifiers.alt), /* alt */
-            Boolean(modifiers.shift), /* shift */
-            Boolean(modifiers.meta), /* meta */
-            button, /* button */
-            document.body ? document.body.parentNode : document.documentElement,
-            0, /* offsetYArg */
-            0, /* offsetXArg */
-            0, /* widthArg */
-            0, /* heightArg */
-            0, /* pressure */
-            0, /* rotation */
-            0, /* tiltX */
-            0, /* tiltY */
-            0, /* pointerIdArg */
-            'mouse', /* pointerType */
-            0, /* hwTimestampArg */
-            true, /* isPrimary */
-        );
-        return event;
-    }
-
-    function createMouseEvent(eventType, modifiers, clientX, clientY, button) {
-        const event = mouseEventConstructorSupported ? new MouseEvent('click', { composed: true }) : document.createEvent('MouseEvents');
-        event.initMouseEvent(
-            eventType,
-            true, /* bubbles */
-            true, /* cancelable */
-            document.defaultView, /* view */
-            1, /* detail */
-            0, /* screenX */
-            0, /* screenY */
-            clientX, /* clientX */
-            clientY, /* clientY */
-            Boolean(modifiers.ctrl), /* ctrl */
-            Boolean(modifiers.alt), /* alt */
-            Boolean(modifiers.shift), /* shift */
-            Boolean(modifiers.meta), /* meta */
-            button, /* button */
-            document.body ? document.body.parentNode : document.documentElement);
-        return event;
-    }
-
-    function createDragEvent(eventType, modifiers, clientX, clientY) {
-        if (eventType === 'dragstart') {
-            if (!window.TSTA) {
-                window.TSTA = {};
-            }
-            window.TSTA.dataTransfer = createDataTransfer();
-        }
-
-        if (!dragEventConstructorSupported) {
-            const event = document.createEvent('CustomEvent');
-            event.initCustomEvent(eventType, true, true, null);
-            event.dataTransfer = window.TSTA.dataTransfer;
-            return event;
-        }
-
-        const eventProperties = getEventDictionary(modifiers, clientX, clientY);
-        const event = new window.DragEvent(eventType, eventProperties);
-        Object.defineProperties(event, {
-            dataTransfer: { get() { return window.TSTA.dataTransfer; } },
-        });
-        return event;
-    }
-
-    function executeAsyncEvent(event, context, currentEvent) {
-        const element = getElement(event, context, currentEvent);
-        if (element) {
-            element.dispatchEvent(event);
-        }
-    }
-
-    function shouldSkipEvent(currentEvent, context) {
-        function isClickInDragAndDrop() {
-            return currentEvent.event === 'click' &&
-                context.isDrag &&
-                !context.allEventsOnSameElement;
-        }
-        return isClickInDragAndDrop();
-    }
-
-    function nextAsyncEvent(context, currentEvent, nextEvent) {
-        if (nextEvent) {
-            const delay = Math.min(nextEvent.timeStamp - currentEvent.timeStamp, 40);
-            setTimeout(() => {
-                executeAsyncNext(context);
-            }, delay);
-        } else {
-            if (window.__unloadNavigator) {
-                window.removeEventListener('unload', window.__unloadNavigator);
-            }
-            resolve();
-        }
-    }
-
-    function executeAsyncNext(context) {
-        let event;
-        const currentEvent = context.events[context.eventIndex];
-        // eslint-disable-next-line no-param-reassign
-        const nextEvent = context.events[++context.eventIndex];
-        try {
-            context.element = getLocatedElement(currentEvent.locatedElement);
-            event = getMouseEvent(currentEvent, eventData, context);
-        } catch (err) {
-            return reject(`exception in get event in drag 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 drag step:${err.message}`);
-            }
-        } else {
-            return reject(`cannot execute event ${currentEvent.event}`);
-        }
-        nextAsyncEvent(context, currentEvent, nextEvent);
-        return undefined;
-    }
-
-    const context = {
-        eventIndex: 0,
-        allEventsOnSameElement: eventData.allEventsOnSameElement,
-        events: eventData.events,
-        eventType: eventData.eventType,
-        eventData: eventData.eventData,
-        stepId: eventData.id,
-        testResultId: eventData.testResultId,
-        isDrag: eventData.isDrag,
-        useRecordedMousedown: eventData.useRecordedMousedown,
-        trackActiveElement: eventData.trackActiveElement,
-    };
-
-    setTimeout(() => {
-        try {
-            executeAsyncNext(context);
-        } catch (err) {
-            reject(err);
-        }
-    }, 0);
-};
-module.exports = html5dndAction;

package/player/stepActions/scripts/runCode.js

@@ -1,147 +0,0 @@
-/* global getLocatedElement */
-
-'use strict';
-
-const runCode = function (eventData, preCompiledCode) {
-    function appendToStorage(name, data) {
-        const sessionItem = `data-testim-${name}`;
-
-        const nativeFuncErrMsg = 'Native sessionStorage is not available';
-        function isNativeFunction(fn) {
-            if (!fn?.toString) {
-                return false;
-            }
-            return fn.toString().includes('[native code]');
-        }
-        try {
-            if (![window.sessionStorage.setItem, window.sessionStorage.getItem].every(isNativeFunction)) {
-                throw new Error(nativeFuncErrMsg);
-            }
-            const oldData = JSON.parse(window.sessionStorage.getItem(sessionItem) || '{}');
-            const newData = Object.assign({}, oldData, data);
-            window.sessionStorage.setItem(sessionItem, JSON.stringify(newData));
-        } catch (err) {
-            // any variation QuotaExceededError from browsers
-            const isQuotaExceededError = err.message.toLowerCase().includes('quota');
-            const isNativeFunctionError = err.message === nativeFuncErrMsg;
-
-            if (
-                err.message.includes('sessionStorage') || // Chrome + Firefox
-                err.message.includes('The operation is insecure') || // Safari
-                isQuotaExceededError ||
-                isNativeFunctionError
-            ) {
-                let storage = document.head.querySelector('#testim-storage-backup');
-                if (!storage) {
-                    storage = document.createElement('meta');
-                    storage.id = 'testim-storage-backup';
-                    document.head.append(storage);
-                }
-                const oldData = JSON.parse(storage.getAttribute(sessionItem) || '{}');
-                const newData = Object.assign({}, oldData, data);
-                storage.setAttribute(sessionItem, JSON.stringify(newData));
-                if (isQuotaExceededError || isNativeFunctionError) {
-                    try {
-                        window.sessionStorage.removeItem(sessionItem);
-                    } catch (e) {
-                        // Prevents future retries from looking in sessionStorage with old data
-                    }
-                    (window.TSTA = window.TSTA || {}).useFallbackStorage = true;
-                }
-                return;
-            }
-            throw err;
-        }
-    }
-
-    function getExecutionArguments(eventData) {
-        // New code with stepParamsBuilder
-        if (eventData.function) {
-            return eventData.function.args
-                .map((arg) => (arg?.locatedElement ? getLocatedElement(arg.locatedElement) : arg));
-        }
-
-        // Old code
-        return eventData.directParams
-            .map((p) => (p.selector ? document.querySelector(p.selector) : p.value))
-            .concat(eventData.otherParams);
-    }
-
-    function constructWithArguments(constructor, args) {
-        function F() {
-            return constructor.apply(this, args);
-        }
-
-        F.prototype = constructor.prototype;
-        return new F();
-    }
-
-    const exportedData = {};
-    const exportedTestData = {};
-    const exportedGlobalData = {};
-
-    const functionParams = eventData.functionParams;
-    const transactionId = eventData.transactionId;
-
-    try {
-        const args = getExecutionArguments(eventData);
-
-        args.push(exportedData, exportedTestData, exportedGlobalData);
-
-        const params = eventData.function?.params || functionParams;
-
-        const functionToRun = preCompiledCode || constructWithArguments(Function, params);
-        const result = functionToRun.apply(null, args);
-
-        if (typeof Promise !== 'undefined' && result instanceof Promise) {
-            appendToStorage(transactionId, { type: 'promise' });
-            result.then((res) => {
-                appendToStorage(transactionId, {
-                    status: 'done',
-                    success: true,
-                    result: {
-                        resultValue: res,
-                        exports: exportedData,
-                        exportsTest: exportedTestData,
-                        exportsGlobal: exportedGlobalData,
-                    },
-                });
-            }, (res) => {
-                appendToStorage(transactionId, {
-                    status: 'failed',
-                    success: false,
-                    result: {
-                        resultValue: res.toString(),
-                        exports: exportedData,
-                        exportsTest: exportedTestData,
-                        exportsGlobal: exportedGlobalData,
-                    },
-                });
-            });
-        } else {
-            appendToStorage(transactionId, {
-                status: 'done',
-                success: true,
-                result: {
-                    resultValue: result,
-                    exports: exportedData,
-                    exportsTest: exportedTestData,
-                    exportsGlobal: exportedGlobalData,
-                },
-            });
-        }
-    } catch (e) {
-        appendToStorage(transactionId, {
-            status: 'failed',
-            success: false,
-            result: {
-                resultValue: e.toString(),
-                exports: exportedData,
-                exportsTest: exportedTestData,
-                exportsGlobal: exportedGlobalData,
-            },
-        });
-    }
-};
-
-module.exports = runCode;

package/player/stepActions/scripts/scroll.js

@@ -1,90 +0,0 @@
-/* globals getLocatedElement, elementScrollTo */
-
-'use strict';
-
-const scroll = function (elementToScrollOn, elementToScrollTo, isScrollToElement, isDynamicScroll, expectedX, expectedY, shouldScrollLeft, shouldScrollTop) {
-    function doScroll(expectedPosition, element) {
-        if (!element) {
-            return { success: false };
-        }
-
-        elementScrollTo(element, expectedPosition.x, expectedPosition.y);
-
-        const actualX = element.scrollLeft;
-        const actualY = element.scrollTop;
-
-        const success = (Math.abs(actualY - expectedPosition.y) < 1) && (Math.abs(actualX - expectedPosition.x) < 1);
-        return { success, actualX, actualY };
-    }
-
-    function getExpectedPosition(parentElement, locatedElement, isScrollToElement, expectedX, expectedY, shouldScrollLeft, shouldScrollTop) {
-        if (!isScrollToElement) {
-            return { x: expectedX, y: expectedY };
-        }
-
-        const target = getLocatedElement(locatedElement);
-
-        if (isDynamicScroll && !target) {
-            return { x: parentElement.scrollWidth, y: parentElement.scrollHeight };
-        }
-
-        if (!target) {
-            throw new Error('could not find target element');
-        }
-
-        const targetRect = target.getBoundingClientRect();
-
-
-        let yScroll = 0;
-        let xScroll = 0;
-        const MAX_HEIGHT = Math.max(window.innerHeight - (targetRect.height + 10), 0);
-        const MAX_WIDTH = Math.max(window.innerWidth - (targetRect.width + 10), 0);
-
-        yScroll = shouldScrollTop ?
-            parentElement.scrollTop + targetRect.top - Math.min(expectedY, MAX_HEIGHT) :
-            parentElement.scrollTop;
-
-        xScroll = shouldScrollLeft ?
-            parentElement.scrollLeft + targetRect.left - Math.min(expectedX, MAX_WIDTH) :
-            parentElement.scrollLeft;
-
-        return { x: Math.round(xScroll), y: Math.round(yScroll) };
-    }
-
-    const isDocument = !elementToScrollOn;
-    elementToScrollOn = !isDocument ? getLocatedElement(elementToScrollOn) : (document.scrollingElement || document.documentElement);
-
-    if (!elementToScrollOn) {
-        throw new Error('could not find target to scroll on');
-    }
-    const positionBeforeScroll = { top: elementToScrollOn.scrollTop, left: elementToScrollOn.scrollLeft };
-    let expectedPosition = getExpectedPosition(elementToScrollOn, elementToScrollTo, isScrollToElement, expectedX, expectedY, shouldScrollLeft, shouldScrollTop);
-
-    let result = doScroll(expectedPosition, elementToScrollOn);
-
-    if (isDocument && (!document.scrollingElement) && (!result.success) && (positionBeforeScroll.top === elementToScrollOn.scrollTop) && (positionBeforeScroll.left === elementToScrollOn.scrollLeft)) {
-        elementToScrollOn = document.body;
-        expectedPosition = getExpectedPosition(elementToScrollOn, elementToScrollTo, isScrollToElement, expectedX, expectedY, shouldScrollLeft, shouldScrollTop);
-        result = doScroll(expectedPosition, elementToScrollOn);
-    }
-
-    let actualXString = result.actualX;
-    let actualYString = result.actualY;
-    const actualScrollToElement = getLocatedElement(elementToScrollTo);
-
-    if (isScrollToElement && isDynamicScroll && !actualScrollToElement) {
-        return { success: false, expectedPosition };
-    }
-
-    if (isScrollToElement) {
-        if (!actualScrollToElement) {
-            throw new Error('could not find target to scroll to');
-        }
-        const rect = actualScrollToElement.getBoundingClientRect();
-        actualXString = rect.left;
-        actualYString = rect.top;
-    }
-    return { success: result.success, actualX: actualXString, actualY: actualYString };
-};
-
-module.exports = scroll;

package/player/stepActions/scripts/selectOption.js

@@ -1,51 +0,0 @@
-/* eslint-disable no-restricted-syntax */ // This code only runs in Safari, not in IE.
-module.exports = function (locatedElement, dispatchEventOnSelectElement) {
-    function closest(el, selectors) {
-        const originalMatches = Element.prototype.matches;
-        /* eslint-disable-next-line no-proto, no-undef */ // Some customers override the native Element prototype, so we need to create a new one if they messed it up.
-        const matches = originalMatches && isNativeFunction(originalMatches) ? originalMatches : document.createElement(el.tagName).__proto__.matches;
-        do {
-            if (matches.call(el, selectors)) return el;
-            el = el.parentElement || el.parentNode;
-        } while (el !== null && el.nodeType === 1);
-        return null;
-    }
-
-    try {
-        /* eslint-disable-next-line no-undef */ // This code depends on pre-injecting this function as well.
-        const optionEl = getLocatedElement(locatedElement);
-        if (!optionEl) {
-            return { success: false, status: 'failed', result: 'option element not found' };
-        }
-
-        const selectEl = closest(optionEl, 'select');
-        if (!selectEl) {
-            return { success: false, status: 'failed', result: 'select element not found' };
-        }
-        selectEl.focus();
-        if (optionEl.selected) {
-            return { success: true, status: 'done' };
-        }
-        optionEl.selected = true;
-
-        const events = [
-            'input',
-            'change',
-        ];
-        events.map((userEvent) => {
-            const event = document.createEvent('HTMLEvents');
-            event.initEvent(userEvent, true, false);
-            return event;
-        }).forEach((event) => {
-            if (dispatchEventOnSelectElement) {
-                selectEl.dispatchEvent(event);
-                return;
-            }
-            optionEl.dispatchEvent(event);
-        });
-
-        return { success: true, status: 'done' };
-    } catch (err) {
-        return { success: false, status: 'failed', result: err.toString() };
-    }
-};