codeceptjs 3.7.4 → 3.7.5-beta.2

package/lib/command/workers/runTests.js

@@ -20,7 +20,7 @@ const stderr = ''
 // Requiring of Codecept need to be after tty.getWindowSize is available.
 const Codecept = require(process.env.CODECEPT_CLASS_PATH || '../../codecept')
 
-const { options, tests, testRoot, workerIndex } = workerData
+const { options, tests, testRoot, workerIndex, poolMode } = workerData
 
 // hide worker output
 if (!options.debug && !options.verbose)
@@ -39,15 +39,26 @@ const codecept = new Codecept(config, options)
 codecept.init(testRoot)
 codecept.loadTests()
 const mocha = container.mocha()
-filterTests()
+
+if (poolMode) {
+  // In pool mode, don't filter tests upfront - wait for assignments
+  // We'll reload test files fresh for each test request
+} else {
+  // Legacy mode - filter tests upfront
+  filterTests()
+}
 
 // run tests
 ;(async function () {
-  if (mocha.suite.total()) {
+  if (poolMode) {
+    await runPoolTests()
+  } else if (mocha.suite.total()) {
     await runTests()
   }
 })()
 
+let globalStats = { passes: 0, failures: 0, tests: 0, pending: 0, failedHooks: 0 }
+
 async function runTests() {
   try {
     await codecept.bootstrap()
@@ -64,6 +75,192 @@ async function runTests() {
   }
 }
 
+async function runPoolTests() {
+  try {
+    await codecept.bootstrap()
+  } catch (err) {
+    throw new Error(`Error while running bootstrap file :${err}`)
+  }
+
+  initializeListeners()
+  disablePause()
+
+  // Accumulate results across all tests in pool mode
+  let consolidatedStats = { passes: 0, failures: 0, tests: 0, pending: 0, failedHooks: 0 }
+  let allTests = []
+  let allFailures = []
+  let previousStats = { passes: 0, failures: 0, tests: 0, pending: 0, failedHooks: 0 }
+
+  // Keep requesting tests until no more available
+  while (true) {
+    // Request a test assignment
+    sendToParentThread({ type: 'REQUEST_TEST', workerIndex })
+
+    const testResult = await new Promise((resolve, reject) => {
+      // Set up pool mode message handler
+      const messageHandler = async eventData => {
+        if (eventData.type === 'TEST_ASSIGNED') {
+          const testUid = eventData.test
+
+          try {
+            // In pool mode, we need to create a fresh Mocha instance for each test
+            // because Mocha instances become disposed after running tests
+            container.createMocha() // Create fresh Mocha instance
+            filterTestById(testUid)
+            const mocha = container.mocha()
+
+            if (mocha.suite.total() > 0) {
+              // Run the test and complete
+              await codecept.run()
+
+              // Get the results from this specific test run
+              const result = container.result()
+              const currentStats = result.stats || {}
+
+              // Calculate the difference from previous accumulated stats
+              const newPasses = Math.max(0, (currentStats.passes || 0) - previousStats.passes)
+              const newFailures = Math.max(0, (currentStats.failures || 0) - previousStats.failures)
+              const newTests = Math.max(0, (currentStats.tests || 0) - previousStats.tests)
+              const newPending = Math.max(0, (currentStats.pending || 0) - previousStats.pending)
+              const newFailedHooks = Math.max(0, (currentStats.failedHooks || 0) - previousStats.failedHooks)
+
+              // Add only the new results
+              consolidatedStats.passes += newPasses
+              consolidatedStats.failures += newFailures
+              consolidatedStats.tests += newTests
+              consolidatedStats.pending += newPending
+              consolidatedStats.failedHooks += newFailedHooks
+
+              // Update previous stats for next comparison
+              previousStats = { ...currentStats }
+
+              // Add new failures to consolidated collections
+              if (result.failures && result.failures.length > allFailures.length) {
+                const newFailures = result.failures.slice(allFailures.length)
+                allFailures.push(...newFailures)
+              }
+            }
+
+            // Signal test completed and request next
+            parentPort?.off('message', messageHandler)
+            resolve('TEST_COMPLETED')
+          } catch (err) {
+            parentPort?.off('message', messageHandler)
+            reject(err)
+          }
+        } else if (eventData.type === 'NO_MORE_TESTS') {
+          // No tests available, exit worker
+          parentPort?.off('message', messageHandler)
+          resolve('NO_MORE_TESTS')
+        } else {
+          // Handle other message types (support messages, etc.)
+          container.append({ support: eventData.data })
+        }
+      }
+
+      parentPort?.on('message', messageHandler)
+    })
+
+    // Exit if no more tests
+    if (testResult === 'NO_MORE_TESTS') {
+      break
+    }
+  }
+
+  try {
+    await codecept.teardown()
+  } catch (err) {
+    // Log teardown errors but don't fail
+    console.error('Teardown error:', err)
+  }
+
+  // Send final consolidated results for the entire worker
+  const finalResult = {
+    hasFailed: consolidatedStats.failures > 0,
+    stats: consolidatedStats,
+    duration: 0, // Pool mode doesn't track duration per worker
+    tests: [], // Keep tests empty to avoid serialization issues - stats are sufficient
+    failures: allFailures, // Include all failures for error reporting
+  }
+
+  sendToParentThread({ event: event.all.after, workerIndex, data: finalResult })
+  sendToParentThread({ event: event.all.result, workerIndex, data: finalResult })
+
+  // Add longer delay to ensure messages are delivered before closing
+  await new Promise(resolve => setTimeout(resolve, 100))
+
+  // Close worker thread when pool mode is complete
+  parentPort?.close()
+}
+
+function filterTestById(testUid) {
+  // Reload test files fresh for each test in pool mode
+  const files = codecept.testFiles
+
+  // Get the existing mocha instance
+  const mocha = container.mocha()
+
+  // Clear suites and tests but preserve other mocha settings
+  mocha.suite.suites = []
+  mocha.suite.tests = []
+
+  // Clear require cache for test files to ensure fresh loading
+  files.forEach(file => {
+    delete require.cache[require.resolve(file)]
+  })
+
+  // Set files and load them
+  mocha.files = files
+  mocha.loadFiles()
+
+  // Now filter to only the target test - use a more robust approach
+  let foundTest = false
+  for (const suite of mocha.suite.suites) {
+    const originalTests = [...suite.tests]
+    suite.tests = []
+
+    for (const test of originalTests) {
+      if (test.uid === testUid) {
+        suite.tests.push(test)
+        foundTest = true
+        break // Only add one matching test
+      }
+    }
+
+    // If no tests found in this suite, remove it
+    if (suite.tests.length === 0) {
+      suite.parent.suites = suite.parent.suites.filter(s => s !== suite)
+    }
+  }
+
+  // Filter out empty suites from the root
+  mocha.suite.suites = mocha.suite.suites.filter(suite => suite.tests.length > 0)
+
+  if (!foundTest) {
+    // If testUid doesn't match, maybe it's a simple test name - try fallback
+    mocha.suite.suites = []
+    mocha.suite.tests = []
+    mocha.loadFiles()
+
+    // Try matching by title
+    for (const suite of mocha.suite.suites) {
+      const originalTests = [...suite.tests]
+      suite.tests = []
+
+      for (const test of originalTests) {
+        if (test.title === testUid || test.fullTitle() === testUid || test.uid === testUid) {
+          suite.tests.push(test)
+          foundTest = true
+          break
+        }
+      }
+    }
+
+    // Clean up empty suites again
+    mocha.suite.suites = mocha.suite.suites.filter(suite => suite.tests.length > 0)
+  }
+}
+
 function filterTests() {
   const files = codecept.testFiles
   mocha.files = files
@@ -102,14 +299,20 @@ function initializeListeners() {
   event.dispatcher.on(event.hook.passed, hook => sendToParentThread({ event: event.hook.passed, workerIndex, data: hook.simplify() }))
   event.dispatcher.on(event.hook.finished, hook => sendToParentThread({ event: event.hook.finished, workerIndex, data: hook.simplify() }))
 
-  event.dispatcher.once(event.all.after, () => {
-    sendToParentThread({ event: event.all.after, workerIndex, data: container.result().simplify() })
-  })
-  // all
-  event.dispatcher.once(event.all.result, () => {
-    sendToParentThread({ event: event.all.result, workerIndex, data: container.result().simplify() })
-    parentPort?.close()
-  })
+  if (!poolMode) {
+    // In regular mode, close worker after all tests are complete
+    event.dispatcher.once(event.all.after, () => {
+      sendToParentThread({ event: event.all.after, workerIndex, data: container.result().simplify() })
+    })
+    // all
+    event.dispatcher.once(event.all.result, () => {
+      sendToParentThread({ event: event.all.result, workerIndex, data: container.result().simplify() })
+      parentPort?.close()
+    })
+  } else {
+    // In pool mode, don't send result events for individual tests
+    // Results will be sent once when the worker completes all tests
+  }
 }
 
 function disablePause() {
@@ -121,7 +324,10 @@ function sendToParentThread(data) {
 }
 
 function listenToParentThread() {
-  parentPort?.on('message', eventData => {
-    container.append({ support: eventData.data })
-  })
+  if (!poolMode) {
+    parentPort?.on('message', eventData => {
+      container.append({ support: eventData.data })
+    })
+  }
+  // In pool mode, message handling is done in runPoolTests()
 }

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