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

package/lib/mocha/factory.js

@@ -6,6 +6,7 @@ import reporter from './cli.js'
 import gherkinParser, { loadTranslations } from './gherkin.js'
 import output from '../output.js'
 import scenarioUiFunction from './ui.js'
+import { initMochaGlobals } from '../globals.js'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = fsPath.dirname(__filename)
@@ -23,6 +24,8 @@ class MochaFactory {
     if (mocha.suite && mocha.suite.emit) {
       const context = {}
       mocha.suite.emit('pre-require', context, '', mocha)
+      // Also set globals immediately so they're available when ESM modules load
+      initMochaGlobals(context)
     }
 
     Mocha.Runner.prototype.uncaught = function (err) {

package/lib/mocha/gherkin.js

@@ -116,7 +116,7 @@ const gherkinParser = (text, file) => {
       )
       continue
     }
-    if (child.scenario && (currentLanguage ? currentLanguage.contexts.ScenarioOutline.includes(child.scenario.keyword) : child.scenario.keyword === 'Scenario Outline')) {
+    if (child.scenario && (currentLanguage ? currentLanguage.contexts.ScenarioOutline === child.scenario.keyword : child.scenario.keyword === 'Scenario Outline')) {
       for (const examples of child.scenario.examples) {
         const fields = examples.tableHeader.cells.map(c => c.value)
         for (const example of examples.tableBody) {

package/lib/mocha/test.js

@@ -78,6 +78,12 @@ function deserializeTest(test) {
   test.parent = Object.assign(new Suite(test.parent?.title || 'Suite'), test.parent)
   enhanceMochaSuite(test.parent)
   if (test.steps) test.steps = test.steps.map(step => Object.assign(new Step(step.title), step))
+
+  // Restore the custom fullTitle function to maintain consistency with original test
+  if (test.parent) {
+    test.fullTitle = () => `${test.parent.title}: ${test.title}`
+  }
+
   return test
 }
 

package/lib/mocha/ui.js

@@ -110,6 +110,19 @@ export default function (suite) {
       return new FeatureConfig(suite)
     }
 
+    /**
+     * Exclusive test suite - runs only this feature.
+     * @global
+     * @kind constant
+     * @type {CodeceptJS.IFeature}
+     */
+    context.Feature.only = function (title, opts) {
+      const reString = `^${escapeRe(`${title}:`)}`
+      mocha.grep(new RegExp(reString))
+      process.env.FEATURE_ONLY = true
+      return context.Feature(title, opts)
+    }
+
     /**
      * Pending test suite.
      * @global

package/lib/output.js

@@ -1,6 +1,6 @@
 import colors from 'chalk'
 import figures from 'figures'
-import { maskSensitiveData } from 'invisi-data'
+import { maskData, shouldMaskData, getMaskConfig } from './utils/mask_data.js'
 
 const styles = {
   error: colors.bgRed.white.bold,
@@ -50,7 +50,40 @@ const output = {
    */
   process(process) {
     if (process === null) return (outputProcess = '')
-    if (process) outputProcess = String(process).length === 1 ? `[0${process}]` : `[${process}]`
+    if (process) {
+      // Handle objects by converting to empty string or extracting properties
+      let processValue = process
+      if (typeof process === 'object') {
+        // If it's an object, try to extract a numeric value or use empty string
+        processValue = process.id || process.index || process.worker || ''
+      }
+
+      // Check if this is a run-multiple process (contains : or .)
+      // Format: "1.runName:browserName" from run-multiple
+      if (String(processValue).includes(':') || (String(processValue).includes('.') && String(processValue).split('.').length > 1)) {
+        // Keep original format for run-multiple
+        outputProcess = colors.cyan.bold(`[${processValue}]`)
+      } else {
+        // Standard worker format for run-workers
+        const processNum = parseInt(processValue, 10)
+        const processStr = !isNaN(processNum) ? String(processNum).padStart(2, '0') : String(processValue).padStart(2, '0')
+
+        // Assign different colors to different workers for better identification
+        const workerColors = [
+          colors.cyan, // Worker 01 - Cyan
+          colors.magenta, // Worker 02 - Magenta
+          colors.green, // Worker 03 - Green
+          colors.yellow, // Worker 04 - Yellow
+          colors.blue, // Worker 05 - Blue
+          colors.red, // Worker 06 - Red
+          colors.white, // Worker 07 - White
+          colors.gray, // Worker 08 - Gray
+        ]
+        const workerIndex = !isNaN(processNum) ? processNum - 1 : -1
+        const colorFn = workerIndex >= 0 && workerColors[workerIndex % workerColors.length] ? workerColors[workerIndex % workerColors.length] : colors.cyan
+        outputProcess = colorFn.bold(`[Worker ${processStr}]`)
+      }
+    }
     return outputProcess
   },
 
@@ -59,7 +92,7 @@ const output = {
    * @param {string} msg
    */
   debug(msg) {
-    const _msg = isMaskedData() ? maskSensitiveData(msg) : msg
+    const _msg = shouldMaskData() ? maskData(msg, getMaskConfig()) : msg
     if (outputLevel >= 2) {
       print(' '.repeat(output.stepShift), styles.debug(`${figures.pointerSmall} ${_msg}`))
     }
@@ -70,7 +103,7 @@ const output = {
    * @param {string} msg
    */
   log(msg) {
-    const _msg = isMaskedData() ? maskSensitiveData(msg) : msg
+    const _msg = shouldMaskData() ? maskData(msg, getMaskConfig()) : msg
     if (outputLevel >= 3) {
       print(' '.repeat(output.stepShift), styles.log(truncate(`   ${_msg}`, output.stepShift)))
     }
@@ -81,7 +114,8 @@ const output = {
    * @param {string} msg
    */
   error(msg) {
-    print(styles.error(msg))
+    const _msg = shouldMaskData() ? maskData(msg, getMaskConfig()) : msg
+    print(styles.error(_msg))
   },
 
   /**
@@ -89,7 +123,8 @@ const output = {
    * @param {string} msg
    */
   success(msg) {
-    print(styles.success(msg))
+    const _msg = shouldMaskData() ? maskData(msg, getMaskConfig()) : msg
+    print(styles.success(_msg))
   },
 
   /**
@@ -124,8 +159,8 @@ const output = {
       stepLine += colors.grey(step.comment.split('\n').join('\n' + ' '.repeat(4)))
     }
 
-    const _stepLine = isMaskedData() ? maskSensitiveData(stepLine) : stepLine
-    print(' '.repeat(output.stepShift), truncate(_stepLine, output.stepShift))
+    const _stepLine = shouldMaskData() ? maskData(stepLine, getMaskConfig()) : stepLine
+    print(' '.repeat(this.stepShift), truncate(_stepLine, this.spaceShift))
   },
 
   /** @namespace */
@@ -147,25 +182,38 @@ const output = {
      * @param {Mocha.Test} test
      */
     started(test) {
-      print(`  ${colors.magenta.bold(test.title)}`)
+      // Only show feature name in workers mode (when outputProcess is set)
+      const featureName = outputProcess && test.parent?.title ? `${colors.cyan.bold(test.parent.title)} › ` : ''
+      print(`  ${featureName}${colors.magenta.bold(test.title)}`)
     },
     /**
      * @param {Mocha.Test} test
      */
     passed(test) {
-      print(`  ${colors.green.bold(figures.tick)} ${test.title} ${colors.grey(`in ${test.duration}ms`)}`)
+      // Only show feature name in workers mode (when outputProcess is set)
+      const featureName = outputProcess && test.parent?.title ? `${colors.cyan(test.parent.title)} › ` : ''
+      const scenarioName = colors.bold(test.title)
+      const executionTime = colors.cyan(`in ${test.duration}ms`)
+      print(`  ${colors.green.bold(figures.tick)} ${featureName}${scenarioName} ${executionTime}`)
     },
     /**
      * @param {Mocha.Test} test
      */
     failed(test) {
-      print(`  ${colors.red.bold(figures.cross)} ${test.title} ${colors.grey(`in ${test.duration}ms`)}`)
+      // Only show feature name in workers mode (when outputProcess is set)
+      const featureName = outputProcess && test.parent?.title ? `${colors.yellow(test.parent.title)} › ` : ''
+      const scenarioName = colors.bold(test.title)
+      const executionTime = colors.yellow(`in ${test.duration}ms`)
+      print(`  ${colors.red.bold(figures.cross)} ${featureName}${scenarioName} ${executionTime}`)
     },
     /**
      * @param {Mocha.Test} test
      */
     skipped(test) {
-      print(`  ${colors.yellow.bold('S')} ${test.title}`)
+      // Only show feature name in workers mode (when outputProcess is set)
+      const featureName = outputProcess && test.parent?.title ? `${colors.gray(test.parent.title)} › ` : ''
+      const scenarioName = colors.bold(test.title)
+      print(`  ${colors.yellow.bold('S')} ${featureName}${scenarioName}`)
     },
   },
 
@@ -256,6 +304,8 @@ const output = {
   },
 }
 
+export default output
+
 function print(...msg) {
   if (outputProcess) {
     msg.unshift(outputProcess)
@@ -278,9 +328,3 @@ function truncate(msg, gap = 0) {
   }
   return msg
 }
-
-function isMaskedData() {
-  return global.maskSensitiveData === true || false
-}
-
-export default output

package/lib/plugin/coverage.js

@@ -149,9 +149,22 @@ export default function (config) {
   const coverageReport = new CoverageReport(coverageOptions)
   coverageReport.cleanCache()
 
-  event.dispatcher.on(event.all.after, async () => {
-    output.print(`writing ${coverageOptions.outputDir}`)
-    await coverageReport.generate()
+  event.dispatcher.on(event.all.after, () => {
+    // Add coverage generation to recorder to ensure it completes before process exit
+    recorder.add(
+      'generate coverage report',
+      async () => {
+        try {
+          output.print(`writing ${coverageOptions.outputDir}`)
+          await coverageReport.generate()
+        } catch (error) {
+          output.print(`Failed to generate coverage report: ${error.message}`)
+          // Don't throw - coverage failure shouldn't fail tests
+        }
+      },
+      true,
+      false,
+    )
   })
 
   //  we're going to try to "start" coverage before each step because this is

package/lib/plugin/enhancedRetryFailedStep.js

@@ -0,0 +1,99 @@
+import event from '../event.js'
+import recorder from '../recorder.js'
+import store from '../store.js'
+import output from '../output.js'
+import { RETRY_PRIORITIES } from '../retryCoordinator.js'
+
+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.
+ */
+export default 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})`)
+      }
+    }
+  })
+}