codeceptjs 4.0.1-beta.21 → 4.0.1-beta.23

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)
   }
 
   /**
@@ -4510,32 +4505,14 @@ async function proceedClick(locator, context = null, options = {}) {
 }
 
 async function findClickable(matcher, locator) {
-  // Convert to Locator first to handle JSON strings properly
-  const matchedLocator = new Locator(locator)
-
-  // Handle role locators from Locator
-  if (matchedLocator.isRole()) {
-    return findByRole(matcher, matchedLocator)
-  }
+  if (locator.react) return findReact(matcher, locator)
+  if (locator.vue) return findVue(matcher, locator)
 
-  if (!matchedLocator.isFuzzy()) return findElements.call(this, matcher, matchedLocator)
+  locator = new Locator(locator)
+  if (!locator.isFuzzy()) return findElements.call(this, matcher, locator)
 
   let els
-  const literal = xpathLocator.literal(matchedLocator.value)
-
-  try {
-    els = await matcher.getByRole('button', { name: matchedLocator.value }).all()
-    if (els.length) return els
-  } catch (err) {
-    // getByRole not supported or failed
-  }
-
-  try {
-    els = await matcher.getByRole('link', { name: matchedLocator.value }).all()
-    if (els.length) return els
-  } catch (err) {
-    // getByRole not supported or failed
-  }
+  const literal = xpathLocator.literal(locator.value)
 
   els = await findElements.call(this, matcher, Locator.clickable.narrow(literal))
   if (els.length) return els
@@ -4550,7 +4527,7 @@ async function findClickable(matcher, locator) {
     // Do nothing
   }
 
-  return findElements.call(this, matcher, matchedLocator.value) // by css or xpath
+  return findElements.call(this, matcher, locator.value) // by css or xpath
 }
 
 async function proceedSee(assertType, text, context, strict = false) {
@@ -4649,6 +4626,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

@@ -6,6 +6,9 @@ const require = createRequire(import.meta.url)
 let cssToXPath
 
 const locatorTypes = ['css', 'by', 'xpath', 'id', 'name', 'fuzzy', 'frame', 'shadow', 'role']
+
+// Roles that can be used as shorthand locators: { button: 'text' } -> { role: 'button', text: 'text' }
+const shorthandRoles = ['button', 'link', 'textbox', 'checkbox', 'radio', 'combobox', 'listbox', 'heading', 'listitem', 'menuitem', 'tab', 'option', 'searchbox', 'alert', 'dialog']
 /** @class */
 class Locator {
   /**
@@ -114,6 +117,16 @@ class Locator {
     this.locator = locator
     const keys = Object.keys(locator)
     const [type] = keys
+
+    // Transform shorthand role locators: { button: 'text' } -> { role: 'button', text: 'text' }
+    if (keys.length === 1 && shorthandRoles.includes(type)) {
+      this.locator = { role: type, text: locator[type] }
+      this.type = 'role'
+      this.value = this.locator
+      Locator.filters.forEach(f => f(this.locator, this))
+      return
+    }
+
     this.type = type
     this.value = keys.length > 1 ? locator : locator[type]
     Locator.filters.forEach(f => f(locator, this))
@@ -500,7 +513,7 @@ Locator.clickable = {
       `.//*[@aria-label = ${literal}]`,
       `.//*[@title = ${literal}]`,
       `.//*[@aria-labelledby = //*[@id][normalize-space(string(.)) = ${literal}]/@id ]`,
-      `.//*[@role='button'][normalize-space(.)=${literal}]`,
+      `.//*[@role='button' or @role='link' or @role='tab' or @role='menuitem' or @role='menuitemcheckbox' or @role='menuitemradio' or @role='option' or @role='radio' or @role='checkbox' or @role='switch' or @role='treeitem' or @role='gridcell' or @role='columnheader' or @role='rowheader' or @role='scrollbar' or @role='slider' or @role='spinbutton'][normalize-space(.)=${literal}]`,
     ]),
 
   /**

package/package.json

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