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

package/lib/history.js

@@ -1,8 +1,7 @@
-const colors = require('chalk');
-const fs = require('fs');
-const path = require('path');
-
-const output = require('./output');
+import colors from 'chalk'
+import fs from 'fs'
+import path from 'path'
+import output from './output.js'
 
 /**
  * REPL history records REPL commands and stores them in
@@ -11,42 +10,46 @@ const output = require('./output');
 class ReplHistory {
   constructor() {
     if (global.output_dir) {
-      this.historyFile = path.join(global.output_dir, 'cli-history');
+      this.historyFile = path.join(global.output_dir, 'cli-history')
     }
-    this.commands = [];
+    this.commands = []
   }
 
   push(cmd) {
-    this.commands.push(cmd);
+    this.commands.push(cmd)
   }
 
   pop() {
-    this.commands.pop();
+    this.commands.pop()
   }
 
   load() {
-    if (!this.historyFile) return;
+    if (!this.historyFile) return
     if (!fs.existsSync(this.historyFile)) {
-      return;
+      return
     }
 
-    const history = fs.readFileSync(this.historyFile, 'utf-8');
-    return history.split('\n').reverse().filter(line => line.startsWith('I.')).map(line => line.slice(2));
+    const history = fs.readFileSync(this.historyFile, 'utf-8')
+    return history
+      .split('\n')
+      .reverse()
+      .filter(line => line.startsWith('I.'))
+      .map(line => line.slice(2))
   }
 
   save() {
-    if (!this.historyFile) return;
+    if (!this.historyFile) return
     if (this.commands.length === 0) {
-      return;
+      return
     }
 
-    const commandSnippet = `\n\n<<< Recorded commands on ${new Date()}\n${this.commands.join('\n')}`;
-    fs.appendFileSync(this.historyFile, commandSnippet);
+    const commandSnippet = `\n\n<<< Recorded commands on ${new Date()}\n${this.commands.join('\n')}`
+    fs.appendFileSync(this.historyFile, commandSnippet)
 
-    output.print(colors.yellow(` Commands have been saved to ${this.historyFile}`));
+    output.print(colors.yellow(` Commands have been saved to ${this.historyFile}`))
 
-    this.commands = [];
+    this.commands = []
   }
 }
 
-module.exports = new ReplHistory();
+export default new ReplHistory()

package/lib/hooks.js

@@ -1,17 +1,17 @@
-const { isFunction, isAsyncFunction } = require('./utils');
-const output = require('./output');
+import { isFunction, isAsyncFunction } from './utils.js'
+import output from './output.js'
 
-module.exports = async function (hook, stage) {
-  if (!hook) return;
+export default async function (hook, stage) {
+  if (!hook) return
   if (!isFunction(hook)) {
-    throw new Error('CodeceptJS 3 allows bootstrap/teardown hooks only as async functions. More info: https://bit.ly/codecept3Up');
+    throw new Error('CodeceptJS 3 allows bootstrap/teardown hooks only as async functions. More info: https://bit.ly/codecept3Up')
   }
 
-  if (stage) output.log(`started ${stage} hook`);
+  if (stage) output.log(`started ${stage} hook`)
   if (isAsyncFunction(hook)) {
-    await hook();
+    await hook()
   } else {
-    hook();
+    hook()
   }
-  if (stage) output.log(`finished ${stage} hook`);
-};
+  if (stage) output.log(`finished ${stage} hook`)
+}

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

@@ -0,0 +1,54 @@
+import figures from 'figures'
+import event from '../event.js'
+import output from '../output.js'
+import { searchWithFusejs } from '../utils.js'
+
+export default function () {
+  let isEmptyRun = true
+
+  event.dispatcher.on(event.test.before, test => {
+    isEmptyRun = false
+  })
+
+  event.dispatcher.on(event.all.result, () => {
+    if (isEmptyRun) {
+      const mocha = global.container.mocha()
+
+      if (mocha.options.grep) {
+        output.print()
+        output.print('No tests found by pattern: ' + mocha.options.grep)
+
+        const allTests = []
+        mocha.suite.suites.forEach(suite => {
+          suite.tests.forEach(test => {
+            allTests.push(test.fullTitle())
+          })
+        })
+
+        const results = searchWithFusejs(allTests, mocha.options.grep.toString(), {
+          includeScore: true,
+          threshold: 0.6,
+          caseSensitive: false,
+        })
+
+        if (results.length > 0) {
+          output.print()
+          output.print('Maybe you wanted to run one of these tests?')
+          results.forEach(result => {
+            output.print(figures.checkboxOff, output.styles.log(result.item))
+          })
+
+          output.print()
+          output.print(output.styles.debug('To run the first test use the following command:'))
+          output.print(output.styles.bold('npx codeceptjs run --debug --grep "' + results[0].item + '"'))
+        }
+      }
+      if (process.env.CI && !process.env.DONT_FAIL_ON_EMPTY_RUN) {
+        output.print()
+        output.error('No tests were executed. Failing on CI to avoid false positives')
+        output.error('To disable this check, set `DONT_FAIL_ON_EMPTY_RUN` environment variable to true in CI config')
+        process.exitCode = 1
+      }
+    }
+  })
+}

package/lib/listener/exit.js

@@ -1,24 +1,22 @@
-const event = require('../event')
+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, (testOrSuite) => {
-    // NOTE When an error happens in one of the hooks (BeforeAll/BeforeEach...) the event object
-    // is a suite and not a test
-    const id = testOrSuite.uid || (testOrSuite.ctx && testOrSuite.ctx.test.uid) || 'empty'
+  event.dispatcher.on(event.test.failed, test => {
+    const id = test.uid || (test.ctx && test.ctx.test.uid) || 'empty'
     failedTests.push(id)
   })
 
   // if test was successful after retries
-  event.dispatcher.on(event.test.passed, (testOrSuite) => {
-    // NOTE When an error happens in one of the hooks (BeforeAll/BeforeEach...) the event object
-    // is a suite and not a test
-    const id = testOrSuite.uid || (testOrSuite.ctx && testOrSuite.ctx.test.uid) || 'empty'
-    failedTests = failedTests.filter((failed) => id !== failed)
+  event.dispatcher.on(event.test.passed, test => {
+    const id = test.uid || (test.ctx && test.ctx.test.uid) || 'empty'
+    failedTests = failedTests.filter(failed => id !== failed)
   })
 
-  process.on('beforeExit', (code) => {
+  process.on('beforeExit', code => {
     if (failedTests.length) {
       code = 1
     }