codeceptjs 3.7.5-beta.9 → 3.7.6-beta.1

package/bin/codecept.js

@@ -296,29 +296,6 @@ program
 
   .action(require('../lib/command/run-rerun'))
 
-program
-  .command('run-failed-tests')
-  .description('Re-run tests that failed in the previous test run')
-  .option(commandFlags.config.flag, commandFlags.config.description)
-  .option(commandFlags.profile.flag, commandFlags.profile.description)
-  .option(commandFlags.verbose.flag, commandFlags.verbose.description)
-  .option(commandFlags.debug.flag, commandFlags.debug.description)
-  .option(commandFlags.steps.flag, commandFlags.steps.description)
-  .option('-o, --override [value]', 'override current config options')
-  .option('-f, --file [path]', 'path to failed tests file (default: ./failed-tests.json)')
-  .option('-g, --grep <pattern>', 'only run failed tests matching <pattern>')
-  .option('-p, --plugins <k=v,k2=v2,...>', 'enable plugins, comma-separated')
-  .option('--features', 'run only *.feature files and skip tests')
-  .option('--tests', 'run only JS test files and skip features')
-  .option('--colors', 'force enabling of colors')
-  .option('--no-colors', 'force disabling of colors')
-  .option('-R, --reporter <name>', 'specify the reporter to use')
-  .option('-O, --reporter-options <k=v,k2=v2,...>', 'reporter-specific options')
-  .option('--workers <number>', 'run failed tests in parallel using specified number of workers')
-  .option('--suites', 'parallel execution of suites not single tests (when using --workers)')
-  .option('--by <strategy>', 'test distribution strategy when using --workers: "test", "suite", or "pool"')
-  .action(errorHandler(require('../lib/command/run-failed-tests')))
-
 program.on('command:*', cmd => {
   console.log(`\nUnknown command ${cmd}\n`)
   program.outputHelp()

package/lib/effects.js

@@ -89,7 +89,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/helper/Appium.js

@@ -275,7 +275,7 @@ class Appium extends Webdriver {
     const _convertedCaps = {}
     for (const [key, value] of Object.entries(capabilities)) {
       if (!key.startsWith(vendorPrefix.appium)) {
-        if (key !== 'platformName' && key !== 'bstack:options') {
+        if (key !== 'platformName' && key !== 'bstack:options' && key !== 'sauce:options') {
           _convertedCaps[`${vendorPrefix.appium}:${key}`] = value
         } else {
           _convertedCaps[`${key}`] = value

package/lib/helper/Playwright.js

@@ -360,10 +360,6 @@ class Playwright extends Helper {
     // override defaults with config
     this._setConfig(config)
 
-    // Call _init() to register selector engines - use setTimeout to avoid blocking constructor
-    setTimeout(() => {
-      this._init().catch(console.error)
-    }, 0)
   }
 
   _validateConfig(config) {
@@ -642,6 +638,9 @@ class Playwright extends Helper {
   async _after() {
     if (!this.isRunning) return
 
+    // Clear popup state to prevent leakage between tests
+    popupStore.clear()
+
     if (this.isElectron) {
       this.browser.close()
       this.electronSessions.forEach(session => session.close())

package/lib/helper/Puppeteer.js

@@ -330,6 +330,9 @@ class Puppeteer extends Helper {
   async _after() {
     if (!this.isRunning) return
 
+    // Clear popup state to prevent leakage between tests
+    popupStore.clear()
+
     // close other sessions
     const contexts = this.browser.browserContexts()
     const defaultCtx = contexts.shift()
@@ -2588,7 +2591,8 @@ class Puppeteer extends Helper {
    *
    * {{> stopRecordingTraffic }}
    */
-  stopRecordingTraffic() {
+  async stopRecordingTraffic() {
+    await this.page.setRequestInterception(false)
     stopRecordingTraffic.call(this)
   }
 

package/lib/helper/REST.js

@@ -281,6 +281,27 @@ class REST extends Helper {
     return this._executeRequest(request)
   }
 
+  /**
+   * Send HEAD request to REST API
+   *
+   * ```js
+   * I.sendHeadRequest('/api/users.json');
+   * ```
+   *
+   * @param {*} url
+   * @param {object} [headers={}] - the headers object to be sent. By default, it is sent as an empty object
+   *
+   * @returns {Promise<*>} response
+   */
+  async sendHeadRequest(url, headers = {}) {
+    const request = {
+      baseURL: this._url(url),
+      method: 'HEAD',
+      headers,
+    }
+    return this._executeRequest(request)
+  }
+
   /**
    * Sends POST request to API.
    *

package/lib/helper/WebDriver.js

@@ -491,7 +491,7 @@ class WebDriver extends Helper {
     }
     config.capabilities.browserName = config.browser || config.capabilities.browserName
 
-    // WebDriver Bidi Protocol. Default: false
+    // WebDriver Bidi Protocol. Default: true
     config.capabilities.webSocketUrl = config.bidiProtocol ?? config.capabilities.webSocketUrl ?? true
 
     config.capabilities.browserVersion = config.browserVersion || config.capabilities.browserVersion
@@ -629,8 +629,11 @@ class WebDriver extends Helper {
 
     this.browser.on('dialog', () => {})
 
-    await this.browser.sessionSubscribe({ events: ['log.entryAdded'] })
-    this.browser.on('log.entryAdded', logEvents)
+    // Check for Bidi, because "sessionSubscribe" is an exclusive Bidi protocol feature. Otherwise, error will be thrown.
+    if (this.browser.capabilities && this.browser.capabilities.webSocketUrl) {
+      await this.browser.sessionSubscribe({ events: ['log.entryAdded'] })
+      this.browser.on('log.entryAdded', logEvents)
+    }
 
     return this.browser
   }

package/lib/helper/network/actions.js

@@ -30,7 +30,7 @@ async function seeTraffic({
     throw new Error('Missing required key "url" in object given to "I.seeTraffic".');
   }
 
-  if (!this.recording || !this.recordedAtLeastOnce) {
+  if (!this.recordedAtLeastOnce) {
     throw new Error('Failure in test automation. You use "I.seeTraffic", but "I.startRecordingTraffic" was never called before.');
   }
 
@@ -66,7 +66,7 @@ async function seeTraffic({
 }
 
 async function grabRecordedNetworkTraffics() {
-  if (!this.recording || !this.recordedAtLeastOnce) {
+  if (!this.recordedAtLeastOnce) {
     throw new Error('Failure in test automation. You use "I.grabRecordedNetworkTraffics", but "I.startRecordingTraffic" was never called before.');
   }
 
@@ -107,6 +107,8 @@ async function grabRecordedNetworkTraffics() {
 function stopRecordingTraffic() {
   // @ts-ignore
   this.page.removeAllListeners('request');
+   // @ts-ignore
+  this.page.removeAllListeners('requestfinished');
   this.recording = false;
 }
 

package/lib/listener/enhancedGlobalRetry.js

@@ -0,0 +1,110 @@
+const event = require('../event')
+const output = require('../output')
+const Config = require('../config')
+const { isNotSet } = require('../utils')
+
+const hooks = ['Before', 'After', 'BeforeSuite', 'AfterSuite']
+
+/**
+ * Priority levels for retry mechanisms (higher number = higher priority)
+ * This ensures consistent behavior when multiple retry mechanisms are active
+ */
+const RETRY_PRIORITIES = {
+  MANUAL_STEP: 100, // I.retry() or step.retry() - highest priority
+  STEP_PLUGIN: 50, // retryFailedStep plugin
+  SCENARIO_CONFIG: 30, // Global scenario retry config
+  FEATURE_CONFIG: 20, // Global feature retry config
+  HOOK_CONFIG: 10, // Hook retry config - lowest priority
+}
+
+/**
+ * Enhanced global retry mechanism that coordinates with other retry types
+ */
+module.exports = function () {
+  event.dispatcher.on(event.suite.before, suite => {
+    let retryConfig = Config.get('retry')
+    if (!retryConfig) return
+
+    if (Number.isInteger(+retryConfig)) {
+      // is number - apply as feature-level retry
+      const retryNum = +retryConfig
+      output.log(`[Global Retry] Feature retries: ${retryNum}`)
+
+      // Only set if not already set by higher priority mechanism
+      if (isNotSet(suite.retries())) {
+        suite.retries(retryNum)
+        suite.opts.retryPriority = RETRY_PRIORITIES.FEATURE_CONFIG
+      }
+      return
+    }
+
+    if (!Array.isArray(retryConfig)) {
+      retryConfig = [retryConfig]
+    }
+
+    for (const config of retryConfig) {
+      if (config.grep) {
+        if (!suite.title.includes(config.grep)) continue
+      }
+
+      // Handle hook retries with priority awareness
+      hooks
+        .filter(hook => !!config[hook])
+        .forEach(hook => {
+          const retryKey = `retry${hook}`
+          if (isNotSet(suite.opts[retryKey])) {
+            suite.opts[retryKey] = config[hook]
+            suite.opts[`${retryKey}Priority`] = RETRY_PRIORITIES.HOOK_CONFIG
+          }
+        })
+
+      // Handle feature-level retries
+      if (config.Feature) {
+        if (isNotSet(suite.retries()) || (suite.opts.retryPriority || 0) <= RETRY_PRIORITIES.FEATURE_CONFIG) {
+          suite.retries(config.Feature)
+          suite.opts.retryPriority = RETRY_PRIORITIES.FEATURE_CONFIG
+          output.log(`[Global Retry] Feature retries: ${config.Feature}`)
+        }
+      }
+    }
+  })
+
+  event.dispatcher.on(event.test.before, test => {
+    let retryConfig = Config.get('retry')
+    if (!retryConfig) return
+
+    if (Number.isInteger(+retryConfig)) {
+      // Only set if not already set by higher priority mechanism
+      if (test.retries() === -1) {
+        test.retries(retryConfig)
+        test.opts.retryPriority = RETRY_PRIORITIES.SCENARIO_CONFIG
+        output.log(`[Global Retry] Scenario retries: ${retryConfig}`)
+      }
+      return
+    }
+
+    if (!Array.isArray(retryConfig)) {
+      retryConfig = [retryConfig]
+    }
+
+    retryConfig = retryConfig.filter(config => !!config.Scenario)
+
+    for (const config of retryConfig) {
+      if (config.grep) {
+        if (!test.fullTitle().includes(config.grep)) continue
+      }
+
+      if (config.Scenario) {
+        // Respect priority system
+        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(`[Global Retry] Scenario retries: ${config.Scenario}`)
+        }
+      }
+    }
+  })
+}
+
+// Export priority constants for use by other retry mechanisms
+module.exports.RETRY_PRIORITIES = RETRY_PRIORITIES

package/lib/mocha/test.js

@@ -121,7 +121,6 @@ function serializeTest(test, error = null) {
   }
 
   return {
-    file: test.file ? relativeDir(test.file) : undefined,
     opts: test.opts || {},
     tags: test.tags || [],
     uid: test.uid,

package/lib/plugin/enhancedRetryFailedStep.js

@@ -0,0 +1,99 @@
+const event = require('../event')
+const recorder = require('../recorder')
+const store = require('../store')
+const output = require('../output')
+const { RETRY_PRIORITIES } = require('../retryCoordinator')
+
+const defaultConfig = {
+  retries: 3,
+  defaultIgnoredSteps: ['amOnPage', 'wait*', 'send*', 'execute*', 'run*', 'have*'],
+  factor: 1.5,
+  ignoredSteps: [],
+}
+
+/**
+ * Enhanced retryFailedStep plugin that coordinates with other retry mechanisms
+ *
+ * This plugin provides step-level retries and coordinates with global retry settings
+ * to avoid conflicts and provide predictable behavior.
+ */
+module.exports = config => {
+  config = Object.assign({}, defaultConfig, config)
+  config.ignoredSteps = config.ignoredSteps.concat(config.defaultIgnoredSteps)
+  const customWhen = config.when
+
+  let enableRetry = false
+
+  const when = err => {
+    if (!enableRetry) return false
+    if (store.debugMode) return false
+    if (!store.autoRetries) return false
+    if (customWhen) return customWhen(err)
+    return true
+  }
+  config.when = when
+
+  event.dispatcher.on(event.step.started, step => {
+    // if a step is ignored - return
+    for (const ignored of config.ignoredSteps) {
+      if (step.name === ignored) return
+      if (ignored instanceof RegExp) {
+        if (step.name.match(ignored)) return
+      } else if (ignored.indexOf('*') && step.name.startsWith(ignored.slice(0, -1))) return
+    }
+    enableRetry = true // enable retry for a step
+  })
+
+  event.dispatcher.on(event.step.finished, () => {
+    enableRetry = false
+  })
+
+  event.dispatcher.on(event.test.before, test => {
+    // pass disableRetryFailedStep is a preferred way to disable retries
+    // test.disableRetryFailedStep is used for backward compatibility
+    if (test.opts.disableRetryFailedStep || test.disableRetryFailedStep) {
+      store.autoRetries = false
+      output.log(`[Step Retry] Disabled for test: ${test.title}`)
+      return // disable retry when a test is not active
+    }
+
+    // Check if step retries should be disabled due to higher priority scenario retries
+    const scenarioRetries = test.retries()
+    const stepRetryPriority = RETRY_PRIORITIES.STEP_PLUGIN
+    const scenarioPriority = test.opts.retryPriority || 0
+
+    if (scenarioRetries > 0 && config.deferToScenarioRetries !== false) {
+      // Scenario retries are configured with higher or equal priority
+      // Option 1: Disable step retries (conservative approach)
+      store.autoRetries = false
+      output.log(`[Step Retry] Deferred to scenario retries (${scenarioRetries} retries)`)
+      return
+
+      // Option 2: Reduce step retries to avoid excessive total retries
+      // const reducedStepRetries = Math.max(1, Math.floor(config.retries / scenarioRetries))
+      // config.retries = reducedStepRetries
+      // output.log(`[Step Retry] Reduced to ${reducedStepRetries} retries due to scenario retries (${scenarioRetries})`)
+    }
+
+    // this option is used to set the retries inside _before() block of helpers
+    store.autoRetries = true
+    test.opts.conditionalRetries = config.retries
+    test.opts.stepRetryPriority = stepRetryPriority
+
+    recorder.retry(config)
+
+    output.log(`[Step Retry] Enabled with ${config.retries} retries for test: ${test.title}`)
+  })
+
+  // Add coordination info for debugging
+  event.dispatcher.on(event.test.finished, test => {
+    if (test.state === 'passed' && test.opts.conditionalRetries && store.autoRetries) {
+      const stepRetries = test.opts.conditionalRetries || 0
+      const scenarioRetries = test.retries() || 0
+
+      if (stepRetries > 0 && scenarioRetries > 0) {
+        output.log(`[Retry Coordination] Test used both step retries (${stepRetries}) and scenario retries (${scenarioRetries})`)
+      }
+    }
+  })
+}

package/lib/recorder.js

@@ -11,6 +11,7 @@ let running = false
 let errFn
 let queueId = 0
 let sessionId = null
+let sessionStack = [] // Stack to support nested sessions
 let asyncErr = null
 let ignoredErrs = []
 
@@ -89,6 +90,7 @@ module.exports = {
     if (promise && running) this.catch()
     queueId++
     sessionId = null
+    sessionStack = [] // Clear the session stack
     asyncErr = null
     log(`${currentQueue()} Starting recording promises`)
     promise = Promise.resolve()
@@ -123,8 +125,13 @@ module.exports = {
      */
     start(name) {
       if (sessionId) {
-        debug(`${currentQueue()}Session already started as ${sessionId}`)
-        this.restore(sessionId)
+        debug(`${currentQueue()}Session already started as ${sessionId}, nesting session ${name}`)
+        // Push current session to stack instead of restoring it
+        sessionStack.push({
+          id: sessionId,
+          promise: promise,
+          running: this.running,
+        })
       }
       debug(`${currentQueue()}Starting <${name}> session`)
       tasks.push('--->')
@@ -142,9 +149,18 @@ module.exports = {
       tasks.push('<---')
       debug(`${currentQueue()}Finalize <${name}> session`)
       this.running = false
-      sessionId = null
       this.catch(errFn)
       promise = promise.then(() => oldPromises.pop())
+
+      // Restore parent session from stack if available
+      if (sessionStack.length > 0) {
+        const parentSession = sessionStack.pop()
+        sessionId = parentSession.id
+        this.running = parentSession.running
+        debug(`${currentQueue()}Restored parent session <${sessionId}>`)
+      } else {
+        sessionId = null
+      }
     },
 
     /**

package/lib/retryCoordinator.js

@@ -0,0 +1,207 @@
+const output = require('./output')
+
+/**
+ * Retry Coordinator - Central coordination for all retry mechanisms
+ *
+ * This module provides:
+ * 1. Priority-based retry coordination
+ * 2. Unified configuration validation
+ * 3. Consolidated retry reporting
+ * 4. Conflict detection and resolution
+ */
+
+/**
+ * Priority levels for retry mechanisms (higher number = higher priority)
+ */
+const RETRY_PRIORITIES = {
+  MANUAL_STEP: 100, // I.retry() or step.retry() - highest priority
+  STEP_PLUGIN: 50, // retryFailedStep plugin
+  SCENARIO_CONFIG: 30, // Global scenario retry config
+  FEATURE_CONFIG: 20, // Global feature retry config
+  HOOK_CONFIG: 10, // Hook retry config - lowest priority
+}
+
+/**
+ * Retry mechanism types
+ */
+const RETRY_TYPES = {
+  MANUAL_STEP: 'manual-step',
+  STEP_PLUGIN: 'step-plugin',
+  SCENARIO: 'scenario',
+  FEATURE: 'feature',
+  HOOK: 'hook',
+}
+
+/**
+ * Global retry coordination state
+ */
+let retryState = {
+  activeTest: null,
+  activeSuite: null,
+  retryHistory: [],
+  conflicts: [],
+}
+
+/**
+ * Registers a retry mechanism for coordination
+ * @param {string} type - Type of retry mechanism
+ * @param {Object} config - Retry configuration
+ * @param {Object} target - Target object (test, suite, etc.)
+ * @param {number} priority - Priority level
+ */
+function registerRetry(type, config, target, priority = 0) {
+  const retryInfo = {
+    type,
+    config,
+    target,
+    priority,
+    timestamp: Date.now(),
+  }
+
+  // Detect conflicts
+  const existingRetries = retryState.retryHistory.filter(r => r.target === target && r.type !== type && r.priority !== priority)
+
+  if (existingRetries.length > 0) {
+    const conflict = {
+      newRetry: retryInfo,
+      existingRetries: existingRetries,
+      resolved: false,
+    }
+    retryState.conflicts.push(conflict)
+    handleRetryConflict(conflict)
+  }
+
+  retryState.retryHistory.push(retryInfo)
+
+  output.log(`[Retry Coordinator] Registered ${type} retry (priority: ${priority})`)
+}
+
+/**
+ * Handles conflicts between retry mechanisms
+ * @param {Object} conflict - Conflict information
+ */
+function handleRetryConflict(conflict) {
+  const { newRetry, existingRetries } = conflict
+
+  // Find highest priority retry
+  const allRetries = [newRetry, ...existingRetries]
+  const highestPriority = Math.max(...allRetries.map(r => r.priority))
+  const winningRetry = allRetries.find(r => r.priority === highestPriority)
+
+  // Log the conflict resolution
+  output.log(`[Retry Coordinator] Conflict detected:`)
+  allRetries.forEach(retry => {
+    const status = retry === winningRetry ? 'ACTIVE' : 'DEFERRED'
+    output.log(`  - ${retry.type} (priority: ${retry.priority}) [${status}]`)
+  })
+
+  conflict.resolved = true
+  conflict.winner = winningRetry
+}
+
+/**
+ * Gets the effective retry configuration for a target
+ * @param {Object} target - Target object (test, suite, etc.)
+ * @returns {Object} Effective retry configuration
+ */
+function getEffectiveRetryConfig(target) {
+  const targetRetries = retryState.retryHistory.filter(r => r.target === target)
+
+  if (targetRetries.length === 0) {
+    return { type: 'none', retries: 0 }
+  }
+
+  // Find highest priority retry
+  const highestPriority = Math.max(...targetRetries.map(r => r.priority))
+  const effectiveRetry = targetRetries.find(r => r.priority === highestPriority)
+
+  return {
+    type: effectiveRetry.type,
+    retries: effectiveRetry.config.retries || effectiveRetry.config,
+    config: effectiveRetry.config,
+  }
+}
+
+/**
+ * Generates a retry summary report
+ * @returns {Object} Retry summary
+ */
+function generateRetrySummary() {
+  const summary = {
+    totalRetryMechanisms: retryState.retryHistory.length,
+    conflicts: retryState.conflicts.length,
+    byType: {},
+    recommendations: [],
+  }
+
+  // Count by type
+  retryState.retryHistory.forEach(retry => {
+    summary.byType[retry.type] = (summary.byType[retry.type] || 0) + 1
+  })
+
+  // Generate recommendations
+  if (summary.conflicts > 0) {
+    summary.recommendations.push('Consider consolidating retry configurations to avoid conflicts')
+  }
+
+  if (summary.byType[RETRY_TYPES.STEP_PLUGIN] && summary.byType[RETRY_TYPES.SCENARIO]) {
+    summary.recommendations.push('Step-level and scenario-level retries are both active - consider using only one approach')
+  }
+
+  return summary
+}
+
+/**
+ * Resets the retry coordination state (useful for testing)
+ */
+function reset() {
+  retryState = {
+    activeTest: null,
+    activeSuite: null,
+    retryHistory: [],
+    conflicts: [],
+  }
+}
+
+/**
+ * Validates retry configuration for common issues
+ * @param {Object} config - Configuration object
+ * @returns {Array} Array of validation warnings
+ */
+function validateConfig(config) {
+  const warnings = []
+
+  if (!config) return warnings
+
+  // Check for potential configuration conflicts
+  if (config.retry && config.plugins && config.plugins.retryFailedStep) {
+    const globalRetries = typeof config.retry === 'number' ? config.retry : config.retry.Scenario || config.retry.Feature
+    const stepRetries = config.plugins.retryFailedStep.retries || 3
+
+    if (globalRetries && stepRetries) {
+      warnings.push(`Both global retries (${globalRetries}) and step retries (${stepRetries}) are configured - total executions could be ${globalRetries * (stepRetries + 1)}`)
+    }
+  }
+
+  // Check for excessive retry counts
+  if (config.retry) {
+    const retryValues = typeof config.retry === 'number' ? [config.retry] : Object.values(config.retry)
+    const maxRetries = Math.max(...retryValues.filter(v => typeof v === 'number'))
+
+    if (maxRetries > 5) {
+      warnings.push(`High retry count detected (${maxRetries}) - consider investigating test stability instead`)
+    }
+  }
+
+  return warnings
+}
+
+module.exports = {
+  RETRY_PRIORITIES,
+  RETRY_TYPES,
+  registerRetry,
+  getEffectiveRetryConfig,
+  generateRetrySummary,
+  validateConfig,
+  reset,
+}