codeceptjs 4.0.0-beta.2 → 4.0.0-beta.20

package/lib/history.js

@@ -1,7 +1,7 @@
-import colors from 'chalk';
-import fs from 'fs';
-import path from 'path';
-import * as output from './output.js';
+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
@@ -10,42 +10,46 @@ import * as output from './output.js';
 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 = []
   }
 }
 
-export default new ReplHistory();
+export default new ReplHistory()

package/lib/hooks.js

@@ -1,17 +1,17 @@
-import { isFunction, isAsyncFunction } from './utils.js';
-import * as output from './output.js';
+import { isFunction, isAsyncFunction } from './utils.js'
+import output from './output.js'
 
 export default async function (hook, stage) {
-  if (!hook) return;
+  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.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.output.log(`finished ${stage} hook`);
+  if (stage) output.log(`finished ${stage} hook`)
 }

package/lib/html.js

@@ -1,7 +1,7 @@
-import { parse, serialize } from 'parse5';
-import { minify } from 'html-minifier-terser';
+import { parse, serialize } from 'parse5'
+import { minify } from 'html-minifier-terser'
 
-export async function minifyHtml(html) {
+async function minifyHtml(html) {
   return minify(html, {
     collapseWhitespace: true,
     removeComments: true,
@@ -11,7 +11,7 @@ export 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'],
-};
+}
 
-export function removeNonInteractiveElements(html, opts = {}) {
-  opts = { ...defaultHtmlOpts, ...opts };
-  const {
-    interactiveElements,
-    textElements,
-    allowedAttrs,
-    allowedRoles,
-  } = opts;
+function removeNonInteractiveElements(html, 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
 }
 
-export function scanForErrorMessages(html, errorClasses = []) {
+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
 }
 
-export function splitByChunks(text, chunkSize) {
-  chunkSize -= 20;
-  const chunks = [];
+function splitByChunks(text, chunkSize) {
+  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())
 }
 
-export default {
-  scanForErrorMessages,
-  removeNonInteractiveElements,
-  splitByChunks,
-  minifyHtml,
-};
+export { scanForErrorMessages, removeNonInteractiveElements, splitByChunks, minifyHtml }

package/lib/index.js

@@ -1,20 +1,3 @@
-import * as _codecept from './codecept.js';
-import * as workers from './workers.js';
-import * as dataTableArgument from './data/dataTableArgument.js';
-import * as dataTable from './data/table.js';
-import * as within from './within.js';
-import * as pause from './pause.js';
-import * as helper from './helper.js';
-import * as actor from './actor.js';
-import * as config from './config.js';
-import * as output from './output.js';
-import * as recorder from './recorder.js';
-import * as container from './container.js';
-import * as locator from './locator.js';
-import * as event from './event.js';
-import * as store from './store.js';
-import * as heal from './heal.js';
-import * as ai from './ai.js';
 /**
  * Index file for loading CodeceptJS programmatically.
  *
@@ -22,14 +5,30 @@ import * as ai from './ai.js';
  * @alias index
  * @namespace
  */
-/** @type {typeof CodeceptJS.Codecept} */
-export { _codecept as codecept };
-/** @type {typeof CodeceptJS.Codecept} */
-export { _codecept as Codecept };
-/** @type {typeof CodeceptJS.Helper} */
-export { helper as Helper };
-export { workers as Workers };
-export {
+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,
+  /** @type {typeof CodeceptJS.Codecept} */
+  Codecept: codecept,
   /** @type {typeof CodeceptJS.output} */
   output,
   /** @type {typeof CodeceptJS.Container} */
@@ -44,6 +43,8 @@ export {
   actor,
   /** @type {typeof CodeceptJS.Helper} */
   helper,
+  /** @type {typeof CodeceptJS.Helper} */
+  Helper: helper,
   /** @type {typeof CodeceptJS.pause} */
   pause,
   /** @type {typeof CodeceptJS.within} */
@@ -56,7 +57,17 @@ export {
   store,
   /** @type {typeof CodeceptJS.Locator} */
   locator,
+
   heal,
   ai,
-  workers,
-};
+
+  Workers,
+
+  /** @type {typeof CodeceptJS.Secret} */
+  Secret,
+  /** @type {typeof CodeceptJS.secret} */
+  secret,
+}
+
+// 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,46 +1,53 @@
-import * as event from '../event.js';
-import container from '../container.js';
-import recorder from '../recorder.js';
-import { deepMerge, deepClone, ucfirst } from '../utils.js';
-import * as output from '../output.js';
+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
  */
 export default function () {
-  const helpers = container.helpers();
+  // Use global flag to prevent duplicate initialization across module re-imports
+  if (global.__codeceptConfigListenerInitialized) {
+    return
+  }
+  global.__codeceptConfigListenerInitialized = true
+  
+  const helpers = global.container.helpers()
 
-  enableDynamicConfigFor('suite');
-  enableDynamicConfigFor('test');
+  enableDynamicConfigFor('suite')
+  enableDynamicConfigFor('test')
 
   function enableDynamicConfigFor(type) {
     event.dispatcher.on(event[type].before, (context = {}) => {
       function updateHelperConfig(helper, config) {
-        const oldConfig = { ...helper.options };
+        const oldConfig = deepClone(helper.options)
         try {
-          helper._setConfig(deepMerge(deepClone(oldConfig), config));
-          debug(`[${ucfirst(type)} Config] ${helper.constructor.name} ${JSON.stringify(config)}`);
+          helper._setConfig(deepMerge(deepClone(oldConfig), config))
+          output.debug(`[${ucfirst(type)} Config] ${helper.constructor.name} ${JSON.stringify(config)}`)
         } catch (err) {
-          recorder.throw(err);
-          return;
+          recorder.throw(err)
+          return
+        }
+        const restoreCallback = () => {
+          helper._setConfig(oldConfig)
+          output.debug(`[${ucfirst(type)} Config] Reverted for ${helper.constructor.name}`)
         }
-        event.dispatcher.once(event[type].after, () => {
-          helper._setConfig(oldConfig);
-          debug(`[${ucfirst(type)} Config] Reverted for ${helper.constructor.name}`);
-        });
+        event.dispatcher.once(event[type].after, restoreCallback)
       }
 
       // change config
       if (context.config) {
         for (let name in context.config) {
-          const config = context.config[name];
-          if (name === '0') { // first helper
-            name = Object.keys(helpers)[0];
+          const config = context.config[name]
+          if (name === '0') {
+            // first helper
+            name = Object.keys(helpers)[0]
           }
-          const helper = helpers[name];
-          updateHelperConfig(helper, config);
+          const helper = helpers[name]
+          updateHelperConfig(helper, config)
         }
       }
-    });
+    })
   }
 }

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
+      }
+    }
+  })
+}