@testim/testim-cli 3.288.0 → 3.290.0-beta

package/player/stepActions/mouseStepAction.js

@@ -1,370 +0,0 @@
-// @ts-check
-
-const _ = require('lodash');
-const StepAction = require('./stepAction');
-const doClickScript = require('./scripts/doClick');
-const dispatchFocus = require('./scripts/focusElement');
-const doDragPathScript = require('./scripts/doDragPath');
-const html5dndAction = require('./scripts/html5dragAction');
-const html5dndActionV2 = require('./scripts/html5dragActionV2');
-const featureFlagService = require('../../commons/featureFlags');
-
-class MouseStepAction extends StepAction {
-    getDnDRectsAndOffsets(target, destTarget, clickOffset, toClickOffset) {
-        const fromOffsets = this.stepActionUtils.getClickOffset(clickOffset, target.rectWithoutFrameOffset);
-        const toOffsets = this.stepActionUtils.getClickOffset(toClickOffset, destTarget.rectWithoutFrameOffset);
-        return {
-            fromRect: target.rectWithoutFrameOffset,
-            fromX: fromOffsets.xOffset,
-            fromY: fromOffsets.yOffset,
-            toRect: destTarget.rectWithoutFrameOffset,
-            toX: toOffsets.xOffset,
-            toY: toOffsets.yOffset,
-        };
-    }
-
-    async clickJs() {
-        const step = this.step;
-        const context = this.context;
-        const target = context.data[step.targetId || 'targetId'];
-        const timeout = context.data.timeToPlayStep + 3000;
-        const events = step.events;
-
-        if (!events?.length) {
-            return undefined;
-        }
-
-        const eventMessage = {
-            isRoot: target.isRoot,
-            locatedElement: target.locatedElement,
-            events,
-            quirks: step.quirks,
-            modifiers: step.modifiers,
-            button: step.button,
-        };
-
-        const doClickCode = `
-            var getLocatedElement = ${this.sessionPlayerInit.codeSnippets.getLocatedElementCode};
-            var dispatchFocus = ${dispatchFocus.toString()};
-            var doClick = ${doClickScript.toString()};
-            var eventData = arguments[0];
-            var done = arguments[1];
-            return doClick.call(null, eventData, done);
-        `;
-
-
-        try {
-            const result = await this.driver.executeCodeAsync(doClickCode, timeout, eventMessage);
-            if (result.value?.success) {
-                return { success: true };
-            }
-            return { success: false };
-        } catch (err) {
-            return {
-                success: false,
-                reason: err.message,
-                exception: err,
-            };
-        }
-    }
-
-    isWithinBounds(start, end, point) {
-        return (point > start) && (point < end);
-    }
-
-    getEventSequenceOffset() {
-        const initialPosition = this.step.events[0]?.pointerPosition;
-        if (!initialPosition) {
-            return { xOffset: 0, yOffset: 0 };
-        }
-
-        const target = this.context.data[this.step.targetId || 'targetId'];
-        const targetElementRect = target.rectWithoutFrameOffset;
-        const isXWithinBounds = this.isWithinBounds(targetElementRect.left, targetElementRect.left + targetElementRect.width, initialPosition.originX);
-        const isYWithinBounds = this.isWithinBounds(targetElementRect.top, targetElementRect.top + targetElementRect.height, initialPosition.originY);
-        const xOffset = isXWithinBounds ? 0 : targetElementRect.left + targetElementRect.width / 2 - initialPosition.originX;
-        const yOffset = isYWithinBounds ? 0 : targetElementRect.top + targetElementRect.height / 2 - initialPosition.originY;
-        return { xOffset, yOffset };
-    }
-
-    addOffsetToEvents(offsetFromElement) {
-        this.step.events.forEach(event => {
-            if (event?.pointerPosition) {
-                event.pointerPosition.originX += offsetFromElement.xOffset;
-                event.pointerPosition.originY += offsetFromElement.yOffset;
-            }
-        });
-    }
-
-    generateEventOfType(baseEvent, type) {
-        const cloneEvent = _.cloneDeep(baseEvent);
-        cloneEvent.event = type;
-        return cloneEvent;
-    }
-
-    fixAbsoluteDragEventSequence() {
-        const downEvent = this.step.events.find(event => ['mousedown', 'pointerdown'].includes(event.event));
-        if (downEvent) {
-            const mousedownEventIndex = this.step.events.indexOf(downEvent);
-            this.step.events.splice(mousedownEventIndex, 0, this.generateEventOfType(downEvent, 'mouseover'));
-        }
-
-        const { recordPointerMoveEvents = false } = this.context.project.defaults || {};
-        const mouseUpEvent = this.step.events.find(event => event.event === 'mouseup') || (recordPointerMoveEvents && this.step.events.find(event => event.event === 'pointerup'));
-        const lastMouseMoveEventIndex =
-            _.findLastIndex(this.step.events, event => event.event === 'mousemove') ||
-            (recordPointerMoveEvents && _.findLastIndex(this.step.events, event => event.event === 'pointermove'));
-        if (mouseUpEvent && lastMouseMoveEventIndex > 0 && !this.step.allEventsOnSameElement) {
-            this.step.events.splice(lastMouseMoveEventIndex + 1, 0, this.generateEventOfType(mouseUpEvent, 'mouseover'));
-        }
-
-        if (this.step.isHTML5Drag && !this.step.toElement) {
-            this.step.events = this.addDragendIfNeeded(this.step.events);
-        }
-
-        this.addOffsetToEvents(this.getEventSequenceOffset());
-    }
-
-    async dragPathJs() {
-        const step = this.step;
-        const context = this.context;
-        const target = context.data[step.targetId || 'targetId'];
-        const timeout = context.data.timeToPlayStep + 3000;
-
-        if (!this.step.events?.length) {
-            return undefined;
-        }
-
-        this.fixAbsoluteDragEventSequence();
-
-        const events = step.events;
-
-        const eventMessage = {
-            isRoot: target.isRoot,
-            locatedElement: target.locatedElement,
-            events,
-            quirks: step.quirks,
-            modifiers: step.modifiers,
-            button: step.button,
-            isDrag: true,
-            allEventsOnSameElement: step.allEventsOnSameElement,
-        };
-
-        const doDragPathCode = `
-            var getLocatedElement = ${this.sessionPlayerInit.codeSnippets.getLocatedElementCode};
-            var dispatchFocus = ${dispatchFocus.toString()};
-            var doDragPath = ${doDragPathScript.toString()};
-            return doDragPath.apply(null, arguments);
-        `;
-
-        try {
-            const result = await this.driver.executeCodeAsync(doDragPathCode, timeout, eventMessage);
-            if (result.value?.success) {
-                return { success: true };
-            }
-            return { success: false };
-        } catch (err) {
-            return {
-                success: false,
-                reason: err.message,
-                exception: err,
-            };
-        }
-    }
-
-    chooseAndRunAction() {
-        const target = this.getTarget();
-        const { locatedElement, seleniumElement, rectWithoutFrameOffset, rect } = target;
-        const { xOffset, yOffset } = this.stepActionUtils.getClickOffset(this.step.element.clickOffset, rectWithoutFrameOffset);
-
-        // used for fallback native click
-        const offsets = {
-            frameOffset: {
-                x: rect.left - rectWithoutFrameOffset.left,
-                y: rect.top - rectWithoutFrameOffset.top,
-            },
-            rect: rectWithoutFrameOffset,
-            clickOffset: { x: xOffset, y: yOffset },
-        };
-        // will skip left click and double click on Edge.
-        const skipFileInputClick =
-            featureFlagService.flags.skipFileInputClicks.isEnabled() &&
-            target.tagName === 'INPUT' &&
-            (target.elementSymbol.includes('type="file"') ||
-                target.elementSymbol.includes('type=\'file\'') ||
-                target.elementSymbol.includes('type=file'));
-
-        if (skipFileInputClick) {
-            return Promise.resolve({
-                keep: true,
-                success: 'skipped',
-                reason: 'Clicking on input type=file is disabled',
-            });
-        }
-
-        if (this.step.isDoubleClick) {
-            const eventData = {
-                elementToFocusLocatedElement: target.elementToFocusLocatedElement,
-                locatedElement,
-                events: this.step.events,
-                timeout: this.context.data.timeToPlayStep + 3000,
-            };
-            return this.driver.doubleClick(seleniumElement, eventData, offsets);
-        }
-        if (this.step.isDrag) {
-            if (this.step.toElement) {
-                const destTarget = this.context.data.toElement;
-                if (this.step.isHTML5Drag) {
-                    if (featureFlagService.flags.usePortedHtml5DragDrop.isEnabled()) {
-                        const events = this.generateHTML5DragEventSequence();
-                        const timeout = this.context.data.timeToPlayStep + 3000;
-                        const contextTarget = this.context.data[this.step.targetId || 'targetId'];
-                        const eventMessage = {
-                            transactionId: `${this.context.testResultId}:${this.step.id}`,
-                            id: this.step.id,
-                            testResultId: this.context.testResultId,
-                            eventType: this.step.type,
-                            events,
-                            eventData: {
-                                modifiers: this.step.modifiers,
-                                button: this.step.button,
-                            },
-                            quirks: this.step.quirks,
-                            isDrag: this.step.isDrag,
-                            useRecordedMousedown: this.step.useRecordedMousedown,
-                            allEventsOnSameElement: this.step.allEventsOnSameElement,
-                            elementToFocusLocatedElement: contextTarget.elementToFocusLocatedElement,
-                            trackActiveElement: this.step.trackActiveElement,
-                            locatedElement: contextTarget.locatedElement,
-                            isRoot: contextTarget.isRoot,
-                        };
-                        const html5DNDCode = `
-                        var getLocatedElement = ${this.sessionPlayerInit.codeSnippets.getLocatedElementCode};
-                        var dnd = ${html5dndActionV2.toString()};
-                        var eventData = arguments[0];
-                        var done = arguments[1];
-                        return dnd.call(null, eventData, done);
-                    `;
-                        return this.driver.executeCodeAsync(html5DNDCode, timeout, eventMessage);
-                    }
-
-                    const html5DNDCode = `
-                        var getLocatedElement = ${this.sessionPlayerInit.codeSnippets.getLocatedElementCode};
-                        var dnd = ${html5dndAction.toString()};
-                        var eventData = arguments[0];
-                        return dnd.call(null, eventData);
-                    `;
-
-                    const eventMessage = { fromLocatedElement: locatedElement, toLocatedElement: destTarget.locatedElement };
-                    return this.driver.executeJS(html5DNDCode, eventMessage);
-                }
-
-                const rectsAndOffsets = this.getDnDRectsAndOffsets(target, destTarget, this.step.element.clickOffset, this.step.toElement.clickOffset);
-                return this.driver.dragAndDrop(seleniumElement, destTarget.seleniumElement, rectsAndOffsets);
-            }
-            return this.dragPathJs();
-
-            // This is the old way, which uses selenium action (AKA "native" drag).
-            // return this.driver.drag(seleniumElement, rectWithoutFrameOffset, xOffset, yOffset, this.step.events);
-        }
-        const useRightClickJS = this.driver.isSafari() && this.step.button === 2;
-        const forceNativeEvent = this.driver.isSafari() && target.tagName === 'SELECT';
-
-        if (this.driver.isSafari() && forceNativeEvent) {
-            // NOTE:
-            // We want to skip click on SELECT elements because of a safari driver bug
-            // that not allowing to set the selected option after this click.
-            return Promise.resolve({
-                keep: true, success: 'skipped', forceTreatAsWarning: true, reason: 'Safari does not support clicking on select elements',
-            });
-        }
-        if (!forceNativeEvent && (!this.step.nativeEvents || useRightClickJS)) {
-            return this.clickJs();
-        }
-        if (this.step.button === 2) {
-            return this.driver.rightClick(seleniumElement, offsets);
-        }
-        return this.driver.leftClick(seleniumElement, offsets);
-    }
-
-    async performAction() {
-        let res = await this.chooseAndRunAction();
-        if (!res.status && res.value && res.value.keep) {
-            res = res.value;
-        }
-        if (res.keep) {
-            delete res.keep;
-            return res;
-        }
-        return undefined;
-    }
-
-    addDragendIfNeeded(events) {
-        if (events.some(event => event.event === 'dragend')) {
-            return events;
-        }
-        const dragendDefaultEvent = {
-            event: 'dragend',
-            eventInfo: {
-                detail: 0,
-            },
-            pointerPosition: this.getToElementPosition(),
-        };
-        return events.concat(dragendDefaultEvent);
-    }
-
-    getToElementPosition() {
-        if (!(this.context.data?.toElement?.rect)) {
-            return undefined;
-        }
-        const { rect } = this.context.data.toElement;
-        return {
-            originX: rect.left + (rect.width / 2),
-            originY: rect.top + (rect.height / 2),
-        };
-    }
-
-    addDragOverBeforeDragEnd(events) {
-        const dropOrEndEventIndex = events.findIndex(e => ['dragend', 'drop'].includes(e.event));
-        const oneBeforeLastEvent = events[dropOrEndEventIndex - 1];
-        if (!oneBeforeLastEvent || (oneBeforeLastEvent.event !== 'dragover')) {
-            const dragenterDefaultEvent = {
-                event: 'dragover',
-                eventInfo: {
-                    detail: 0,
-                },
-                pointerPosition: this.getToElementPosition(),
-                fireOnTarget: true,
-            };
-            events.splice(dropOrEndEventIndex, 0, dragenterDefaultEvent);
-        } else {
-            oneBeforeLastEvent.fireOnTarget = true;
-        }
-        return events;
-    }
-
-    fixEventSequence(events) {
-        const withDragEnd = this.addDragendIfNeeded(events);
-        return this.addDragOverBeforeDragEnd(withDragEnd);
-    }
-
-    addElementLocatedElementToDragEvents(events, fromElementLocatedElement, toElementLocatedElement) {
-        const isOnToElement = e => e.fireOnTarget || ['drop', 'dragenter'].includes(e.event);
-        events.forEach(event => (event.locatedElement = isOnToElement(event) ? toElementLocatedElement : fromElementLocatedElement));
-        return events;
-    }
-
-    generateHTML5DragEventSequence() {
-        const fromElement = this.context.data.targetId;
-        const toElement = this.context.data.toElement;
-        let events = this.step.events.filter(event => event.event !== 'mousemove' && event.event !== 'pointermove');
-        events = this.fixEventSequence(events);
-        events = this.addElementLocatedElementToDragEvents(events, fromElement.locatedElement, toElement.locatedElement);
-        if (this.step.dispatchDragEventsOnClosestDraggable) {
-            events.forEach(event => (event.dispatchDragEventsOnClosestDraggable = true));
-        }
-        return events;
-    }
-}
-
-module.exports = MouseStepAction;

package/player/stepActions/navigationStepAction.js

@@ -1,29 +0,0 @@
-'use strict';
-
-const StepAction = require('./stepAction');
-const requiredUrl = require('url');
-
-class NavigationStepAction extends StepAction {
-    async updateBaseUrl(location) {
-        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;
-        }
-        return orgUrl.href;
-    }
-
-    async performAction() {
-        const url = this.context.data.testimNavigationStepDestination || this.context.data.url;
-        // Opens a new tab and switches to new tab
-        if (this.step.openInNewTab) {
-            await this.driver.client.newWindow(url);
-            return;
-        }
-        const updatedUrl = await this.updateBaseUrl(url);
-        await this.driver.url(updatedUrl);
-    }
-}
-
-module.exports = NavigationStepAction;

package/player/stepActions/nodePackageStepAction.js

@@ -1,47 +0,0 @@
-'use strict';
-
-const StepAction = require('./stepAction');
-const { NpmPackageError } = require('../../errors');
-
-const service = require('../../agent/routers/cliJsCode/service');
-const utils = require('../../utils');
-
-class NodePackageStepAction extends StepAction {
-    async performAction() {
-        const { context } = this;
-        const { stepId, packageData, resultId, retryIndex, stepResultId, timeToPlayBeforeExec } = context;
-
-        try {
-            const data = await service.installPackage(
-                stepId,
-                resultId,
-                retryIndex,
-                packageData,
-                stepResultId,
-                timeToPlayBeforeExec,
-            );
-            return ({ data, success: true });
-        } catch (err) {
-            if (err instanceof NpmPackageError) {
-                return {
-                    success: false,
-                    code: 'invalid-node-package',
-                    message: err.message,
-                };
-            }
-            if (err instanceof utils.TimeoutError) {
-                return {
-                    success: false,
-                    code: 'timeout',
-                };
-            }
-            return {
-                success: false,
-                reason: err.message,
-                exception: err,
-            };
-        }
-    }
-}
-
-module.exports = NodePackageStepAction;

package/player/stepActions/pixelValidationStepAction.js

@@ -1,39 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-const StepAction = require('./stepAction');
-const { eyeSdkService } = require('../utils/eyeSdkService');
-const { getLogger } = require('../../commons/logger');
-
-const logger = getLogger('pixel-validation-step-action');
-
-class PixelValidationStepAction extends StepAction {
-    async performAction() {
-        const { shouldUseVisualGrid, applitoolsSdkConfig: config, applitoolsSdkLogger, testResultId } = this.context;
-        this.runContext = this.context.getRunContext(undefined);
-        const finalParams = this.runContext.incomingParams?.final || {};
-        const batchId = config.batch?.id || testResultId;
-        const eyeManager = await eyeSdkService.getManager(shouldUseVisualGrid, this.context.config.applitoolsConcurrency || 5, batchId, this.runContext.applitoolsIntegrationData);
-        const targetElementData = this.getTarget() || {};
-        let result;
-        try {
-            const openedEye = await eyeManager.openEyes({ driver: this.driver.client, config, logger: applitoolsSdkLogger });
-            const region = (this.step.action === 'element' && targetElementData.seleniumElement) || undefined;
-            const settings = { region, fully: this.step.action === 'stitched' };
-            if (_.isPlainObject(finalParams.applitoolsStepSettings)) {
-                Object.assign(settings, finalParams.applitoolsStepSettings);
-                logger.info('Applitools SDK step executed with applitoolsStepSettings parameter', { applitoolsStepSettings: finalParams.applitoolsStepSettings });
-            }
-            await openedEye.check({ settings });
-            const eyesResults = await openedEye.close();
-
-            result = { isApplitoolsSdkResult: true, success: true, eyesResults };
-        } catch (err) {
-            logger.error('Applitools SDK step failed', { err, info: err.info });
-            result = { isApplitoolsSdkResult: true, success: false, err };
-        }
-        return await eyeSdkService.handleApplitoolsSdkResult(this.context, result, this.step);
-    }
-}
-
-module.exports = PixelValidationStepAction;