codeceptjs 3.7.6-beta.4 → 4.0.0-beta.10.esm-aria

package/lib/plugin/pageInfo.js

@@ -1,13 +1,13 @@
-const path = require('path')
-const fs = require('fs')
-const Container = require('../container')
-const recorder = require('../recorder')
-const event = require('../event')
+import path from 'path'
+import fs from 'fs'
+import Container from '../container.js'
 const supportedHelpers = Container.STANDARD_ACTING_HELPERS
-const { scanForErrorMessages } = require('../html')
-const { output } = require('..')
-const { humanizeString, ucfirst } = require('../utils')
-const { testToFileName } = require('../mocha/test')
+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'],
@@ -35,7 +35,7 @@ const defaultConfig = {
  * * `browserLogs` - list of types of errors to search for in browser logs (default: `['error']`)
  *
  */
-module.exports = function (config = {}) {
+export default function (config = {}) {
   const helpers = Container.helpers()
   let helper
 

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,6 +1,9 @@
-const event = require('../event')
-const recorder = require('../recorder')
-const store = require('../store')
+import event from '../event.js'
+
+import recorder from '../recorder.js'
+
+import store from '../store.js'
+
 const defaultConfig = {
   retries: 3,
   defaultIgnoredSteps: ['amOnPage', 'wait*', 'send*', 'execute*', 'run*', 'have*'],
@@ -74,7 +77,7 @@ const defaultConfig = {
  * ```
  *
  */
-module.exports = config => {
+export default function (config) {
   config = Object.assign(defaultConfig, config)
   config.ignoredSteps = config.ignoredSteps.concat(config.defaultIgnoredSteps)
   const customWhen = config.when
@@ -85,11 +88,20 @@ module.exports = config => {
     if (!enableRetry) return
     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
 
+  // 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) {
@@ -101,20 +113,51 @@ 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 => {
     // pass disableRetryFailedStep is a preferred way to disable retries
     // test.disableRetryFailedStep is used for backward compatibility
+    if (!test.opts) test.opts = {}
     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
+    }
+  })
 }

package/lib/plugin/screenshotOnFail.js

@@ -1,13 +1,17 @@
-const fs = require('fs')
-const path = require('path')
+import fs from 'fs'
+import path from 'path'
 
-const Container = require('../container')
-const recorder = require('../recorder')
-const event = require('../event')
-const output = require('../output')
-const { fileExists } = require('../utils')
-const Codeceptjs = require('../index')
-const { testToFileName } = require('../mocha/test')
+import Container from '../container.js'
+
+import recorder from '../recorder.js'
+
+import event from '../event.js'
+
+import output from '../output.js'
+
+import { fileExists } from '../utils.js'
+import Codeceptjs from '../index.js'
+import { testToFileName } from '../mocha/test.js'
 
 const defaultConfig = {
   uniqueScreenshotNames: false,
@@ -43,7 +47,7 @@ const supportedHelpers = Container.STANDARD_ACTING_HELPERS
  *
  *
  */
-module.exports = function (config) {
+export default function (config) {
   const helpers = Container.helpers()
   let helper
 
@@ -86,11 +90,28 @@ module.exports = function (config) {
         let fileName
 
         if (options.uniqueScreenshotNames && test) {
-          fileName = `${testToFileName(test, { unique: true })}.failed.png`
+          fileName = `${testToFileName(test, { suffix: '', unique: true })}.failed.png`
         } else {
-          fileName = `${testToFileName(test)}.failed.png`
+          fileName = `${testToFileName(test, { suffix: '', unique: false })}.failed.png`
+        }
+        const quietMode = !('output_dir' in global) || !global.output_dir
+        if (!quietMode) {
+          output.plugin('screenshotOnFail', 'Test failed, try to save a screenshot')
+        }
+
+        // Re-check helpers at runtime in case they weren't ready during plugin init
+        const runtimeHelpers = Container.helpers()
+        let runtimeHelper = null
+        for (const helperName of supportedHelpers) {
+          if (Object.keys(runtimeHelpers).indexOf(helperName) > -1) {
+            runtimeHelper = runtimeHelpers[helperName]
+            break
+          }
+        }
+
+        if (runtimeHelper && typeof runtimeHelper.saveScreenshot === 'function') {
+          helper = runtimeHelper
         }
-        output.plugin('screenshotOnFail', 'Test failed, try to save a screenshot')
 
         try {
           if (options.reportDir) {
@@ -100,36 +121,53 @@ module.exports = function (config) {
               fs.mkdirSync(mochaReportDir)
             }
           }
-          await helper.saveScreenshot(fileName, options.fullPageScreenshots)
 
-          if (!test.artifacts) test.artifacts = {}
-          test.artifacts.screenshot = path.join(global.output_dir, fileName)
-          if (Container.mocha().options.reporterOptions['mocha-junit-reporter'] && Container.mocha().options.reporterOptions['mocha-junit-reporter'].options.attachments) {
-            test.attachments = [path.join(global.output_dir, fileName)]
+          // Check if browser/page is still available before attempting screenshot
+          if (helper.page && helper.page.isClosed && helper.page.isClosed()) {
+            throw new Error('Browser page has been closed')
           }
-
-          const allureReporter = Container.plugins('allure')
-          if (allureReporter) {
-            allureReporter.addAttachment('Main session - Last Seen Screenshot', fs.readFileSync(path.join(global.output_dir, fileName)), dataType)
-
-            if (helper.activeSessionName) {
-              const sessions = helper.sessionPages || helper.sessionWindows
-              for (const sessionName in sessions) {
-                const screenshotFileName = `${sessionName}_${fileName}`
-                test.artifacts[`${sessionName.replace(/ /g, '_')}_screenshot`] = path.join(global.output_dir, screenshotFileName)
-                allureReporter.addAttachment(`${sessionName} - Last Seen Screenshot`, fs.readFileSync(path.join(global.output_dir, screenshotFileName)), dataType)
-              }
-            }
+          if (helper.browser && helper.browser.isConnected && !helper.browser.isConnected()) {
+            throw new Error('Browser has been disconnected')
           }
 
-          const cucumberReporter = Container.plugins('cucumberJsonReporter')
-          if (cucumberReporter) {
-            cucumberReporter.addScreenshot(test.artifacts.screenshot)
+          // Add timeout wrapper to prevent hanging with shorter timeout for ESM
+          const screenshotPromise = helper.saveScreenshot(fileName, options.fullPageScreenshots)
+          const timeoutPromise = new Promise((_, reject) => {
+            setTimeout(() => reject(new Error('Screenshot timeout after 5 seconds')), 5000)
+          })
+
+          await Promise.race([screenshotPromise, timeoutPromise])
+
+          if (!test.artifacts) test.artifacts = {}
+          // Some unit tests may not define global.output_dir; avoid throwing when it is undefined
+          // Detect output directory safely (may not be initialized in narrow unit tests)
+          const baseOutputDir = 'output_dir' in global && typeof global.output_dir === 'string' && global.output_dir ? global.output_dir : null
+          if (baseOutputDir) {
+            test.artifacts.screenshot = path.join(baseOutputDir, fileName)
+            if (Container.mocha().options.reporterOptions['mocha-junit-reporter'] && Container.mocha().options.reporterOptions['mocha-junit-reporter'].options.attachments) {
+              test.attachments = [path.join(baseOutputDir, fileName)]
+            }
+          } else {
+            // Fallback: just store the file name to keep tests stable without triggering path errors
+            test.artifacts.screenshot = fileName
           }
         } catch (err) {
-          output.plugin(err)
-          if (err && err.type && err.type === 'RuntimeError' && err.message && (err.message.indexOf('was terminated due to') > -1 || err.message.indexOf('no such window: target window already closed') > -1)) {
-            output.log(`Can't make screenshot, ${err}`)
+          if (!quietMode) {
+            output.plugin('screenshotOnFail', `Failed to save screenshot: ${err.message}`)
+          }
+          // Enhanced error handling for browser closed scenarios
+          if (
+            err &&
+            ((err.message &&
+              (err.message.includes('Target page, context or browser has been closed') ||
+                err.message.includes('Browser page has been closed') ||
+                err.message.includes('Browser has been disconnected') ||
+                err.message.includes('was terminated due to') ||
+                err.message.includes('no such window: target window already closed') ||
+                err.message.includes('Screenshot timeout after'))) ||
+              (err.type && err.type === 'RuntimeError'))
+          ) {
+            output.log(`Can't make screenshot, ${err.message}`)
             helper.isRunning = false
           }
         }

package/lib/plugin/stepByStepReport.js

@@ -1,16 +1,16 @@
-const colors = require('chalk')
-const crypto = require('crypto')
-const figures = require('figures')
-const fs = require('fs')
-const mkdirp = require('mkdirp')
-const path = require('path')
-const cheerio = require('cheerio')
-
-const Container = require('../container')
-const recorder = require('../recorder')
-const event = require('../event')
-const output = require('../output')
-const { template, deleteDir } = require('../utils')
+import colors from 'chalk'
+import crypto from 'crypto'
+import figures from 'figures'
+import fs from 'fs'
+import { mkdirp } from 'mkdirp'
+import path from 'path'
+import cheerio from 'cheerio'
+
+import Container from '../container.js'
+import recorder from '../recorder.js'
+import event from '../event.js'
+import output from '../output.js'
+import { template, deleteDir } from '../utils.js'
 
 const supportedHelpers = Container.STANDARD_ACTING_HELPERS
 
@@ -63,7 +63,7 @@ const templates = {}
  * @param {*} config
  */
 
-module.exports = function (config) {
+export default function (config) {
   const helpers = Container.helpers()
   let helper
 

package/lib/plugin/stepTimeout.js

@@ -1,5 +1,6 @@
-const event = require('../event')
-const { TIMEOUT_ORDER } = require('../timeout')
+import event from '../event.js'
+
+import { TIMEOUT_ORDER } from '../timeout.js'
 
 const defaultConfig = {
   timeout: 150,
@@ -61,7 +62,7 @@ const defaultConfig = {
  * ```
  *
  */
-module.exports = config => {
+export default function(config) {
   config = Object.assign(defaultConfig, config)
   // below override rule makes sure customTimeoutSteps go first but then they override noTimeoutSteps in case of exact pattern match
   config.customTimeoutSteps = config.customTimeoutSteps.concat(config.noTimeoutSteps).concat(config.customTimeoutSteps)

package/lib/plugin/subtitles.js

@@ -1,7 +1,8 @@
-const { v4: uuidv4 } = require('uuid')
-const fsPromise = require('fs').promises
-const path = require('path')
-const event = require('../event')
+import { v4 as uuidv4 } from 'uuid'
+import fs from 'fs'
+const fsPromise = fs.promises
+import path from 'path'
+import event from '../event.js'
 
 // This will convert a given timestamp in milliseconds to
 // an SRT recognized timestamp, ie HH:mm:ss,SSS
@@ -28,7 +29,7 @@ let testStartedAt
  * }
  * ```
  */
-module.exports = function () {
+export default function () {
   event.dispatcher.on(event.test.before, _ => {
     testStartedAt = Date.now()
     steps = {}

package/lib/recorder.js

@@ -1,9 +1,10 @@
-const debug = require('debug')('codeceptjs:recorder')
-const promiseRetry = require('promise-retry')
-const chalk = require('chalk')
-const { printObjectProperties } = require('./utils')
-const { log } = require('./output')
-const { TimeoutError } = require('./timeout')
+import debugModule from 'debug'
+const debug = debugModule('codeceptjs:recorder')
+import promiseRetry from 'promise-retry'
+import chalk from 'chalk'
+import { printObjectProperties } from './utils.js'
+import output from './output.js'
+import { TimeoutError } from './timeout.js'
 const MAX_TASKS = 100
 
 let promise
@@ -29,7 +30,7 @@ const defaultRetryOptions = {
  * @alias recorder
  * @interface
  */
-module.exports = {
+export default {
   /**
    * @type {Array<Object<string, *>>}
    * @inner
@@ -92,7 +93,7 @@ module.exports = {
     sessionId = null
     sessionStack = [] // Clear the session stack
     asyncErr = null
-    log(`${currentQueue()} Starting recording promises`)
+    output.log(`${currentQueue()} Starting recording promises`)
     promise = Promise.resolve()
     oldPromises = []
     tasks = []
@@ -217,7 +218,7 @@ module.exports = {
 
       const retryRules = this.retries.slice().reverse()
       return promiseRetry(Object.assign(defaultRetryOptions, retryOpts), (retry, number) => {
-        if (number > 1) log(`${currentQueue()}Retrying... Attempt #${number}`)
+        if (number > 1) output.log(`${currentQueue()}Retrying... Attempt #${number}`)
         const [promise, timer] = getTimeoutPromise(timeout, taskName)
         return Promise.race([promise, Promise.resolve(res).then(fn)])
           .finally(() => clearTimeout(timer))
@@ -247,7 +248,9 @@ module.exports = {
     if (Number.isInteger(opts)) {
       opts = { retries: opts }
     }
-    return this.add(() => this.retries.push(opts))
+    // Push retry options immediately so first step can see them
+    this.retries.push(opts)
+    return Promise.resolve()
   },
 
   /**
@@ -262,8 +265,9 @@ module.exports = {
       .replace(/\n/g, ' ')
       ?.slice(0, 50)
     debug(chalk.gray(`${currentQueue()} Queued | catch with error handler ${fnDescription || ''}`))
+    if (!promise) promise = Promise.resolve()
     return (promise = promise.catch(err => {
-      log(`${currentQueue()}Error | ${err} ${fnDescription}...`)
+      output.log(`${currentQueue()}Error | ${err} ${fnDescription}...`)
       if (!(err instanceof Error)) {
         // strange things may happen
         err = new Error(`[Wrapped Error] ${printObjectProperties(err)}`) // we should be prepared for them
@@ -288,15 +292,30 @@ module.exports = {
       ?.replace(/\s{2,}/g, ' ')
       .replace(/\n/g, ' ')
       ?.slice(0, 50)
+    if (!promise) promise = Promise.resolve()
     return (promise = promise.catch(err => {
       if (ignoredErrs.includes(err)) return // already caught
-      log(`${currentQueue()} Error (Non-Terminated) | ${err} | ${fnDescription || ''}...`)
+
+      // Handle terminal errors - don't continue, re-throw immediately
+      if (err && (err.isTerminal || (err.message && (err.message.includes('ERR_ABORTED') || err.message.includes('frame was detached') || err.message.includes('Target page, context or browser has been closed'))))) {
+        output.log(`${currentQueue()} Terminal Error | ${err} | ${fnDescription || ''}...`)
+        throw err // Re-throw terminal errors immediately
+      }
+
+      output.log(`${currentQueue()} Error (Non-Terminated) | ${err} | ${fnDescription || ''}...`)
       if (!(err instanceof Error)) {
         // strange things may happen
         err = new Error(`[Wrapped Error] ${JSON.stringify(err)}`) // we should be prepared for them
       }
       if (customErrFn) {
-        return customErrFn(err)
+        try {
+          const result = customErrFn(err)
+          // If customErrFn returns a value (not throwing), treat it as handled
+          return result
+        } catch (thrownErr) {
+          // If customErrFn throws an error, propagate it up
+          throw thrownErr
+        }
       }
     }))
   },
@@ -354,7 +373,7 @@ module.exports = {
    */
   stop() {
     debug(this.toString())
-    log(`${currentQueue()} Stopping recording promises`)
+    output.log(`${currentQueue()} Stopping recording promises`)
     running = false
   },
 

package/lib/rerun.js

@@ -1,34 +1,77 @@
-const fsPath = require('path')
-const container = require('./container')
-const event = require('./event')
-const BaseCodecept = require('./codecept')
-const output = require('./output')
+import fsPath from 'path'
+import container from './container.js'
+import event from './event.js'
+import BaseCodecept from './codecept.js'
+import output from './output.js'
+import { createRequire } from 'module'
+
+const require = createRequire(import.meta.url)
 
 class CodeceptRerunner extends BaseCodecept {
-  runOnce(test) {
-    return new Promise((resolve, reject) => {
-      // @ts-ignore
-      container.createMocha()
-      const mocha = container.mocha()
-      this.testFiles.forEach(file => {
-        delete require.cache[file]
-      })
-      mocha.files = this.testFiles
-      if (test) {
-        if (!fsPath.isAbsolute(test)) {
-          test = fsPath.join(global.codecept_dir, test)
-        }
-        mocha.files = mocha.files.filter(t => fsPath.basename(t, '.js') === test || t === test)
-      }
+  async runOnce(test) {
+    await container.started()
+
+    // Ensure translations are loaded for Gherkin features
+    try {
+      const { loadTranslations } = await import('./mocha/gherkin.js')
+      await loadTranslations()
+    } catch (e) {
+      // Ignore if gherkin module not available
+    }
+
+    return new Promise(async (resolve, reject) => {
       try {
-        mocha.run(failures => {
-          if (failures === 0) {
-            resolve()
+        // Create a fresh Mocha instance for each run
+        // @ts-ignore
+        container.createMocha()
+        const mocha = container.mocha()
+
+        let filesToRun = this.testFiles
+        if (test) {
+          if (!fsPath.isAbsolute(test)) {
+            test = fsPath.join(global.codecept_dir, test)
+          }
+          filesToRun = this.testFiles.filter(t => fsPath.basename(t, '.js') === test || t === test)
+        }
+
+        // Clear any existing tests/suites
+        mocha.suite.suites = []
+        mocha.suite.tests = []
+
+        // Manually load each test file by importing it
+        for (const file of filesToRun) {
+          try {
+            // Clear CommonJS cache if available (for mixed environments)
+            try {
+              delete require.cache[file]
+            } catch (e) {
+              // ESM modules don't have require.cache, ignore
+            }
+
+            // Force reload the module by using a cache-busting query parameter
+            const fileUrl = `${fsPath.resolve(file)}?t=${Date.now()}`
+            await import(fileUrl)
+          } catch (e) {
+            console.error(`Error loading test file ${file}:`, e)
+          }
+        }
+
+        const done = () => {
+          event.emit(event.all.result, container.result())
+          event.emit(event.all.after, this)
+
+          // Check if there were any failures
+          if (container.result().hasFailed) {
+            reject(new Error('Test run failed'))
           } else {
-            reject(new Error(`${failures} tests fail`))
+            resolve(undefined)
           }
-        })
+        }
+
+        event.emit(event.all.before, this)
+        mocha.run(() => done())
       } catch (e) {
+        output.error(e.stack)
         reject(e)
       }
     })
@@ -79,4 +122,4 @@ class CodeceptRerunner extends BaseCodecept {
   }
 }
 
-module.exports = CodeceptRerunner
+export default CodeceptRerunner

package/lib/result.js

@@ -1,6 +1,6 @@
-const fs = require('fs')
-const path = require('path')
-const { serializeTest } = require('./mocha/test')
+import fs from 'fs'
+import path from 'path'
+import { serializeTest } from './mocha/test.js'
 
 /**
  * @typedef {Object} Stats Statistics for a test result.
@@ -235,4 +235,4 @@ class Result {
   }
 }
 
-module.exports = Result
+export default Result

package/lib/retryCoordinator.js

@@ -1,4 +1,4 @@
-const output = require('./output')
+import output from './output.js'
 
 /**
  * Retry Coordinator - Central coordination for all retry mechanisms
@@ -196,7 +196,7 @@ function validateConfig(config) {
   return warnings
 }
 
-module.exports = {
+export {
   RETRY_PRIORITIES,
   RETRY_TYPES,
   registerRetry,