codeceptjs 4.0.0-rc.20 → 4.0.0-rc.22

package/lib/helper/Playwright.js

@@ -755,6 +755,11 @@ class Playwright extends Helper {
   }
 
   async _afterSuite() {
+    // Reset leftover test-level cleanup state (e.g. screenshot failures)
+    // so only errors from this suite teardown are evaluated below.
+    this.hasCleanupError = false
+    this.testFailures = []
+
     // Stop browser after suite completes
     // For restart strategies: stop after each suite
     // For session mode (restart:false): stop after the last suite
@@ -2678,7 +2683,7 @@ class Playwright extends Helper {
     if (arg && typeof arg.evaluate === 'function' && typeof arg.locator === 'function') {
       return arg.evaluate(fn)
     }
-    if (this.context && this.context.constructor.name === 'FrameLocator') {
+    if (this.context && typeof this.context.url !== 'function' && typeof this.context.innerText !== 'function') {
       return this.context.locator(':root').evaluate(fn, arg)
     }
     return this.page.evaluate.apply(this.page, [fn, arg])
@@ -3415,7 +3420,7 @@ class Playwright extends Helper {
   }
 
   async _getContext() {
-    if ((this.context && this.context.constructor.name === 'FrameLocator') || this.context) {
+    if (this.context) {
       return this.context
     }
     if (this.frame) {
@@ -4354,7 +4359,9 @@ async function proceedSee(assertType, text, context, strict = false) {
   if (!context) {
     const el = await this.context
 
-    allText = el.constructor.name !== 'Locator' ? [await el.locator('body').innerText()] : [await el.innerText()]
+    allText = typeof el.url !== 'function' && typeof el.innerText === 'function'
+      ? [await el.innerText()]
+      : [await el.locator('body').innerText()]
 
     description = 'web application'
   } else {
@@ -4637,12 +4644,16 @@ async function targetCreatedHandler(page) {
       .catch(() => null)
       .then(async () => {
         if (this.context && this.context._type === 'Frame') {
-          // we are inside iframe?
+          // we are inside iframe via Frame object — refresh handle
           const frameEl = await this.context.frameElement()
           this.context = await frameEl.contentFrame()
           this.contextLocator = null
           return
         }
+        if (this.context && this.context.constructor && this.context.constructor.name === 'FrameLocator') {
+          // we are inside iframe via FrameLocator — keep it across load events
+          return
+        }
         // if context element was in iframe - keep it
         // if (await this.context.ownerFrame()) return;
         this.context = page

package/lib/plugin/aiTrace.js

@@ -92,6 +92,7 @@ export default function (config = {}) {
   let testStartTime
   let currentUrl = null
   let testFailed = false
+  let pendingArtifactCapture = null
   let firstFailedStepSaved = false
 
   const reportDir = config.output ? path.resolve(store.codeceptDir, config.output) : defaultConfig.output
@@ -129,6 +130,7 @@ export default function (config = {}) {
     currentUrl = null
     testFailed = false
     firstFailedStepSaved = false
+    pendingArtifactCapture = null
   })
 
   event.dispatcher.on(event.step.after, step => {
@@ -162,13 +164,12 @@ export default function (config = {}) {
       return
     }
 
-    const stepPersistPromise = persistStep(step).catch(err => {
+    recorder.add(`aiTrace step persistence: ${step.toString()}`, () => persistStep(step).catch(err => {
       output.debug(`aiTrace: Error saving step: ${err.message}`)
-    })
-    recorder.add(`wait aiTrace step persistence: ${step.toString()}`, () => stepPersistPromise, true)
+    }), true)
   })
 
-  event.dispatcher.on(event.step.failed, async step => {
+  event.dispatcher.on(event.step.failed, step => {
     if (!currentTest) return
     if (step.status === 'queued' && testFailed) {
       output.debug(`aiTrace: Skipping queued failed step "${step.toString()}" - testFailed: ${testFailed}`)
@@ -188,11 +189,9 @@ export default function (config = {}) {
       }
       existingStep.status = 'failed'
 
-      try {
-        await captureArtifactsForStep(step, existingStep, existingStep.prefix)
-      } catch (err) {
+      pendingArtifactCapture = captureArtifactsForStep(step, existingStep, existingStep.prefix).catch(err => {
         output.debug(`aiTrace: Error updating failed step: ${err.message}`)
-      }
+      })
     } else {
       if (stepNum === -1) return
       if (isStepIgnored(step)) return
@@ -218,11 +217,9 @@ export default function (config = {}) {
       steps.push(stepData)
       firstFailedStepSaved = true
 
-      try {
-        await captureArtifactsForStep(step, stepData, stepPrefix)
-      } catch (err) {
+      pendingArtifactCapture = captureArtifactsForStep(step, stepData, stepPrefix).catch(err => {
         output.debug(`aiTrace: Error capturing failed step artifacts: ${err.message}`)
-      }
+      })
     }
   })
 
@@ -238,7 +235,13 @@ export default function (config = {}) {
     if (hookName === 'BeforeSuite' || hookName === 'AfterSuite') {
       return
     }
-    persist(test, 'failed')
+    recorder.add('aiTrace:persist failed', async () => {
+      if (pendingArtifactCapture) {
+        await pendingArtifactCapture
+        pendingArtifactCapture = null
+      }
+      persist(test, 'failed')
+    }, true)
   })
 
   async function persistStep(step) {

package/lib/plugin/analyze.js

@@ -12,6 +12,7 @@ const ai = aiModule.default || aiModule
 import colors from 'chalk'
 import ora from 'ora'
 import event from '../event.js'
+import recorder from '../recorder.js'
 
 import output from '../output.js'
 
@@ -227,14 +228,14 @@ export default function (config = {}) {
     console.log('Enabled AI analysis')
   })
 
-  event.dispatcher.on(event.all.result, async result => {
+  event.dispatcher.on(event.all.result, result => {
     if (!isMainThread) return // run only on main thread
     if (!ai.isEnabled) {
       console.log('AI is disabled, no analysis will be performed. Run tests with --ai flag to enable it.')
       return
     }
 
-    printReport(result)
+    recorder.add('analyze:print-ai-report', () => printReport(result), true)
   })
 
   event.dispatcher.on(event.workers.result, async result => {
@@ -248,7 +249,7 @@ export default function (config = {}) {
       return
     }
 
-    printReport(result)
+    await printReport(result)
   })
 
   async function printReport(result) {
@@ -294,7 +295,7 @@ export default function (config = {}) {
       console.error('Error analyzing failed tests', err)
     }
 
-    if (!Object.keys(container.plugins()).includes('pageInfo')) {
+    if (!Object.keys(Container.plugins()).includes('pageInfo')) {
       console.log('To improve analysis, enable pageInfo plugin to get more context for failed tests.')
     }
   }

package/lib/plugin/heal.js

@@ -80,6 +80,7 @@ export default function (config = {}) {
   event.dispatcher.on(event.test.before, test => {
     currentTest = test
     healedSteps = 0
+    healTries = 0
     caughtError = null
   })
 
@@ -94,7 +95,9 @@ export default function (config = {}) {
     if (trigger.on === 'file' && !matchStepFile(step, trigger.path, trigger.line)) return
 
     recorder.catchWithoutStop(async err => {
+      if (healTries >= config.healLimit) throw err
       isHealing = true
+      healTries++
       if (caughtError === err) throw err // avoid double handling
       caughtError = err
 
@@ -121,8 +124,6 @@ export default function (config = {}) {
 
       await heal.healStep(step, err, { test })
 
-      healTries++
-
       recorder.add('close healing session', () => {
         recorder.reset()
         recorder.session.restore('heal')

package/lib/plugin/junitReporter.js

@@ -0,0 +1,303 @@
+import fs from 'fs'
+import path from 'path'
+import os from 'os'
+import { mkdirp } from 'mkdirp'
+import { DOMImplementation, XMLSerializer } from '@xmldom/xmldom'
+
+import event from '../event.js'
+import store from '../store.js'
+import output from '../output.js'
+
+const defaultConfig = {
+  outputName: 'report.xml',
+  output: null,
+  testGroupName: 'CodeceptJS',
+  attachSteps: true,
+  attachMeta: true,
+  stepsInFailure: true,
+}
+
+const INVALID_XML_CHARS = new RegExp('[\\u0000-\\u0008\\u000B\\u000C\\u000E-\\u001F\\uFFFE\\uFFFF]', 'g')
+
+/**
+ *
+ * Generates a JUnit-compatible XML report after a test run.
+ *
+ * Unlike Mocha's `mocha-junit-reporter`, this plugin understands CodeceptJS steps and substeps.
+ * For every `<testcase>` it includes:
+ *
+ * * `<properties>` — the test's meta information: every `meta` key from `Scenario('...', { meta })`, plus its `tags` and `retries`
+ * * `<system-out>` — an indented step/substep log (substeps are nested under their meta step); only failed steps are marked
+ * * `<failure>` — for failed tests: the error message, type, stack trace and (optionally) the step trace
+ *
+ * The produced file is consumable by Jenkins, GitLab CI, CircleCI, GitHub Actions test reporters, etc.
+ *
+ * #### Configuration
+ *
+ * ```js
+ * "plugins": {
+ *    "junitReporter": {
+ *      "enabled": true
+ *    }
+ *  }
+ * ```
+ *
+ * Possible config options:
+ *
+ * * `outputName`: file name for the report. Default: `report.xml`.
+ * * `output`: directory where the report is stored, relative to the project root. Default: the `output` directory.
+ * * `testGroupName`: value of the `name` attribute on the root `<testsuites>` element. Default: `CodeceptJS`.
+ * * `attachMeta`: add the test's meta information (`meta` keys, `tags`, `retries`) as `<properties>`. Default: true.
+ * * `attachSteps`: add the step/substep log as `<system-out>`. Default: true.
+ * * `stepsInFailure`: append the step trace to the `<failure>` body. Default: true.
+ *
+ * CLI examples:
+ *
+ * ```
+ * npx codeceptjs run -p junitReporter
+ * npx codeceptjs run -p junitReporter:outputName=junit.xml
+ * ```
+ *
+ * > ℹ When running with `run-workers`, steps are serialized between processes and substep nesting is flattened.
+ *
+ * @param {*} config
+ */
+export default function (config = {}) {
+  config = Object.assign({}, defaultConfig, config)
+
+  let written = false
+
+  const writeReport = result => {
+    if (written) return
+    if (!result || !Array.isArray(result.tests)) return
+    written = true
+
+    const dir = config.output ? path.resolve(store.codeceptDir || process.cwd(), config.output) : store.outputDir || process.cwd()
+    mkdirp.sync(dir)
+    const file = path.join(dir, config.outputName)
+
+    fs.writeFileSync(file, buildXml(result, config))
+    output.plugin('junitReporter', `JUnit report saved to ${file}`)
+  }
+
+  event.dispatcher.on(event.all.result, writeReport)
+  event.dispatcher.on(event.workers.result, writeReport)
+}
+
+function buildXml(result, config) {
+  const doc = new DOMImplementation().createDocument(null, null, null)
+  const suites = groupBySuite(result.tests)
+
+  const root = doc.createElement('testsuites')
+  setAttr(root, 'name', config.testGroupName)
+  setAttr(root, 'tests', result.tests.length)
+  setAttr(root, 'failures', countState(result.tests, 'failed'))
+  setAttr(root, 'skipped', countSkipped(result.tests))
+  setAttr(root, 'errors', 0)
+  setAttr(root, 'time', toSeconds(sumDuration(result.tests)))
+  setAttr(root, 'timestamp', toIso(result.stats && result.stats.start))
+  doc.appendChild(root)
+
+  suites.forEach((tests, index) => {
+    const suite = tests[0] && tests[0].parent
+    const suiteName = (suite && suite.title) || 'Tests'
+    const suiteFile = (suite && suite.file) || (tests[0] && tests[0].file) || ''
+
+    const suiteEl = doc.createElement('testsuite')
+    setAttr(suiteEl, 'name', suiteName)
+    setAttr(suiteEl, 'id', index)
+    setAttr(suiteEl, 'tests', tests.length)
+    setAttr(suiteEl, 'failures', countState(tests, 'failed'))
+    setAttr(suiteEl, 'skipped', countSkipped(tests))
+    setAttr(suiteEl, 'errors', 0)
+    setAttr(suiteEl, 'time', toSeconds(sumDuration(tests)))
+    setAttr(suiteEl, 'timestamp', toIso(suite && suite.startedAt))
+    setAttr(suiteEl, 'hostname', os.hostname())
+    if (suiteFile) setAttr(suiteEl, 'file', suiteFile)
+    root.appendChild(suiteEl)
+
+    for (const test of tests) {
+      suiteEl.appendChild(buildTestCase(doc, test, suiteName, config))
+    }
+  })
+
+  return '<?xml version="1.0" encoding="UTF-8"?>\n' + new XMLSerializer().serializeToString(doc) + '\n'
+}
+
+function buildTestCase(doc, test, suiteName, config) {
+  const testEl = doc.createElement('testcase')
+  setAttr(testEl, 'name', test.title || '(no title)')
+  setAttr(testEl, 'classname', suiteName)
+  setAttr(testEl, 'time', toSeconds(test.duration || 0))
+  const file = test.file || (test.parent && test.parent.file)
+  if (file) setAttr(testEl, 'file', file)
+
+  if (config.attachMeta) {
+    const properties = metaProperties(test)
+    if (properties.length) {
+      const propertiesEl = doc.createElement('properties')
+      for (const [name, value] of properties) {
+        const prop = doc.createElement('property')
+        setAttr(prop, 'name', name)
+        setAttr(prop, 'value', value)
+        propertiesEl.appendChild(prop)
+      }
+      testEl.appendChild(propertiesEl)
+    }
+  }
+
+  const flat = flattenSteps(Array.isArray(test.steps) ? test.steps : [])
+
+  if (test.state === 'skipped' || test.state === 'pending') {
+    const skipped = doc.createElement('skipped')
+    const reason = skipReason(test)
+    if (reason) setAttr(skipped, 'message', reason)
+    testEl.appendChild(skipped)
+  } else if (test.state === 'failed') {
+    const err = test.err || {}
+    const failure = doc.createElement('failure')
+    setAttr(failure, 'message', err.message || 'Test failed')
+    setAttr(failure, 'type', err.name || 'Error')
+    let body = err.stack || err.message || 'Test failed'
+    if (config.stepsInFailure && flat.length) {
+      body += '\n\nSteps:\n' + flat.map(stepLogLine).join('\n')
+    }
+    failure.appendChild(doc.createTextNode(cleanText(body)))
+    testEl.appendChild(failure)
+  }
+
+  if (config.attachSteps && flat.length) {
+    const out = doc.createElement('system-out')
+    out.appendChild(doc.createTextNode(cleanText(flat.map(stepLogLine).join('\n'))))
+    testEl.appendChild(out)
+  }
+
+  return testEl
+}
+
+function metaProperties(test) {
+  const props = []
+  const meta = test.meta || {}
+  for (const key of Object.keys(meta)) {
+    if (meta[key] === undefined || meta[key] === null) continue
+    props.push([key, stringifyMeta(meta[key])])
+  }
+  if (Array.isArray(test.tags) && test.tags.length) {
+    props.push(['tags', test.tags.join(' ')])
+  }
+  if (test.retries > 0 || test.retryNum > 0) {
+    props.push(['retries', String(test.retryNum || test.retries)])
+  }
+  return props
+}
+
+function stringifyMeta(value) {
+  if (typeof value === 'string') return value
+  if (typeof value === 'number' || typeof value === 'boolean') return String(value)
+  try {
+    return JSON.stringify(value)
+  } catch (err) {
+    return String(value)
+  }
+}
+
+function flattenSteps(steps) {
+  const out = []
+  let prevChain = []
+
+  for (const step of steps) {
+    const chain = metaChain(step)
+
+    let common = 0
+    while (common < chain.length && common < prevChain.length && chain[common].key === prevChain[common].key) common++
+
+    for (let d = common; d < chain.length; d++) {
+      out.push({ depth: d, step: chain[d].step })
+    }
+    out.push({ depth: chain.length, step })
+    prevChain = chain
+  }
+
+  return out
+}
+
+function metaChain(step) {
+  const chain = []
+  let meta = step && step.metaStep
+  while (meta) {
+    chain.unshift({ step: meta, key: meta })
+    meta = meta.metaStep
+  }
+  if (!chain.length && step && step.parent && step.parent.title) {
+    chain.push({ step: { title: step.parent.title, status: step.status }, key: `meta:${step.parent.title}` })
+  }
+  return chain
+}
+
+function stepLogLine(entry) {
+  const indent = '  '.repeat(entry.depth)
+  const mark = entry.step && entry.step.status === 'failed' ? '[FAILED] ' : ''
+  return `${indent}${mark}${stepText(entry.step)} (${stepDuration(entry.step)}ms)`
+}
+
+function stepText(step) {
+  if (step && typeof step.toString === 'function' && step.toString !== Object.prototype.toString) return step.toString()
+  return (step && (step.title || step.name)) || 'step'
+}
+
+function stepDuration(step) {
+  if (!step) return 0
+  if (typeof step.duration === 'number' && step.duration >= 0) return step.duration
+  if (step.startTime && step.endTime) return Math.max(0, step.endTime - step.startTime)
+  return 0
+}
+
+function groupBySuite(tests) {
+  const groups = []
+  const byKey = new Map()
+  for (const test of tests) {
+    const key = test.parent || test
+    if (!byKey.has(key)) {
+      const list = []
+      byKey.set(key, list)
+      groups.push(list)
+    }
+    byKey.get(key).push(test)
+  }
+  return groups
+}
+
+function skipReason(test) {
+  if (test.opts && test.opts.skipInfo && test.opts.skipInfo.message) return test.opts.skipInfo.message
+  if (test.meta && test.meta.skipReason) return test.meta.skipReason
+  return ''
+}
+
+function countState(tests, state) {
+  return tests.filter(t => t.state === state).length
+}
+
+function countSkipped(tests) {
+  return tests.filter(t => t.state === 'skipped' || t.state === 'pending').length
+}
+
+function sumDuration(tests) {
+  return tests.reduce((sum, t) => sum + (t.duration || 0), 0)
+}
+
+function toSeconds(ms) {
+  return (Math.max(0, ms) / 1000).toFixed(3)
+}
+
+function toIso(value) {
+  const date = value ? new Date(value) : new Date()
+  return Number.isNaN(date.getTime()) ? new Date().toISOString() : date.toISOString()
+}
+
+function cleanText(text) {
+  return String(text == null ? '' : text).replace(INVALID_XML_CHARS, '')
+}
+
+function setAttr(el, name, value) {
+  el.setAttribute(name, cleanText(value))
+}

package/lib/plugin/pageInfo.js

@@ -40,10 +40,10 @@ const defaultConfig = {
 export default function (config = {}) {
   config = Object.assign(defaultConfig, config)
 
-  const helper = pickActingHelper(Container.helpers())
-  if (!helper) return
-
   event.dispatcher.on(event.test.failed, test => {
+    const helper = pickActingHelper(Container.helpers())
+    if (!helper) return
+
     const pageState = {}
 
     recorder.add('pageInfo capture', async () => {
@@ -60,8 +60,6 @@ export default function (config = {}) {
         if (captured.html) {
           const htmlPath = path.join(store.outputDir, captured.html)
           pageState.htmlSnapshot = htmlPath
-          // Scan raw HTML (pre-cleanHtml) so error classes containing digits
-          // or trash-class prefixes aren't stripped before detection.
           const htmlForScan = captured.htmlRaw || (() => {
             try { return fs.readFileSync(htmlPath, 'utf8') } catch { return '' }
           })()
@@ -90,7 +88,7 @@ export default function (config = {}) {
           } catch {}
         }
       } catch {}
-    })
+    }, true)
 
     recorder.add('Save page info', () => {
       test.addNote('pageInfo', pageStateToMarkdown(pageState))
@@ -99,7 +97,7 @@ export default function (config = {}) {
       fs.writeFileSync(pageStateFileName, pageStateToMarkdown(pageState))
       test.artifacts.pageInfo = pageStateFileName
       return pageState
-    })
+    }, true)
   })
 }
 

package/lib/plugin/retryFailedStep.js

@@ -1,7 +1,10 @@
+import debugModule from 'debug'
 import event from '../event.js'
 import recorder from '../recorder.js'
 import store from '../store.js'
 
+const debug = debugModule('codeceptjs:retryFailedStep')
+
 const defaultConfig = {
   retries: 3,
   defaultIgnoredSteps: ['amOnPage', 'wait*', 'send*', 'execute*', 'run*', 'have*'],
@@ -147,9 +150,7 @@ export default function (config) {
     test.opts.conditionalRetries = config.retries
     test.opts.stepRetryPriority = stepRetryPriority
 
-    if (process.env.DEBUG_RETRY_PLUGIN) {
-      console.log('[retryFailedStep] applying retries =', config.retries, 'for test', test.title)
-    }
+    debug('applying retries = %d for test %s', config.retries, test.title)
     recorder.retry(config)
   })
 

package/lib/plugin/screencast.js

@@ -106,6 +106,12 @@ function wireScreencast(mode, options) {
     state.startedAt = options.subtitles ? Date.now() : null
   })
 
+  event.dispatcher.on(event.test.started, test => {
+    if (!options.video || state.startQueued) return
+    state.startQueued = true
+    recorder.add('screencast:start', async () => startScreencast(state.test, options, state), true)
+  })
+
   event.dispatcher.on(event.step.started, step => {
     if (state.steps) {
       const at = Date.now()
@@ -116,10 +122,6 @@ function wireScreencast(mode, options) {
         title: stepTitle(step),
       }
     }
-    if (!options.video || state.startQueued || !state.test) return
-    state.startQueued = true
-    const test = state.test
-    recorder.add('screencast:start', async () => startScreencast(test, options, state), true)
   })
 
   if (options.subtitles) {

package/lib/workers.js

@@ -547,10 +547,11 @@ class Workers extends EventEmitter {
     if (this.isPoolMode) {
       this.activeWorkers.set(worker, { available: true, workerIndex: null })
     }
-    
+
     // Track last activity time to detect hanging workers
     let lastActivity = Date.now()
     let currentTest = null
+    let autoTerminated = false
     const workerTimeout = process.env.CODECEPT_WORKER_TIMEOUT ? ms(process.env.CODECEPT_WORKER_TIMEOUT) : ms('5m')
     
     const timeoutChecker = setInterval(() => {
@@ -611,6 +612,13 @@ class Workers extends EventEmitter {
             })
           }
 
+          const exitTimeout = parseInt(process.env.CODECEPT_AUTO_EXIT_TIMEOUT, 10)
+          if (exitTimeout === 0) break
+          setTimeout(() => {
+            autoTerminated = true
+            worker.terminate()
+          }, exitTimeout || 2000)
+
           break
         case event.suite.before:
           {
@@ -741,8 +749,8 @@ class Workers extends EventEmitter {
     worker.on('exit', (code) => {
       clearInterval(timeoutChecker)
       this.closedWorkers += 1
-      
-      if (code !== 0) {
+
+      if (code !== 0 && !autoTerminated) {
         console.error(`[Main] Worker exited with code ${code}`)
         if (currentTest) {
           console.error(`[Main] Last test running: ${currentTest}`)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeceptjs",
-  "version": "4.0.0-rc.20",
+  "version": "4.0.0-rc.22",
   "type": "module",
   "description": "Supercharged End 2 End Testing Framework for NodeJS",
   "keywords": [