codeceptjs 4.0.0-beta.9.esm-aria → 4.0.0-rc.10

package/lib/helper/Puppeteer.js

@@ -26,17 +26,24 @@ import {
   isModifierKey,
   requireWithFallback,
   normalizeSpacesInString,
+  normalizePath,
+  resolveUrl,
+  getMimeType,
+  base64EncodeFile,
 } from '../utils.js'
 import { isColorProperty, convertColorToRGBA } from '../colorUtils.js'
 import ElementNotFound from './errors/ElementNotFound.js'
+import MultipleElementsFound from './errors/MultipleElementsFound.js'
 import RemoteBrowserConnectionRefused from './errors/RemoteBrowserConnectionRefused.js'
 import Popup from './extras/Popup.js'
 import Console from './extras/Console.js'
 import { highlightElement } from './scripts/highlightElement.js'
 import { blurElement } from './scripts/blurElement.js'
+import { dropFile } from './scripts/dropFile.js'
 import { dontSeeElementError, seeElementError, dontSeeElementInDOMError, seeElementInDOMError } from './errors/ElementAssertion.js'
 import { dontSeeTraffic, seeTraffic, grabRecordedNetworkTraffics, stopRecordingTraffic, flushNetworkTraffics } from './network/actions.js'
 import WebElement from '../element/WebElement.js'
+import { selectElement } from './extras/elementSelection.js'
 
 let puppeteer
 
@@ -266,6 +273,7 @@ class Puppeteer extends Helper {
       show: false,
       defaultPopupAction: 'accept',
       highlightElement: false,
+      strict: false,
     }
 
     return Object.assign(defaults, config)
@@ -814,9 +822,26 @@ class Puppeteer extends Helper {
    * {{ react }}
    */
   async moveCursorTo(locator, offsetX = 0, offsetY = 0) {
-    const el = await this._locateElement(locator)
-    if (!el) {
-      throw new ElementNotFound(locator, 'Element to move cursor to')
+    let context = null
+    if (typeof offsetX !== 'number') {
+      context = offsetX
+      offsetX = 0
+    }
+
+    let el
+    if (context) {
+      const contextEls = await findElements.call(this, this.page, context)
+      assertElementExists(contextEls, context, 'Context element')
+      const els = await findElements.call(this, contextEls[0], locator)
+      if (!els || els.length === 0) {
+        throw new ElementNotFound(locator, 'Element to move cursor to')
+      }
+      el = els[0]
+    } else {
+      el = await this._locateElement(locator)
+      if (!el) {
+        throw new ElementNotFound(locator, 'Element to move cursor to')
+      }
     }
 
     // Use manual mouse.move instead of .hover() so the offset can be added to the coordinates
@@ -984,6 +1009,14 @@ class Puppeteer extends Helper {
    */
   async _locateElement(locator) {
     const context = await this.context
+    const elementIndex = store.currentStep?.opts?.elementIndex
+    if (this.options.strict || elementIndex) {
+      const elements = await findElements.call(this, context, locator)
+      if (elements.length === 0) {
+        throw new ElementNotFound(locator, 'Element', 'was not found')
+      }
+      return selectElement(elements, locator, this)
+    }
     return findElement.call(this, context, locator)
   }
 
@@ -1001,7 +1034,7 @@ class Puppeteer extends Helper {
     if (!els || els.length === 0) {
       throw new ElementNotFound(locator, 'Checkbox or radio')
     }
-    return els[0]
+    return selectElement(els, locator, this)
   }
 
   /**
@@ -1158,8 +1191,16 @@ class Puppeteer extends Helper {
    * {{> seeElement }}
    * {{ react }}
    */
-  async seeElement(locator) {
-    let els = await this._locate(locator)
+  async seeElement(locator, context = null) {
+    let els
+    if (context) {
+      const contextPage = await this.context
+      const contextEls = await findElements.call(this, contextPage, context)
+      assertElementExists(contextEls, context, 'Context element')
+      els = await findElements.call(this, contextEls[0], locator)
+    } else {
+      els = await this._locate(locator)
+    }
     els = (await Promise.all(els.map(el => el.boundingBox() && el))).filter(v => v)
     // Puppeteer visibility was ignored? | Remove when Puppeteer is fixed
     els = await Promise.all(els.map(async el => (await el.evaluate(node => window.getComputedStyle(node).visibility !== 'hidden' && window.getComputedStyle(node).display !== 'none')) && el))
@@ -1174,8 +1215,16 @@ class Puppeteer extends Helper {
    * {{> dontSeeElement }}
    * {{ react }}
    */
-  async dontSeeElement(locator) {
-    let els = await this._locate(locator)
+  async dontSeeElement(locator, context = null) {
+    let els
+    if (context) {
+      const contextPage = await this.context
+      const contextEls = await findElements.call(this, contextPage, context)
+      assertElementExists(contextEls, context, 'Context element')
+      els = await findElements.call(this, contextEls[0], locator)
+    } else {
+      els = await this._locate(locator)
+    }
     els = (await Promise.all(els.map(el => el.boundingBox() && el))).filter(v => v)
     // Puppeteer visibility was ignored? | Remove when Puppeteer is fixed
     els = await Promise.all(els.map(async el => (await el.evaluate(node => window.getComputedStyle(node).visibility !== 'hidden' && window.getComputedStyle(node).display !== 'none')) && el))
@@ -1541,10 +1590,10 @@ class Puppeteer extends Helper {
    * {{> fillField }}
    * {{ react }}
    */
-  async fillField(field, value) {
-    const els = await findVisibleFields.call(this, field)
+  async fillField(field, value, context = null) {
+    const els = await findVisibleFields.call(this, field, context)
     assertElementExists(els, field, 'Field')
-    const el = els[0]
+    const el = selectElement(els, field, this)
     const tag = await el.getProperty('tagName').then(el => el.jsonValue())
     const editable = await el.getProperty('contenteditable').then(el => el.jsonValue())
     if (tag === 'INPUT' || tag === 'TEXTAREA') {
@@ -1562,8 +1611,8 @@ class Puppeteer extends Helper {
   /**
    * {{> clearField }}
    */
-  async clearField(field) {
-    return this.fillField(field, '')
+  async clearField(field, context = null) {
+    return this.fillField(field, '', context)
   }
 
   /**
@@ -1571,29 +1620,30 @@ class Puppeteer extends Helper {
    *
    * {{ react }}
    */
-  async appendField(field, value) {
-    const els = await findVisibleFields.call(this, field)
+  async appendField(field, value, context = null) {
+    const els = await findVisibleFields.call(this, field, context)
     assertElementExists(els, field, 'Field')
-    highlightActiveElement.call(this, els[0], await this._getContext())
-    await els[0].press('End')
-    await els[0].type(value.toString(), { delay: this.options.pressKeyDelay })
+    const el = selectElement(els, field, this)
+    highlightActiveElement.call(this, el, await this._getContext())
+    await el.press('End')
+    await el.type(value.toString(), { delay: this.options.pressKeyDelay })
     return this._waitForAction()
   }
 
   /**
    * {{> seeInField }}
    */
-  async seeInField(field, value) {
+  async seeInField(field, value, context = null) {
     const _value = typeof value === 'boolean' ? value : value.toString()
-    return proceedSeeInField.call(this, 'assert', field, _value)
+    return proceedSeeInField.call(this, 'assert', field, _value, context)
   }
 
   /**
    * {{> dontSeeInField }}
    */
-  async dontSeeInField(field, value) {
+  async dontSeeInField(field, value, context = null) {
     const _value = typeof value === 'boolean' ? value : value.toString()
-    return proceedSeeInField.call(this, 'negate', field, _value)
+    return proceedSeeInField.call(this, 'negate', field, _value, context)
   }
 
   /**
@@ -1601,49 +1651,71 @@ class Puppeteer extends Helper {
    *
    * {{> attachFile }}
    */
-  async attachFile(locator, pathToFile) {
+  async attachFile(locator, pathToFile, context = null) {
     const file = path.join(global.codecept_dir, pathToFile)
 
     if (!fileExists(file)) {
       throw new Error(`File at ${file} can not be found on local system`)
     }
-    const els = await findFields.call(this, locator)
-    assertElementExists(els, locator, 'Field')
-    await els[0].uploadFile(file)
+    const els = await findFields.call(this, locator, context)
+    if (els.length) {
+      const el = selectElement(els, locator, this)
+      const tag = await el.evaluate(el => el.tagName)
+      const type = await el.evaluate(el => el.type)
+      if (tag === 'INPUT' && type === 'file') {
+        await el.uploadFile(file)
+        return this._waitForAction()
+      }
+    }
+
+    const targetEls = els.length ? els : await this._locate(locator)
+    assertElementExists(targetEls, locator, 'Element')
+    const el = selectElement(targetEls, locator, this)
+    const fileData = {
+      base64Content: base64EncodeFile(file),
+      fileName: path.basename(file),
+      mimeType: getMimeType(path.basename(file)),
+    }
+    await el.evaluate(dropFile, fileData)
     return this._waitForAction()
   }
 
   /**
    * {{> selectOption }}
    */
-  async selectOption(select, option) {
-    const els = await findVisibleFields.call(this, select)
-    assertElementExists(els, select, 'Selectable field')
-    const el = els[0]
-    if ((await el.getProperty('tagName').then(t => t.jsonValue())) !== 'SELECT') {
-      throw new Error('Element is not <select>')
-    }
-    highlightActiveElement.call(this, els[0], await this._getContext())
-    if (!Array.isArray(option)) option = [option]
-
-    for (const key in option) {
-      const opt = xpathLocator.literal(option[key])
-      let optEl = await findElements.call(this, el, { xpath: Locator.select.byVisibleText(opt) })
-      if (optEl.length) {
-        this._evaluateHandeInContext(el => (el.selected = true), optEl[0])
-        continue
-      }
-      optEl = await findElements.call(this, el, { xpath: Locator.select.byValue(opt) })
-      if (optEl.length) {
-        this._evaluateHandeInContext(el => (el.selected = true), optEl[0])
-      }
+  async selectOption(select, option, context = null) {
+    const pageContext = await this._getContext()
+    const matchedLocator = new Locator(select)
+
+    let contextEl
+    if (context) {
+      const contextEls = await findElements.call(this, pageContext, context)
+      assertElementExists(contextEls, context, 'Context element')
+      contextEl = contextEls[0]
     }
-    await this._evaluateHandeInContext(element => {
-      element.dispatchEvent(new Event('input', { bubbles: true }))
-      element.dispatchEvent(new Event('change', { bubbles: true }))
-    }, el)
 
-    return this._waitForAction()
+    // Strict locator
+    if (!matchedLocator.isFuzzy()) {
+      this.debugSection('SelectOption', `Strict: ${JSON.stringify(select)}`)
+      const els = contextEl ? await findElements.call(this, contextEl, select) : await this._locate(select)
+      assertElementExists(els, select, 'Selectable element')
+      return proceedSelect.call(this, pageContext, selectElement(els, select, this), option)
+    }
+
+    // Fuzzy: try combobox
+    this.debugSection('SelectOption', `Fuzzy: "${matchedLocator.value}"`)
+    const comboboxSearchCtx = contextEl || pageContext
+    let els = await findByRole(comboboxSearchCtx, { role: 'combobox', name: matchedLocator.value })
+    if (els?.length) return proceedSelect.call(this, pageContext, selectElement(els, select, this), option)
+
+    // Fuzzy: try listbox
+    els = await findByRole(comboboxSearchCtx, { role: 'listbox', name: matchedLocator.value })
+    if (els?.length) return proceedSelect.call(this, pageContext, selectElement(els, select, this), option)
+
+    // Fuzzy: try native select
+    const visibleEls = await findVisibleFields.call(this, select, context)
+    assertElementExists(visibleEls, select, 'Selectable field')
+    return proceedSelect.call(this, pageContext, selectElement(visibleEls, select, this), option)
   }
 
   /**
@@ -1687,6 +1759,26 @@ class Puppeteer extends Helper {
     urlEquals(this.options.url).negate(url, await this._getPageUrl())
   }
 
+  /**
+   * {{> seeCurrentPathEquals }}
+   */
+  async seeCurrentPathEquals(path) {
+    const currentUrl = await this._getPageUrl()
+    const baseUrl = this.options.url || 'http://localhost'
+    const actualPath = new URL(currentUrl, baseUrl).pathname
+    return equals('url path').assert(normalizePath(path), normalizePath(actualPath))
+  }
+
+  /**
+   * {{> dontSeeCurrentPathEquals }}
+   */
+  async dontSeeCurrentPathEquals(path) {
+    const currentUrl = await this._getPageUrl()
+    const baseUrl = this.options.url || 'http://localhost'
+    const actualPath = new URL(currentUrl, baseUrl).pathname
+    return equals('url path').negate(normalizePath(path), normalizePath(actualPath))
+  }
+
   /**
    * {{> see }}
    *
@@ -2424,6 +2516,7 @@ class Puppeteer extends Helper {
    */
   async waitInUrl(urlPart, sec = null) {
     const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+    const expectedUrl = resolveUrl(urlPart, this.options.url)
 
     return this.page
       .waitForFunction(
@@ -2432,12 +2525,12 @@ class Puppeteer extends Helper {
           return currUrl.indexOf(urlPart) > -1
         },
         { timeout: waitTimeout },
-        urlPart,
+        expectedUrl,
       )
       .catch(async e => {
-        const currUrl = await this._getPageUrl() // Required because the waitForFunction can't return data.
+        const currUrl = await this._getPageUrl()
         if (/Waiting failed:/i.test(e.message) || /failed: timeout/i.test(e.message)) {
-          throw new Error(`expected url to include ${urlPart}, but found ${currUrl}`)
+          throw new Error(`expected url to include ${expectedUrl}, but found ${currUrl}`)
         } else {
           throw e
         }
@@ -2449,25 +2542,50 @@ class Puppeteer extends Helper {
    */
   async waitUrlEquals(urlPart, sec = null) {
     const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+    const expectedUrl = resolveUrl(urlPart, this.options.url)
 
-    const baseUrl = this.options.url
-    if (urlPart.indexOf('http') < 0) {
-      urlPart = baseUrl + urlPart
-    }
+    return this.page
+      .waitForFunction(
+        url => {
+          const currUrl = decodeURIComponent(window.location.href)
+          return currUrl === url
+        },
+        { timeout: waitTimeout },
+        expectedUrl,
+      )
+      .catch(async e => {
+        const currUrl = await this._getPageUrl()
+        if (/Waiting failed/i.test(e.message) || /failed: timeout/i.test(e.message)) {
+          throw new Error(`expected url to be ${expectedUrl}, but found ${currUrl}`)
+        } else {
+          throw e
+        }
+      })
+  }
+
+  /**
+   * {{> waitCurrentPathEquals }}
+   */
+  async waitCurrentPathEquals(path, sec = null) {
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+    const normalizedPath = normalizePath(path)
 
     return this.page
       .waitForFunction(
-        urlPart => {
-          const currUrl = decodeURIComponent(decodeURIComponent(decodeURIComponent(window.location.href)))
-          return currUrl.indexOf(urlPart) > -1
+        expectedPath => {
+          const actualPath = window.location.pathname
+          const normalizePath = p => (p === '' || p === '/' ? '/' : p.replace(/\/+/g, '/').replace(/\/$/, '') || '/')
+          return normalizePath(actualPath) === expectedPath
         },
         { timeout: waitTimeout },
-        urlPart,
+        normalizedPath,
       )
       .catch(async e => {
-        const currUrl = await this._getPageUrl() // Required because the waitForFunction can't return data.
+        const currUrl = await this._getPageUrl()
+        const baseUrl = this.options.url || 'http://localhost'
+        const actualPath = new URL(currUrl, baseUrl).pathname
         if (/Waiting failed/i.test(e.message) || /failed: timeout/i.test(e.message)) {
-          throw new Error(`expected url to be ${urlPart}, but found ${currUrl}`)
+          throw new Error(`expected path to be ${normalizedPath}, but found ${normalizePath(actualPath)}`)
         } else {
           throw e
         }
@@ -2895,10 +3013,17 @@ async function findElements(matcher, locator) {
   if (isReactLocator) return findReactElements.call(this, locator)
   
   locator = new Locator(locator, 'css')
-  
+
   // Check if locator is a role locator and call findByRole
   if (locator.isRole()) return findByRole.call(this, matcher, locator)
 
+  // Handle shadow DOM locators with >>> deep descendant combinator
+  // { shadow: ['my-app', 'recipe-hello', 'button'] } => 'my-app >>> recipe-hello >>> button'
+  if (locator.isShadow()) {
+    const shadowSelector = locator.value.join(' >>> ')
+    return matcher.$$(shadowSelector)
+  }
+
   // Use proven legacy approach - Puppeteer Locator API doesn't have .all() method
   if (!locator.isXPath()) return matcher.$$(locator.simplify())
   
@@ -2955,22 +3080,32 @@ async function findElements(matcher, locator) {
 async function findElement(matcher, locator) {
   if (locator.react) return findReactElements.call(this, locator)
   locator = new Locator(locator, 'css')
-  
+
   // Check if locator is a role locator and call findByRole
   if (locator.isRole()) {
     const elements = await findByRole.call(this, matcher, locator)
     return elements[0]
   }
 
+  // Handle shadow DOM locators with >>> deep descendant combinator
+  if (locator.isShadow()) {
+    const shadowSelector = locator.value.join(' >>> ')
+    const elements = await matcher.$$(shadowSelector)
+    return elements[0]
+  }
+
   // Use proven legacy approach - Puppeteer Locator API doesn't have .first() method
   if (!locator.isXPath()) {
     const elements = await matcher.$$(locator.simplify())
     return elements[0]
   }
-  
-  // For XPath in Puppeteer 24.x+, use the same approach as findElements
-  // $x method was removed, so we use ::-p-xpath() or fallback
-  const elements = await findElements.call(this, matcher, locator)
+  // puppeteer version < 19.4.0 is no longer supported. This one is backward support.
+  if (puppeteer.default?.defaultBrowserRevision) {
+    const elements = await matcher.$$(`xpath/${locator.value}`)
+    return elements[0]
+  }
+  // For Puppeteer 24.x+, $x method was removed - use ::-p-xpath() selector
+  const elements = await matcher.$$(`::-p-xpath(${locator.value})`)
   return elements[0]
 }
 
@@ -2987,10 +3122,11 @@ async function proceedClick(locator, context = null, options = {}) {
   } else {
     assertElementExists(els, locator, 'Clickable element')
   }
+  const el = selectElement(els, locator, this)
 
-  highlightActiveElement.call(this, els[0], await this._getContext())
+  highlightActiveElement.call(this, el, await this._getContext())
 
-  await els[0].click(options)
+  await el.click(options)
   const promises = []
   if (options.waitForNavigation) {
     promises.push(this.waitForNavigation())
@@ -3121,43 +3257,57 @@ async function proceedIsChecked(assertType, option) {
   return truth(`checkable ${option}`, 'to be checked')[assertType](selected)
 }
 
-async function findVisibleFields(locator) {
-  const els = await findFields.call(this, locator)
+async function findVisibleFields(locator, context = null) {
+  const els = await findFields.call(this, locator, context)
   const visible = await Promise.all(els.map(el => el.boundingBox()))
   return els.filter((el, index) => visible[index])
 }
 
-async function findFields(locator) {
+async function findFields(locator, context = null) {
+  let contextEl
+  if (context) {
+    const contextPage = await this.context
+    const contextEls = await findElements.call(this, contextPage, context)
+    assertElementExists(contextEls, context, 'Context element')
+    contextEl = contextEls[0]
+  }
+
+  const locateFn = contextEl
+    ? loc => findElements.call(this, contextEl, loc)
+    : loc => this._locate(loc)
+
   const matchedLocator = new Locator(locator)
   if (!matchedLocator.isFuzzy()) {
-    return this._locate(matchedLocator)
+    return locateFn(matchedLocator)
   }
   const literal = xpathLocator.literal(matchedLocator.value)
 
-  let els = await this._locate({ xpath: Locator.field.labelEquals(literal) })
+  let els = await locateFn({ xpath: Locator.field.labelEquals(literal) })
   if (els.length) {
     return els
   }
 
-  els = await this._locate({ xpath: Locator.field.labelContains(literal) })
+  els = await locateFn({ xpath: Locator.field.labelContains(literal) })
   if (els.length) {
     return els
   }
-  els = await this._locate({ xpath: Locator.field.byName(literal) })
+  els = await locateFn({ xpath: Locator.field.byName(literal) })
   if (els.length) {
     return els
   }
 
   // Try ARIA selector for accessible name
-  try {
-    const page = await this.context
-    els = await page.$$(`::-p-aria(${matchedLocator.value})`)
-    if (els.length) return els
-  } catch (err) {
-    // ARIA selector not supported or failed
+  if (!contextEl) {
+    try {
+      const page = await this.context
+      els = await page.$$(`::-p-aria(${matchedLocator.value})`)
+      if (els.length) return els
+    } catch (err) {
+      // ARIA selector not supported or failed
+    }
   }
 
-  return this._locate({ css: matchedLocator.value })
+  return locateFn({ css: matchedLocator.value })
 }
 
 async function proceedDragAndDrop(sourceLocator, destinationLocator) {
@@ -3186,8 +3336,8 @@ async function proceedDragAndDrop(sourceLocator, destinationLocator) {
   await this._waitForAction()
 }
 
-async function proceedSeeInField(assertType, field, value) {
-  const els = await findVisibleFields.call(this, field)
+async function proceedSeeInField(assertType, field, value, context) {
+  const els = await findVisibleFields.call(this, field, context)
   assertElementExists(els, field, 'Field')
   const el = els[0]
   const tag = await el.getProperty('tagName').then(el => el.jsonValue())
@@ -3300,6 +3450,13 @@ function assertElementExists(res, locator, prefix, suffix) {
   }
 }
 
+function assertOnlyOneElement(elements, locator, helper) {
+  if (elements.length > 1) {
+    const webElements = elements.map(el => new WebElement(el, helper))
+    throw new MultipleElementsFound(locator, webElements)
+  }
+}
+
 function $XPath(element, selector) {
   const found = document.evaluate(selector, element || document.body, null, 5, null)
   const res = []
@@ -3538,3 +3695,81 @@ function createRoleTextMatcher(expected, exactMatch) {
   return value => typeof value === 'string' && value.includes(target)
 }
 
+async function proceedSelect(context, el, option) {
+  const role = await el.evaluate(e => e.getAttribute('role'))
+  const options = Array.isArray(option) ? option : [option]
+
+  if (role === 'combobox') {
+    this.debugSection('SelectOption', 'Expanding combobox')
+    highlightActiveElement.call(this, el, context)
+    const ariaOwns = await el.evaluate(e => e.getAttribute('aria-owns'))
+    const ariaControls = await el.evaluate(e => e.getAttribute('aria-controls'))
+    await el.click()
+    await this._waitForAction()
+
+    const listboxId = ariaOwns || ariaControls
+    let listbox = null
+    if (listboxId) {
+      const listboxEls = await context.$$( `#${listboxId}`)
+      if (listboxEls.length) listbox = listboxEls[0]
+    }
+    if (!listbox) {
+      const listboxEls = await findByRole.call(this, context, { role: 'listbox' })
+      if (listboxEls?.length) listbox = listboxEls[0]
+    }
+
+    if (listbox) {
+      for (const opt of options) {
+        const optEls = await findByRole.call(this, listbox, { role: 'option', name: opt })
+        if (optEls?.length) {
+          const optEl = optEls[0]
+          this.debugSection('SelectOption', `Clicking: "${opt}"`)
+          highlightActiveElement.call(this, optEl, context)
+          await optEl.click()
+        }
+      }
+    }
+    return this._waitForAction()
+  }
+
+  if (role === 'listbox') {
+    for (const opt of options) {
+      const optEls = await findByRole.call(this, el, { role: 'option', name: opt })
+      if (optEls?.length) {
+        const optEl = optEls[0]
+        this.debugSection('SelectOption', `Clicking: "${opt}"`)
+        highlightActiveElement.call(this, optEl, context)
+        await optEl.click()
+      }
+    }
+    return this._waitForAction()
+  }
+
+  // Native <select> element
+  const tagName = await el.evaluate(e => e.tagName)
+  if (tagName !== 'SELECT') {
+    throw new Error('Element is not <select>')
+  }
+  highlightActiveElement.call(this, el, context)
+  const optionArray = Array.isArray(option) ? option : [option]
+
+  for (const key in optionArray) {
+    const opt = xpathLocator.literal(optionArray[key])
+    let optEl = await findElements.call(this, el, { xpath: Locator.select.byVisibleText(opt) })
+    if (optEl.length) {
+      this._evaluateHandeInContext(el => (el.selected = true), optEl[0])
+      continue
+    }
+    optEl = await findElements.call(this, el, { xpath: Locator.select.byValue(opt) })
+    if (optEl.length) {
+      this._evaluateHandeInContext(el => (el.selected = true), optEl[0])
+    }
+  }
+  await this._evaluateHandeInContext(element => {
+    element.dispatchEvent(new Event('input', { bubbles: true }))
+    element.dispatchEvent(new Event('change', { bubbles: true }))
+  }, el)
+
+  return this._waitForAction()
+}
+