codeceptjs 3.7.4 → 3.7.5-beta.1

package/lib/element/WebElement.js

@@ -0,0 +1,327 @@
+const assert = require('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()
+  }
+}
+
+module.exports = WebElement

package/lib/helper/JSONResponse.js

@@ -72,10 +72,11 @@ class JSONResponse extends Helper {
     if (!this.helpers[this.options.requestHelper]) {
       throw new Error(`Error setting JSONResponse, helper ${this.options.requestHelper} is not enabled in config, helpers: ${Object.keys(this.helpers)}`)
     }
-    // connect to REST helper
+    const origOnResponse = this.helpers[this.options.requestHelper].config.onResponse;
     this.helpers[this.options.requestHelper].config.onResponse = response => {
-      this.response = response
-    }
+      this.response = response;
+      if (typeof origOnResponse === 'function') origOnResponse(response);
+    };
   }
 
   _before() {
@@ -349,7 +350,25 @@ class JSONResponse extends Helper {
     for (const key in expected) {
       assert(key in actual, `Key "${key}" not found in ${JSON.stringify(actual)}`)
       if (typeof expected[key] === 'object' && expected[key] !== null) {
-        this._assertContains(actual[key], expected[key])
+        if (Array.isArray(expected[key])) {
+          // Handle array comparison: each expected element should have a match in actual array
+          assert(Array.isArray(actual[key]), `Expected array for key "${key}", but got ${typeof actual[key]}`)
+          for (const expectedItem of expected[key]) {
+            let found = false
+            for (const actualItem of actual[key]) {
+              try {
+                this._assertContains(actualItem, expectedItem)
+                found = true
+                break
+              } catch (err) {
+                continue
+              }
+            }
+            assert(found, `No matching element found in array for ${JSON.stringify(expectedItem)}`)
+          }
+        } else {
+          this._assertContains(actual[key], expected[key])
+        }
       } else {
         assert.deepStrictEqual(actual[key], expected[key], `Values for key "${key}" don't match`)
       }

package/lib/helper/Mochawesome.js

@@ -37,7 +37,20 @@ class Mochawesome extends Helper {
   }
 
   _test(test) {
-    currentTest = { test }
+    // If this is a retried test, we want to add context to the retried test
+    // but also potentially preserve context from the original test
+    const originalTest = test.retriedTest && test.retriedTest()
+    if (originalTest) {
+      // This is a retried test - use the retried test for context
+      currentTest = { test }
+
+      // Optionally copy context from original test if it exists
+      // Note: mochawesome context is stored in test.ctx, but we need to be careful
+      // not to break the mocha context structure
+    } else {
+      // Normal test (not a retry)
+      currentTest = { test }
+    }
   }
 
   _failed(test) {
@@ -64,7 +77,16 @@ class Mochawesome extends Helper {
 
   addMochawesomeContext(context) {
     if (currentTest === '') currentTest = { test: currentSuite.ctx.test }
-    return this._addContext(currentTest, context)
+
+    // For retried tests, make sure we're adding context to the current (retried) test
+    // not the original test
+    let targetTest = currentTest
+    if (currentTest.test && currentTest.test.retriedTest && currentTest.test.retriedTest()) {
+      // This test has been retried, make sure we're using the current test for context
+      targetTest = { test: currentTest.test }
+    }
+
+    return this._addContext(targetTest, context)
   }
 }
 

package/lib/helper/Playwright.js

@@ -33,6 +33,7 @@ const RemoteBrowserConnectionRefused = require('./errors/RemoteBrowserConnection
 const Popup = require('./extras/Popup')
 const Console = require('./extras/Console')
 const { findReact, findVue, findByPlaywrightLocator } = require('./extras/PlaywrightReactVueLocator')
+const WebElement = require('../element/WebElement')
 
 let playwright
 let perfTiming
@@ -1341,7 +1342,8 @@ class Playwright extends Helper {
    *
    */
   async grabWebElements(locator) {
-    return this._locate(locator)
+    const elements = await this._locate(locator)
+    return elements.map(element => new WebElement(element, this))
   }
 
   /**
@@ -1349,7 +1351,8 @@ class Playwright extends Helper {
    *
    */
   async grabWebElement(locator) {
-    return this._locateElement(locator)
+    const element = await this._locateElement(locator)
+    return new WebElement(element, this)
   }
 
   /**
@@ -2776,47 +2779,63 @@ class Playwright extends Helper {
             .locator(`${locator.isCustom() ? `${locator.type}=${locator.value}` : locator.simplify()} >> text=${text}`)
             .first()
             .waitFor({ timeout: waitTimeout, state: 'visible' })
+            .catch(e => {
+              throw new Error(errorMessage)
+            })
         }
 
         if (locator.isXPath()) {
-          return contextObject.waitForFunction(
-            ([locator, text, $XPath]) => {
-              eval($XPath)
-              const el = $XPath(null, locator)
-              if (!el.length) return false
-              return el[0].innerText.indexOf(text) > -1
-            },
-            [locator.value, text, $XPath.toString()],
-            { timeout: waitTimeout },
-          )
+          return contextObject
+            .waitForFunction(
+              ([locator, text, $XPath]) => {
+                eval($XPath)
+                const el = $XPath(null, locator)
+                if (!el.length) return false
+                return el[0].innerText.indexOf(text) > -1
+              },
+              [locator.value, text, $XPath.toString()],
+              { timeout: waitTimeout },
+            )
+            .catch(e => {
+              throw new Error(errorMessage)
+            })
         }
       } catch (e) {
         throw new Error(`${errorMessage}\n${e.message}`)
       }
     }
 
+    // Based on original implementation but fixed to check title text and remove problematic promiseRetry
+    // Original used timeoutGap for waitForFunction to give it slightly more time than the locator
     const timeoutGap = waitTimeout + 1000
 
-    // We add basic timeout to make sure we don't wait forever
-    // We apply 2 strategies here: wait for text as innert text on page (wide strategy) - older
-    // or we use native Playwright matcher to wait for text in element (narrow strategy) - newer
-    // If a user waits for text on a page they are mostly expect it to be there, so wide strategy can be helpful even PW strategy is available
     return Promise.race([
-      new Promise((_, reject) => {
-        setTimeout(() => reject(errorMessage), waitTimeout)
-      }),
-      this.page.waitForFunction(text => document.body && document.body.innerText.indexOf(text) > -1, text, { timeout: timeoutGap }),
-      promiseRetry(
-        async retry => {
-          const textPresent = await contextObject
-            .locator(`:has-text(${JSON.stringify(text)})`)
-            .first()
-            .isVisible()
-          if (!textPresent) retry(errorMessage)
+      // Strategy 1: waitForFunction that checks both body AND title text
+      // Use this.page instead of contextObject because FrameLocator doesn't have waitForFunction
+      // Original only checked document.body.innerText, missing title text like "TestEd"
+      this.page.waitForFunction(
+        function (text) {
+          // Check body text (original behavior)
+          if (document.body && document.body.innerText && document.body.innerText.indexOf(text) > -1) {
+            return true
+          }
+          // Check document title (fixes the TestEd in title issue)
+          if (document.title && document.title.indexOf(text) > -1) {
+            return true
+          }
+          return false
         },
-        { retries: 1000, minTimeout: 500, maxTimeout: 500, factor: 1 },
+        text,
+        { timeout: timeoutGap },
       ),
-    ])
+      // Strategy 2: Native Playwright text locator (replaces problematic promiseRetry)
+      contextObject
+        .locator(`:has-text(${JSON.stringify(text)})`)
+        .first()
+        .waitFor({ timeout: waitTimeout }),
+    ]).catch(err => {
+      throw new Error(errorMessage)
+    })
   }
 
   /**