codeceptjs 4.0.1-beta.23 → 4.0.1-beta.26

package/lib/helper/Puppeteer.js

@@ -1617,30 +1617,33 @@ class Puppeteer extends Helper {
    * {{> selectOption }}
    */
   async selectOption(select, option) {
-    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)
+    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])
+      }
+    }
+    await this._evaluateHandeInContext(element => {
+      element.dispatchEvent(new Event('input', { bubbles: true }))
+      element.dispatchEvent(new Event('change', { bubbles: true }))
+    }, el)
 
-    // 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)
+    return this._waitForAction()
   }
 
   /**
@@ -2952,7 +2955,7 @@ 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)
@@ -2964,10 +2967,13 @@ async function findElement(matcher, locator) {
     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]
 }
 
@@ -3157,90 +3163,6 @@ 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,29 +1302,33 @@ class WebDriver extends Helper {
    * {{> selectOption }}
    */
   async selectOption(select, option) {
-    const matchedLocator = new Locator(select)
+    const res = await findFields.call(this, select)
+    assertElementExists(res, select, 'Selectable field')
+    const elem = usingFirstElement(res)
+    highlightActiveElement.call(this, elem)
 
-    // 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)
+    if (!Array.isArray(option)) {
+      option = [option]
     }
 
-    // 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)
+    // 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 listbox
-    els = await this._locateByRole({ role: 'listbox', 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 native select
-    els = await findFields.call(this, select)
-    assertElementExists(els, select, 'Selectable element')
-    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)
   }
 
   /**
@@ -3014,91 +3018,6 @@ 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/helper/extras/PlaywrightLocator.js

@@ -11,20 +11,22 @@ function buildLocatorString(locator) {
 }
 
 async function findElements(matcher, locator) {
-  const matchedLocator = Locator.from(locator, 'css')
+  const matchedLocator = new Locator(locator, 'css')
 
   if (matchedLocator.type === 'react') return findReact(matcher, matchedLocator)
   if (matchedLocator.type === 'vue') return findVue(matcher, matchedLocator)
+  if (matchedLocator.type === 'pw') return findByPlaywrightLocator(matcher, matchedLocator)
   if (matchedLocator.isRole()) return findByRole(matcher, matchedLocator)
 
   return matcher.locator(buildLocatorString(matchedLocator)).all()
 }
 
 async function findElement(matcher, locator) {
-  const matchedLocator = Locator.from(locator, 'css')
+  const matchedLocator = new Locator(locator, 'css')
 
   if (matchedLocator.type === 'react') return findReact(matcher, matchedLocator)
   if (matchedLocator.type === 'vue') return findVue(matcher, matchedLocator)
+  if (matchedLocator.type === 'pw') return findByPlaywrightLocator(matcher, matchedLocator, { first: true })
   if (matchedLocator.isRole()) return findByRole(matcher, matchedLocator, { first: true })
 
   return matcher.locator(buildLocatorString(matchedLocator)).first()
@@ -44,30 +46,49 @@ async function getVisibleElements(elements) {
 }
 
 async function findReact(matcher, locator) {
-  const props = locator.locator?.props
-  let locatorString = `_react=${locator.value}`
+  const details = locator.locator ?? { react: locator.value }
+  let locatorString = `_react=${details.react}`
 
-  if (props) {
-    locatorString += propBuilder(props)
+  if (details.props) {
+    locatorString += propBuilder(details.props)
   }
 
   return matcher.locator(locatorString).all()
 }
 
 async function findVue(matcher, locator) {
-  const props = locator.locator?.props
-  let locatorString = `_vue=${locator.value}`
+  const details = locator.locator ?? { vue: locator.value }
+  let locatorString = `_vue=${details.vue}`
 
-  if (props) {
-    locatorString += propBuilder(props)
+  if (details.props) {
+    locatorString += propBuilder(details.props)
   }
 
   return matcher.locator(locatorString).all()
 }
 
+async function findByPlaywrightLocator(matcher, locator, { first = false } = {}) {
+  const details = locator.locator ?? { pw: locator.value }
+  const locatorValue = details.pw
+
+  const handle = matcher.locator(locatorValue)
+  return first ? handle.first() : handle.all()
+}
+
 async function findByRole(matcher, locator, { first = false } = {}) {
-  const roleOptions = locator.getRoleOptions()
-  const roleLocator = matcher.getByRole(roleOptions.role, roleOptions.options)
+  const details = locator.locator ?? { role: locator.value }
+  const { role, text, name, exact, includeHidden, ...rest } = details
+  const options = { ...rest }
+
+  if (includeHidden !== undefined) options.includeHidden = includeHidden
+
+  const accessibleName = name ?? text
+  if (accessibleName !== undefined) {
+    options.name = accessibleName
+    if (exact === true) options.exact = true
+  }
+
+  const roleLocator = matcher.getByRole(role, options)
   return first ? roleLocator.first() : roleLocator.all()
 }
 
@@ -86,4 +107,4 @@ function propBuilder(props) {
   return _props
 }
 
-export { buildLocatorString, findElements, findElement, getVisibleElements, findReact, findVue, findByRole }
+export { buildLocatorString, findElements, findElement, getVisibleElements, findReact, findVue, findByPlaywrightLocator, findByRole }

package/lib/helper/extras/PlaywrightReactVueLocator.js

@@ -0,0 +1,52 @@
+async function findReact(matcher, locator) {
+  // Handle both Locator objects and raw locator objects
+  const reactLocator = locator.locator || locator
+  let _locator = `_react=${reactLocator.react}`;
+  let props = '';
+
+  if (reactLocator.props) {
+    props += propBuilder(reactLocator.props);
+    _locator += props;
+  }
+  return matcher.locator(_locator).all();
+}
+
+async function findVue(matcher, locator) {
+  // Handle both Locator objects and raw locator objects
+  const vueLocator = locator.locator || locator
+  let _locator = `_vue=${vueLocator.vue}`;
+  let props = '';
+
+  if (vueLocator.props) {
+    props += propBuilder(vueLocator.props);
+    _locator += props;
+  }
+  return matcher.locator(_locator).all();
+}
+
+async function findByPlaywrightLocator(matcher, locator) {
+  // Handle both Locator objects and raw locator objects
+  const pwLocator = locator.locator || locator
+  if (pwLocator && pwLocator.toString && pwLocator.toString().includes(process.env.testIdAttribute)) {
+    return matcher.getByTestId(pwLocator.pw.value.split('=')[1]);
+  }
+  const pwValue = typeof pwLocator.pw === 'string' ? pwLocator.pw : pwLocator.pw
+  return matcher.locator(pwValue).all();
+}
+
+function propBuilder(props) {
+  let _props = '';
+
+  for (const [key, value] of Object.entries(props)) {
+    if (typeof value === 'object') {
+      for (const [k, v] of Object.entries(value)) {
+        _props += `[${key}.${k} = "${v}"]`;
+      }
+    } else {
+      _props += `[${key} = "${value}"]`;
+    }
+  }
+  return _props;
+}
+
+export { findReact, findVue, findByPlaywrightLocator };

package/lib/locator.js

@@ -5,10 +5,7 @@ import { createRequire } from 'module'
 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']
+const locatorTypes = ['css', 'by', 'xpath', 'id', 'name', 'fuzzy', 'frame', 'shadow', 'pw', 'role']
 /** @class */
 class Locator {
   /**
@@ -27,16 +24,19 @@ class Locator {
      */
     this.strict = false
 
-    if (typeof locator === 'string' && this.parsedJsonAsString(locator)) {
-      return
-    }
-
     if (typeof locator === 'object') {
       if (locator.constructor.name === 'Locator') {
         Object.assign(this, locator)
         return
       }
-      this._applyObjectLocator(locator)
+
+      this.locator = locator
+      this.type = Object.keys(locator)[0]
+      this.value = locator[this.type]
+      this.strict = true
+
+      Locator.filters.forEach(f => f(locator, this))
+
       return
     }
 
@@ -53,9 +53,8 @@ class Locator {
     if (isShadow(locator)) {
       this.type = 'shadow'
     }
-    if (isReactVueLocator(locator)) {
-      // React/Vue locators - keep as fuzzy type, helpers will handle them specially
-      this.type = 'fuzzy'
+    if (isPlaywrightLocator(locator)) {
+      this.type = 'pw'
     }
 
     Locator.filters.forEach(f => f(locator, this))
@@ -77,6 +76,8 @@ class Locator {
         return this.value
       case 'shadow':
         return { shadow: this.value }
+      case 'pw':
+        return { pw: this.value }
       case 'role':
         return `[role="${this.value}"]`
     }
@@ -85,62 +86,14 @@ class Locator {
 
   toStrict() {
     if (!this.type) return null
-    if (this.type === 'role' && this.locator) {
-      return this.locator
-    }
     return { [this.type]: this.value }
   }
 
-  parsedJsonAsString(locator) {
-    if (typeof locator !== 'string') {
-      return false
-    }
-
-    const trimmed = locator.trim()
-    if (!trimmed.startsWith('{') || !trimmed.endsWith('}')) {
-      return false
-    }
-
-    try {
-      const parsed = JSON.parse(trimmed)
-      if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
-        this._applyObjectLocator(parsed)
-        return true
-      }
-    } catch (e) {
-    }
-    return false
-  }
-
-  _applyObjectLocator(locator) {
-    this.strict = true
-    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))
-  }
-
   /**
    * @returns {string}
    */
   toString() {
-    if (this.output) return this.output
-    if (this.locator && this.value === this.locator) {
-      return JSON.stringify(this.locator)
-    }
-    return `{${this.type}: ${this.value}}`
+    return this.output || `{${this.type}: ${this.value}}`
   }
 
   /**
@@ -174,27 +127,17 @@ class Locator {
   /**
    * @returns {boolean}
    */
-  isRole() {
-    return this.type === 'role'
+  isPlaywrightLocator() {
+    return this.type === 'pw'
   }
 
   /**
-   * @returns {{role: string, options: object}|null}
+   * @returns {boolean}
    */
-  getRoleOptions() {
-    if (!this.isRole()) return null
-    const data = this.locator && typeof this.locator === 'object' ? this.locator : { role: this.value }
-    const { role, text, name, exact, includeHidden, ...rest } = data
-    let options = { ...rest }
-    const accessibleName = name ?? text
-    if (accessibleName !== undefined) options.name = accessibleName
-    if (exact !== undefined) options.exact = exact
-    if (includeHidden !== undefined) options.includeHidden = includeHidden
-    if (Object.keys(options).length === 0) options = undefined
-    return { role, options }
+  isRole() {
+    return this.type === 'role'
   }
 
-
   /**
    * @returns {boolean}
    */
@@ -461,16 +404,6 @@ Locator.build = locator => {
   return new Locator(locator, 'css')
 }
 
-/**
- * @param {CodeceptJS.LocatorOrString|Locator} locator
- * @param {string} [defaultType]
- * @returns {Locator}
- */
-Locator.from = (locator, defaultType = '') => {
-  if (locator instanceof Locator) return locator
-  return new Locator(locator, defaultType)
-}
-
 /**
  * Filters to modify locators
  * @type {Array<function(CodeceptJS.LocatorOrString, Locator): void>}
@@ -513,7 +446,7 @@ Locator.clickable = {
       `.//*[@aria-label = ${literal}]`,
       `.//*[@title = ${literal}]`,
       `.//*[@aria-labelledby = //*[@id][normalize-space(string(.)) = ${literal}]/@id ]`,
-      `.//*[@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}]`,
+      `.//*[@role='button'][normalize-space(.)=${literal}]`,
     ]),
 
   /**
@@ -671,10 +604,20 @@ function removePrefix(xpath) {
  * @param {string} locator
  * @returns {boolean}
  */
-function isReactVueLocator(locator) {
+function isPlaywrightLocator(locator) {
   return locator.includes('_react') || locator.includes('_vue')
 }
 
+/**
+ * @private
+ * check if the locator is a role locator
+ * @param {{role: string}} locator
+ * @returns {boolean}
+ */
+function isRoleLocator(locator) {
+  return locator.role !== undefined && typeof locator.role === 'string' && Object.keys(locator).length >= 1
+}
+
 /**
  * @private
  * @param {CodeceptJS.LocatorOrString} locator

package/lib/mocha/test.js

@@ -154,14 +154,16 @@ function cloneTest(test) {
 function testToFileName(test, { suffix = '', unique = false } = {}) {
   let fileName = test.title
 
-  if (unique) fileName = `${fileName}_${test?.uid || Math.floor(new Date().getTime() / 1000)}`
-  if (suffix) fileName = `${fileName}_${suffix}`
   // remove tags with empty string (disable for now)
   // fileName = fileName.replace(/\@\w+/g, '')
   fileName = fileName.slice(0, 100)
   if (fileName.indexOf('{') !== -1) {
     fileName = fileName.substr(0, fileName.indexOf('{') - 3).trim()
   }
+
+  // Apply unique suffix AFTER removing data part to ensure uniqueness
+  if (unique) fileName = `${fileName}_${test?.uid || Math.floor(new Date().getTime())}`
+  if (suffix) fileName = `${fileName}_${suffix}`
   if (test.ctx && test.ctx.test && test.ctx.test.type === 'hook') fileName = clearString(`${test.title}_${test.ctx.test.title}`)
   // TODO: add suite title to file name
   // if (test.parent && test.parent.title) {