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

package/lib/html.js

@@ -1,5 +1,5 @@
-const { parse, serialize } = require('parse5');
-const { minify } = require('html-minifier-terser');
+import { parse, serialize } from 'parse5'
+import { minify } from 'html-minifier-terser'
 
 async function minifyHtml(html) {
   return minify(html, {
@@ -11,7 +11,7 @@ async function minifyHtml(html) {
     removeStyleLinkTypeAttributes: true,
     collapseBooleanAttributes: true,
     useShortDoctype: true,
-  });
+  })
 }
 
 const defaultHtmlOpts = {
@@ -19,240 +19,230 @@ const defaultHtmlOpts = {
   textElements: ['label', 'h1', 'h2'],
   allowedAttrs: ['id', 'for', 'class', 'name', 'type', 'value', 'tabindex', 'aria-labelledby', 'aria-label', 'label', 'placeholder', 'title', 'alt', 'src', 'role'],
   allowedRoles: ['button', 'checkbox', 'search', 'textbox', 'tab'],
-};
+}
 
 function removeNonInteractiveElements(html, opts = {}) {
-  opts = { ...defaultHtmlOpts, ...opts };
-  const {
-    interactiveElements,
-    textElements,
-    allowedAttrs,
-    allowedRoles,
-  } = opts;
+  opts = { ...defaultHtmlOpts, ...opts }
+  const { interactiveElements, textElements, allowedAttrs, allowedRoles } = opts
 
   // Parse the HTML into a document tree
-  const document = parse(html);
+  const document = parse(html)
 
-  const trashHtmlClasses = /^(text-|color-|flex-|float-|v-|ember-|d-|border-)/;
+  const trashHtmlClasses = /^(text-|color-|flex-|float-|v-|ember-|d-|border-)/
   // Array to store interactive elements
-  const removeElements = ['path', 'script'];
+  const removeElements = ['path', 'script']
 
   function isFilteredOut(node) {
-    if (removeElements.includes(node.nodeName)) return true;
+    if (removeElements.includes(node.nodeName)) return true
     if (node.attrs) {
-      if (node.attrs.find(attr => attr.name === 'role' && attr.value === 'tooltip')) return true;
+      if (node.attrs.find(attr => attr.name === 'role' && attr.value === 'tooltip')) return true
     }
-    return false;
+    return false
   }
 
   // Function to check if an element is interactive
   function isInteractive(element) {
-    if (element.nodeName === 'input' && element.attrs.find(attr => attr.name === 'type' && attr.value === 'hidden')) return false;
-    if (interactiveElements.includes(element.nodeName)) return true;
+    if (element.nodeName === 'input' && element.attrs.find(attr => attr.name === 'type' && attr.value === 'hidden')) return false
+    if (interactiveElements.includes(element.nodeName)) return true
     if (element.attrs) {
-      if (element.attrs.find(attr => attr.name === 'contenteditable')) return true;
-      if (element.attrs.find(attr => attr.name === 'tabindex')) return true;
-      const role = element.attrs.find(attr => attr.name === 'role');
-      if (role && allowedRoles.includes(role.value)) return true;
+      if (element.attrs.find(attr => attr.name === 'contenteditable')) return true
+      if (element.attrs.find(attr => attr.name === 'tabindex')) return true
+      const role = element.attrs.find(attr => attr.name === 'role')
+      if (role && allowedRoles.includes(role.value)) return true
     }
-    return false;
+    return false
   }
 
   function hasMeaningfulText(node) {
-    if (textElements.includes(node.nodeName)) return true;
-    return false;
+    if (textElements.includes(node.nodeName)) return true
+    return false
   }
 
   function hasInteractiveDescendant(node) {
-    if (!node.childNodes) return false;
-    let result = false;
+    if (!node.childNodes) return false
+    let result = false
 
     for (const childNode of node.childNodes) {
-      if (isInteractive(childNode) || hasMeaningfulText(childNode)) return true;
-      result = result || hasInteractiveDescendant(childNode);
+      if (isInteractive(childNode) || hasMeaningfulText(childNode)) return true
+      result = result || hasInteractiveDescendant(childNode)
     }
 
-    return result;
+    return result
   }
 
   // Function to remove non-interactive elements recursively
   function removeNonInteractive(node) {
     if (node.nodeName !== '#document') {
-      const parent = node.parentNode;
-      const index = parent.childNodes.indexOf(node);
+      const parent = node.parentNode
+      const index = parent.childNodes.indexOf(node)
 
       if (isFilteredOut(node)) {
-        parent.childNodes.splice(index, 1);
-        return true;
+        parent.childNodes.splice(index, 1)
+        return true
       }
 
       // keep texts for interactive elements
       if ((isInteractive(parent) || hasMeaningfulText(parent)) && node.nodeName === '#text') {
-        node.value = node.value.trim().slice(0, 200);
-        if (!node.value) return false;
-        return true;
+        node.value = node.value.trim().slice(0, 200)
+        if (!node.value) return false
+        return true
       }
 
       if (
         // if parent is interactive, we may need child element to match
-        !isInteractive(parent)
-        && !isInteractive(node)
-        && !hasInteractiveDescendant(node)
-        && !hasMeaningfulText(node)) {
-        parent.childNodes.splice(index, 1);
-        return true;
+        !isInteractive(parent) &&
+        !isInteractive(node) &&
+        !hasInteractiveDescendant(node) &&
+        !hasMeaningfulText(node)
+      ) {
+        parent.childNodes.splice(index, 1)
+        return true
       }
     }
 
     if (node.attrs) {
       // Filter and keep allowed attributes, accessibility attributes
       node.attrs = node.attrs.filter(attr => {
-        const { name, value } = attr;
+        const { name, value } = attr
         if (name === 'class') {
           // Remove classes containing digits
-          attr.value = value.split(' ')
+          attr.value = value
+            .split(' ')
             // remove classes containing digits/
             .filter(className => !/\d/.test(className))
             // remove popular trash classes
             .filter(className => !className.match(trashHtmlClasses))
             // remove classes with : and __ in them
             .filter(className => !className.match(/(:|__)/))
-            .join(' ');
+            .join(' ')
         }
 
-        return allowedAttrs.includes(name);
-      });
+        return allowedAttrs.includes(name)
+      })
     }
 
     if (node.childNodes) {
       for (let i = node.childNodes.length - 1; i >= 0; i--) {
-        const childNode = node.childNodes[i];
-        removeNonInteractive(childNode);
+        const childNode = node.childNodes[i]
+        removeNonInteractive(childNode)
       }
     }
-    return false;
+    return false
   }
 
   // Remove non-interactive elements starting from the root element
-  removeNonInteractive(document);
+  removeNonInteractive(document)
 
   // Serialize the modified document tree back to HTML
-  const serializedHTML = serialize(document);
+  const serializedHTML = serialize(document)
 
-  return serializedHTML;
+  return serializedHTML
 }
 
 function scanForErrorMessages(html, errorClasses = []) {
   // Parse the HTML into a document tree
-  const document = parse(html);
+  const document = parse(html)
 
   // Array to store error messages
-  const errorMessages = [];
+  const errorMessages = []
 
   // Function to recursively scan for error classes and messages
   function scanErrors(node) {
     if (node.attrs) {
-      const classAttr = node.attrs.find(attr => attr.name === 'class');
+      const classAttr = node.attrs.find(attr => attr.name === 'class')
       if (classAttr && classAttr.value) {
-        const classNameChunks = classAttr.value.split(' ');
-        const errorClassFound = errorClasses.some(errorClass => classNameChunks.includes(errorClass));
+        const classNameChunks = classAttr.value.split(' ')
+        const errorClassFound = errorClasses.some(errorClass => classNameChunks.includes(errorClass))
         if (errorClassFound && node.childNodes) {
-          const errorMessage = sanitizeTextContent(node);
-          errorMessages.push(errorMessage);
+          const errorMessage = sanitizeTextContent(node)
+          errorMessages.push(errorMessage)
         }
       }
     }
 
     if (node.childNodes) {
       for (const childNode of node.childNodes) {
-        scanErrors(childNode);
+        scanErrors(childNode)
       }
     }
   }
 
   // Start scanning for error classes and messages from the root element
-  scanErrors(document);
+  scanErrors(document)
 
-  return errorMessages;
+  return errorMessages
 }
 
 function sanitizeTextContent(node) {
   if (node.nodeName === '#text') {
-    return node.value.trim();
+    return node.value.trim()
   }
 
-  let sanitizedText = '';
+  let sanitizedText = ''
 
   if (node.childNodes) {
     for (const childNode of node.childNodes) {
-      sanitizedText += sanitizeTextContent(childNode);
+      sanitizedText += sanitizeTextContent(childNode)
     }
   }
 
-  return sanitizedText;
+  return sanitizedText
 }
 
 function buildPath(node, path = '') {
-  const tag = node.nodeName;
-  let attributes = '';
+  const tag = node.nodeName
+  let attributes = ''
 
   if (node.attrs) {
-    attributes = node.attrs
-      .map(attr => `${attr.name}="${attr.value}"`)
-      .join(' ');
+    attributes = node.attrs.map(attr => `${attr.name}="${attr.value}"`).join(' ')
   }
 
   if (!tag.startsWith('#') && tag !== 'body' && tag !== 'html') {
-    path += `<${node.nodeName}${node.attrs ? ` ${attributes}` : ''}>`;
+    path += `<${node.nodeName}${node.attrs ? ` ${attributes}` : ''}>`
   }
 
-  if (!node.childNodes) return path;
+  if (!node.childNodes) return path
 
-  const children = node.childNodes.filter(child => !child.nodeName.startsWith('#'));
+  const children = node.childNodes.filter(child => !child.nodeName.startsWith('#'))
 
   if (children.length) {
-    return buildPath(children[children.length - 1], path);
+    return buildPath(children[children.length - 1], path)
   }
-  return path;
+  return path
 }
 
 function splitByChunks(text, chunkSize) {
-  chunkSize -= 20;
-  const chunks = [];
+  chunkSize -= 20
+  const chunks = []
   for (let i = 0; i < text.length; i += chunkSize) {
-    chunks.push(text.slice(i, i + chunkSize));
+    chunks.push(text.slice(i, i + chunkSize))
   }
 
-  const regex = /<\s*\w+(?:\s+\w+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^>\s]+)))*\s*$/;
+  const regex = /<\s*\w+(?:\s+\w+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^>\s]+)))*\s*$/
 
   // append tag to chunk if it was split out
   for (const index in chunks) {
-    const nextIndex = parseInt(index, 10) + 1;
-    if (!chunks[nextIndex]) break;
+    const nextIndex = parseInt(index, 10) + 1
+    if (!chunks[nextIndex]) break
 
-    const currentChunk = chunks[index];
-    const nextChunk = chunks[nextIndex];
+    const currentChunk = chunks[index]
+    const nextChunk = chunks[nextIndex]
 
-    const lastTag = currentChunk.match(regex);
+    const lastTag = currentChunk.match(regex)
     if (lastTag) {
-      chunks[nextIndex] = lastTag[0] + nextChunk;
+      chunks[nextIndex] = lastTag[0] + nextChunk
     }
 
-    const path = buildPath(parse(currentChunk));
+    const path = buildPath(parse(currentChunk))
     if (path) {
-      chunks[nextIndex] = path + chunks[nextIndex];
+      chunks[nextIndex] = path + chunks[nextIndex]
     }
 
-    if (chunks[nextIndex].includes('<html')) continue;
-    chunks[nextIndex] = `<html><body>${chunks[nextIndex]}</body></html>`;
+    if (chunks[nextIndex].includes('<html')) continue
+    chunks[nextIndex] = `<html><body>${chunks[nextIndex]}</body></html>`
   }
 
-  return chunks.map(chunk => chunk.trim());
+  return chunks.map(chunk => chunk.trim())
 }
 
-module.exports = {
-  scanForErrorMessages,
-  removeNonInteractiveElements,
-  splitByChunks,
-  minifyHtml,
-};
+export { scanForErrorMessages, removeNonInteractiveElements, splitByChunks, minifyHtml }

package/lib/index.js

@@ -5,42 +5,69 @@
  * @alias index
  * @namespace
  */
-module.exports = {
+import codecept from './codecept.js'
+import output from './output.js'
+import container from './container.js'
+import event from './event.js'
+import recorder from './recorder.js'
+import config from './config.js'
+import actor from './actor.js'
+import helper from './helper.js'
+import pause from './pause.js'
+import { within } from './effects.js'
+import dataTable from './data/table.js'
+import dataTableArgument from './data/dataTableArgument.js'
+import store from './store.js'
+import locator from './locator.js'
+import heal from './heal.js'
+import ai from './ai.js'
+import Workers from './workers.js'
+import Secret, { secret } from './secret.js'
+
+export default {
   /** @type {typeof CodeceptJS.Codecept} */
-  codecept: require('./codecept'),
+  codecept,
   /** @type {typeof CodeceptJS.Codecept} */
-  Codecept: require('./codecept'),
+  Codecept: codecept,
   /** @type {typeof CodeceptJS.output} */
-  output: require('./output'),
+  output,
   /** @type {typeof CodeceptJS.Container} */
-  container: require('./container'),
+  container,
   /** @type {typeof CodeceptJS.event} */
-  event: require('./event'),
+  event,
   /** @type {CodeceptJS.recorder} */
-  recorder: require('./recorder'),
+  recorder,
   /** @type {typeof CodeceptJS.Config} */
-  config: require('./config'),
+  config,
   /** @type {CodeceptJS.actor} */
-  actor: require('./actor'),
+  actor,
   /** @type {typeof CodeceptJS.Helper} */
-  helper: require('./helper'),
+  helper,
   /** @type {typeof CodeceptJS.Helper} */
-  Helper: require('./helper'),
+  Helper: helper,
   /** @type {typeof CodeceptJS.pause} */
-  pause: require('./pause'),
+  pause,
   /** @type {typeof CodeceptJS.within} */
-  within: require('./within'),
+  within,
   /**  @type {typeof CodeceptJS.DataTable} */
-  dataTable: require('./data/table'),
+  dataTable,
   /**  @type {typeof CodeceptJS.DataTableArgument} */
-  dataTableArgument: require('./data/dataTableArgument'),
+  dataTableArgument,
   /** @type {typeof CodeceptJS.store} */
-  store: require('./store'),
+  store,
   /** @type {typeof CodeceptJS.Locator} */
-  locator: require('./locator'),
+  locator,
+
+  heal,
+  ai,
+
+  Workers,
 
-  heal: require('./heal'),
-  ai: require('./ai'),
+  /** @type {typeof CodeceptJS.Secret} */
+  Secret,
+  /** @type {typeof CodeceptJS.secret} */
+  secret,
+}
 
-  Workers: require('./workers'),
-};
+// Named exports for ESM compatibility
+export { codecept, output, container, event, recorder, config, actor, helper, pause, within, dataTable, dataTableArgument, store, locator, heal, ai, Workers, Secret, secret }

package/lib/listener/config.js

@@ -1,13 +1,12 @@
-const event = require('../event')
-const container = require('../container')
-const recorder = require('../recorder')
-const { deepMerge, deepClone, ucfirst } = require('../utils')
-const { debug } = require('../output')
+import event from '../event.js'
+import recorder from '../recorder.js'
+import { deepMerge, deepClone, ucfirst } from '../utils.js'
+import output from '../output.js'
 /**
  * Enable Helpers to listen to test events
  */
-module.exports = function () {
-  const helpers = container.helpers()
+export default function () {
+  const helpers = global.container.helpers()
 
   enableDynamicConfigFor('suite')
   enableDynamicConfigFor('test')
@@ -18,14 +17,14 @@ module.exports = function () {
         const oldConfig = { ...helper.options }
         try {
           helper._setConfig(deepMerge(deepClone(oldConfig), config))
-          debug(`[${ucfirst(type)} Config] ${helper.constructor.name} ${JSON.stringify(config)}`)
+          output.debug(`[${ucfirst(type)} Config] ${helper.constructor.name} ${JSON.stringify(config)}`)
         } catch (err) {
           recorder.throw(err)
           return
         }
         event.dispatcher.once(event[type].after, () => {
           helper._setConfig(oldConfig)
-          debug(`[${ucfirst(type)} Config] Reverted for ${helper.constructor.name}`)
+          output.debug(`[${ucfirst(type)} Config] Reverted for ${helper.constructor.name}`)
         })
       }
 

package/lib/listener/emptyRun.js

@@ -1,10 +1,9 @@
-const figures = require('figures')
-const Container = require('../container')
-const event = require('../event')
-const output = require('../output')
-const { searchWithFusejs } = require('../utils')
+import figures from 'figures'
+import event from '../event.js'
+import output from '../output.js'
+import { searchWithFusejs } from '../utils.js'
 
-module.exports = function () {
+export default function () {
   let isEmptyRun = true
 
   event.dispatcher.on(event.test.before, test => {
@@ -13,7 +12,7 @@ module.exports = function () {
 
   event.dispatcher.on(event.all.result, () => {
     if (isEmptyRun) {
-      const mocha = Container.mocha()
+      const mocha = global.container.mocha()
 
       if (mocha.options.grep) {
         output.print()

package/lib/listener/exit.js

@@ -1,7 +1,8 @@
-const event = require('../event')
-const debug = require('debug')('codeceptjs:exit')
+import event from '../event.js'
+import debugModule from 'debug'
+const debug = debugModule('codeceptjs:exit')
 
-module.exports = function () {
+export default function () {
   let failedTests = []
 
   event.dispatcher.on(event.test.failed, test => {

package/lib/listener/globalRetry.js

@@ -1,11 +1,11 @@
-const event = require('../event')
-const output = require('../output')
-const Config = require('../config')
-const { isNotSet } = require('../utils')
+import event from '../event.js'
+import output from '../output.js'
+import Config from '../config.js'
+import { isNotSet } from '../utils.js'
 
 const hooks = ['Before', 'After', 'BeforeSuite', 'AfterSuite']
 
-module.exports = function () {
+export default function () {
   event.dispatcher.on(event.suite.before, suite => {
     let retryConfig = Config.get('retry')
     if (!retryConfig) return

package/lib/listener/globalTimeout.js

@@ -1,13 +1,14 @@
-const event = require('../event')
-const output = require('../output')
-const recorder = require('../recorder')
-const Config = require('../config')
-const store = require('../store')
-const debug = require('debug')('codeceptjs:timeout')
-const { TIMEOUT_ORDER, TimeoutError, TestTimeoutError, StepTimeoutError } = require('../timeout')
-const { BeforeSuiteHook, AfterSuiteHook } = require('../mocha/hooks')
-
-module.exports = function () {
+import event from '../event.js'
+import output from '../output.js'
+import recorder from '../recorder.js'
+import Config from '../config.js'
+import store from '../store.js'
+import debugModule from 'debug'
+const debug = debugModule('codeceptjs:timeout')
+import { TIMEOUT_ORDER, TimeoutError, TestTimeoutError, StepTimeoutError } from '../timeout.js'
+import { BeforeSuiteHook, AfterSuiteHook } from '../mocha/hooks.js'
+
+export default function () {
   let timeout
   let suiteTimeout = []
   let currentTest

package/lib/listener/helpers.js

@@ -1,14 +1,13 @@
-const path = require('path')
-const event = require('../event')
-const container = require('../container')
-const recorder = require('../recorder')
-const store = require('../store')
-const { error } = require('../output')
+import path from 'path'
+import event from '../event.js'
+import recorder from '../recorder.js'
+import store from '../store.js'
+import output from '../output.js'
 /**
  * Enable Helpers to listen to test events
  */
-module.exports = function () {
-  const helpers = container.helpers()
+export default function () {
+  const helpers = global.container.helpers()
 
   const runHelpersHook = (hook, param) => {
     if (store.dryRun) return
@@ -39,30 +38,30 @@ module.exports = function () {
 
   event.dispatcher.on(event.test.started, test => {
     runHelpersHook('_test', test)
-    recorder.catch(e => error(e))
+    recorder.catch(e => output.error(e))
   })
 
   event.dispatcher.on(event.test.before, test => {
     // schedule config to revert changes
     runAsyncHelpersHook('_before', test, true)
-    recorder.catchWithoutStop(e => error(e))
+    recorder.catchWithoutStop(e => output.error(e))
   })
 
   event.dispatcher.on(event.test.passed, test => {
     runAsyncHelpersHook('_passed', test, true)
     // should not fail test execution, so errors should be caught
-    recorder.catchWithoutStop(e => error(e))
+    recorder.catchWithoutStop(e => output.error(e))
   })
 
   event.dispatcher.on(event.test.failed, test => {
     runAsyncHelpersHook('_failed', test, true)
     // should not fail test execution, so errors should be caught
-    recorder.catchWithoutStop(e => error(e))
+    recorder.catchWithoutStop(e => output.error(e))
   })
 
   event.dispatcher.on(event.test.after, () => {
     runAsyncHelpersHook('_after', {}, true)
-    recorder.catchWithoutStop(e => error(e))
+    recorder.catchWithoutStop(e => output.error(e))
   })
 
   event.dispatcher.on(event.step.before, step => {
@@ -74,6 +73,26 @@ module.exports = function () {
   })
 
   event.dispatcher.on(event.all.result, () => {
-    runAsyncHelpersHook('_finishTest', {}, true)
+    // Skip _finishTest for all helpers if any browser helper restarts to avoid double cleanup
+    const hasBrowserRestart = Object.values(helpers).some(helper => (helper.config && helper.config.restart) || (helper.options && helper.options.restart === 'context'))
+
+    Object.keys(helpers).forEach(key => {
+      const helper = helpers[key]
+      if (helper._finishTest && !hasBrowserRestart) {
+        recorder.add(`hook ${key}._finishTest()`, () => helper._finishTest(), true, false)
+      }
+    })
+  })
+
+  event.dispatcher.on(event.all.after, () => {
+    // Skip _cleanup for all helpers if any browser helper restarts to avoid double cleanup
+    const hasBrowserRestart = Object.values(helpers).some(helper => (helper.config && helper.config.restart) || (helper.options && helper.options.restart === 'context'))
+
+    Object.keys(helpers).forEach(key => {
+      const helper = helpers[key]
+      if (helper._cleanup && !hasBrowserRestart) {
+        recorder.add(`hook ${key}._cleanup()`, () => helper._cleanup(), true, false)
+      }
+    })
   })
 }

package/lib/listener/mocha.js

@@ -1,11 +1,10 @@
-const event = require('../event')
-const container = require('../container')
+import event from '../event.js'
 
-module.exports = function () {
+export default function () {
   let mocha
 
   event.dispatcher.on(event.all.before, () => {
-    mocha = container.mocha()
+    mocha = global.container.mocha()
   })
 
   event.dispatcher.on(event.test.passed, test => {