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

package/lib/helper/errors/MultipleElementsFound.js

@@ -0,0 +1,52 @@
+import Locator from '../../locator.js'
+
+class MultipleElementsFound extends Error {
+  constructor(locator, webElements) {
+    const locatorStr = (typeof locator === 'object' && !(locator instanceof Locator))
+      ? new Locator(locator).toString()
+      : String(locator)
+    super(`Multiple elements (${webElements.length}) found for "${locatorStr}" in strict mode. Call fetchDetails() for full information.`)
+    this.name = 'MultipleElementsFound'
+    this.locator = locator
+    this.webElements = webElements
+    this.count = webElements.length
+    this._detailsFetched = false
+  }
+
+  async fetchDetails() {
+    if (this._detailsFetched) return
+
+    try {
+      const items = []
+      const maxToShow = Math.min(this.count, 10)
+
+      for (let i = 0; i < maxToShow; i++) {
+        const webEl = this.webElements[i]
+        try {
+          const xpath = await webEl.toAbsoluteXPath()
+          const html = await webEl.toSimplifiedHTML()
+          items.push(`  ${i + 1}. > ${xpath}\n     ${html}`)
+        } catch (err) {
+          items.push(`  ${i + 1}. [Unable to get element info: ${err.message}]`)
+        }
+      }
+
+      if (this.count > 10) {
+        items.push(`  ... and ${this.count - 10} more`)
+      }
+
+      const locatorStr = (typeof this.locator === 'object' && !(this.locator instanceof Locator))
+        ? new Locator(this.locator).toString()
+        : String(this.locator)
+      this.message = `Multiple elements (${this.count}) found for "${locatorStr}" in strict mode.\n` +
+        items.join('\n') +
+        `\nUse a more specific locator or use grabWebElements() to handle multiple elements.`
+    } catch (err) {
+      this.message = `Multiple elements (${this.count}) found. Failed to fetch details: ${err.message}`
+    }
+
+    this._detailsFetched = true
+  }
+}
+
+export default MultipleElementsFound

package/lib/helper/extras/elementSelection.js

@@ -0,0 +1,58 @@
+import store from '../../store.js'
+import output from '../../output.js'
+import WebElement from '../../element/WebElement.js'
+import MultipleElementsFound from '../errors/MultipleElementsFound.js'
+
+function resolveElementIndex(value) {
+  if (value === 'first') return 1
+  if (value === 'last') return -1
+  return value
+}
+
+function isStrictStep(opts, helper) {
+  if (opts?.exact === true || opts?.strictMode === true) return true
+  if (opts?.exact === false || opts?.strictMode === false) return false
+  return helper.options.strict
+}
+
+function selectElement(els, locator, helper) {
+  const opts = store.currentStep?.opts
+  const rawIndex = opts?.elementIndex
+  const elementIndex = resolveElementIndex(rawIndex)
+
+  if (elementIndex != null) {
+    if (els.length === 1) return els[0]
+
+    if (!Number.isInteger(elementIndex) || elementIndex === 0) {
+      throw new Error(`elementIndex must be a non-zero integer or 'first'/'last', got: ${rawIndex}`)
+    }
+
+    let idx
+    if (elementIndex > 0) {
+      idx = elementIndex - 1
+      if (idx >= els.length) {
+        throw new Error(`elementIndex ${elementIndex} exceeds the number of elements found (${els.length}) for "${locator}"`)
+      }
+    } else {
+      idx = els.length + elementIndex
+      if (idx < 0) {
+        throw new Error(`elementIndex ${elementIndex} exceeds the number of elements found (${els.length}) for "${locator}"`)
+      }
+    }
+
+    output.debug(`[Elements] Using element #${elementIndex} out of ${els.length}`)
+    return els[idx]
+  }
+
+  if (isStrictStep(opts, helper)) {
+    if (els.length > 1) {
+      const webElements = Array.from(els).map(el => new WebElement(el, helper))
+      throw new MultipleElementsFound(locator, webElements)
+    }
+  }
+
+  if (els.length > 1) output.debug(`[Elements] Using first element out of ${els.length}`)
+  return els[0]
+}
+
+export { selectElement }

package/lib/helper/scripts/dropFile.js

@@ -0,0 +1,11 @@
+export const dropFile = (el, { base64Content, fileName, mimeType }) => {
+  const binaryStr = atob(base64Content)
+  const bytes = new Uint8Array(binaryStr.length)
+  for (let i = 0; i < binaryStr.length; i++) bytes[i] = binaryStr.charCodeAt(i)
+  const fileObj = new File([bytes], fileName, { type: mimeType })
+  const dataTransfer = new DataTransfer()
+  dataTransfer.items.add(fileObj)
+  el.dispatchEvent(new DragEvent('dragenter', { dataTransfer, bubbles: true }))
+  el.dispatchEvent(new DragEvent('dragover', { dataTransfer, bubbles: true }))
+  el.dispatchEvent(new DragEvent('drop', { dataTransfer, bubbles: true }))
+}

package/lib/html.js

@@ -245,4 +245,17 @@ function splitByChunks(text, chunkSize) {
   return chunks.map(chunk => chunk.trim())
 }
 
-export { scanForErrorMessages, removeNonInteractiveElements, splitByChunks, minifyHtml }
+function simplifyHtmlElement(html, maxLength = 300) {
+  try {
+    html = removeNonInteractiveElements(html)
+    html = html.replace(/<html>(?:<head>.*?<\/head>)?<body>(.*)<\/body><\/html>/s, '$1').trim()
+  } catch (e) {
+    // keep raw html if minification fails
+  }
+  if (html.length > maxLength) {
+    html = html.slice(0, maxLength) + '...'
+  }
+  return html
+}
+
+export { scanForErrorMessages, removeNonInteractiveElements, splitByChunks, minifyHtml, simplifyHtmlElement }

package/lib/listener/config.js

@@ -12,15 +12,23 @@ export default function () {
     return
   }
   global.__codeceptConfigListenerInitialized = true
-  
-  const helpers = global.container.helpers()
 
   enableDynamicConfigFor('suite')
   enableDynamicConfigFor('test')
 
   function enableDynamicConfigFor(type) {
     event.dispatcher.on(event[type].before, (context = {}) => {
+      // Get helpers dynamically at runtime, not at initialization time
+      // This ensures we get the actual helper instances, not placeholders
+      const helpers = global.container.helpers()
+
       function updateHelperConfig(helper, config) {
+        // Guard against undefined or invalid helpers
+        if (!helper || !helper.constructor) {
+          output.debug(`[${ucfirst(type)} Config] Helper not found or not properly initialized`)
+          return
+        }
+
         const oldConfig = deepClone(helper.options)
         try {
           helper._setConfig(deepMerge(deepClone(oldConfig), config))
@@ -41,7 +49,7 @@ export default function () {
         for (let name in context.config) {
           const config = context.config[name]
           if (name === '0') {
-            // first helper
+            // first helper - get dynamically
             name = Object.keys(helpers)[0]
           }
           const helper = helpers[name]

package/lib/listener/globalRetry.js

@@ -5,16 +5,27 @@ import { isNotSet } from '../utils.js'
 
 const hooks = ['Before', 'After', 'BeforeSuite', 'AfterSuite']
 
+const RETRY_PRIORITIES = {
+  MANUAL_STEP: 100,
+  STEP_PLUGIN: 50,
+  SCENARIO_CONFIG: 30,
+  FEATURE_CONFIG: 20,
+  HOOK_CONFIG: 10,
+}
+
 export default function () {
   event.dispatcher.on(event.suite.before, suite => {
     let retryConfig = Config.get('retry')
     if (!retryConfig) return
 
     if (Number.isInteger(+retryConfig)) {
-      // is number
       const retryNum = +retryConfig
       output.log(`Retries: ${retryNum}`)
-      suite.retries(retryNum)
+
+      if (suite.retries() === -1 || (suite.opts.retryPriority || 0) <= RETRY_PRIORITIES.FEATURE_CONFIG) {
+        suite.retries(retryNum)
+        suite.opts.retryPriority = RETRY_PRIORITIES.FEATURE_CONFIG
+      }
       return
     }
 
@@ -30,11 +41,18 @@ export default function () {
       hooks
         .filter(hook => !!config[hook])
         .forEach(hook => {
-          if (isNotSet(suite.opts[`retry${hook}`])) suite.opts[`retry${hook}`] = config[hook]
+          const retryKey = `retry${hook}`
+          if (isNotSet(suite.opts[retryKey])) {
+            suite.opts[retryKey] = config[hook]
+            suite.opts[`${retryKey}Priority`] = RETRY_PRIORITIES.HOOK_CONFIG
+          }
         })
 
       if (config.Feature) {
-        if (isNotSet(suite.retries())) suite.retries(config.Feature)
+        if (suite.retries() === -1 || (suite.opts.retryPriority || 0) <= RETRY_PRIORITIES.FEATURE_CONFIG) {
+          suite.retries(config.Feature)
+          suite.opts.retryPriority = RETRY_PRIORITIES.FEATURE_CONFIG
+        }
       }
 
       output.log(`Retries: ${JSON.stringify(config)}`)
@@ -46,7 +64,10 @@ export default function () {
     if (!retryConfig) return
 
     if (Number.isInteger(+retryConfig)) {
-      if (test.retries() === -1) test.retries(retryConfig)
+      if (test.retries() === -1) {
+        test.retries(retryConfig)
+        test.opts.retryPriority = RETRY_PRIORITIES.SCENARIO_CONFIG
+      }
       return
     }
 
@@ -62,9 +83,14 @@ export default function () {
       }
 
       if (config.Scenario) {
-        if (test.retries() === -1) test.retries(config.Scenario)
+        if (test.retries() === -1 || (test.opts.retryPriority || 0) <= RETRY_PRIORITIES.SCENARIO_CONFIG) {
+          test.retries(config.Scenario)
+          test.opts.retryPriority = RETRY_PRIORITIES.SCENARIO_CONFIG
+        }
         output.log(`Retries: ${config.Scenario}`)
       }
     }
   })
 }
+
+export { RETRY_PRIORITIES }

package/lib/listener/helpers.js

@@ -73,30 +73,18 @@ export default function () {
   })
 
   event.dispatcher.on(event.all.result, () => {
-    // Skip _finishTest for all helpers if any browser helper restarts to avoid double cleanup
-    const hasBrowserRestart = Object.values(helpers).some(helper => 
-      (helper.config && (helper.config.restart === 'browser' || helper.config.restart === 'context' || helper.config.restart === true)) || 
-      (helper.options && (helper.options.restart === 'browser' || helper.options.restart === 'context' || helper.options.restart === true))
-    )
-
     Object.keys(helpers).forEach(key => {
       const helper = helpers[key]
-      if (helper._finishTest && !hasBrowserRestart) {
+      if (helper._finishTest) {
         recorder.add(`hook ${key}._finishTest()`, () => helper._finishTest(), true, false)
       }
     })
   })
 
   event.dispatcher.on(event.all.after, () => {
-    // Skip _cleanup for all helpers if any browser helper restarts to avoid double cleanup
-    const hasBrowserRestart = Object.values(helpers).some(helper => 
-      (helper.config && (helper.config.restart === 'browser' || helper.config.restart === 'context' || helper.config.restart === true)) || 
-      (helper.options && (helper.options.restart === 'browser' || helper.options.restart === 'context' || helper.options.restart === true))
-    )
-
     Object.keys(helpers).forEach(key => {
       const helper = helpers[key]
-      if (helper._cleanup && !hasBrowserRestart) {
+      if (helper._cleanup) {
         recorder.add(`hook ${key}._cleanup()`, () => helper._cleanup(), true, false)
       }
     })

package/lib/locator.js

@@ -40,6 +40,11 @@ class Locator {
       return
     }
 
+    // Try to parse JSON strings that look like objects
+    if (this.parsedJsonAsString(locator)) {
+      return
+    }
+
     this.type = defaultType || 'fuzzy'
     this.output = locator
     this.value = locator
@@ -89,6 +94,33 @@ class 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.locator = parsed
+        this.type = Object.keys(parsed)[0]
+        this.value = parsed[this.type]
+        this.strict = true
+
+        Locator.filters.forEach(f => f(parsed, this))
+        return true
+      }
+    } catch (e) {
+      // continue with normal string processing
+    }
+    return false
+  }
+
   /**
    * @returns {string}
    */

package/lib/mocha/cli.js

@@ -9,6 +9,7 @@ import event from '../event.js'
 import AssertionFailedError from '../assert/error.js'
 import output from '../output.js'
 import test, { cloneTest } from './test.js'
+import { fixErrorStack } from '../utils/typescript.js'
 
 // Get version from package.json to avoid circular dependency
 const __filename = fileURLToPath(import.meta.url)
@@ -201,6 +202,16 @@ class Cli extends Base {
 
     // failures
     if (stats.failures) {
+      for (const test of this.failures) {
+        if (test.err && typeof test.err.fetchDetails === 'function') {
+          try {
+            await test.err.fetchDetails()
+          } catch (e) {
+            // ignore fetch errors
+          }
+        }
+      }
+
       // append step traces
       this.failures = this.failures.map(test => {
         // we will change the stack trace, so we need to clone the test
@@ -264,6 +275,11 @@ class Cli extends Base {
         }
 
         try {
+          const fileMapping = global.container?.tsFileMapping?.()
+          if (fileMapping) {
+            fixErrorStack(err, fileMapping)
+          }
+
           let stack = err.stack
           stack = (stack || '').replace(originalMessage, '')
           stack = stack ? stack.split('\n') : []

package/lib/mocha/factory.js

@@ -7,6 +7,7 @@ import gherkinParser, { loadTranslations } from './gherkin.js'
 import output from '../output.js'
 import scenarioUiFunction from './ui.js'
 import { initMochaGlobals } from '../globals.js'
+import { fixErrorStack } from '../utils/typescript.js'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = fsPath.dirname(__filename)
@@ -34,6 +35,10 @@ class MochaFactory {
           // Handle ECONNREFUSED without dynamic import for now
           err = new Error('Connection refused: ' + err.toString())
         }
+        const fileMapping = global.container?.tsFileMapping?.()
+        if (fileMapping) {
+          fixErrorStack(err, fileMapping)
+        }
         output.error(err)
         output.print(err.stack)
         process.exit(1)
@@ -62,34 +67,9 @@ class MochaFactory {
         const jsFiles = this.files.filter(file => !file.match(/\.feature$/))
         this.files = this.files.filter(file => !file.match(/\.feature$/))
 
-        // Load JavaScript test files using ESM imports
+        // Load JavaScript test files using original loadFiles
         if (jsFiles.length > 0) {
-          try {
-            // Try original loadFiles first for compatibility
-            originalLoadFiles.call(this, fn)
-          } catch (e) {
-            // If original loadFiles fails, load ESM files manually
-            if (e.message.includes('not in cache') || e.message.includes('ESM') || e.message.includes('getStatus')) {
-              // Load ESM files by importing them synchronously using top-level await workaround
-              for (const file of jsFiles) {
-                try {
-                  // Convert file path to file:// URL for dynamic import
-                  const fileUrl = `file://${file}`
-                  // Use import() but don't await it - let it load in the background
-                  import(fileUrl).catch(importErr => {
-                    // If dynamic import fails, the file may have syntax errors or other issues
-                    console.error(`Failed to load test file ${file}:`, importErr.message)
-                  })
-                  if (fn) fn()
-                } catch (fileErr) {
-                  console.error(`Error processing test file ${file}:`, fileErr.message)
-                  if (fn) fn(fileErr)
-                }
-              }
-            } else {
-              throw e
-            }
-          }
+          originalLoadFiles.call(this, fn)
         }
 
         // add ids for each test and check uniqueness

package/lib/mocha/gherkin.js

@@ -1,4 +1,4 @@
-import Gherkin from '@cucumber/gherkin'
+import { AstBuilder, GherkinClassicTokenMatcher, Parser } from '@cucumber/gherkin'
 import { IdGenerator } from '@cucumber/messages'
 import { Context, Suite } from 'mocha'
 import debug from 'debug'
@@ -15,9 +15,9 @@ import { createTest } from './test.js'
 import { matchStep } from './bdd.js'
 
 const uuidFn = IdGenerator.uuid()
-const builder = new Gherkin.AstBuilder(uuidFn)
-const matcher = new Gherkin.GherkinClassicTokenMatcher()
-const parser = new Gherkin.Parser(builder, matcher)
+const builder = new AstBuilder(uuidFn)
+const matcher = new GherkinClassicTokenMatcher()
+const parser = new Parser(builder, matcher)
 parser.stopAtFirstError = false
 
 const gherkinParser = (text, file) => {

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) {

package/lib/output.js

@@ -222,12 +222,10 @@ const output = {
     /**
      * @param {Mocha.Test} test
      */
-
     started(test) {
       if (outputLevel < 1) return
       print(`  ${colors.dim.bold('Scenario()')}`)
     },
-
     /**
      * @param {Mocha.Test} test
      */
@@ -273,10 +271,12 @@ const output = {
   },
 
   /**
+   * Prints the stats of a test run to the console.
    * @param {number} passed
    * @param {number} failed
    * @param {number} skipped
    * @param {number|string} duration
+   * @param {number} [failedHooks]
    */
   result(passed, failed, skipped, duration, failedHooks = 0) {
     let style = colors.bgGreen