codeceptjs 4.0.0-beta.4 → 4.0.0-beta.6.esm-aria

package/lib/plugin/autoDelay.js

@@ -1,9 +1,13 @@
-const Container = require('../container')
-const store = require('../store')
-const recorder = require('../recorder')
-const event = require('../event')
-const log = require('../output').log
-const supportedHelpers = require('./standardActingHelpers').slice()
+import Container from '../container.js'
+
+import store from '../store.js'
+
+import recorder from '../recorder.js'
+
+import event from '../event.js'
+
+import output from '../output.js'
+const standardActingHelpers = Container.STANDARD_ACTING_HELPERS
 
 const methodsToDelay = ['click', 'fillField', 'checkOption', 'pressKey', 'doubleClick', 'rightClick']
 
@@ -51,14 +55,14 @@ const defaultConfig = {
  * * `delayAfter`: put a delay after a command. 200ms by default
  *
  */
-module.exports = function (config) {
-  supportedHelpers.push('REST')
+export default function (config) {
+  const affectedHelpers = [...standardActingHelpers, 'REST']
   const helpers = Container.helpers()
   let helper
 
   config = Object.assign(defaultConfig, config)
 
-  for (const helperName of supportedHelpers) {
+  for (const helperName of affectedHelpers) {
     if (Object.keys(helpers).indexOf(helperName) > -1) {
       helper = helpers[helperName]
     }
@@ -66,25 +70,25 @@ module.exports = function (config) {
 
   if (!helper) return // no helpers for auto-delay
 
-  event.dispatcher.on(event.step.before, (step) => {
+  event.dispatcher.on(event.step.before, step => {
     if (config.methods.indexOf(step.helperMethod) < 0) return // skip non-actions
 
     recorder.add('auto-delay', async () => {
       if (store.debugMode) return // no need to delay in debug
-      log(`Delaying for ${config.delayBefore}ms`)
-      return new Promise((resolve) => {
+      output.log(`Delaying for ${config.delayBefore}ms`)
+      return new Promise(resolve => {
         setTimeout(resolve, config.delayBefore)
       })
     })
   })
 
-  event.dispatcher.on(event.step.after, (step) => {
+  event.dispatcher.on(event.step.after, step => {
     if (config.methods.indexOf(step.helperMethod) < 0) return // skip non-actions
 
     recorder.add('auto-delay', async () => {
       if (store.debugMode) return // no need to delay in debug
-      log(`Delaying for ${config.delayAfter}ms`)
-      return new Promise((resolve) => {
+      output.log(`Delaying for ${config.delayAfter}ms`)
+      return new Promise(resolve => {
         setTimeout(resolve, config.delayAfter)
       })
     })

package/lib/plugin/coverage.js

@@ -1,10 +1,14 @@
-const debugModule = require('debug')
-const { CoverageReport } = require('monocart-coverage-reports')
-const Container = require('../container')
-const recorder = require('../recorder')
-const event = require('../event')
-const output = require('../output')
-const { deepMerge } = require('../utils')
+import debugModule from 'debug'
+import { CoverageReport } from 'monocart-coverage-reports'
+import Container from '../container.js'
+
+import recorder from '../recorder.js'
+
+import event from '../event.js'
+
+import output from '../output.js'
+
+import { deepMerge } from '../utils.js'
 
 const defaultConfig = {
   name: 'CodeceptJS Coverage Report',
@@ -15,7 +19,7 @@ const supportedHelpers = ['Puppeteer', 'Playwright', 'WebDriver']
 
 const v8CoverageHelpers = {
   Playwright: {
-    startCoverage: async (page) => {
+    startCoverage: async page => {
       await Promise.all([
         page.coverage.startJSCoverage({
           resetOnNavigation: false,
@@ -26,16 +30,13 @@ const v8CoverageHelpers = {
       ])
     },
     takeCoverage: async (page, coverageReport) => {
-      const [jsCoverage, cssCoverage] = await Promise.all([
-        page.coverage.stopJSCoverage(),
-        page.coverage.stopCSSCoverage(),
-      ])
+      const [jsCoverage, cssCoverage] = await Promise.all([page.coverage.stopJSCoverage(), page.coverage.stopCSSCoverage()])
       const coverageList = [...jsCoverage, ...cssCoverage]
       await coverageReport.add(coverageList)
     },
   },
   Puppeteer: {
-    startCoverage: async (page) => {
+    startCoverage: async page => {
       await Promise.all([
         page.coverage.startJSCoverage({
           resetOnNavigation: false,
@@ -47,13 +48,10 @@ const v8CoverageHelpers = {
       ])
     },
     takeCoverage: async (page, coverageReport) => {
-      const [jsCoverage, cssCoverage] = await Promise.all([
-        page.coverage.stopJSCoverage(),
-        page.coverage.stopCSSCoverage(),
-      ])
+      const [jsCoverage, cssCoverage] = await Promise.all([page.coverage.stopJSCoverage(), page.coverage.stopCSSCoverage()])
       // to raw V8 script coverage
       const coverageList = [
-        ...jsCoverage.map((it) => {
+        ...jsCoverage.map(it => {
           return {
             source: it.text,
             ...it.rawScriptCoverage,
@@ -65,7 +63,7 @@ const v8CoverageHelpers = {
     },
   },
   WebDriver: {
-    startCoverage: async (page) => {
+    startCoverage: async page => {
       await Promise.all([
         page.coverage.startJSCoverage({
           resetOnNavigation: false,
@@ -77,13 +75,10 @@ const v8CoverageHelpers = {
       ])
     },
     takeCoverage: async (page, coverageReport) => {
-      const [jsCoverage, cssCoverage] = await Promise.all([
-        page.coverage.stopJSCoverage(),
-        page.coverage.stopCSSCoverage(),
-      ])
+      const [jsCoverage, cssCoverage] = await Promise.all([page.coverage.stopJSCoverage(), page.coverage.stopCSSCoverage()])
       // to raw V8 script coverage
       const coverageList = [
-        ...jsCoverage.map((it) => {
+        ...jsCoverage.map(it => {
           return {
             source: it.text,
             ...it.rawScriptCoverage,
@@ -122,7 +117,7 @@ const v8CoverageHelpers = {
  * * `sourcePath`: option to resolve a custom path.
  *
  */
-module.exports = function (config) {
+export default function (config) {
   config = deepMerge(defaultConfig, config)
 
   if (config.debug) config.logging = 'debug'
@@ -131,7 +126,7 @@ module.exports = function (config) {
   let coverageRunning = false
 
   const v8Names = Object.keys(v8CoverageHelpers)
-  const helperName = Object.keys(helpers).find((it) => v8Names.includes(it))
+  const helperName = Object.keys(helpers).find(it => v8Names.includes(it))
   if (!helperName) {
     console.error(`Coverage is only supported in ${supportedHelpers.join(' or ')}`)
     // no helpers for screenshot
@@ -180,7 +175,7 @@ module.exports = function (config) {
   })
 
   // Save coverage data after every test run
-  event.dispatcher.on(event.test.after, (test) => {
+  event.dispatcher.on(event.test.after, test => {
     recorder.add(
       'take coverage',
       async () => {

package/lib/plugin/customLocator.js

@@ -1,5 +1,5 @@
-const Locator = require('../locator')
-const { xpathLocator } = require('../utils')
+import Locator from '../locator.js'
+import { xpathLocator } from '../utils.js'
 
 const defaultConfig = {
   prefix: '$',
@@ -111,7 +111,7 @@ const defaultConfig = {
  * I.click('=sign-up'); // matches => [data-qa=sign-up],[data-test=sign-up]
  * ```
  */
-module.exports = (config) => {
+export default function (config) {
   config = { ...defaultConfig, ...config }
 
   Locator.addFilter((value, locatorObj) => {
@@ -125,7 +125,7 @@ module.exports = (config) => {
     if (config.strategy.toLowerCase() === 'xpath') {
       locatorObj.value = `.//*[${[]
         .concat(config.attribute)
-        .map((attr) => `@${attr}=${xpathLocator.literal(val)}`)
+        .map(attr => `@${attr}=${xpathLocator.literal(val)}`)
         .join(' or ')}]`
       locatorObj.type = 'xpath'
     }
@@ -133,7 +133,7 @@ module.exports = (config) => {
     if (config.strategy.toLowerCase() === 'css') {
       locatorObj.value = []
         .concat(config.attribute)
-        .map((attr) => `[${attr}=${val}]`)
+        .map(attr => `[${attr}=${val}]`)
         .join(',')
       locatorObj.type = 'css'
     }

package/lib/plugin/customReporter.js

@@ -0,0 +1,53 @@
+import event from '../event.js'
+
+
+/**
+ * Sample custom reporter for CodeceptJS.
+ */
+export default function (config) {
+  event.dispatcher.on(event.hook.finished, hook => {
+    if (config.onHookFinished) {
+      config.onHookFinished(hook)
+    }
+  })
+
+  event.dispatcher.on(event.test.before, test => {
+    if (config.onTestBefore) {
+      config.onTestBefore(test)
+    }
+  })
+
+  event.dispatcher.on(event.test.failed, (test, err) => {
+    if (config.onTestFailed) {
+      config.onTestFailed(test, err)
+    }
+  })
+
+  event.dispatcher.on(event.test.passed, test => {
+    if (config.onTestPassed) {
+      config.onTestPassed(test)
+    }
+  })
+
+  event.dispatcher.on(event.test.skipped, test => {
+    if (config.onTestSkipped) {
+      config.onTestSkipped(test)
+    }
+  })
+
+  event.dispatcher.on(event.test.finished, test => {
+    if (config.onTestFinished) {
+      config.onTestFinished(test)
+    }
+  })
+
+  event.dispatcher.on(event.all.result, result => {
+    if (config.onResult) {
+      config.onResult(result)
+    }
+
+    if (config.save) {
+      result.save()
+    }
+  })
+}

package/lib/plugin/heal.js

@@ -1,10 +1,16 @@
-const debug = require('debug')('codeceptjs:heal')
-const colors = require('chalk')
-const recorder = require('../recorder')
-const event = require('../event')
-const output = require('../output')
-const heal = require('../heal')
-const store = require('../store')
+import debugFactory from 'debug'
+const debug = debugFactory('codeceptjs:heal')
+import colors from 'chalk'
+import recorder from '../recorder.js'
+
+import event from '../event.js'
+
+import output from '../output.js'
+
+import healModule from '../heal.js'
+const heal = healModule.default || healModule
+import store from '../store.js'
+
 
 const defaultConfig = {
   healLimit: 2,
@@ -28,13 +34,10 @@ const defaultConfig = {
  * * `healLimit` - how many steps can be healed in a single test (default: 2)
  *
  */
-module.exports = function (config = {}) {
+export default function (config = {}) {
   if (store.debugMode && !process.env.DEBUG) {
     event.dispatcher.on(event.test.failed, () => {
-      output.plugin(
-        'heal',
-        'Healing is disabled in --debug mode, use DEBUG="codeceptjs:heal" to enable it in debug mode',
-      )
+      output.plugin('heal', 'Healing is disabled in --debug mode, use DEBUG="codeceptjs:heal" to enable it in debug mode')
     })
     return
   }
@@ -48,21 +51,21 @@ module.exports = function (config = {}) {
 
   config = Object.assign(defaultConfig, config)
 
-  event.dispatcher.on(event.test.before, (test) => {
+  event.dispatcher.on(event.test.before, test => {
     currentTest = test
     healedSteps = 0
     caughtError = null
   })
 
-  event.dispatcher.on(event.step.started, (step) => (currentStep = step))
+  event.dispatcher.on(event.step.started, step => (currentStep = step))
 
-  event.dispatcher.on(event.step.after, (step) => {
+  event.dispatcher.on(event.step.after, step => {
     if (isHealing) return
     if (healTries >= config.healLimit) return // out of limit
 
     if (!heal.hasCorrespondingRecipes(step)) return
 
-    recorder.catchWithoutStop(async (err) => {
+    recorder.catchWithoutStop(async err => {
       isHealing = true
       if (caughtError === err) throw err // avoid double handling
       caughtError = err
@@ -99,7 +102,7 @@ module.exports = function (config = {}) {
 
     print(`${colors.bold(heal.fixes.length)} ${heal.fixes.length === 1 ? 'step was' : 'steps were'} healed`)
 
-    const suggestions = heal.fixes.filter((fix) => fix.recipe && heal.recipes[fix.recipe].suggest)
+    const suggestions = heal.fixes.filter(fix => fix.recipe && heal.recipes[fix.recipe].suggest)
 
     if (!suggestions.length) return
 
@@ -118,4 +121,33 @@ module.exports = function (config = {}) {
       i++
     }
   })
+
+  event.dispatcher.on(event.workers.result, result => {
+    const { print } = output
+
+    const healedTests = Object.values(result.tests)
+      .flat()
+      .filter(test => test.notes.some(note => note.type === 'heal'))
+    if (!healedTests.length) return
+
+    setTimeout(() => {
+      print('')
+      print('===================')
+      print(colors.bold.green('Self-Healing Report:'))
+
+      print('')
+      print('Suggested changes:')
+      print('')
+
+      healedTests.forEach(test => {
+        print(`${colors.bold.magenta(test.title)}`)
+        test.notes
+          .filter(note => note.type === 'heal')
+          .forEach(note => {
+            print(note.text)
+            print('')
+          })
+      })
+    }, 0)
+  })
 }

package/lib/plugin/pageInfo.js

@@ -0,0 +1,140 @@
+import path from 'path'
+import fs from 'fs'
+import Container from '../container.js'
+const supportedHelpers = Container.STANDARD_ACTING_HELPERS
+import recorder from '../recorder.js'
+import event from '../event.js'
+import { scanForErrorMessages } from '../html.js'
+import { output } from '../index.js'
+import { humanizeString, ucfirst } from '../utils.js'
+import { testToFileName } from '../mocha/test.js'
+const defaultConfig = {
+  errorClasses: ['error', 'warning', 'alert', 'danger'],
+  browserLogs: ['error'],
+}
+
+/**
+ * Collects information from web page after each failed test and adds it to the test as an artifact.
+ * It is suggested to enable this plugin if you run tests on CI and you need to debug failed tests.
+ * This plugin can be paired with `analyze` plugin to provide more context.
+ *
+ * It collects URL, HTML errors (by classes), and browser logs.
+ *
+ * Enable this plugin in config:
+ *
+ * ```js
+ * plugins: {
+ *  pageInfo: {
+ *   enabled: true,
+ * }
+ * ```
+ *
+ * Additional config options:
+ *
+ * * `errorClasses` - list of classes to search for errors (default: `['error', 'warning', 'alert', 'danger']`)
+ * * `browserLogs` - list of types of errors to search for in browser logs (default: `['error']`)
+ *
+ */
+export default function (config = {}) {
+  const helpers = Container.helpers()
+  let helper
+
+  config = Object.assign(defaultConfig, config)
+
+  for (const helperName of supportedHelpers) {
+    if (Object.keys(helpers).indexOf(helperName) > -1) {
+      helper = helpers[helperName]
+    }
+  }
+
+  if (!helper) return // no helpers for screenshot
+
+  event.dispatcher.on(event.test.failed, test => {
+    const pageState = {}
+
+    recorder.add('URL of failed test', async () => {
+      try {
+        const url = await helper.grabCurrentUrl()
+        pageState.url = url
+      } catch (err) {
+        // not really needed
+      }
+    })
+    recorder.add('HTML snapshot failed test', async () => {
+      try {
+        const html = await helper.grabHTMLFrom('body')
+
+        if (!html) return
+
+        const errors = scanForErrorMessages(html, config.errorClasses)
+        if (errors.length) {
+          output.debug('Detected errors in HTML code')
+          errors.forEach(error => output.debug(error))
+          pageState.htmlErrors = errors
+        }
+      } catch (err) {
+        // not really needed
+      }
+    })
+
+    recorder.add('Browser logs for failed test', async () => {
+      try {
+        const logs = await helper.grabBrowserLogs()
+
+        if (!logs) return
+
+        pageState.browserErrors = getBrowserErrors(logs, config.browserLogs)
+      } catch (err) {
+        // not really needed
+      }
+    })
+
+    recorder.add('Save page info', () => {
+      test.addNote('pageInfo', pageStateToMarkdown(pageState))
+
+      const pageStateFileName = path.join(global.output_dir, `${testToFileName(test)}.pageInfo.md`)
+      fs.writeFileSync(pageStateFileName, pageStateToMarkdown(pageState))
+      test.artifacts.pageInfo = pageStateFileName
+      return pageState
+    })
+  })
+}
+
+function pageStateToMarkdown(pageState) {
+  let markdown = ''
+
+  for (const [key, value] of Object.entries(pageState)) {
+    if (!value) continue
+    let result = ''
+
+    if (Array.isArray(value)) {
+      result = value.map(v => `- ${JSON.stringify(v, null, 2)}`).join('\n')
+    } else if (typeof value === 'string') {
+      result = `${value}`
+    } else {
+      result = JSON.stringify(value, null, 2)
+    }
+
+    if (!result.trim()) continue
+
+    markdown += `### ${ucfirst(humanizeString(key))}\n\n`
+    markdown += result
+    markdown += '\n\n'
+  }
+
+  return markdown
+}
+
+function getBrowserErrors(logs, type = ['error']) {
+  // Playwright & WebDriver console messages
+  let errors = logs
+    .map(log => {
+      if (typeof log === 'string') return log
+      if (!log.type) return null
+      return { type: log.type(), text: log.text() }
+    })
+    .filter(l => l && (typeof l === 'string' || type.includes(l.type)))
+    .map(l => (typeof l === 'string' ? l : l.text))
+
+  return errors
+}

package/lib/plugin/pauseOnFail.js

@@ -1,5 +1,6 @@
-const event = require('../event')
-const pause = require('../pause')
+import event from '../event.js'
+
+import pause from '../pause.js'
 
 /**
  * Automatically launches [interactive pause](/basics/#pause) when a test fails.
@@ -21,7 +22,7 @@ const pause = require('../pause')
  * ```
  *
  */
-module.exports = () => {
+export default function() {
   let failed = false
 
   event.dispatcher.on(event.test.started, () => {

package/lib/plugin/retryFailedStep.js

@@ -1,7 +1,8 @@
-const event = require('../event')
-const recorder = require('../recorder')
-const container = require('../container')
-const { log } = require('../output')
+import event from '../event.js'
+
+import recorder from '../recorder.js'
+
+import store from '../store.js'
 
 const defaultConfig = {
   retries: 3,
@@ -70,34 +71,38 @@ const defaultConfig = {
  * Use scenario configuration to disable plugin for a test
  *
  * ```js
- * Scenario('scenario tite', () => {
+ * Scenario('scenario tite', { disableRetryFailedStep: true }, () => {
  *    // test goes here
- * }).config(test => test.disableRetryFailedStep = true)
+ * })
  * ```
  *
  */
-module.exports = (config) => {
+export default function (config) {
   config = Object.assign(defaultConfig, config)
   config.ignoredSteps = config.ignoredSteps.concat(config.defaultIgnoredSteps)
   const customWhen = config.when
 
   let enableRetry = false
 
-  const when = (err) => {
+  const when = err => {
     if (!enableRetry) return
-    const store = require('../store')
     if (store.debugMode) return false
+    if (!store.autoRetries) return false
+    // Don't retry terminal errors (e.g., frame detachment errors)
+    if (err && err.isTerminal) return false
+    // Don't retry navigation errors that are known to be terminal
+    if (err && err.message && (err.message.includes('ERR_ABORTED') || err.message.includes('frame was detached') || err.message.includes('Target page, context or browser has been closed'))) return false
     if (customWhen) return customWhen(err)
     return true
   }
   config.when = when
 
-  event.dispatcher.on(event.step.started, (step) => {
-    if (process.env.TRY_TO === 'true') {
-      log('Info: RetryFailedStep plugin is disabled inside tryTo block')
-      return
-    }
+  // Ensure retry options are available before any steps run
+  if (!recorder.retries.find(r => r === config)) {
+    recorder.retries.push(config)
+  }
 
+  event.dispatcher.on(event.step.started, step => {
     // if a step is ignored - return
     for (const ignored of config.ignoredSteps) {
       if (step.name === ignored) return
@@ -108,14 +113,50 @@ module.exports = (config) => {
     enableRetry = true // enable retry for a step
   })
 
-  event.dispatcher.on(event.step.finished, () => {
+  // Disable retry only after a successful step; keep it enabled for failure so retry logic can act
+  event.dispatcher.on(event.step.passed, () => {
     enableRetry = false
   })
 
-  event.dispatcher.on(event.test.before, (test) => {
-    if (test && test.disableRetryFailedStep) return // disable retry when a test is not active
-    // this env var is used to set the retries inside _before() block of helpers
-    process.env.FAILED_STEP_RETRIES = config.retries
+  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
+      return // disable retry when a test is not active
+    }
+
+    // Don't apply plugin retry logic if there are already manual retries configured
+    // Check if any retry configs exist that aren't from this plugin
+    const hasManualRetries = recorder.retries.some(retry => retry !== config)
+    if (hasManualRetries) {
+      store.autoRetries = false
+      return
+    }
+
+    // this option is used to set the retries inside _before() block of helpers
+    store.autoRetries = true
+    test.opts.conditionalRetries = config.retries
+    // debug: record applied retries value for tests
+    if (process.env.DEBUG_RETRY_PLUGIN) {
+      // eslint-disable-next-line no-console
+      console.log('[retryFailedStep] applying retries =', config.retries, 'for test', test.title)
+    }
     recorder.retry(config)
   })
+
+  // Fallback for environments where event.test.before wasn't emitted (runner scenarios)
+  event.dispatcher.on(event.test.started, test => {
+    if (test.opts?.disableRetryFailedStep || test.disableRetryFailedStep) return
+
+    // Don't apply plugin retry logic if there are already manual retries configured
+    // Check if any retry configs exist that aren't from this plugin
+    const hasManualRetries = recorder.retries.some(retry => retry !== config)
+    if (hasManualRetries) return
+
+    if (!store.autoRetries) {
+      store.autoRetries = true
+      test.opts.conditionalRetries = test.opts.conditionalRetries || config.retries
+    }
+  })
 }