codeceptjs 4.0.1-beta.20 → 4.0.1-beta.22

package/bin/codecept.js

@@ -91,7 +91,8 @@ program
   .option(commandFlags.profile.flag, commandFlags.profile.description)
   .option(commandFlags.ai.flag, commandFlags.ai.description)
   .option(commandFlags.config.flag, commandFlags.config.description)
-  .action(commandHandler('../lib/command/interactive.js'))
+  .option('--file [path]', 'JavaScript file to execute in shell context')
+  .action(commandHandler('../lib/command/shell.js'))
 
 program.command('list [path]').alias('l').description('List all actions for I.').action(commandHandler('../lib/command/list.js'))
 

package/lib/command/{interactive.js → shell.js}

@@ -5,9 +5,17 @@ import Container from '../container.js'
 import event from '../event.js'
 import pause from '../pause.js'
 import output from '../output.js'
+import { fileURLToPath } from 'url'
+import { createRequire } from 'module'
+import path from 'path'
+
+const require = createRequire(import.meta.url)
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
 const webHelpers = Container.STANDARD_ACTING_HELPERS
 
-export default async function (path, options) {
+export default async function (shellPath, options) {
   // Backward compatibility for --profile
   process.profile = options.profile
   process.env.profile = options.profile
@@ -17,7 +25,7 @@ export default async function (path, options) {
   const testsPath = getTestRoot(configFile)
 
   const codecept = new Codecept(config, options)
-  codecept.init(testsPath)
+  await codecept.init(testsPath)
 
   try {
     await codecept.bootstrap()
@@ -53,7 +61,27 @@ export default async function (path, options) {
         break
       }
     }
-    pause()
+
+    if (options.file) {
+      const scriptPath = path.resolve(options.file)
+      output.print(`Executing script: ${scriptPath}`)
+
+      // Use the same I actor that pause() uses
+      const I = Container.support('I')
+      global.I = I
+      globalThis.I = I
+
+      recorder.add('execute script', async () => {
+        try {
+          await import(scriptPath)
+          output.print('Script executed successfully')
+        } catch (err) {
+          output.error(`Error executing script: ${err.message}`)
+        }
+      })
+    } else {
+      pause()
+    }
     recorder.add(() => event.emit(event.test.after, {}))
     recorder.add(() => event.emit(event.suite.after, {}))
     recorder.add(() => event.emit(event.all.result, {}))

package/lib/helper/Playwright.js

@@ -2489,35 +2489,30 @@ class Playwright extends Helper {
    * {{> selectOption }}
    */
   async selectOption(select, option) {
-    const selectLocator = Locator.from(select, 'css')
-    let els = null
+    const context = await this.context
+    const matchedLocator = new Locator(select)
 
-    if (selectLocator.isFuzzy()) {
-      els = await findByRole(this.page, { role: 'listbox', name: selectLocator.value })
-      if (!els || els.length === 0) {
-        els = await findByRole(this.page, { role: 'combobox', name: selectLocator.value })
-      }
-    }
-
-    if (!els || els.length === 0) {
-      els = await findFields.call(this, select)
+    // Strict locator
+    if (!matchedLocator.isFuzzy()) {
+      this.debugSection('SelectOption', `Strict: ${JSON.stringify(select)}`)
+      const els = await this._locate(matchedLocator)
+      assertElementExists(els, select, 'Selectable element')
+      return proceedSelect.call(this, context, els[0], option)
     }
-    assertElementExists(els, select, 'Selectable field')
-    const el = els[0]
-
-    await highlightActiveElement.call(this, el)
-    let optionToSelect = ''
 
-    try {
-      optionToSelect = (await el.locator('option', { hasText: option }).textContent()).trim()
-    } catch (e) {
-      optionToSelect = option
-    }
+    // Fuzzy: try combobox
+    this.debugSection('SelectOption', `Fuzzy: "${matchedLocator.value}"`)
+    let els = await findByRole(context, { role: 'combobox', name: matchedLocator.value })
+    if (els?.length) return proceedSelect.call(this, context, els[0], option)
 
-    if (!Array.isArray(option)) option = [optionToSelect]
+    // Fuzzy: try listbox
+    els = await findByRole(context, { role: 'listbox', name: matchedLocator.value })
+    if (els?.length) return proceedSelect.call(this, context, els[0], option)
 
-    await el.selectOption(option)
-    return this._waitForAction()
+    // Fuzzy: try native select
+    els = await findFields.call(this, select)
+    assertElementExists(els, select, 'Selectable element')
+    return proceedSelect.call(this, context, els[0], option)
   }
 
   /**
@@ -4649,6 +4644,45 @@ async function findFields(locator) {
   return this._locate({ css: locator })
 }
 
+async function proceedSelect(context, el, option) {
+  const role = await el.getAttribute('role')
+  const options = Array.isArray(option) ? option : [option]
+
+  if (role === 'combobox') {
+    this.debugSection('SelectOption', 'Expanding combobox')
+    await highlightActiveElement.call(this, el)
+    const [ariaOwns, ariaControls] = await Promise.all([el.getAttribute('aria-owns'), el.getAttribute('aria-controls')])
+    await el.click()
+    await this._waitForAction()
+
+    const listboxId = ariaOwns || ariaControls
+    let listbox = listboxId ? context.locator(`#${listboxId}`).first() : null
+    if (!listbox || !(await listbox.count())) listbox = context.getByRole('listbox').first()
+
+    for (const opt of options) {
+      const optEl = listbox.getByRole('option', { name: opt }).first()
+      this.debugSection('SelectOption', `Clicking: "${opt}"`)
+      await highlightActiveElement.call(this, optEl)
+      await optEl.click()
+    }
+    return this._waitForAction()
+  }
+
+  if (role === 'listbox') {
+    for (const opt of options) {
+      const optEl = el.getByRole('option', { name: opt }).first()
+      this.debugSection('SelectOption', `Clicking: "${opt}"`)
+      await highlightActiveElement.call(this, optEl)
+      await optEl.click()
+    }
+    return this._waitForAction()
+  }
+
+  await highlightActiveElement.call(this, el)
+  await el.selectOption(option)
+  return this._waitForAction()
+}
+
 async function proceedSeeInField(assertType, field, value) {
   const els = await findFields.call(this, field)
   assertElementExists(els, field, 'Field')

package/lib/helper/Puppeteer.js

@@ -1617,33 +1617,30 @@ class Puppeteer extends Helper {
    * {{> 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])
-      }
+    const context = await this._getContext()
+    const matchedLocator = new Locator(select)
+
+    // Strict locator
+    if (!matchedLocator.isFuzzy()) {
+      this.debugSection('SelectOption', `Strict: ${JSON.stringify(select)}`)
+      const els = await this._locate(matchedLocator)
+      assertElementExists(els, select, 'Selectable element')
+      return proceedSelect.call(this, context, els[0], option)
     }
-    await this._evaluateHandeInContext(element => {
-      element.dispatchEvent(new Event('input', { bubbles: true }))
-      element.dispatchEvent(new Event('change', { bubbles: true }))
-    }, el)
 
-    return this._waitForAction()
+    // Fuzzy: try combobox
+    this.debugSection('SelectOption', `Fuzzy: "${matchedLocator.value}"`)
+    let els = await findByRole.call(this, context, { role: 'combobox', name: matchedLocator.value })
+    if (els?.length) return proceedSelect.call(this, context, els[0], option)
+
+    // Fuzzy: try listbox
+    els = await findByRole.call(this, context, { role: 'listbox', name: matchedLocator.value })
+    if (els?.length) return proceedSelect.call(this, context, els[0], option)
+
+    // Fuzzy: try native select
+    els = await findVisibleFields.call(this, select)
+    assertElementExists(els, select, 'Selectable element')
+    return proceedSelect.call(this, context, els[0], option)
   }
 
   /**
@@ -3160,6 +3157,90 @@ async function findFields(locator) {
   return this._locate({ css: matchedLocator.value })
 }
 
+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, ariaControls] = await el.evaluate(e => [e.getAttribute('aria-owns'), e.getAttribute('aria-controls')])
+    await el.click()
+    await this._waitForAction()
+
+    const listboxId = ariaOwns || ariaControls
+    let listbox = listboxId ? await context.$(`#${listboxId}`) : null
+    if (!listbox) {
+      const listboxes = await context.$$('::-p-aria([role="listbox"])')
+      listbox = listboxes[0]
+    }
+    if (!listbox) throw new Error('Cannot find listbox for combobox')
+
+    for (const opt of options) {
+      const optionEls = await listbox.$$('::-p-aria([role="option"])')
+      let optEl = null
+      for (const optionEl of optionEls) {
+        const text = await optionEl.evaluate(e => e.textContent.trim())
+        if (text === opt || text.includes(opt)) {
+          optEl = optionEl
+          break
+        }
+      }
+      if (!optEl) throw new Error(`Cannot find option "${opt}" in listbox`)
+      this.debugSection('SelectOption', `Clicking: "${opt}"`)
+      highlightActiveElement.call(this, optEl, context)
+      await optEl.click()
+    }
+    return this._waitForAction()
+  }
+
+  if (role === 'listbox') {
+    highlightActiveElement.call(this, el, context)
+    for (const opt of options) {
+      const optionEls = await el.$$('::-p-aria([role="option"])')
+      let optEl = null
+      for (const optionEl of optionEls) {
+        const text = await optionEl.evaluate(e => e.textContent.trim())
+        if (text === opt || text.includes(opt)) {
+          optEl = optionEl
+          break
+        }
+      }
+      if (!optEl) throw new Error(`Cannot find option "${opt}" in listbox`)
+      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)
+  for (const key in options) {
+    const opt = xpathLocator.literal(options[key])
+    let optEl = await findElements.call(this, el, { xpath: Locator.select.byVisibleText(opt) })
+    if (optEl.length) {
+      this._evaluateHandeInContext(e => (e.selected = true), optEl[0])
+      continue
+    }
+    optEl = await findElements.call(this, el, { xpath: Locator.select.byValue(opt) })
+    if (optEl.length) {
+      this._evaluateHandeInContext(e => (e.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()
+}
+
 async function proceedDragAndDrop(sourceLocator, destinationLocator) {
   const src = await this._locateElement(sourceLocator)
   if (!src) {

package/lib/helper/WebDriver.js

@@ -1302,33 +1302,29 @@ class WebDriver extends Helper {
    * {{> selectOption }}
    */
   async selectOption(select, option) {
-    const res = await findFields.call(this, select)
-    assertElementExists(res, select, 'Selectable field')
-    const elem = usingFirstElement(res)
-    highlightActiveElement.call(this, elem)
+    const matchedLocator = new Locator(select)
 
-    if (!Array.isArray(option)) {
-      option = [option]
+    // Strict locator
+    if (!matchedLocator.isFuzzy()) {
+      this.debugSection('SelectOption', `Strict: ${JSON.stringify(select)}`)
+      const els = await this._locate(matchedLocator)
+      assertElementExists(els, select, 'Selectable element')
+      return proceedSelect.call(this, els[0], option)
     }
 
-    // select options by visible text
-    let els = await forEachAsync(option, async opt => this.browser.findElementsFromElement(getElementId(elem), 'xpath', Locator.select.byVisibleText(xpathLocator.literal(opt))))
+    // Fuzzy: try combobox
+    this.debugSection('SelectOption', `Fuzzy: "${matchedLocator.value}"`)
+    let els = await this._locateByRole({ role: 'combobox', text: matchedLocator.value })
+    if (els?.length) return proceedSelect.call(this, els[0], option)
 
-    const clickOptionFn = async el => {
-      if (el[0]) el = el[0]
-      const elementId = getElementId(el)
-      if (elementId) return this.browser.elementClick(elementId)
-    }
+    // Fuzzy: try listbox
+    els = await this._locateByRole({ role: 'listbox', text: matchedLocator.value })
+    if (els?.length) return proceedSelect.call(this, els[0], option)
 
-    if (Array.isArray(els) && els.length) {
-      return forEachAsync(els, clickOptionFn)
-    }
-    // select options by value
-    els = await forEachAsync(option, async opt => this.browser.findElementsFromElement(getElementId(elem), 'xpath', Locator.select.byValue(xpathLocator.literal(opt))))
-    if (els.length === 0) {
-      throw new ElementNotFound(select, `Option "${option}" in`, 'was not found neither by a visible text nor by a value')
-    }
-    return forEachAsync(els, clickOptionFn)
+    // Fuzzy: try native select
+    els = await findFields.call(this, select)
+    assertElementExists(els, select, 'Selectable element')
+    return proceedSelect.call(this, els[0], option)
   }
 
   /**
@@ -3018,6 +3014,91 @@ async function findFields(locator) {
   return await this._locate(locator.value) // by css or xpath
 }
 
+async function proceedSelect(el, option) {
+  const elementId = getElementId(el)
+  const role = await this.browser.getElementAttribute(elementId, 'role')
+  const options = Array.isArray(option) ? option : [option]
+
+  if (role === 'combobox') {
+    this.debugSection('SelectOption', 'Expanding combobox')
+    highlightActiveElement.call(this, el)
+    const ariaOwns = await this.browser.getElementAttribute(elementId, 'aria-owns')
+    const ariaControls = await this.browser.getElementAttribute(elementId, 'aria-controls')
+    await this.browser.elementClick(elementId)
+    await this._waitForAction()
+
+    const listboxId = ariaOwns || ariaControls
+    let listboxEls = listboxId ? await this.browser.$$(`#${listboxId}`) : []
+    if (!listboxEls.length) {
+      listboxEls = await this.browser.$$('[role="listbox"]')
+    }
+    if (!listboxEls.length) throw new Error('Cannot find listbox for combobox')
+    const listbox = listboxEls[0]
+    const listboxElId = getElementId(listbox)
+
+    for (const opt of options) {
+      const optionEls = await this.browser.findElementsFromElement(listboxElId, 'css selector', '[role="option"]')
+      let optEl = null
+      for (const optionEl of optionEls) {
+        const optElId = getElementId(optionEl)
+        const text = await this.browser.getElementText(optElId)
+        if (text === opt || (text && text.includes(opt))) {
+          optEl = optionEl
+          break
+        }
+      }
+      if (!optEl) throw new Error(`Cannot find option "${opt}" in listbox`)
+      this.debugSection('SelectOption', `Clicking: "${opt}"`)
+      highlightActiveElement.call(this, optEl)
+      await this.browser.elementClick(getElementId(optEl))
+    }
+    return this._waitForAction()
+  }
+
+  if (role === 'listbox') {
+    highlightActiveElement.call(this, el)
+    for (const opt of options) {
+      const optionEls = await this.browser.findElementsFromElement(elementId, 'css selector', '[role="option"]')
+      let optEl = null
+      for (const optionEl of optionEls) {
+        const optElId = getElementId(optionEl)
+        const text = await this.browser.getElementText(optElId)
+        if (text === opt || (text && text.includes(opt))) {
+          optEl = optionEl
+          break
+        }
+      }
+      if (!optEl) throw new Error(`Cannot find option "${opt}" in listbox`)
+      this.debugSection('SelectOption', `Clicking: "${opt}"`)
+      highlightActiveElement.call(this, optEl)
+      await this.browser.elementClick(getElementId(optEl))
+    }
+    return this._waitForAction()
+  }
+
+  // Native <select> element
+  highlightActiveElement.call(this, el)
+
+  // select options by visible text
+  let els = await forEachAsync(options, async opt => this.browser.findElementsFromElement(elementId, 'xpath', Locator.select.byVisibleText(xpathLocator.literal(opt))))
+
+  const clickOptionFn = async optEl => {
+    if (optEl[0]) optEl = optEl[0]
+    const optElId = getElementId(optEl)
+    if (optElId) return this.browser.elementClick(optElId)
+  }
+
+  if (Array.isArray(els) && els.length) {
+    return forEachAsync(els, clickOptionFn)
+  }
+  // select options by value
+  els = await forEachAsync(options, async opt => this.browser.findElementsFromElement(elementId, 'xpath', Locator.select.byValue(xpathLocator.literal(opt))))
+  if (els.length === 0) {
+    throw new ElementNotFound(el, `Option "${options}" in`, 'was not found neither by a visible text nor by a value')
+  }
+  return forEachAsync(els, clickOptionFn)
+}
+
 async function proceedSeeField(assertType, field, value) {
   const res = await findFields.call(this, field)
   assertElementExists(res, field, 'Field')

package/lib/locator.js

@@ -123,7 +123,11 @@ class Locator {
    * @returns {string}
    */
   toString() {
-    return this.output || `{${this.type}: ${this.value}}`
+    if (this.output) return this.output
+    if (this.locator && this.value === this.locator) {
+      return JSON.stringify(this.locator)
+    }
+    return `{${this.type}: ${this.value}}`
   }
 
   /**
@@ -496,7 +500,7 @@ Locator.clickable = {
       `.//*[@aria-label = ${literal}]`,
       `.//*[@title = ${literal}]`,
       `.//*[@aria-labelledby = //*[@id][normalize-space(string(.)) = ${literal}]/@id ]`,
-      `.//*[@role='button'][normalize-space(.)=${literal}]`,
+      `.//*[@role='link' | @role='tab' | @role='menuitem' | @role='menuitemcheckbox' | @role='menuitemradio' | @role='option' | @role='radio' | @role='checkbox' | @role='switch' | @role='treeitem' | @role='gridcell' | @role='columnheader' | @role='rowheader' | @role='scrollbar' | @role='slider' | @role='spinbutton'][normalize-space(.)='${literal}']`,
     ]),
 
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeceptjs",
-  "version": "4.0.1-beta.20",
+  "version": "4.0.1-beta.22",
   "type": "module",
   "description": "Supercharged End 2 End Testing Framework for NodeJS",
   "keywords": [