codeceptjs 4.0.0-beta.6.esm-aria → 4.0.0-beta.8.esm-aria

package/lib/container.js

@@ -30,6 +30,7 @@ let container = {
   translation: {},
   /** @type {Result | null} */
   result: null,
+  sharedKeys: new Set() // Track keys shared via share() function
 }
 
 /**
@@ -220,6 +221,7 @@ class Container {
     container.translation = await loadTranslation()
     container.proxySupport = createSupportObjects(newSupport)
     container.plugins = newPlugins
+    container.sharedKeys = new Set() // Clear shared keys
     asyncHelperPromise = Promise.resolve()
     store.actor = null
     debug('container cleared')
@@ -243,7 +245,13 @@ class Container {
    * @param {Object} options - set {local: true} to not share among workers
    */
   static share(data, options = {}) {
-    Container.append({ support: data })
+    // Instead of using append which replaces the entire container,
+    // directly update the support object to maintain proxy references
+    Object.assign(container.support, data)
+    
+    // Track which keys were explicitly shared
+    Object.keys(data).forEach(key => container.sharedKeys.add(key))
+    
     if (!options.local) {
       WorkerStorage.share(data)
     }
@@ -508,10 +516,11 @@ function createSupportObjects(config) {
     {},
     {
       has(target, key) {
-        return keys.includes(key)
+        return keys.includes(key) || container.sharedKeys.has(key)
       },
       ownKeys() {
-        return keys
+        // Return both original config keys and explicitly shared keys
+        return [...new Set([...keys, ...container.sharedKeys])]
       },
       getOwnPropertyDescriptor(target, prop) {
         return {
@@ -521,16 +530,9 @@ function createSupportObjects(config) {
         }
       },
       get(target, key) {
-        if (typeof key === 'symbol') {
-          // safely ignore symbol-based meta properties used by tooling
-          return undefined
-        }
-        // Allow special I even if not declared in includes
-        if (key === 'I') {
-          return lazyLoad('I')
-        }
-        if (!keys.includes(key)) {
-          throw new Error(`Support object "${String(key)}" is not defined`)
+        // First check if this is an explicitly shared property
+        if (container.sharedKeys.has(key) && key in container.support) {
+          return container.support[key]
         }
         return lazyLoad(key)
       },

package/lib/effects.js

@@ -171,7 +171,7 @@ async function hopeThat(callback) {
  * - Restores the session state after each attempt, whether successful or not.
  *
  * @example
- * const { hopeThat } = require('codeceptjs/effects')
+ * const { retryTo } = require('codeceptjs/effects')
  * await retryTo((tries) => {
  *   if (tries < 3) {
  *     I.see('Non-existent element'); // Simulates a failure

package/lib/element/WebElement.js

@@ -0,0 +1,327 @@
+import assert from 'assert'
+
+/**
+ * Unified WebElement class that wraps native element instances from different helpers
+ * and provides a consistent API across all supported helpers (Playwright, WebDriver, Puppeteer).
+ */
+class WebElement {
+  constructor(element, helper) {
+    this.element = element
+    this.helper = helper
+    this.helperType = this._detectHelperType(helper)
+  }
+
+  _detectHelperType(helper) {
+    if (!helper) return 'unknown'
+
+    const className = helper.constructor.name
+    if (className === 'Playwright') return 'playwright'
+    if (className === 'WebDriver') return 'webdriver'
+    if (className === 'Puppeteer') return 'puppeteer'
+
+    return 'unknown'
+  }
+
+  /**
+   * Get the native element instance
+   * @returns {ElementHandle|WebElement|ElementHandle} Native element
+   */
+  getNativeElement() {
+    return this.element
+  }
+
+  /**
+   * Get the helper instance
+   * @returns {Helper} Helper instance
+   */
+  getHelper() {
+    return this.helper
+  }
+
+  /**
+   * Get text content of the element
+   * @returns {Promise<string>} Element text content
+   */
+  async getText() {
+    switch (this.helperType) {
+      case 'playwright':
+        return this.element.textContent()
+      case 'webdriver':
+        return this.element.getText()
+      case 'puppeteer':
+        return this.element.evaluate(el => el.textContent)
+      default:
+        throw new Error(`Unsupported helper type: ${this.helperType}`)
+    }
+  }
+
+  /**
+   * Get attribute value of the element
+   * @param {string} name Attribute name
+   * @returns {Promise<string|null>} Attribute value
+   */
+  async getAttribute(name) {
+    switch (this.helperType) {
+      case 'playwright':
+        return this.element.getAttribute(name)
+      case 'webdriver':
+        return this.element.getAttribute(name)
+      case 'puppeteer':
+        return this.element.evaluate((el, attrName) => el.getAttribute(attrName), name)
+      default:
+        throw new Error(`Unsupported helper type: ${this.helperType}`)
+    }
+  }
+
+  /**
+   * Get property value of the element
+   * @param {string} name Property name
+   * @returns {Promise<any>} Property value
+   */
+  async getProperty(name) {
+    switch (this.helperType) {
+      case 'playwright':
+        return this.element.evaluate((el, propName) => el[propName], name)
+      case 'webdriver':
+        return this.element.getProperty(name)
+      case 'puppeteer':
+        return this.element.evaluate((el, propName) => el[propName], name)
+      default:
+        throw new Error(`Unsupported helper type: ${this.helperType}`)
+    }
+  }
+
+  /**
+   * Get innerHTML of the element
+   * @returns {Promise<string>} Element innerHTML
+   */
+  async getInnerHTML() {
+    switch (this.helperType) {
+      case 'playwright':
+        return this.element.innerHTML()
+      case 'webdriver':
+        return this.element.getProperty('innerHTML')
+      case 'puppeteer':
+        return this.element.evaluate(el => el.innerHTML)
+      default:
+        throw new Error(`Unsupported helper type: ${this.helperType}`)
+    }
+  }
+
+  /**
+   * Get value of the element (for input elements)
+   * @returns {Promise<string>} Element value
+   */
+  async getValue() {
+    switch (this.helperType) {
+      case 'playwright':
+        return this.element.inputValue()
+      case 'webdriver':
+        return this.element.getValue()
+      case 'puppeteer':
+        return this.element.evaluate(el => el.value)
+      default:
+        throw new Error(`Unsupported helper type: ${this.helperType}`)
+    }
+  }
+
+  /**
+   * Check if element is visible
+   * @returns {Promise<boolean>} True if element is visible
+   */
+  async isVisible() {
+    switch (this.helperType) {
+      case 'playwright':
+        return this.element.isVisible()
+      case 'webdriver':
+        return this.element.isDisplayed()
+      case 'puppeteer':
+        return this.element.evaluate(el => {
+          const style = window.getComputedStyle(el)
+          return style.display !== 'none' && style.visibility !== 'hidden' && style.opacity !== '0'
+        })
+      default:
+        throw new Error(`Unsupported helper type: ${this.helperType}`)
+    }
+  }
+
+  /**
+   * Check if element is enabled
+   * @returns {Promise<boolean>} True if element is enabled
+   */
+  async isEnabled() {
+    switch (this.helperType) {
+      case 'playwright':
+        return this.element.isEnabled()
+      case 'webdriver':
+        return this.element.isEnabled()
+      case 'puppeteer':
+        return this.element.evaluate(el => !el.disabled)
+      default:
+        throw new Error(`Unsupported helper type: ${this.helperType}`)
+    }
+  }
+
+  /**
+   * Check if element exists in DOM
+   * @returns {Promise<boolean>} True if element exists
+   */
+  async exists() {
+    try {
+      switch (this.helperType) {
+        case 'playwright':
+          // For Playwright, if we have the element, it exists
+          return await this.element.evaluate(el => !!el)
+        case 'webdriver':
+          // For WebDriver, if we have the element, it exists
+          return true
+        case 'puppeteer':
+          // For Puppeteer, if we have the element, it exists
+          return await this.element.evaluate(el => !!el)
+        default:
+          throw new Error(`Unsupported helper type: ${this.helperType}`)
+      }
+    } catch (e) {
+      return false
+    }
+  }
+
+  /**
+   * Get bounding box of the element
+   * @returns {Promise<Object>} Bounding box with x, y, width, height properties
+   */
+  async getBoundingBox() {
+    switch (this.helperType) {
+      case 'playwright':
+        return this.element.boundingBox()
+      case 'webdriver':
+        const rect = await this.element.getRect()
+        return {
+          x: rect.x,
+          y: rect.y,
+          width: rect.width,
+          height: rect.height,
+        }
+      case 'puppeteer':
+        return this.element.boundingBox()
+      default:
+        throw new Error(`Unsupported helper type: ${this.helperType}`)
+    }
+  }
+
+  /**
+   * Click the element
+   * @param {Object} options Click options
+   * @returns {Promise<void>}
+   */
+  async click(options = {}) {
+    switch (this.helperType) {
+      case 'playwright':
+        return this.element.click(options)
+      case 'webdriver':
+        return this.element.click()
+      case 'puppeteer':
+        return this.element.click(options)
+      default:
+        throw new Error(`Unsupported helper type: ${this.helperType}`)
+    }
+  }
+
+  /**
+   * Type text into the element
+   * @param {string} text Text to type
+   * @param {Object} options Type options
+   * @returns {Promise<void>}
+   */
+  async type(text, options = {}) {
+    switch (this.helperType) {
+      case 'playwright':
+        return this.element.type(text, options)
+      case 'webdriver':
+        return this.element.setValue(text)
+      case 'puppeteer':
+        return this.element.type(text, options)
+      default:
+        throw new Error(`Unsupported helper type: ${this.helperType}`)
+    }
+  }
+
+  /**
+   * Find first child element matching the locator
+   * @param {string|Object} locator Element locator
+   * @returns {Promise<WebElement|null>} WebElement instance or null if not found
+   */
+  async $(locator) {
+    let childElement
+
+    switch (this.helperType) {
+      case 'playwright':
+        childElement = await this.element.$(this._normalizeLocator(locator))
+        break
+      case 'webdriver':
+        try {
+          childElement = await this.element.$(this._normalizeLocator(locator))
+        } catch (e) {
+          return null
+        }
+        break
+      case 'puppeteer':
+        childElement = await this.element.$(this._normalizeLocator(locator))
+        break
+      default:
+        throw new Error(`Unsupported helper type: ${this.helperType}`)
+    }
+
+    return childElement ? new WebElement(childElement, this.helper) : null
+  }
+
+  /**
+   * Find all child elements matching the locator
+   * @param {string|Object} locator Element locator
+   * @returns {Promise<WebElement[]>} Array of WebElement instances
+   */
+  async $$(locator) {
+    let childElements
+
+    switch (this.helperType) {
+      case 'playwright':
+        childElements = await this.element.$$(this._normalizeLocator(locator))
+        break
+      case 'webdriver':
+        childElements = await this.element.$$(this._normalizeLocator(locator))
+        break
+      case 'puppeteer':
+        childElements = await this.element.$$(this._normalizeLocator(locator))
+        break
+      default:
+        throw new Error(`Unsupported helper type: ${this.helperType}`)
+    }
+
+    return childElements.map(el => new WebElement(el, this.helper))
+  }
+
+  /**
+   * Normalize locator for element search
+   * @param {string|Object} locator Locator to normalize
+   * @returns {string} Normalized CSS selector
+   * @private
+   */
+  _normalizeLocator(locator) {
+    if (typeof locator === 'string') {
+      return locator
+    }
+
+    if (typeof locator === 'object') {
+      // Handle CodeceptJS locator objects
+      if (locator.css) return locator.css
+      if (locator.xpath) return locator.xpath
+      if (locator.id) return `#${locator.id}`
+      if (locator.name) return `[name="${locator.name}"]`
+      if (locator.className) return `.${locator.className}`
+    }
+
+    return locator.toString()
+  }
+}
+
+export default WebElement

package/lib/event.js

@@ -3,13 +3,22 @@ const debug = debugModule('codeceptjs:event')
 import events from 'events'
 import output from './output.js'
 
+const MAX_LISTENERS = 200
+
 const dispatcher = new events.EventEmitter()
 
-dispatcher.setMaxListeners(50)
+dispatcher.setMaxListeners(MAX_LISTENERS)
+
+// Increase process max listeners to prevent warnings for beforeExit and other events
+if (typeof process.setMaxListeners === 'function') {
+  process.setMaxListeners(MAX_LISTENERS)
+}
+
 /**
  * @namespace
  * @alias event
  */
+
 export default {
   /**
    * @type {NodeJS.EventEmitter}

package/lib/helper/AI.js

@@ -1,13 +1,13 @@
-const HelperModule = require('@codeceptjs/helper')
-const ora = require('ora-classic')
-const fs = require('fs')
-const path = require('path')
-const ai = require('../ai')
-const Container = require('../container')
-const { splitByChunks, minifyHtml } = require('../html')
-const { beautify } = require('../utils')
-const output = require('../output')
-const { registerVariable } = require('../pause')
+import HelperModule from '@codeceptjs/helper'
+import ora from 'ora-classic'
+import fs from 'fs'
+import path from 'path'
+import ai from '../ai.js'
+import Container from '../container.js'
+import { splitByChunks, minifyHtml } from '../html.js'
+import { beautify } from '../utils.js'
+import output from '../output.js'
+import { registerVariable } from '../pause.js'
 
 const standardActingHelpers = Container.STANDARD_ACTING_HELPERS
 
@@ -211,4 +211,4 @@ class AI extends Helper {
   }
 }
 
-module.exports = AI
+export default AI

package/lib/helper/ApiDataFactory.js

@@ -241,10 +241,25 @@ class ApiDataFactory extends Helper {
       if (!createdItems.length) continue
       this.debug(`Deleting ${createdItems.length} ${factoryName}(s)`)
       for (const id in createdItems) {
-        promises.push(this._requestDelete(factoryName, createdItems[id]))
+        const deletePromise = this._requestDelete(factoryName, createdItems[id])
+        if (deletePromise) {
+          promises.push(deletePromise.catch(err => {
+            this.debugSection('Delete Error', `Failed to delete ${factoryName} with id ${createdItems[id]}: ${err.message}`)
+            // Don't reject Promise.all, just log the error
+            return Promise.resolve()
+          }))
+        }
       }
     }
-    return Promise.all(promises)
+    return Promise.all(promises).then(() => {
+      // Clear the created items after successful cleanup
+      for (const factoryName in this.created) {
+        this.created[factoryName] = []
+      }
+      // Add a small delay to ensure file system changes propagate in Docker environments
+      // This helps avoid race conditions where GET requests after DELETE don't see the changes yet
+      return new Promise(resolve => setTimeout(resolve, 100))
+    })
   }
 
   /**
@@ -386,21 +401,34 @@ Current file error: ${err.message}`)
       const url = this.factories[factory].delete[method].replace('{id}', id)
 
       request = {
-        method,
+        method: method.toUpperCase(), // Ensure HTTP method is uppercase
         url,
       }
     }
 
+    // Ensure method is uppercase (some servers require uppercase HTTP methods)
+    if (request.method) {
+      request.method = request.method.toUpperCase()
+    }
+
     request.baseURL = this.config.endpoint
 
     if (request.url.match(/^undefined/)) {
       return this.debugSection('Please configure the delete request in your ApiDataFactory helper', "delete: () => ({ method: 'DELETE',  url: '/api/users' })")
     }
 
-    return this.restHelper._executeRequest(request).then(() => {
+    this.debugSection('Deleting', `${request.method} ${request.baseURL}${request.url} (ID: ${id})`)
+
+    return this.restHelper._executeRequest(request).then((resp) => {
       const idx = this.created[factory].indexOf(id)
-      this.debugSection('Deleted Id', `Id: ${id}`)
-      this.created[factory].splice(idx, 1)
+      this.debugSection('Deleted Successfully', `${factory} ID: ${id}, Status: ${resp.status || 'OK'}`)
+      if (idx !== -1) {
+        this.created[factory].splice(idx, 1)
+      }
+      return resp
+    }).catch(err => {
+      this.debugSection('Delete Failed', `${factory} ID: ${id}, Error: ${err.message}`)
+      throw err
     })
   }
 }