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

package/lib/plugin/screenshotOnFail.js

@@ -1,12 +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, clearString } = require('../utils')
-const Codeceptjs = require('../index')
+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,
@@ -14,7 +19,7 @@ const defaultConfig = {
   fullPageScreenshots: false,
 }
 
-const supportedHelpers = require('./standardActingHelpers')
+const supportedHelpers = Container.STANDARD_ACTING_HELPERS
 
 /**
  * Creates screenshot on failure. Screenshot is saved into `output` directory.
@@ -42,7 +47,7 @@ const supportedHelpers = require('./standardActingHelpers')
  *
  *
  */
-module.exports = function (config) {
+export default function (config) {
   const helpers = Container.helpers()
   let helper
 
@@ -63,9 +68,7 @@ module.exports = function (config) {
   }
 
   if (Codeceptjs.container.mocha()) {
-    options.reportDir =
-      Codeceptjs.container.mocha().options.reporterOptions &&
-      Codeceptjs.container.mocha().options.reporterOptions.reportDir
+    options.reportDir = Codeceptjs.container.mocha()?.options?.reporterOptions && Codeceptjs.container.mocha()?.options?.reporterOptions?.reportDir
   }
 
   if (options.disableScreenshots) {
@@ -73,32 +76,42 @@ module.exports = function (config) {
     return
   }
 
-  event.dispatcher.on(event.test.failed, (test) => {
-    if (test.ctx?._runnable.title.includes('hook: ')) {
-      output.plugin(
-        'screenshotOnFail',
-        'BeforeSuite/AfterSuite do not have any access to the browser, hence it could not take screenshot.',
-      )
+  event.dispatcher.on(event.test.failed, (test, _err, hookName) => {
+    if (hookName === 'BeforeSuite' || hookName === 'AfterSuite') {
+      // no browser here
       return
     }
+
     recorder.add(
       'screenshot of failed test',
       async () => {
-        let fileName = clearString(test.title)
         const dataType = 'image/png'
         // This prevents data driven to be included in the failed screenshot file name
-        if (fileName.indexOf('{') !== -1) {
-          fileName = fileName.substr(0, fileName.indexOf('{') - 3).trim()
-        }
-        if (test.ctx && test.ctx.test && test.ctx.test.type === 'hook')
-          fileName = clearString(`${test.title}_${test.ctx.test.title}`)
+        let fileName
+
         if (options.uniqueScreenshotNames && test) {
-          const uuid = _getUUID(test)
-          fileName = `${fileName.substring(0, 10)}_${uuid}.failed.png`
+          fileName = `${testToFileName(test, { suffix: '', unique: true })}.failed.png`
         } else {
-          fileName += '.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) {
@@ -108,57 +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 (!quietMode) {
+            output.plugin('screenshotOnFail', `Failed to save screenshot: ${err.message}`)
+          }
+          // Enhanced error handling for browser closed scenarios
           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)
+            ((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}`)
+            output.log(`Can't make screenshot, ${err.message}`)
             helper.isRunning = false
           }
         }
@@ -166,16 +175,4 @@ module.exports = function (config) {
       true,
     )
   })
-
-  function _getUUID(test) {
-    if (test.uuid) {
-      return test.uuid
-    }
-
-    if (test.ctx && test.ctx.test.uuid) {
-      return test.ctx.test.uuid
-    }
-
-    return Math.floor(new Date().getTime() / 1000)
-  }
 }

package/lib/plugin/stepByStepReport.js

@@ -1,17 +1,18 @@
-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 Container = require('../container')
-const recorder = require('../recorder')
-const event = require('../event')
-const output = require('../output')
-const { template, deleteDir } = require('../utils')
-
-const supportedHelpers = require('./standardActingHelpers')
+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
 
 const defaultConfig = {
   deleteSuccessful: true,
@@ -62,7 +63,7 @@ const templates = {}
  * @param {*} config
  */
 
-module.exports = function (config) {
+export default function (config) {
   const helpers = Container.helpers()
   let helper
 
@@ -88,11 +89,11 @@ module.exports = function (config) {
   const pad = '0000'
   const reportDir = config.output ? path.resolve(global.codecept_dir, config.output) : defaultConfig.output
 
-  event.dispatcher.on(event.suite.before, (suite) => {
+  event.dispatcher.on(event.suite.before, suite => {
     stepNum = -1
   })
 
-  event.dispatcher.on(event.test.before, (test) => {
+  event.dispatcher.on(event.test.before, test => {
     const sha256hash = crypto
       .createHash('sha256')
       .update(test.file + test.title)
@@ -106,34 +107,74 @@ module.exports = function (config) {
     currentTest = test
   })
 
-  event.dispatcher.on(event.step.failed, (step) => {
+  event.dispatcher.on(event.step.failed, step => {
     recorder.add('screenshot of failed test', async () => persistStep(step), true)
   })
 
-  event.dispatcher.on(event.step.after, (step) => {
+  event.dispatcher.on(event.step.after, step => {
     recorder.add('screenshot of step of test', async () => persistStep(step), true)
   })
 
-  event.dispatcher.on(event.test.passed, (test) => {
+  event.dispatcher.on(event.test.passed, test => {
     if (!config.deleteSuccessful) return persist(test)
     // cleanup
     deleteDir(dir)
   })
 
-  event.dispatcher.on(event.test.failed, (test, err) => {
-    if (test.ctx._runnable.title.includes('hook: ')) {
-      output.plugin(
-        'stepByStepReport',
-        'BeforeSuite/AfterSuite do not have any access to the browser, hence it could not take screenshot.',
-      )
+  event.dispatcher.on(event.test.failed, (test, _err, hookName) => {
+    if (hookName === 'BeforeSuite' || hookName === 'AfterSuite') {
+      // no browser here
       return
     }
-    persist(test, err)
+
+    persist(test)
   })
 
   event.dispatcher.on(event.all.result, () => {
     if (Object.keys(recordedTests).length === 0 || !Object.keys(slides).length) return
+    generateRecordsHtml(recordedTests)
+  })
+
+  event.dispatcher.on(event.workers.result, async () => {
+    await recorder.add(() => {
+      const recordedTests = getRecordFoldersWithDetails(reportDir)
+      generateRecordsHtml(recordedTests)
+    })
+  })
+
+  function getRecordFoldersWithDetails(dirPath) {
+    let results = {}
+
+    try {
+      const items = fs.readdirSync(dirPath, { withFileTypes: true })
+
+      items.forEach(item => {
+        if (item.isDirectory() && item.name.startsWith('record_')) {
+          const recordFolderPath = path.join(dirPath, item.name)
+          const indexPath = path.join(recordFolderPath, 'index.html')
+
+          let name = ''
+          if (fs.existsSync(indexPath)) {
+            try {
+              const htmlContent = fs.readFileSync(indexPath, 'utf-8')
+              const $ = cheerio.load(htmlContent)
+              name = $('.navbar-brand').text().trim()
+            } catch (err) {
+              console.error(`Error reading index.html in ${recordFolderPath}:`, err.message)
+            }
+          }
+
+          results[name || 'Unkown'] = `${item.name}/index.html`
+        }
+      })
+    } catch (err) {
+      console.error(`Error reading directory ${dirPath}:`, err.message)
+    }
 
+    return results
+  }
+
+  function generateRecordsHtml(recordedTests) {
     let links = ''
 
     for (const link in recordedTests) {
@@ -147,10 +188,8 @@ module.exports = function (config) {
 
     fs.writeFileSync(path.join(reportDir, 'records.html'), indexHTML)
 
-    output.print(
-      `${figures.circleFilled} Step-by-step preview: ${colors.white.bold(`file://${reportDir}/records.html`)}`,
-    )
-  })
+    output.print(`${figures.circleFilled} Step-by-step preview: ${colors.white.bold(`file://${reportDir}/records.html`)}`)
+  }
 
   async function persistStep(step) {
     if (stepNum === -1) return // Ignore steps from BeforeSuite function

package/lib/plugin/stepTimeout.js

@@ -1,5 +1,6 @@
-const event = require('../event')
-const TIMEOUT_ORDER = require('../step').TIMEOUT_ORDER
+import event from '../event.js'
+
+import { TIMEOUT_ORDER } from '../timeout.js'
 
 const defaultConfig = {
   timeout: 150,
@@ -61,12 +62,12 @@ 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)
 
-  event.dispatcher.on(event.step.before, (step) => {
+  event.dispatcher.on(event.step.before, step => {
     let stepTimeout
     for (let stepRule of config.customTimeoutSteps) {
       let customTimeout = 0
@@ -74,19 +75,12 @@ module.exports = (config) => {
         if (stepRule.length > 1) customTimeout = stepRule[1]
         stepRule = stepRule[0]
       }
-      if (
-        stepRule instanceof RegExp
-          ? step.name.match(stepRule)
-          : step.name === stepRule || (stepRule.indexOf('*') && step.name.startsWith(stepRule.slice(0, -1)))
-      ) {
+      if (stepRule instanceof RegExp ? step.name.match(stepRule) : step.name === stepRule || (stepRule.indexOf('*') && step.name.startsWith(stepRule.slice(0, -1)))) {
         stepTimeout = customTimeout
         break
       }
     }
     stepTimeout = stepTimeout === undefined ? config.timeout : stepTimeout
-    step.setTimeout(
-      stepTimeout * 1000,
-      config.overrideStepLimits ? TIMEOUT_ORDER.stepTimeoutHard : TIMEOUT_ORDER.stepTimeoutSoft,
-    )
+    step.setTimeout(stepTimeout * 1000, config.overrideStepLimits ? TIMEOUT_ORDER.stepTimeoutHard : TIMEOUT_ORDER.stepTimeoutSoft)
   })
 }

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,13 +29,13 @@ let testStartedAt
  * }
  * ```
  */
-module.exports = function () {
-  event.dispatcher.on(event.test.before, (_) => {
+export default function () {
+  event.dispatcher.on(event.test.before, _ => {
     testStartedAt = Date.now()
     steps = {}
   })
 
-  event.dispatcher.on(event.step.started, (step) => {
+  event.dispatcher.on(event.step.started, step => {
     const stepStartedAt = Date.now()
     step.id = uuidv4()
 
@@ -50,13 +51,13 @@ module.exports = function () {
     }
   })
 
-  event.dispatcher.on(event.step.finished, (step) => {
+  event.dispatcher.on(event.step.finished, step => {
     if (step && step.id && steps[step.id]) {
       steps[step.id].end = formatTimestamp(Date.now() - testStartedAt)
     }
   })
 
-  event.dispatcher.on(event.test.after, async (test) => {
+  event.dispatcher.on(event.test.after, async test => {
     if (test && test.artifacts && test.artifacts.video) {
       const stepsSortedByStartTime = Object.values(steps)
       stepsSortedByStartTime.sort((stepA, stepB) => {