testcafe 2.3.1-rc.2 → 2.4.0-rc.1

package/lib/client/automation/index.js

@@ -271,7 +271,8 @@ window['%hammerhead%'].utils.removeInjectedScript();
     var reverse = createNativeMethodWrapper('reverse');
     var reduce = createNativeMethodWrapper('reduce');
     var concat = createNativeMethodWrapper('concat');
-    var join = createNativeMethodWrapper('join');
+    var join = createNativeMethodWrapper('join');
+    var every = createNativeMethodWrapper('every');
 
     var browserUtils = hammerhead__default.utils.browser;
     var nativeMethods$1 = hammerhead__default.nativeMethods;
@@ -3053,8 +3054,9 @@ window['%hammerhead%'].utils.removeInjectedScript();
     var EventType;
     (function (EventType) {
         EventType[EventType["Mouse"] = 0] = "Mouse";
-        EventType[EventType["Key"] = 1] = "Key";
+        EventType[EventType["Keyboard"] = 1] = "Keyboard";
         EventType[EventType["Touch"] = 2] = "Touch";
+        EventType[EventType["Delay"] = 3] = "Delay";
     })(EventType || (EventType = {}));
 
     var KeyModifierValues;
@@ -3065,8 +3067,16 @@ window['%hammerhead%'].utils.removeInjectedScript();
         KeyModifierValues[KeyModifierValues["shift"] = 8] = "shift";
     })(KeyModifierValues || (KeyModifierValues = {}));
 
+    var EMPTY_MODIFIERS = {
+        ctrl: false,
+        alt: false,
+        shift: false,
+        meta: false,
+    };
     function calculateKeyModifiersValue(modifiers) {
         var result = 0;
+        if (!modifiers)
+            return result;
         if (modifiers.ctrl)
             result |= KeyModifierValues.ctrl;
         if (modifiers.alt)
@@ -3077,6 +3087,24 @@ window['%hammerhead%'].utils.removeInjectedScript();
             result |= KeyModifierValues.meta;
         return result;
     }
+    function getModifiersState(modifiersBit) {
+        var modifiers = hammerhead.utils.extend({}, EMPTY_MODIFIERS);
+        if (!modifiersBit)
+            return modifiers;
+        if (modifiersBit & KeyModifierValues.ctrl)
+            modifiers.ctrl = true;
+        if (modifiersBit & KeyModifierValues.alt)
+            modifiers.alt = true;
+        if (modifiersBit & KeyModifierValues.shift)
+            modifiers.shift = true;
+        if (modifiersBit & KeyModifierValues.meta)
+            modifiers.meta = true;
+        return modifiers;
+    }
+    function getModifiersBit(key) {
+        // @ts-ignore
+        return KeyModifierValues[key] || 0;
+    }
     function calculateMouseButtonValue(options) {
         if (!options.button)
             return 'left';
@@ -3087,29 +3115,89 @@ window['%hammerhead%'].utils.removeInjectedScript();
         clickCount: 1,
         button: 'left',
     };
-    var ProxylessEventSimulator = /** @class */ (function () {
-        function ProxylessEventSimulator(dispatchEventFn, leftTopPoint) {
-            this._dispatchEventFn = dispatchEventFn;
-            this._leftTopPoint = leftTopPoint || new AxisValues(0, 0);
-        }
-        ProxylessEventSimulator.prototype._createMouseEventOptions = function (type, options) {
+    var CDPEventDescriptor = /** @class */ (function () {
+        function CDPEventDescriptor() {
+        }
+        CDPEventDescriptor._getKeyDownEventText = function (options) {
+            if (options.isNewLine)
+                return '\r';
+            if (options.keyProperty.length === 1)
+                return options.keyProperty;
+            return '';
+        };
+        CDPEventDescriptor.createKeyDownOptions = function (options) {
+            var text = CDPEventDescriptor._getKeyDownEventText(options);
+            return {
+                type: text ? 'keyDown' : 'rawKeyDown',
+                modifiers: options.modifiers || 0,
+                windowsVirtualKeyCode: options.keyCode,
+                key: options.keyProperty,
+                text: text,
+            };
+        };
+        CDPEventDescriptor.createKeyUpOptions = function (options) {
+            return {
+                type: 'keyUp',
+                modifiers: options.modifiers || 0,
+                key: options.keyProperty,
+                windowsVirtualKeyCode: options.keyCode,
+            };
+        };
+        CDPEventDescriptor.createMouseEventOptions = function (type, options, leftTopPoint) {
             return hammerhead.utils.extend({
-                x: options.options.clientX + this._leftTopPoint.x,
-                y: options.options.clientY + this._leftTopPoint.y,
+                x: options.options.clientX + leftTopPoint.x,
+                y: options.options.clientY + leftTopPoint.y,
                 modifiers: calculateKeyModifiersValue(options.options),
                 button: calculateMouseButtonValue(options.options),
                 type: type,
             }, MOUSE_EVENT_OPTIONS);
         };
-        ProxylessEventSimulator.prototype.mouseDown = function (options) {
-            var eventOptions = this._createMouseEventOptions('mousePressed', options);
-            return this._dispatchEventFn(EventType.Mouse, eventOptions);
+        CDPEventDescriptor.delay = function (delay) {
+            return {
+                type: EventType.Delay,
+                options: { delay: delay },
+            };
+        };
+        CDPEventDescriptor.keyDown = function (keyInfo) {
+            return {
+                type: EventType.Keyboard,
+                options: CDPEventDescriptor.createKeyDownOptions(keyInfo),
+            };
+        };
+        CDPEventDescriptor.keyUp = function (keyInfo) {
+            return {
+                type: EventType.Keyboard,
+                options: CDPEventDescriptor.createKeyUpOptions(keyInfo),
+            };
+        };
+        return CDPEventDescriptor;
+    }());
+
+    var ProxylessInput = /** @class */ (function () {
+        function ProxylessInput(dispatchEventFn, leftTopPoint) {
+            this._dispatchEventFn = dispatchEventFn;
+            this._leftTopPoint = leftTopPoint || new AxisValues(0, 0);
+        }
+        ProxylessInput.prototype.mouseDown = function (options) {
+            var eventOptions = CDPEventDescriptor.createMouseEventOptions('mousePressed', options, this._leftTopPoint);
+            return this._dispatchEventFn.single(EventType.Mouse, eventOptions);
+        };
+        ProxylessInput.prototype.mouseUp = function (options) {
+            var eventOptions = CDPEventDescriptor.createMouseEventOptions('mouseReleased', options, this._leftTopPoint);
+            return this._dispatchEventFn.single(EventType.Mouse, eventOptions);
+        };
+        ProxylessInput.prototype.keyDown = function (options) {
+            var eventOptions = CDPEventDescriptor.createKeyDownOptions(options);
+            return this._dispatchEventFn.single(EventType.Keyboard, eventOptions);
         };
-        ProxylessEventSimulator.prototype.mouseUp = function (options) {
-            var eventOptions = this._createMouseEventOptions('mouseReleased', options);
-            return this._dispatchEventFn(EventType.Mouse, eventOptions);
+        ProxylessInput.prototype.keyUp = function (options) {
+            var eventOptions = CDPEventDescriptor.createKeyUpOptions(options);
+            return this._dispatchEventFn.single(EventType.Keyboard, eventOptions);
         };
-        return ProxylessEventSimulator;
+        ProxylessInput.prototype.executeEventSequence = function (eventSequence) {
+            return this._dispatchEventFn.sequence(eventSequence);
+        };
+        return ProxylessInput;
     }());
 
     var AVAILABLE_OFFSET_DEEP = 2;
@@ -3156,7 +3244,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
             _this.automationSettings = new AutomationSettings(offsetOptions.speed || 1);
             _this.window = win;
             _this.cursor = cursor;
-            _this.proxylessEventSimulator = dispatchProxylessEventFn ? new ProxylessEventSimulator(dispatchProxylessEventFn, topLeftPoint) : null;
+            _this.proxylessInput = dispatchProxylessEventFn ? new ProxylessInput(dispatchProxylessEventFn, topLeftPoint) : null;
             // NOTE: only for legacy API
             _this._ensureWindowAndCursorForLegacyTests(_this);
             return _this;
@@ -3166,7 +3254,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
             automation.cursor = cursor;
         };
         VisibleElementAutomation.prototype.canUseProxylessEventSimulator = function (element) {
-            return !!this.proxylessEventSimulator
+            return !!this.proxylessInput
                 && !!element
                 && getTagName(element) !== 'select';
         };
@@ -3913,12 +4001,20 @@ window['%hammerhead%'].utils.removeInjectedScript();
         }
         ClickAutomation.prototype._mousedown = function (eventArgs) {
             if (this.canUseProxylessEventSimulator(eventArgs.element))
-                return this.proxylessEventSimulator.mouseDown(eventArgs);
+                return this.proxylessInput.mouseDown(eventArgs);
             return this.strategy.mousedown(eventArgs);
         };
         ClickAutomation.prototype._mouseup = function (element, eventArgs) {
-            if (this.canUseProxylessEventSimulator(eventArgs.element))
-                return this.proxylessEventSimulator.mouseUp(eventArgs);
+            var _this = this;
+            if (this.canUseProxylessEventSimulator(eventArgs.element)) {
+                return this.proxylessInput.mouseUp(eventArgs)
+                    .then(function (result) {
+                    var caretPos = _this.options.caretPos;
+                    if (typeof caretPos === 'number')
+                        setCaretPosition(element, caretPos);
+                    return result;
+                });
+            }
             return this.strategy.mouseup(element, eventArgs);
         };
         ClickAutomation.prototype.run = function (useStrictElementCheck) {
@@ -5023,11 +5119,13 @@ window['%hammerhead%'].utils.removeInjectedScript();
         return correctFocusableElement(allFocusable, allFocusable[currentIndex + offset], skipRadioGroups);
     }
 
-    function getKeyCode (char) {
-        if (isLetterKey(char))
-            return char.toUpperCase().charCodeAt(0);
-        var res = testCafeCore.KEY_MAPS.shiftMap[char] ? testCafeCore.KEY_MAPS.shiftMap[char].charCodeAt(0) : char.charCodeAt(0);
-        return testCafeCore.KEY_MAPS.symbolCharCodeToKeyCode[res] || res;
+    function getKeyProperties(isKeyPressEvent, key, keyIdentifier) {
+        var properties = {};
+        if ('keyIdentifier' in KeyboardEvent.prototype)
+            properties.keyIdentifier = isKeyPressEvent ? '' : keyIdentifier;
+        if ('key' in KeyboardEvent.prototype)
+            properties.key = key;
+        return properties;
     }
 
     var KEY_IDENTIFIER_MAPS = {
@@ -5127,13 +5225,44 @@ window['%hammerhead%'].utils.removeInjectedScript();
         return KEY_IDENTIFIER_MAPS.SYMBOLS[char] || KEY_IDENTIFIER_MAPS.SPECIAL_KEYS[char] || char;
     }
 
-    function getKeyProperties(isKeyPressEvent, key, keyIdentifier) {
-        var properties = {};
-        if ('keyIdentifier' in KeyboardEvent.prototype)
-            properties.keyIdentifier = isKeyPressEvent ? '' : keyIdentifier;
-        if ('key' in KeyboardEvent.prototype)
-            properties.key = key;
-        return properties;
+    function getKeyCode (char) {
+        if (isLetterKey(char))
+            return char.toUpperCase().charCodeAt(0);
+        var res = testCafeCore.KEY_MAPS.shiftMap[char] ? testCafeCore.KEY_MAPS.shiftMap[char].charCodeAt(0) : char.charCodeAt(0);
+        return testCafeCore.KEY_MAPS.symbolCharCodeToKeyCode[res] || res;
+    }
+
+    function isNewLineKey(key) {
+        return testCafeCore.KEY_MAPS.newLineKeys.indexOf(key) > -1;
+    }
+    function getKeyInfo (key, eventKeyProperty) {
+        var sanitizedKey = testCafeCore.getSanitizedKey(key);
+        var isChar = key.length === 1 || key === 'space';
+        var isNewLine = isNewLineKey(key);
+        var modifierKeyCode = testCafeCore.KEY_MAPS.modifiers[sanitizedKey];
+        var specialKeyCode = testCafeCore.KEY_MAPS.specialKeys[sanitizedKey];
+        eventKeyProperty = eventKeyProperty || key;
+        return {
+            sanitizedKey: sanitizedKey,
+            isChar: isChar,
+            modifierKeyCode: modifierKeyCode,
+            specialKeyCode: specialKeyCode,
+            isNewLine: isNewLine,
+            isLetter: isLetterKey(key),
+            keyIdentifierProperty: getKeyIdentifier(eventKeyProperty),
+            keyProperty: testCafeCore.KEY_MAPS.keyProperty[eventKeyProperty] || eventKeyProperty,
+            keyCode: getResultKeyCode(key, isChar, sanitizedKey, modifierKeyCode, specialKeyCode),
+        };
+    }
+    function getResultKeyCode(key, isChar, sanitizedKey, modifierKeyCode, specialKeyCode) {
+        var keyCode = null;
+        if (isChar && key !== 'space')
+            keyCode = getKeyCode(sanitizedKey);
+        else if (modifierKeyCode)
+            keyCode = modifierKeyCode;
+        else if (specialKeyCode)
+            keyCode = specialKeyCode;
+        return keyCode;
     }
 
     var browserUtils$a = hammerhead__default.utils.browser;
@@ -5141,21 +5270,9 @@ window['%hammerhead%'].utils.removeInjectedScript();
     var eventSimulator$a = hammerhead__default.eventSandbox.eventSimulator;
     var KeyPressSimulator = /** @class */ (function () {
         function KeyPressSimulator(key, eventKeyProperty) {
-            this.isLetter = isLetterKey(key);
-            this.isChar = key.length === 1 || key === 'space';
-            this.sanitizedKey = testCafeCore.getSanitizedKey(key);
-            this.modifierKeyCode = testCafeCore.KEY_MAPS.modifiers[this.sanitizedKey];
-            this.specialKeyCode = testCafeCore.KEY_MAPS.specialKeys[this.sanitizedKey];
-            this.keyCode = null;
-            this.keyIdentifierProperty = getKeyIdentifier(eventKeyProperty);
+            var keyInfo = getKeyInfo(key, eventKeyProperty);
+            extend$2(this, keyInfo);
             this.topSameDomainDocument = testCafeCore.domUtils.getTopSameDomainWindow(window).document;
-            this.keyProperty = testCafeCore.KEY_MAPS.keyProperty[eventKeyProperty] || eventKeyProperty;
-            if (this.isChar && key !== 'space')
-                this.keyCode = getKeyCode(this.sanitizedKey);
-            else if (this.modifierKeyCode)
-                this.keyCode = this.modifierKeyCode;
-            else if (this.specialKeyCode)
-                this.keyCode = this.specialKeyCode;
             this.storedActiveElement = null;
         }
         KeyPressSimulator._isKeyActivatedInputElement = function (el) {
@@ -5719,6 +5836,21 @@ window['%hammerhead%'].utils.removeInjectedScript();
         _a[SHORTCUT_TYPE.esc] = esc,
         _a);
 
+    function getSimulatedKeyInfo(keyCombination) {
+        var keysArray = testCafeCore.getKeyArray(keyCombination);
+        var _a = getActualKeysAndEventKeyProperties(keysArray), actualKeys = _a.actualKeys, eventKeyProperties = _a.eventKeyProperties;
+        return testCafeCore.arrayUtils.map(actualKeys, function (key, index) {
+            return hammerhead.utils.extend({ key: key }, getKeyInfo(key, eventKeyProperties[index]));
+        });
+    }
+    function changeLetterCaseIfNecessary(keyInfo) {
+        var modifiersState = getModifiersState(keyInfo.modifiers);
+        if (modifiersState.shift && keyInfo.isLetter) {
+            keyInfo.keyProperty = changeLetterCase(keyInfo.keyProperty);
+            keyInfo.keyCode = getKeyCode(keyInfo.keyProperty);
+        }
+    }
+
     var Promise$a = hammerhead__default.Promise;
     var browserUtils$c = hammerhead__default.utils.browser;
     var messageSandbox$3 = hammerhead__default.eventSandbox.message;
@@ -5736,7 +5868,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
         }
     });
     var PressAutomation = /** @class */ (function () {
-        function PressAutomation(keyCombinations, options) {
+        function PressAutomation(keyCombinations, options, dispatchProxylessEventFn) {
             this.keyCombinations = keyCombinations;
             this.isSelectElement = false;
             this.pressedKeyString = '';
@@ -5745,6 +5877,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
             this.topSameDomainDocument = testCafeCore.domUtils.getTopSameDomainWindow(window).document;
             this.automationSettings = new AutomationSettings(options.speed);
             this.options = options;
+            this.proxylessInput = dispatchProxylessEventFn ? new ProxylessInput(dispatchProxylessEventFn) : null;
         }
         PressAutomation._getKeyPressSimulators = function (keyCombination) {
             var keysArray = testCafeCore.getKeyArray(keyCombination);
@@ -5834,6 +5967,28 @@ window['%hammerhead%'].utils.removeInjectedScript();
                 return testCafeCore.promiseUtils.each(keyPressSimulators, function (keySimulator) { return _this._up(keySimulator); });
             });
         };
+        PressAutomation.prototype._calculateCDPEventSequence = function () {
+            var eventSequence = [];
+            for (var _i = 0, _a = this.keyCombinations; _i < _a.length; _i++) {
+                var keyCombination = _a[_i];
+                var simulatedKeyInfos = getSimulatedKeyInfo(keyCombination);
+                var modifiersBit = 0;
+                for (var _b = 0, simulatedKeyInfos_1 = simulatedKeyInfos; _b < simulatedKeyInfos_1.length; _b++) {
+                    var keyInfo = simulatedKeyInfos_1[_b];
+                    modifiersBit |= getModifiersBit(keyInfo.key);
+                    keyInfo.modifiers = modifiersBit;
+                    changeLetterCaseIfNecessary(keyInfo);
+                    eventSequence.push(CDPEventDescriptor.keyDown(keyInfo), CDPEventDescriptor.delay(this.automationSettings.keyActionStepDelay));
+                }
+                for (var i = simulatedKeyInfos.length - 1; i >= 0; i--) {
+                    var keyInfo = simulatedKeyInfos[i];
+                    modifiersBit &= ~getModifiersBit(keyInfo.key);
+                    keyInfo.modifiers = modifiersBit;
+                    eventSequence.push(CDPEventDescriptor.keyUp(keyInfo));
+                }
+            }
+            return eventSequence;
+        };
         PressAutomation.prototype.run = function () {
             var _this = this;
             var activeElement = testCafeCore.domUtils.getActiveElement();
@@ -5846,6 +6001,10 @@ window['%hammerhead%'].utils.removeInjectedScript();
                 };
                 return testCafeCore.sendRequestToFrame(msg, PRESS_RESPONSE_CMD, nativeMethods$d.contentWindowGetter.call(activeElement));
             }
+            if (this.proxylessInput) {
+                var eventSequence = this._calculateCDPEventSequence();
+                return this.proxylessInput.executeEventSequence(eventSequence);
+            }
             return testCafeCore.promiseUtils.each(this.keyCombinations, function (combination) {
                 return _this
                     ._runCombination(combination)
@@ -6415,7 +6574,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
     var delay$5 = testCafeCore__default.delay;
     var SPECIAL_KEYS = testCafeCore__default.KEY_MAPS.specialKeys;
     var TypeAutomation = /** @class */ (function () {
-        function TypeAutomation(element, text, typeOptions) {
+        function TypeAutomation(element, text, typeOptions, dispatchProxylessEventFn) {
             this.element = TypeAutomation.findTextEditableChild(element) || element;
             this.typingText = text.toString();
             this.modifiers = typeOptions.modifiers;
@@ -6442,6 +6601,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
                 simulateKeypress: true,
                 simulateTypeChar: true,
             };
+            this.proxylessInput = dispatchProxylessEventFn ? new ProxylessInput(dispatchProxylessEventFn) : null;
         }
         TypeAutomation.findTextEditableChild = function (element) {
             var innerElement = null;
@@ -6500,6 +6660,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
                     caretPos: this.caretPos,
                     modifiers: this.modifiers,
                 });
+                cursor.shouldRender = !this.proxylessInput;
                 var clickAutomation = new ClickAutomation(this.element, clickOptions, window, cursor);
                 return clickAutomation
                     .run(useStrictElementCheck)
@@ -6526,21 +6687,57 @@ window['%hammerhead%'].utils.removeInjectedScript();
                 else if (isContentEditable)
                     textSelection$5.deleteSelectionContents(this.element, true);
             }
+            if (this._canUseProxylessInput()) {
+                var eventSequence = this._calculateCDPEventSequence();
+                return this.proxylessInput.executeEventSequence(eventSequence);
+            }
             return promiseUtils.whilst(function () { return !_this._isTypingFinished(); }, function () { return _this._typingStep(); });
         };
         TypeAutomation.prototype._isTypingFinished = function () {
             return this.currentPos === this.typingText.length;
         };
+        TypeAutomation.prototype._getCurrentKey = function (keyCode, char) {
+            return keyCode === SPECIAL_KEYS['enter'] ? 'Enter' : char;
+        };
+        TypeAutomation.prototype._calculateCDPEventSequence = function () {
+            var eventSequence = [];
+            for (var _i = 0, _a = this.typingText; _i < _a.length; _i++) {
+                var char = _a[_i];
+                var currentKeyCode = getKeyCode(char);
+                var currentKey = this._getCurrentKey(currentKeyCode, char);
+                var keyInfo = getKeyInfo(currentKey);
+                var simulatedKeyInfo = extend$4({ key: currentKey }, keyInfo);
+                eventSequence.push(CDPEventDescriptor.keyDown(simulatedKeyInfo), CDPEventDescriptor.keyUp(simulatedKeyInfo), CDPEventDescriptor.delay(this.automationSettings.keyActionStepDelay));
+            }
+            return eventSequence;
+        };
+        TypeAutomation.prototype._canUseProxylessInput = function () {
+            if (!this.proxylessInput)
+                return false;
+            // NOTE: 'paste' is a synthetic option that don't have equivalent for native user action.
+            if (this.paste)
+                return false;
+            // NOTE: Type to non text-editable and content-editable elements are not supported in the proxyless mode.
+            // In this case, TestCafe just set element value with raising events.
+            if (!domUtils$d.isTextEditableElement(this.element)
+                && domUtils$d.isInputElement(this.element)
+                || domUtils$d.isContentEditableElement(this.element))
+                return false;
+            return true;
+        };
+        TypeAutomation.prototype._performTypingStep = function () {
+            this._keydown();
+            this._keypress();
+            return this._keyup();
+        };
         TypeAutomation.prototype._typingStep = function () {
             var char = this.typingText.charAt(this.currentPos);
             this.currentKeyCode = getKeyCode(char);
             this.currentCharCode = this.typingText.charCodeAt(this.currentPos);
-            this.currentKey = this.currentKeyCode === SPECIAL_KEYS['enter'] ? 'Enter' : char;
+            this.currentKey = this._getCurrentKey(this.currentKeyCode, char);
             this.currentKeyIdentifier = getKeyIdentifier(this.currentKey);
             this.ignoreChangeEvent = domUtils$d.getElementValue(this.element) === elementEditingWatcher$1.getElementSavedValue(this.element);
-            this._keydown();
-            this._keypress();
-            return this._keyup();
+            return this._performTypingStep();
         };
         TypeAutomation.prototype._keydown = function () {
             this.eventArgs = this._calculateEventArguments();