codeceptjs 2.4.3 → 2.6.2

package/lib/helper/WebDriver.js

@@ -2,6 +2,7 @@ let webdriverio;
 
 const assert = require('assert');
 const path = require('path');
+const fs = require('fs');
 const requireg = require('requireg');
 
 const Helper = require('../helper');
@@ -28,8 +29,10 @@ const ElementNotFound = require('./errors/ElementNotFound');
 const ConnectionRefused = require('./errors/ConnectionRefused');
 const Locator = require('../locator');
 
+const SHADOW = 'shadow';
 const webRoot = 'body';
 
+let version;
 /**
  * WebDriver helper which wraps [webdriverio](http://webdriver.io/) library to
  * manipulate browser using Selenium WebDriver or PhantomJS.
@@ -380,10 +383,22 @@ class WebDriver extends Helper {
     if (webdriverio.VERSION && webdriverio.VERSION.indexOf('4') === 0) {
       throw new Error(`This helper is compatible with "webdriverio@5". Current version: ${webdriverio.VERSION}. Please upgrade webdriverio to v5+ or use WebDriverIO helper instead`);
     }
+    try {
+      version = JSON.parse(fs.readFileSync(path.join(requireg.resolve('webdriverio'), '/../../', 'package.json')).toString()).version;
+    } catch (err) {
+      this.debug('Can\'t detect webdriverio version, assuming webdriverio v6 is used');
+    }
+
+    if (isWebDriver5()) {
+      console.log('DEPRECATION NOTICE:');
+      console.log('You are using webdriverio v5. It is recommended to update to webdriverio@6.\nSupport of webdriverio v5 is deprecated and will be removed in CodeceptJS 3.0\n');
+    }
     // set defaults
     this.root = webRoot;
     this.isWeb = true;
     this.isRunning = false;
+    this.sessionWindows = {};
+    this.activeSessionName = '';
 
     this._setConfig(config);
 
@@ -402,6 +417,7 @@ class WebDriver extends Helper {
   _validateConfig(config) {
     const defaults = {
       logLevel: 'silent',
+      path: '/wd/hub',
       // codeceptjs
       remoteFileUpload: true,
       smartWait: 0,
@@ -500,6 +516,11 @@ class WebDriver extends Helper {
       if (this.options.multiremote) {
         this.browser = await webdriverio.multiremote(this.options.multiremote);
       } else {
+        // remove non w3c capabilities
+        delete this.options.capabilities.protocol;
+        delete this.options.capabilities.hostname;
+        delete this.options.capabilities.port;
+        delete this.options.capabilities.path;
         this.browser = await webdriverio.remote(this.options);
       }
     } catch (err) {
@@ -563,12 +584,12 @@ class WebDriver extends Helper {
   _session() {
     const defaultSession = this.browser;
     return {
-      start: async (opts) => {
+      start: async (sessionName, opts) => {
         // opts.disableScreenshots = true; // screenshots cant be saved as session will be already closed
         opts = this._validateConfig(Object.assign(this.options, opts));
         this.debugSection('New Browser', JSON.stringify(opts));
         const browser = await webdriverio.remote(opts);
-
+        this.activeSessionName = sessionName;
         if (opts.timeouts && this.isWeb) {
           await this._defineBrowserTimeout(browser, opts.timeouts);
         }
@@ -578,14 +599,19 @@ class WebDriver extends Helper {
         return browser;
       },
       stop: async (browser) => {
+        if (!browser) return;
         return browser.deleteSession();
       },
       loadVars: async (browser) => {
         if (this.context !== this.root) throw new Error('Can\'t start session inside within block');
         this.browser = browser;
         this.$$ = this.browser.$$.bind(this.browser);
+        this.sessionWindows[this.activeSessionName] = browser;
       },
-      restoreVars: async () => {
+      restoreVars: async (session) => {
+        if (!session) {
+          this.activeSessionName = '';
+        }
         this.browser = defaultSession;
         this.$$ = this.browser.$$.bind(this.browser);
       },
@@ -626,6 +652,62 @@ class WebDriver extends Helper {
     this.$$ = this.browser.$$.bind(this.browser);
   }
 
+  /**
+   * Check if locator is type of "Shadow"
+   *
+   * @param {object} locator
+   */
+  _isShadowLocator(locator) {
+    return locator.type === SHADOW || locator[SHADOW];
+  }
+
+  /**
+   * Locate Element within the Shadow Dom
+   *
+   * @param {object} locator
+   */
+  async _locateShadow(locator) {
+    const shadow = locator.value ? locator.value : locator[SHADOW];
+    const shadowSequence = [];
+    let elements;
+
+    if (!Array.isArray(shadow)) {
+      throw new Error(`Shadow '${shadow}' should be defined as an Array of elements.`);
+    }
+
+    // traverse through the Shadow locators in sequence
+    for (let index = 0; index < shadow.length; index++) {
+      const shadowElement = shadow[index];
+      shadowSequence.push(shadowElement);
+
+      if (!elements) {
+        elements = await (this.browser.$$(shadowElement));
+      } else if (Array.isArray(elements)) {
+        elements = await elements[0].shadow$$(shadowElement);
+      } else if (elements) {
+        elements = await elements.shadow$$(shadowElement);
+      }
+
+      if (!elements || !elements[0]) {
+        throw new Error(`Shadow Element '${shadowElement}' is not found. It is possible the element is incorrect or elements sequence is incorrect. Please verify the sequence '${shadowSequence.join('>')}' is correctly chained.`);
+      }
+    }
+
+    this.debugSection('Elements', `Found ${elements.length} '${SHADOW}' elements`);
+
+    return elements;
+  }
+
+  /**
+   * Smart Wait to locate an element
+   *
+   * @param {object} locator
+   */
+  async _smartWait(locator) {
+    this.debugSection(`SmartWait (${this.options.smartWait}ms)`, `Locating ${locator} in ${this.options.smartWait}`);
+    await this.defineTimeout({ implicit: this.options.smartWait });
+  }
+
   /**
    * Get elements by different locator types, including strict locator.
    * Should be used in custom helpers:
@@ -640,6 +722,18 @@ class WebDriver extends Helper {
   async _locate(locator, smartWait = false) {
     if (require('../store').debugMode) smartWait = false;
 
+    // special locator type for Shadow DOM
+    if (this._isShadowLocator(locator)) {
+      if (!this.options.smartWait || !smartWait) {
+        const els = await this._locateShadow(locator);
+        return els;
+      }
+
+
+      const els = await this._locateShadow(locator);
+      return els;
+    }
+
     // special locator type for React
     if (locator.react) {
       const els = await this.browser.react$$(locator.react, locator.props || undefined, locator.state || undefined);
@@ -651,9 +745,9 @@ class WebDriver extends Helper {
       const els = await this.$$(withStrictLocator(locator));
       return els;
     }
-    this.debugSection(`SmartWait (${this.options.smartWait}ms)`, `Locating ${locator} in ${this.options.smartWait}`);
 
-    await this.defineTimeout({ implicit: this.options.smartWait });
+    await this._smartWait(locator);
+
     const els = await this.$$(withStrictLocator(locator));
     await this.defineTimeout({ implicit: 0 });
     return els;
@@ -676,13 +770,15 @@ class WebDriver extends Helper {
    * Find a clickable element by providing human readable text:
    *
    * ```js
-   * this.helpers['WebDriver']._locateClickable('Next page').then // ...
+   * const els = await this.helpers.WebDriver._locateClickable('Next page');
+   * const els = await this.helpers.WebDriver._locateClickable('Next page', '.pages');
    * ```
    *
    * @param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
    */
-  async _locateClickable(locator) {
-    return findClickable.call(this, locator, this.$$.bind(this)).then(res => res);
+  async _locateClickable(locator, context) {
+    const locateFn = prepareLocateFn.call(this, context);
+    return findClickable.call(this, locator, locateFn);
   }
 
   /**
@@ -753,6 +849,32 @@ class WebDriver extends Helper {
     return this.browser[clickMethod](getElementId(elem));
   }
 
+  /**
+   * {{> forceClick }}
+   *
+   * {{ react }}
+   */
+  async forceClick(locator, context = null) {
+    const locateFn = prepareLocateFn.call(this, context);
+
+    const res = await findClickable.call(this, locator, locateFn);
+    if (context) {
+      assertElementExists(res, locator, 'Clickable element', `was not found inside element ${new Locator(context)}`);
+    } else {
+      assertElementExists(res, locator, 'Clickable element');
+    }
+    const elem = usingFirstElement(res);
+
+    return this.executeScript((el) => {
+      if (document.activeElement instanceof HTMLElement) {
+        document.activeElement.blur();
+      }
+      const event = document.createEvent('MouseEvent');
+      event.initEvent('click', true, true);
+      return el.dispatchEvent(event);
+    }, elem);
+  }
+
   /**
    * {{> doubleClick }}
    *
@@ -1382,11 +1504,12 @@ class WebDriver extends Helper {
    * {{> moveCursorTo }}
    *
    */
-  async moveCursorTo(locator, offsetX = 0, offsetY = 0) {
+  async moveCursorTo(locator, xOffset, yOffset) {
     const res = await this._locate(withStrictLocator(locator), true);
     assertElementExists(res, locator);
     const elem = usingFirstElement(res);
-    return elem.moveTo(offsetX, offsetY);
+    if (isWebDriver5()) return elem.moveTo(xOffset, yOffset);
+    return elem.moveTo({ xOffset, yOffset });
   }
 
   /**
@@ -1396,6 +1519,15 @@ class WebDriver extends Helper {
   async saveScreenshot(fileName, fullPage = false) {
     const outputFile = screenshotOutputFolder(fileName);
 
+    if (this.activeSessionName) {
+      const browser = this.sessionWindows[this.activeSessionName];
+
+      if (browser) {
+        this.debug(`Screenshot of ${this.activeSessionName} session has been saved to ${outputFile}`);
+        return browser.saveScreenshot(outputFile);
+      }
+    }
+
     if (!fullPage) {
       this.debug(`Screenshot has been saved to ${outputFile}`);
       return this.browser.saveScreenshot(outputFile);
@@ -1604,6 +1736,18 @@ class WebDriver extends Helper {
     }
   }
 
+  /**
+   * {{> type }}
+   * Type out given array of keys or a string of text
+   */
+  async type(keys) {
+    if (Array.isArray(keys)) {
+      await this.browser.keys(keys);
+      return;
+    }
+    await this.browser.keys(keys.split(''));
+  }
+
   /**
    * {{> resizeWindow }}
    * Appium: not tested in web, in apps doesn't work
@@ -1748,6 +1892,19 @@ class WebDriver extends Helper {
    */
   async waitForEnabled(locator, sec = null) {
     const aSec = sec || this.options.waitForTimeout;
+    if (isWebDriver5()) {
+      return this.browser.waitUntil(async () => {
+        const res = await this.$$(withStrictLocator(locator));
+        if (!res || res.length === 0) {
+          return false;
+        }
+        const selected = await forEachAsync(res, async el => this.browser.isElementEnabled(getElementId(el)));
+        if (Array.isArray(selected)) {
+          return selected.filter(val => val === true).length > 0;
+        }
+        return selected;
+      }, aSec * 1000, `element (${new Locator(locator)}) still not enabled after ${aSec} sec`);
+    }
     return this.browser.waitUntil(async () => {
       const res = await this.$$(withStrictLocator(locator));
       if (!res || res.length === 0) {
@@ -1758,7 +1915,10 @@ class WebDriver extends Helper {
         return selected.filter(val => val === true).length > 0;
       }
       return selected;
-    }, aSec * 1000, `element (${new Locator(locator)}) still not enabled after ${aSec} sec`);
+    }, {
+      timeout: aSec * 1000,
+      timeoutMsg: `element (${new Locator(locator)}) still not enabled after ${aSec} sec`,
+    });
   }
 
   /**
@@ -1766,10 +1926,16 @@ class WebDriver extends Helper {
    */
   async waitForElement(locator, sec = null) {
     const aSec = sec || this.options.waitForTimeout;
+    if (isWebDriver5()) {
+      return this.browser.waitUntil(async () => {
+        const res = await this.$$(withStrictLocator(locator));
+        return res && res.length;
+      }, aSec * 1000, `element (${locator}) still not present on page after ${aSec} sec`);
+    }
     return this.browser.waitUntil(async () => {
       const res = await this.$$(withStrictLocator(locator));
       return res && res.length;
-    }, aSec * 1000, `element (${locator}) still not present on page after ${aSec} sec`);
+    }, { timeout: aSec * 1000, timeoutMsg: `element (${locator}) still not present on page after ${aSec} sec` });
   }
 
   /**
@@ -1802,13 +1968,27 @@ class WebDriver extends Helper {
     const client = this.browser;
     const aSec = sec || this.options.waitForTimeout;
     let currUrl = '';
+    if (isWebDriver5()) {
+      return client
+        .waitUntil(function () {
+          return this.getUrl().then((res) => {
+            currUrl = decodeUrl(res);
+            return currUrl.indexOf(urlPart) > -1;
+          });
+        }, aSec * 1000).catch((e) => {
+          if (e.message.indexOf('timeout')) {
+            throw new Error(`expected url to include ${urlPart}, but found ${currUrl}`);
+          }
+          throw e;
+        });
+    }
     return client
       .waitUntil(function () {
         return this.getUrl().then((res) => {
           currUrl = decodeUrl(res);
           return currUrl.indexOf(urlPart) > -1;
         });
-      }, aSec * 1000).catch((e) => {
+      }, { timeout: aSec * 1000 }).catch((e) => {
         if (e.message.indexOf('timeout')) {
           throw new Error(`expected url to include ${urlPart}, but found ${currUrl}`);
         }
@@ -1846,6 +2026,21 @@ class WebDriver extends Helper {
   async waitForText(text, sec = null, context = null) {
     const aSec = sec || this.options.waitForTimeout;
     const _context = context || this.root;
+    if (isWebDriver5()) {
+      return this.browser.waitUntil(
+        async () => {
+          const res = await this.$$(withStrictLocator.call(this, _context));
+          if (!res || res.length === 0) return false;
+          const selected = await forEachAsync(res, async el => this.browser.getElementText(getElementId(el)));
+          if (Array.isArray(selected)) {
+            return selected.filter(part => part.indexOf(text) >= 0).length > 0;
+          }
+          return selected.indexOf(text) >= 0;
+        }, aSec * 1000,
+        `element (${_context}) is not in DOM or there is no element(${_context}) with text "${text}" after ${aSec} sec`,
+      );
+    }
+
     return this.browser.waitUntil(
       async () => {
         const res = await this.$$(withStrictLocator.call(this, _context));
@@ -1855,8 +2050,10 @@ class WebDriver extends Helper {
           return selected.filter(part => part.indexOf(text) >= 0).length > 0;
         }
         return selected.indexOf(text) >= 0;
-      }, aSec * 1000,
-      `element (${_context}) is not in DOM or there is no element(${_context}) with text "${text}" after ${aSec} sec`,
+      }, {
+        timeout: aSec * 1000,
+        timeoutMsg: `element (${_context}) is not in DOM or there is no element(${_context}) with text "${text}" after ${aSec} sec`,
+      },
     );
   }
 
@@ -1866,6 +2063,20 @@ class WebDriver extends Helper {
   async waitForValue(field, value, sec = null) {
     const client = this.browser;
     const aSec = sec || this.options.waitForTimeout;
+    if (isWebDriver5()) {
+      return client.waitUntil(
+        async () => {
+          const res = await findFields.call(this, field);
+          if (!res || res.length === 0) return false;
+          const selected = await forEachAsync(res, async el => el.getValue());
+          if (Array.isArray(selected)) {
+            return selected.filter(part => part.indexOf(value) >= 0).length > 0;
+          }
+          return selected.indexOf(value) >= 0;
+        }, aSec * 1000,
+        `element (${field}) is not in DOM or there is no element(${field}) with value "${value}" after ${aSec} sec`,
+      );
+    }
     return client.waitUntil(
       async () => {
         const res = await findFields.call(this, field);
@@ -1875,8 +2086,10 @@ class WebDriver extends Helper {
           return selected.filter(part => part.indexOf(value) >= 0).length > 0;
         }
         return selected.indexOf(value) >= 0;
-      }, aSec * 1000,
-      `element (${field}) is not in DOM or there is no element(${field}) with value "${value}" after ${aSec} sec`,
+      }, {
+        timeout: aSec * 1000,
+        timeoutMsg: `element (${field}) is not in DOM or there is no element(${field}) with value "${value}" after ${aSec} sec`,
+      },
     );
   }
 
@@ -1886,6 +2099,17 @@ class WebDriver extends Helper {
    */
   async waitForVisible(locator, sec = null) {
     const aSec = sec || this.options.waitForTimeout;
+    if (isWebDriver5()) {
+      return this.browser.waitUntil(async () => {
+        const res = await this.$$(withStrictLocator(locator));
+        if (!res || res.length === 0) return false;
+        const selected = await forEachAsync(res, async el => el.isDisplayed());
+        if (Array.isArray(selected)) {
+          return selected.filter(val => val === true).length > 0;
+        }
+        return selected;
+      }, aSec * 1000, `element (${new Locator(locator)}) still not visible after ${aSec} sec`);
+    }
     return this.browser.waitUntil(async () => {
       const res = await this.$$(withStrictLocator(locator));
       if (!res || res.length === 0) return false;
@@ -1894,7 +2118,7 @@ class WebDriver extends Helper {
         return selected.filter(val => val === true).length > 0;
       }
       return selected;
-    }, aSec * 1000, `element (${new Locator(locator)}) still not visible after ${aSec} sec`);
+    }, { timeout: aSec * 1000, timeoutMsg: `element (${new Locator(locator)}) still not visible after ${aSec} sec` });
   }
 
   /**
@@ -1902,6 +2126,16 @@ class WebDriver extends Helper {
    */
   async waitNumberOfVisibleElements(locator, num, sec = null) {
     const aSec = sec || this.options.waitForTimeout;
+    if (isWebDriver5()) {
+      return this.browser.waitUntil(async () => {
+        const res = await this.$$(withStrictLocator(locator));
+        if (!res || res.length === 0) return false;
+        let selected = await forEachAsync(res, async el => el.isDisplayed());
+
+        if (!Array.isArray(selected)) selected = [selected];
+        return selected.length === num;
+      }, aSec * 1000, `The number of elements (${new Locator(locator)}) is not ${num} after ${aSec} sec`);
+    }
     return this.browser.waitUntil(async () => {
       const res = await this.$$(withStrictLocator(locator));
       if (!res || res.length === 0) return false;
@@ -1909,7 +2143,7 @@ class WebDriver extends Helper {
 
       if (!Array.isArray(selected)) selected = [selected];
       return selected.length === num;
-    }, aSec * 1000, `The number of elements (${new Locator(locator)}) is not ${num} after ${aSec} sec`);
+    }, { timeout: aSec * 1000, timeoutMsg: `The number of elements (${new Locator(locator)}) is not ${num} after ${aSec} sec` });
   }
 
   /**
@@ -1918,12 +2152,20 @@ class WebDriver extends Helper {
    */
   async waitForInvisible(locator, sec = null) {
     const aSec = sec || this.options.waitForTimeout;
+    if (isWebDriver5()) {
+      return this.browser.waitUntil(async () => {
+        const res = await this.$$(withStrictLocator(locator));
+        if (!res || res.length === 0) return true;
+        const selected = await forEachAsync(res, async el => el.isDisplayed());
+        return !selected.length;
+      }, aSec * 1000, `element (${new Locator(locator)}) still visible after ${aSec} sec`);
+    }
     return this.browser.waitUntil(async () => {
       const res = await this.$$(withStrictLocator(locator));
       if (!res || res.length === 0) return true;
       const selected = await forEachAsync(res, async el => el.isDisplayed());
       return !selected.length;
-    }, aSec * 1000, `element (${new Locator(locator)}) still visible after ${aSec} sec`);
+    }, { timeout: aSec * 1000, timeoutMsg: `element (${new Locator(locator)}) still visible after ${aSec} sec` });
   }
 
   /**
@@ -1945,13 +2187,22 @@ class WebDriver extends Helper {
    */
   async waitForDetached(locator, sec = null) {
     const aSec = sec || this.options.waitForTimeout;
+    if (isWebDriver5()) {
+      return this.browser.waitUntil(async () => {
+        const res = await this.$$(withStrictLocator(locator));
+        if (!res || res.length === 0) {
+          return true;
+        }
+        return false;
+      }, aSec * 1000, `element (${new Locator(locator)}) still on page after ${aSec} sec`);
+    }
     return this.browser.waitUntil(async () => {
       const res = await this.$$(withStrictLocator(locator));
       if (!res || res.length === 0) {
         return true;
       }
       return false;
-    }, aSec * 1000, `element (${new Locator(locator)}) still on page after ${aSec} sec`);
+    }, { timeout: aSec * 1000, timeoutMsg: `element (${new Locator(locator)}) still on page after ${aSec} sec` });
   }
 
   /**
@@ -1969,7 +2220,10 @@ class WebDriver extends Helper {
     }
 
     const aSec = sec || this.options.waitForTimeout;
-    return this.browser.waitUntil(async () => this.browser.execute(fn, ...args), aSec * 1000);
+    if (isWebDriver5()) {
+      return this.browser.waitUntil(async () => this.browser.execute(fn, ...args), aSec * 1000, '');
+    }
+    return this.browser.waitUntil(async () => this.browser.execute(fn, ...args), { timeout: aSec * 1000, timeoutMsg: '' });
   }
 
   /**
@@ -1979,7 +2233,10 @@ class WebDriver extends Helper {
   async waitUntil(fn, sec = null, timeoutMsg = null, interval = null) {
     const aSec = sec || this.options.waitForTimeout;
     const _interval = typeof interval === 'number' ? interval * 1000 : null;
-    return this.browser.waitUntil(fn, aSec * 1000, timeoutMsg, _interval);
+    if (isWebDriver5()) {
+      return this.browser.waitUntil(fn, aSec * 1000, timeoutMsg, _interval);
+    }
+    return this.browser.waitUntil(fn, { timeout: aSec * 1000, timeoutMsg, interval: _interval });
   }
 
   /**
@@ -2016,6 +2273,19 @@ class WebDriver extends Helper {
     const aSec = sec || this.options.waitForTimeout;
     let target;
     const current = await this.browser.getWindowHandle();
+
+    if (isWebDriver5()) {
+      await this.browser.waitUntil(async () => {
+        await this.browser.getWindowHandles().then((handles) => {
+          if (handles.indexOf(current) + num + 1 <= handles.length) {
+            target = handles[handles.indexOf(current) + num];
+          }
+        });
+        return target;
+      }, aSec * 1000, `There is no ability to switch to next tab with offset ${num}`);
+      return this.browser.switchToWindow(target);
+    }
+
     await this.browser.waitUntil(async () => {
       await this.browser.getWindowHandles().then((handles) => {
         if (handles.indexOf(current) + num + 1 <= handles.length) {
@@ -2023,7 +2293,7 @@ class WebDriver extends Helper {
         }
       });
       return target;
-    }, aSec * 1000, `There is no ability to switch to next tab with offset ${num}`);
+    }, { timeout: aSec * 1000, timeoutMsg: `There is no ability to switch to next tab with offset ${num}` });
     return this.browser.switchToWindow(target);
   }
 
@@ -2042,6 +2312,19 @@ class WebDriver extends Helper {
     const aSec = sec || this.options.waitForTimeout;
     const current = await this.browser.getWindowHandle();
     let target;
+
+    if (isWebDriver5()) {
+      await this.browser.waitUntil(async () => {
+        await this.browser.getWindowHandles().then((handles) => {
+          if (handles.indexOf(current) - num > -1) {
+            target = handles[handles.indexOf(current) - num];
+          }
+        });
+        return target;
+      }, aSec * 1000, `There is no ability to switch to previous tab with offset ${num}`);
+      return this.browser.switchToWindow(target);
+    }
+
     await this.browser.waitUntil(async () => {
       await this.browser.getWindowHandles().then((handles) => {
         if (handles.indexOf(current) - num > -1) {
@@ -2049,7 +2332,7 @@ class WebDriver extends Helper {
         }
       });
       return target;
-    }, aSec * 1000, `There is no ability to switch to previous tab with offset ${num}`);
+    }, { timeout: aSec * 1000, timeoutMsg: `There is no ability to switch to previous tab with offset ${num}` });
     return this.browser.switchToWindow(target);
   }
 
@@ -2284,7 +2567,6 @@ async function filterAsync(array, callback) {
   return values;
 }
 
-
 async function findClickable(locator, locateFn) {
   locator = new Locator(locator);
   if (locator.isAccessibilityId() && !this.isWeb) return locateFn(locator, true);
@@ -2308,6 +2590,7 @@ async function findClickable(locator, locateFn) {
 
 async function findFields(locator) {
   locator = new Locator(locator);
+
   if (locator.isAccessibilityId() && !this.isWeb) return this._locate(locator, true);
   if (!locator.isFuzzy()) return this._locate(locator, true);
 
@@ -2622,4 +2905,8 @@ function prepareLocateFn(context) {
   };
 }
 
+function isWebDriver5() {
+  return version && version.indexOf('5') === 0;
+}
+
 module.exports = WebDriver;

package/lib/helper/extras/PlaywrightPropEngine.js

@@ -0,0 +1,53 @@
+module.exports.createValueEngine = () => {
+  return {
+    // Creates a selector that matches given target when queried at the root.
+    // Can return undefined if unable to create one.
+    create(root, target) {
+      return null;
+    },
+
+    // Returns the first element matching given selector in the root's subtree.
+    query(root, selector) {
+      if (!root) {
+        return null;
+      }
+      return `${root.value}`.includes(selector) ? root : null;
+    },
+
+    // Returns all elements matching given selector in the root's subtree.
+    queryAll(root, selector) {
+      if (!root) {
+        return null;
+      }
+      return `${root.value}`.includes(selector) ? root : null;
+    },
+  };
+};
+
+module.exports.createDisabledEngine = () => {
+  return {
+    // Creates a selector that matches given target when queried at the root.
+    // Can return undefined if unable to create one.
+    create(root, target) {
+      return null;
+    },
+
+    // Returns the first element matching given selector in the root's subtree.
+    query(root, value) {
+      const bool = value === 'true';
+      if (!root) {
+        return null;
+      }
+      return root.disabled === bool ? root : null;
+    },
+
+    // Returns all elements matching given selector in the root's subtree.
+    queryAll(root, value) {
+      const bool = value === 'true';
+      if (!root) {
+        return null;
+      }
+      return root.disabled === bool ? root : null;
+    },
+  };
+};