@testim/testim-cli 3.273.0 → 3.275.0

package/player/stepActions/scripts/setText.js

@@ -2,19 +2,18 @@
 
 'use strict';
 
-/*global KeyboardEvent */
-var setText = function (eventData, done) {
-    var eventConstructorSupported = typeof Event === 'function';
-    var element = eventData.isRoot ? document.documentElement : getLocatedElement(eventData.locatedElement);
-    var context = {
+const setText = function (eventData, done) {
+    const eventConstructorSupported = typeof Event === 'function';
+    const element = eventData.isRoot ? document.documentElement : getLocatedElement(eventData.locatedElement);
+    const context = {
         eventIndex: 0,
-        element: element,
+        element,
         events: eventData.events,
         eventType: eventData.eventType,
-        quirks: eventData.quirks
+        quirks: eventData.quirks,
     };
 
-    if(!element) {
+    if (!element) {
         throw new Error('element not found');
     }
 
@@ -22,10 +21,10 @@ var setText = function (eventData, done) {
         resolve();
     };
 
-    window.addEventListener("unload", window.__unloadNavigator);
+    window.addEventListener('unload', window.__unloadNavigator);
 
-    var keyboardEventNames = ["keydown", "keyup", "keypress"];
-    var MAX_KEYBOARD_EVENT_TIMEOUT = 15; //max msec between keyboard events
+    const keyboardEventNames = ['keydown', 'keyup', 'keypress'];
+    const MAX_KEYBOARD_EVENT_TIMEOUT = 15; //max msec between keyboard events
 
     function getTextInputEventObject(userEvent) {
         try {
@@ -33,28 +32,28 @@ var setText = function (eventData, done) {
                 return undefined;
             }
 
-            var event = new CustomEvent("textInput", {
+            const event = new CustomEvent('textInput', {
                 bubbles: true,
-                cancelable: true
+                cancelable: true,
             });
             if (userEvent.eventData) {
                 event.data = userEvent.eventData.data;
             }
             return event;
-        } catch (err) {
-        }
+        } catch (err) { /* ignored */ }
+        return undefined;
     }
 
     function initTextInputEvent(userEvent) {
         try {
-            var event = document.createEvent('TextEvent');
+            const event = document.createEvent('TextEvent');
             event.data = userEvent.eventData.data;
-            var method = 1; // keyboard
-            var locale = userEvent.eventData.locale || 'en-US';
+            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) {
-        }
+        } catch (err) { /* ignored */ }
+        return undefined;
     }
 
     function getTextInputEvent(userEvent) {
@@ -67,48 +66,50 @@ var setText = function (eventData, done) {
                 bubbles: true,
                 cancelable: true,
                 location: eventData.location || 0,
-                key: eventData.key || "",
+                key: eventData.key || '',
                 ctrlKey: Boolean(modifiers.ctrl),
                 shiftKey: Boolean(modifiers.shift),
                 altKey: Boolean(modifiers.alt),
-                metaKey: Boolean(modifiers.meta)
+                metaKey: Boolean(modifiers.meta),
             });
-        } catch (err) {
-        }
+        } catch (err) { /* ignored */ }
+        return undefined;
     }
 
     function initKeyboardEvent(eventType, eventData, modifiers) {
         try {
-            var event = document.createEvent('KeyboardEvent');
+            const event = document.createEvent('KeyboardEvent');
 
-            event.initKeyEvent(eventType,// typeArg,
-                true,// canBubbleArg,
-                true,// cancelableArg,
-                null,// viewArg,  Specifies UIEvent.view. This value may be null.
+            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);
+                eventData.key || '',
+                0, // charCodeArg
+            );
 
             return event;
-        } catch (err) {
-        }
+        } catch (err) { /* ignored */ }
+        return undefined;
     }
 
     function createKeyboardEvents(eventType, eventData, modifiers) {
         try {
-            var event = document.createEvent('Events');
+            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 || "";
+            event.keyCode = eventData.key || '';
             return event;
-        } catch (err) {
-        }
+        } catch (err) { /* ignored */ }
+        return undefined;
     }
 
     function createKeyboardEvent(eventType, eventData, modifiers) {
@@ -119,36 +120,36 @@ var setText = function (eventData, done) {
 
     function getKeyboardEvent(userEvent) {
         // some apps override Array.indexOf to return undefined if element not found (like Arkia)
-        var index = keyboardEventNames.indexOf(userEvent.event);
-        if ((typeof index !== "number") || (index < 0)) {
+        const index = keyboardEventNames.indexOf(userEvent.event);
+        if ((typeof index !== 'number') || (index < 0)) {
             return null;
         }
 
-        var eventData = userEvent.eventData;
-        var modifiers = eventData.modifiers || {};
+        const eventData = userEvent.eventData;
+        const modifiers = eventData.modifiers || {};
 
-        var event = createKeyboardEvent(userEvent.event, 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: function () {
+                get() {
                     return this._keyCode_;
-                }
+                },
             },
             charCode: {
                 enumerable: true,
-                get: function () {
+                get() {
                     return this._charCode_;
-                }
+                },
             },
             which: {
                 enumerable: true,
-                get: function () {
+                get() {
                     return this._keyCode_;
-                }
-            }
+                },
+            },
         });
         event._keyCode_ = eventData.keyCode;
         event._charCode_ = eventData.charCode || 0;
@@ -156,42 +157,42 @@ var setText = function (eventData, done) {
     }
 
     function getEvent(userEvent) {
-        return userEvent.event === "textInput" ?
+        return userEvent.event === 'textInput' ?
             getTextInputEvent(userEvent) :
             getKeyboardEvent(userEvent);
     }
 
     function shouldSkipEvent(currentEvent, context) {
-        var isTextInputAuth0Form = function () {
-            return currentEvent.event === "textInput" && !(context.quirks && context.quirks.isAuth0Form);
+        const isTextInputAuth0Form = function () {
+            return currentEvent.event === 'textInput' && !context.quirks?.isAuth0Form;
         };
         return isTextInputAuth0Form();
     }
 
     function getTextEventTimeout(currentEvent, nextEvent) {
-        return ((currentEvent.event === "keyup") && (nextEvent.event === "keydown")) ?
+        return ((currentEvent.event === 'keyup') && (nextEvent.event === 'keydown')) ?
             MAX_KEYBOARD_EVENT_TIMEOUT :
             0;
     }
 
     function getTimeBetweenFiringEvents(context, currentEvent, nextEvent) {
-        var maxTimeout = getTextEventTimeout(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
-        var descriptor = Object.getOwnPropertyDescriptor(element, 'value');
+        const descriptor = Object.getOwnPropertyDescriptor(element, 'value');
         if (!descriptor) {
             return;
         }
-        var initialValue = element.value;
-        element.value = initialValue + '#';
+        const initialValue = element.value;
+        element.value = `${initialValue}#`;
         if (descriptor.configurable) {
             delete element.value;
         }
         element.value = initialValue;
-        var event = document.createEvent('HTMLEvents');
+        const event = document.createEvent('HTMLEvents');
         event.initEvent('input', true, false);
         element.dispatchEvent(event);
         Object.defineProperty(element, 'value', descriptor);
@@ -204,25 +205,23 @@ var setText = function (eventData, done) {
         try {
             handleReactFormFocus(context.element);
             if (eventConstructorSupported) {
-                context.element.dispatchEvent(new Event("change"));
+                context.element.dispatchEvent(new Event('change'));
             } else {
-                var event = document.createEvent("HTMLEvents");
-                event.initEvent("change", false, true);
+                const event = document.createEvent('HTMLEvents');
+                event.initEvent('change', false, true);
                 context.element.dispatchEvent(event);
             }
-        } catch (e) {
-        }
-
+        } catch (e) { /* ignored */ }
     }
 
     function nextAsyncEvent(context, currentEvent, nextEvent) {
         if (nextEvent) {
-            setTimeout(function () {
+            setTimeout(() => {
                 executeAsyncNext(context);
             }, getTimeBetweenFiringEvents(context, currentEvent, nextEvent));
         } else {
             if (window.__unloadNavigator) {
-                window.removeEventListener("unload", window.__unloadNavigator);
+                window.removeEventListener('unload', window.__unloadNavigator);
             }
             handleChangeEventIfNeeded(context);
             resolve();
@@ -230,29 +229,27 @@ var setText = function (eventData, done) {
     }
 
     function shouldDispatchOnParentElement(eventType, context) {
-        return (eventType === "change" || eventType === "blur") && context.element.tagName === "OPTION";
+        return (eventType === 'change' || eventType === 'blur') && context.element.tagName === 'OPTION';
     }
 
     function getElement(event, context, currentEvent) {
         if (shouldDispatchOnParentElement(event.type, context)) {
             return context.element.parentElement;
-        } else if (currentEvent.locatedElement) {
+        } if (currentEvent.locatedElement) {
             return getLocatedElement(currentEvent.locatedElement);
-        } else {
-            return context.element;
         }
+        return context.element;
     }
 
     function findTextNode(element, offsetData) {
-        var child = element.firstChild,
-            innerChild;
+        let child = element.firstChild;
+        let innerChild;
         while (child) {
             if (child.nodeType === 3) {
                 if (offsetData.offset-- <= 0) {
                     return child;
                 }
-            }
-            else if (child.nodeType === 1) {
+            } else if (child.nodeType === 1) {
                 innerChild = findTextNode(child, offsetData);
                 if (innerChild) {
                     return innerChild;
@@ -267,46 +264,43 @@ var setText = function (eventData, done) {
         if (!element || !selection) {
             return;
         }
+        // eslint-disable-next-line no-restricted-globals
         if (!isNaN(selection.start)) {
             element.selectionStart = selection.start;
             element.selectionEnd = selection.end;
-        }
-        else if (!isNaN(selection.nodeOffset)) {
-            var startNode;
+        // eslint-disable-next-line no-restricted-globals
+        } else if (!isNaN(selection.nodeOffset)) {
+            let startNode;
             if (element.firstChild) {
                 startNode = findTextNode(element, { offset: selection.nodeOffset });
-            }
-            else {
+            } else {
                 startNode = element;
             }
             if (startNode) {
-                var sel = window.getSelection(),
-                    range = document.createRange();
+                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) {
-                }
+                } catch (ignore) { /* ignored */ }
             }
         }
     }
 
     function executeAsyncEvent(event, context, currentEvent) {
-        if (context.isFocusable && context.isSelectable(event) && event.type !== "submit") {
+        if (context.isFocusable && context.isSelectable(event) && event.type !== 'submit') {
             try {
                 setSelection(context.element, currentEvent.eventData.selection);
-            } catch (ignore) {
-            }
+            } catch (ignore) { /* ignored */ }
         }
-        var element = getElement(event, context, currentEvent);
+        const element = getElement(event, context, currentEvent);
         if (!element) {
             throw new Error('could not find element');
         }
-        if (event.type === "submit" && element.action) {
+        if (event.type === 'submit' && element.action) {
             element.submit();
         } else {
             element.dispatchEvent(event);
@@ -314,70 +308,70 @@ var setText = function (eventData, done) {
     }
 
     function executeAsyncNext(context) {
-        var event;
-        var currentEvent = context.events[context.eventIndex];
-        var nextEvent = context.events[++context.eventIndex];
+        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);
+            return reject(`exception in get event in text step:${err.message}`);
         }
 
         if (shouldSkipEvent(currentEvent, context)) {
             return nextAsyncEvent(context, currentEvent, nextEvent);
-        } else if (event) {
+        } if (event) {
             try {
                 executeAsyncEvent(event, context, currentEvent);
             } catch (err) {
-                return reject("exception in executeEvent in text step:" + err.message);
+                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);
+            return reject(`cannot execute event ${currentEvent.event}`);
         }
         nextAsyncEvent(context, currentEvent, nextEvent);
+        return undefined;
     }
 
     function isFocusableInput(target) {
-        var tagName = target.tagName;
-        return (tagName === "INPUT" || tagName === "TEXTAREA");
+        const tagName = target.tagName;
+        return (tagName === 'INPUT' || tagName === 'TEXTAREA');
     }
 
     function isContentEditable(target) {
         return target.getAttribute ?
-            Boolean(target.getAttribute("contenteditable") === "true") :
+            Boolean(target.getAttribute('contenteditable') === 'true') :
             false;
     }
 
     function executeSetValue(context, userEvent) {
         if (context.isInput) {
             context.element.value = userEvent.eventData.text;
-            var inputEvent = document.createEvent("Event");
-            inputEvent.initEvent("input", true, false);
+            const inputEvent = document.createEvent('Event');
+            inputEvent.initEvent('input', true, false);
             context.element.dispatchEvent(inputEvent);
-        }
-        else if (context.isContentEditable) {
+        } else if (context.isContentEditable) {
             context.element.innerHTML = userEvent.eventData.text;
         }
     }
 
     function findEffectiveActiveElement() {
-        var activeElement = document.activeElement;
-        while (activeElement.shadowRoot && activeElement.shadowRoot.activeElement) {
+        let activeElement = document.activeElement;
+        while (activeElement.shadowRoot?.activeElement) {
             activeElement = activeElement.shadowRoot.activeElement;
         }
         return activeElement;
     }
 
     function resolve(result) {
-        var status = {
+        const status = {
             status: 'done',
-            result: result,
-            success: true
+            result,
+            success: true,
         };
         if (context.isNonTextableElemnet) {
-            status.reason = "Set text on non input element";
+            status.reason = 'Set text on non input element';
         }
 
         done(status);
@@ -385,13 +379,13 @@ var setText = function (eventData, done) {
 
     function reject(result) {
         result = result || {};
-        var status = {
+        const status = {
             status: 'failed',
-            result: result,
-            success: false
+            result,
+            success: false,
         };
         if (context.isNonTextableElemnet) {
-            status.reason = "Set text on non input element";
+            status.reason = 'Set text on non input element';
         }
 
         done(status);
@@ -405,14 +399,15 @@ var setText = function (eventData, done) {
         }
         context.isFocusable = context.isInput || context.isContentEditable;
         context.isSelectable = function (event) {
-            return event.type !== "keyup";
+            return event.type !== 'keyup';
         };
         context.noEventExecuter = executeSetValue;
     } catch (err) {
-        return reject("exception in set text step:" + err.message);
+        reject(`exception in set text step:${err.message}`);
+        return;
     }
 
-    var oldActiveElement = findEffectiveActiveElement();
+    const oldActiveElement = findEffectiveActiveElement();
     dispatchFocus(eventData.elementToFocusLocatedElement, oldActiveElement);
     executeAsyncNext(context);
 };

package/player/stepActions/scripts/wheel.js

@@ -1,24 +1,25 @@
+/* global getLocatedElement */
+
 'use strict';
 
-/*global WheelEvent */
-var wheel = function (eventData, done) {
-    var MAX_WHEEL_EVENT_TIMEOUT = 200;
+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);
         }
-        var pointerPosition = userEvent.pointerPosition || {};
-        var rect = element.getBoundingClientRect();
-        var clientX = pointerPosition.originX && isWithinBounds(rect.left, rect.left + rect.width, pointerPosition.originX) ? pointerPosition.originX : rect.left + (rect.width / 2);
-        var clientY = pointerPosition.originY && isWithinBounds(rect.top, rect.top + rect.height, pointerPosition.originY) ? pointerPosition.originY : rect.top + (rect.height / 2);
+        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) {
-        var pos = getEventPosition(userEvent, element);
-        var modifiers = eventData?.modifiers || {};
-        var dict = {
+        const pos = getEventPosition(userEvent, element);
+        const modifiers = eventData?.modifiers || {};
+        const dict = {
             deltaX: userEvent.deltaX,
             deltaY: userEvent.deltaY,
             deltaZ: userEvent.deltaZ,
@@ -37,22 +38,23 @@ var wheel = function (eventData, done) {
 
     function executeEvents(events, element) {
         if (events.length === 0) {
-            return done({ state: 'success' });
+            done({ state: 'success' });
+            return;
         }
         if (!element) {
             throw new Error('element not found');
         }
 
-        var event = events.shift();
-        var currentEvent = getWheelEvent(event, eventData.eventData, element);
-        var timeout = events[0] ? Math.min(events[0].timeStamp - event.timeStamp, MAX_WHEEL_EVENT_TIMEOUT) : MAX_WHEEL_EVENT_TIMEOUT;
+        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(function () {
+        setTimeout(() => {
             executeEvents(events, element);
         }, timeout);
     }
 
-    var element = getLocatedElement(eventData.locatedElement);
+    const element = getLocatedElement(eventData.locatedElement);
     executeEvents(eventData.events, element);
 };
 

package/polyfills/index.js

@@ -1,5 +1,9 @@
 require('./Array.prototype.at');
 const xhr2 = require('../commons/xhr2');
+const { performance } = require('perf_hooks');
 
 global.xhr2 = xhr2;
 global.XMLHttpRequest = xhr2;
+
+// TODO [engine:node@>=16.6.0]: can be removed once we support 16+
+global.performance = performance;

package/testRunStatus.js

@@ -202,20 +202,6 @@ class RunStatus {
         try {
             const params = await runHook(this.options.beforeTest, Object.assign({}, test, { exportsGlobal: globalParameters, globalParameters }), this.options.userData.loginData.token);
 
-            // Temporary Sapiens log (SUP-3192)
-            if (this.options.projectData && this.options.projectData.projectId === 'fZ63D61PRQQVvvtGY6Ue' && this.options.suites && this.options.suites.includes('Sanity')) {
-                logger.info('testRunStatus - testStartReport', {
-                    'test.config.testData': test.config.testData,
-                    'this.exportsGlobal': this.exportsGlobal,
-                    'this.fileUserParamsData': this.fileUserParamsData,
-                    'this.beforeSuiteParams': this.beforeSuiteParams,
-                    params,
-                    executionId,
-                    'test.testId': test.testId,
-                    'test.resultId': test.resultId,
-                });
-            }
-
             test.config.testData = Object.assign({}, test.config.testData, this.exportsGlobal, this.fileUserParamsData, this.beforeSuiteParams, params);
             this.options.runParams[test.resultId] = test.config.testData;
             test.startTime = Date.now();
@@ -316,17 +302,7 @@ class RunStatus {
         reporter.onTestFinished(test, wid, isRerun, isCodeMode);
 
         const afterMerge = Object.assign({}, this.exportsGlobal, result.exportsGlobal);
-        // Temporary Sapiens log (SUP-3192)
-        if (this.options.projectData && this.options.projectData.projectId === 'fZ63D61PRQQVvvtGY6Ue' && this.options.suites && this.options.suites.includes('Sanity')) {
-            logger.info('testRunStatus - testEnd', {
-                'this.exportsGlobal': this.exportsGlobal,
-                'result.exportsGlobal': result.exportsGlobal,
-                afterMerge,
-                executionId,
-                'test.testId': test.testId,
-                'test.resultId': test.resultId,
-            });
-        }
+
         this.exportsGlobal = afterMerge;
         return test;
     }

package/testimNpmDriver.js

@@ -14,7 +14,7 @@ const getNpmVersion = localRunnerCache.memoize(() => npmWrapper.getLatestPackage
 
 function getPackageVersion() {
     try {
-        logger.info('Get package version');
+        logger.debug('Get package version');
         const path = `${__dirname}/package.json`;
         if (!fs.existsSync(path)) {
             // This usually means that the program runs from a dev environment (in which __dirname