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

package/lib/codecept.js

@@ -1,15 +1,34 @@
-const { existsSync, readFileSync } = require('fs')
-const { globSync } = require('glob')
-const shuffle = require('lodash.shuffle')
-const fsPath = require('path')
-const { resolve } = require('path')
-
-const container = require('./container')
-const Config = require('./config')
-const event = require('./event')
-const runHook = require('./hooks')
-const output = require('./output')
-const { emptyFolder } = require('./utils')
+import { existsSync, readFileSync } from 'fs'
+import { globSync } from 'glob'
+import fsPath from 'path'
+import { resolve } from 'path'
+import { fileURLToPath } from 'url'
+import { dirname } from 'path'
+import { createRequire } from 'module'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const require = createRequire(import.meta.url)
+
+import Helper from '@codeceptjs/helper'
+import container from './container.js'
+import Config from './config.js'
+import event from './event.js'
+import runHook from './hooks.js'
+import ActorFactory from './actor.js'
+import output from './output.js'
+import { emptyFolder } from './utils.js'
+import { initCodeceptGlobals } from './globals.js'
+
+import storeListener from './listener/store.js'
+import stepsListener from './listener/steps.js'
+import configListener from './listener/config.js'
+import resultListener from './listener/result.js'
+import helpersListener from './listener/helpers.js'
+import globalTimeoutListener from './listener/globalTimeout.js'
+import globalRetryListener from './listener/globalRetry.js'
+import exitListener from './listener/exit.js'
+import emptyRunListener from './listener/emptyRun.js'
 
 /**
  * CodeceptJS runner
@@ -52,11 +71,13 @@ class Codecept {
    *
    * @param {string} dir
    */
-  init(dir) {
-    this.initGlobals(dir)
+  async init(dir) {
+    await this.initGlobals(dir)
     // initializing listeners
-    container.create(this.config, this.opts)
-    this.runHooks()
+    await container.create(this.config, this.opts)
+    // Store container globally for easy access
+    global.container = container
+    await this.runHooks()
   }
 
   /**
@@ -64,56 +85,24 @@ class Codecept {
    *
    * @param {string} dir
    */
-  initGlobals(dir) {
-    global.codecept_dir = dir
-    global.output_dir = fsPath.resolve(dir, this.config.output)
-
-    if (this.config.emptyOutputFolder) emptyFolder(global.output_dir)
-
-    if (!this.config.noGlobals) {
-      global.Helper = global.codecept_helper = require('@codeceptjs/helper')
-      global.actor = global.codecept_actor = require('./actor')
-      global.pause = require('./pause')
-      global.within = require('./within')
-      global.session = require('./session')
-      global.DataTable = require('./data/table')
-      global.locate = locator => require('./locator').build(locator)
-      global.inject = container.support
-      global.share = container.share
-      global.secret = require('./secret').secret
-      global.codecept_debug = output.debug
-      global.codeceptjs = require('./index') // load all objects
-
-      // BDD
-      const stepDefinitions = require('./mocha/bdd')
-      global.Given = stepDefinitions.Given
-      global.When = stepDefinitions.When
-      global.Then = stepDefinitions.Then
-      global.DefineParameterType = stepDefinitions.defineParameterType
-
-      // debug mode
-      global.debugMode = false
-
-      // mask sensitive data
-      global.maskSensitiveData = this.config.maskSensitiveData || false
-    }
+  async initGlobals(dir) {
+    await initCodeceptGlobals(dir, this.config, container)
   }
 
   /**
    * Executes hooks.
    */
-  runHooks() {
+  async runHooks() {
     // default hooks
-    runHook(require('./listener/store'))
-    runHook(require('./listener/steps'))
-    runHook(require('./listener/config'))
-    runHook(require('./listener/result'))
-    runHook(require('./listener/helpers'))
-    runHook(require('./listener/globalTimeout'))
-    runHook(require('./listener/globalRetry'))
-    runHook(require('./listener/retryEnhancer'))
-    runHook(require('./listener/exit'))
-    runHook(require('./listener/emptyRun'))
+    runHook(storeListener)
+    runHook(stepsListener)
+    runHook(configListener)
+    runHook(resultListener)
+    runHook(helpersListener)
+    runHook(globalTimeoutListener)
+    runHook(globalRetryListener)
+    runHook(exitListener)
+    runHook(emptyRunListener)
 
     // custom hooks (previous iteration of plugins)
     this.config.hooks.forEach(hook => runHook(hook))
@@ -158,7 +147,7 @@ class Codecept {
         }
       }
 
-      if (this.config.gherkin.features && !this.opts.tests) {
+      if (this.config.gherkin && this.config.gherkin.features && !this.opts.tests) {
         if (Array.isArray(this.config.gherkin.features)) {
           this.config.gherkin.features.forEach(feature => {
             patterns.push(feature)
@@ -182,50 +171,6 @@ class Codecept {
         })
       }
     }
-
-    if (this.opts.shuffle) {
-      this.testFiles = shuffle(this.testFiles)
-    }
-
-    if (this.opts.shard) {
-      this.testFiles = this._applySharding(this.testFiles, this.opts.shard)
-    }
-  }
-
-  /**
-   * Apply sharding to test files based on shard configuration
-   *
-   * @param {Array<string>} testFiles - Array of test file paths
-   * @param {string} shardConfig - Shard configuration in format "index/total" (e.g., "1/4")
-   * @returns {Array<string>} - Filtered array of test files for this shard
-   */
-  _applySharding(testFiles, shardConfig) {
-    const shardMatch = shardConfig.match(/^(\d+)\/(\d+)$/)
-    if (!shardMatch) {
-      throw new Error('Invalid shard format. Expected format: "index/total" (e.g., "1/4")')
-    }
-
-    const shardIndex = parseInt(shardMatch[1], 10)
-    const shardTotal = parseInt(shardMatch[2], 10)
-
-    if (shardTotal < 1) {
-      throw new Error('Shard total must be at least 1')
-    }
-
-    if (shardIndex < 1 || shardIndex > shardTotal) {
-      throw new Error(`Shard index ${shardIndex} must be between 1 and ${shardTotal}`)
-    }
-
-    if (testFiles.length === 0) {
-      return testFiles
-    }
-
-    // Calculate which tests belong to this shard
-    const shardSize = Math.ceil(testFiles.length / shardTotal)
-    const startIndex = (shardIndex - 1) * shardSize
-    const endIndex = Math.min(startIndex + shardSize, testFiles.length)
-
-    return testFiles.slice(startIndex, endIndex)
   }
 
   /**
@@ -237,15 +182,29 @@ class Codecept {
   async run(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((resolve, reject) => {
       const mocha = container.mocha()
       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)
+        const testBasename = fsPath.basename(test, '.js')
+        const testFeatureBasename = fsPath.basename(test, '.feature')
+        mocha.files = mocha.files.filter(t => {
+          return fsPath.basename(t, '.js') === testBasename || fsPath.basename(t, '.feature') === testFeatureBasename || t === test
+        })
       }
+
       const done = () => {
         event.emit(event.all.result, container.result())
         event.emit(event.all.after, this)
@@ -267,4 +226,4 @@ class Codecept {
   }
 }
 
-module.exports = Codecept
+export default Codecept

package/lib/colorUtils.js

@@ -144,14 +144,14 @@ function convertColorNameToHex(color) {
     whitesmoke: '#f5f5f5',
     yellow: '#ffff00',
     yellowgreen: '#9acd32',
-  };
+  }
 
-  const cColor = `${color}`.toLowerCase();
+  const cColor = `${color}`.toLowerCase()
   if (typeof colors[cColor] !== 'undefined') {
-    return colors[cColor];
+    return colors[cColor]
   }
 
-  return color;
+  return color
 }
 
 /**
@@ -160,23 +160,23 @@ function convertColorNameToHex(color) {
  */
 function convertHexColorToRgba(hex) {
   // Expand shorthand form (e.g. "#03F") to full form (e.g. "#0033FF")
-  const shorthandRegex = /^#([a-f\d])([a-f\d])([a-f\d])$/i;
+  const shorthandRegex = /^#([a-f\d])([a-f\d])([a-f\d])$/i
   const hexFull = `${hex}`.replace(shorthandRegex, (m, r, g, b) => {
-    return r + r + g + g + b + b;
-  });
+    return r + r + g + g + b + b
+  })
 
-  const result = /^#([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hexFull);
+  const result = /^#([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hexFull)
   if (!result) {
     // Return untouched if not a hex code
-    return hex;
+    return hex
   }
 
-  const r = parseInt(result[1], 16);
-  const g = parseInt(result[2], 16);
-  const b = parseInt(result[3], 16);
-  const a = 1;
+  const r = parseInt(result[1], 16)
+  const g = parseInt(result[2], 16)
+  const b = parseInt(result[3], 16)
+  const a = 1
 
-  return `rgba(${r}, ${g}, ${b}, ${a})`;
+  return `rgba(${r}, ${g}, ${b}, ${a})`
 }
 
 /**
@@ -190,29 +190,29 @@ function convertHexColorToRgba(hex) {
  * @param {string} color Color as a string, i.e. rgb(85,0,0)
  */
 function convertColorToRGBA(color) {
-  const cstr = `${color}`.toLowerCase().trim() || '';
+  const cstr = `${color}`.toLowerCase().trim() || ''
 
   if (!/^rgba?\(.+?\)$/.test(cstr)) {
     // Convert both color names and hex colors to rgba
-    const hexColor = convertColorNameToHex(color);
-    return convertHexColorToRgba(hexColor);
+    const hexColor = convertColorNameToHex(color)
+    return convertHexColorToRgba(hexColor)
   }
 
   // Convert rgb to rgba
-  const channels = cstr.match(/([\-0-9.]+)/g) || [];
+  const channels = cstr.match(/([\-0-9.]+)/g) || []
 
   switch (channels.length) {
     case 3:
       // Convert rgb to rgba
-      return `rgba(${channels.join(', ')}, 1)`;
+      return `rgba(${channels.join(', ')}, 1)`
 
     case 4:
       // Format rgba
-      return `rgba(${channels.join(', ')})`;
+      return `rgba(${channels.join(', ')})`
 
     default:
       // Unexpected color format. Leave it untouched (let the user handle it)
-      return color;
+      return color
   }
 }
 
@@ -222,34 +222,32 @@ function convertColorToRGBA(color) {
  * @param {string} prop CSS Property name
  */
 function isColorProperty(prop) {
-  return [
-    'color',
-    'background',
-    'backgroundColor',
-    'background-color',
-    'borderColor',
-    'border-color',
-    'borderBottomColor',
-    'border-bottom-color',
-    'borderLeftColor',
-    'border-left-color',
-    'borderRightColor',
-    'borderTopColor',
-    'caretColor',
-    'columnRuleColor',
-    'outlineColor',
-    'textDecorationColor',
-    'border-right-color',
-    'border-top-color',
-    'caret-color',
-    'column-rule-color',
-    'outline-color',
-    'text-decoration-color',
-  ].indexOf(prop) > -1;
+  return (
+    [
+      'color',
+      'background',
+      'backgroundColor',
+      'background-color',
+      'borderColor',
+      'border-color',
+      'borderBottomColor',
+      'border-bottom-color',
+      'borderLeftColor',
+      'border-left-color',
+      'borderRightColor',
+      'borderTopColor',
+      'caretColor',
+      'columnRuleColor',
+      'outlineColor',
+      'textDecorationColor',
+      'border-right-color',
+      'border-top-color',
+      'caret-color',
+      'column-rule-color',
+      'outline-color',
+      'text-decoration-color',
+    ].indexOf(prop) > -1
+  )
 }
 
-module.exports = {
-  isColorProperty,
-  convertColorToRGBA,
-  convertColorNameToHex,
-};
+export { isColorProperty, convertColorToRGBA, convertColorNameToHex }

package/lib/command/check.js

@@ -1,15 +1,15 @@
-const { getConfig, getTestRoot } = require('./utils')
-const Codecept = require('../codecept')
-const output = require('../output')
-const store = require('../store')
-const container = require('../container')
-const figures = require('figures')
-const chalk = require('chalk')
-const { createTest } = require('../mocha/test')
-const { getMachineInfo } = require('./info')
-const definitions = require('./definitions')
-
-module.exports = async function (options) {
+import { getConfig, getTestRoot } from './utils.js'
+import Codecept from '../codecept.js'
+import output from '../output.js'
+import store from '../store.js'
+import Container from '../container.js'
+import figures from 'figures'
+import chalk from 'chalk'
+import { createTest } from '../mocha/test.js'
+import { getMachineInfo } from './info.js'
+import definitions from './definitions.js'
+
+export default async function (options) {
   const configFile = options.config
 
   setTimeout(() => {
@@ -31,10 +31,10 @@ module.exports = async function (options) {
   }
 
   const testRoot = getTestRoot(configFile)
-  let config = getConfig(configFile)
+  let config = await getConfig(configFile)
 
   try {
-    config = getConfig(configFile)
+    config = await getConfig(configFile)
     checks['config'] = true
   } catch (err) {
     checks['config'] = err
@@ -45,14 +45,14 @@ module.exports = async function (options) {
   let codecept
   try {
     codecept = new Codecept(config, options)
-    codecept.init(testRoot)
-    await container.started()
+    await codecept.init(testRoot)
+    await Container.started()
     checks.container = true
   } catch (err) {
     checks.container = err
   }
 
-  const standardActingHelpers = container.STANDARD_ACTING_HELPERS
+  const standardActingHelpers = Container.STANDARD_ACTING_HELPERS
 
   printCheck('container', checks['container'])
 
@@ -70,12 +70,17 @@ module.exports = async function (options) {
   if (codecept) {
     try {
       codecept.loadTests()
-      const mocha = container.mocha()
-      mocha.files = codecept.testFiles
+      const files = codecept.testFiles
+      const mocha = Container.mocha()
+      mocha.files = files
       mocha.loadFiles()
-      mocha.suite.suites.forEach(suite => {
-        numTests += suite.tests.length
-      })
+
+      for (const suite of mocha.suite.suites) {
+        if (suite && suite.tests) {
+          numTests += suite.tests.length
+        }
+      }
+
       if (numTests > 0) {
         checks.tests = true
       } else {
@@ -97,13 +102,13 @@ module.exports = async function (options) {
 
   store.dryRun = true
 
-  const helpers = container.helpers()
+  const helpers = Container.helpers()
 
   try {
     if (!Object.keys(helpers).length) throw new Error('No helpers found')
     // load helpers
     for (const helper of Object.values(helpers)) {
-      if (helper._init) helper._init()
+      if (helper._init) await helper._init()
     }
     checks.helpers = true
   } catch (err) {
@@ -112,7 +117,7 @@ module.exports = async function (options) {
 
   printCheck('helpers', checks['helpers'], `${Object.keys(helpers).join(', ')}`)
 
-  const pageObjects = container.support()
+  const pageObjects = Container.support()
 
   try {
     if (Object.keys(pageObjects).length) {
@@ -127,10 +132,10 @@ module.exports = async function (options) {
   printCheck('page objects', checks['pageObjects'], `Total: ${Object.keys(pageObjects).length} support objects`)
 
   checks.plugins = true // how to check plugins?
-  printCheck('plugins', checks['plugins'], Object.keys(container.plugins()).join(', '))
+  printCheck('plugins', checks['plugins'], Object.keys(Container.plugins()).join(', '))
 
   if (Object.keys(helpers).length) {
-    const suite = container.mocha().suite
+    const suite = Container.mocha().suite
     const test = createTest('test', () => {})
     checks.setup = true
     for (const helper of Object.values(helpers)) {

package/lib/command/configMigrate.js

@@ -1,15 +1,16 @@
-const colors = require('chalk')
-const fs = require('fs')
-const inquirer = require('inquirer')
-const mkdirp = require('mkdirp')
-const path = require('path')
-const util = require('util')
+import colors from 'chalk'
+import fs from 'fs'
+import inquirer from 'inquirer'
+import { mkdirp } from 'mkdirp'
+import path from 'path'
+import util from 'util'
 
-const { print, success, error } = require('../output')
-const { fileExists } = require('../utils')
-const { getTestRoot } = require('./utils')
+import output from '../output.js'
+const { print, success, error } = output
+import { fileExists } from '../utils.js'
+import { getTestRoot } from './utils.js'
 
-module.exports = function (initPath) {
+export default function (initPath) {
   const testsPath = getTestRoot(initPath)
 
   print()

package/lib/command/definitions.js

@@ -1,10 +1,10 @@
-const fs = require('fs')
-const path = require('path')
+import fs from 'fs'
+import path from 'path'
 
-const { getConfig, getTestRoot } = require('./utils')
-const Codecept = require('../codecept')
-const container = require('../container')
-const output = require('../output')
+import { getConfig, getTestRoot } from './utils.js'
+import Codecept from '../codecept.js'
+import container from '../container.js'
+import output from '../output.js'
 const actingHelpers = [...container.STANDARD_ACTING_HELPERS, 'REST']
 
 /**
@@ -86,11 +86,11 @@ const helperNames = []
 /** @type {Array<string>} */
 const customHelpers = []
 
-module.exports = function (genPath, options) {
+export default async function (genPath, options) {
   const configFile = options.config || genPath
   /** @type {string} */
   const testsPath = getTestRoot(configFile)
-  const config = getConfig(configFile)
+  const config = await getConfig(configFile)
   if (!config) return
 
   /** @type {Object<string, string>} */
@@ -106,7 +106,8 @@ module.exports = function (genPath, options) {
   const targetFolderPath = (options.output && getTestRoot(options.output)) || testsPath
 
   const codecept = new Codecept(config, {})
-  codecept.init(testsPath)
+  await codecept.init(testsPath)
+  await container.started()
 
   const helpers = container.helpers()
   const translations = container.translation()
@@ -229,7 +230,12 @@ function getImportString(testsPath, targetFolderPath, pathsToType, pathsToValue)
 
   for (const name in pathsToType) {
     const relativePath = getPath(pathsToType[name], targetFolderPath, testsPath)
-    importStrings.push(`type ${name} = typeof import('${relativePath}');`)
+    // For ESM modules with default exports, we need to access the default export type
+    if (relativePath.endsWith('.js')) {
+      importStrings.push(`type ${name} = typeof import('${relativePath}')['default'];`)
+    } else {
+      importStrings.push(`type ${name} = typeof import('${relativePath}');`)
+    }
   }
 
   for (const name in pathsToValue) {

package/lib/command/dryRun.js

@@ -1,18 +1,18 @@
-const { getConfig, getTestRoot } = require('./utils')
-const Config = require('../config')
-const Codecept = require('../codecept')
-const output = require('../output')
-const event = require('../event')
-const store = require('../store')
-const Container = require('../container')
-
-module.exports = async function (test, options) {
+import { getConfig, getTestRoot } from './utils.js'
+import Config from '../config.js'
+import Codecept from '../codecept.js'
+import output from '../output.js'
+import event from '../event.js'
+import store from '../store.js'
+import Container from '../container.js'
+
+export default async function (test, options) {
   if (options.grep) process.env.grep = options.grep
   const configFile = options.config
   let codecept
 
   const testRoot = getTestRoot(configFile)
-  let config = getConfig(configFile)
+  let config = await getConfig(configFile)
   if (options.override) {
     config = Config.append(JSON.parse(options.override))
   }
@@ -27,7 +27,7 @@ module.exports = async function (test, options) {
 
   try {
     codecept = new Codecept(config, options)
-    codecept.init(testRoot)
+    await codecept.init(testRoot)
 
     if (options.bootstrap) await codecept.bootstrap()
 
@@ -35,20 +35,20 @@ module.exports = async function (test, options) {
     store.dryRun = true
 
     if (!options.steps && !options.verbose && !options.debug) {
-      printTests(codecept.testFiles)
+      await printTests(codecept.testFiles)
       return
     }
     event.dispatcher.on(event.all.result, printFooter)
-    codecept.run(test)
+    await codecept.run(test)
   } catch (err) {
     console.error(err)
     process.exit(1)
   }
 }
 
-function printTests(files) {
-  const figures = require('figures')
-  const colors = require('chalk')
+async function printTests(files) {
+  const { default: figures } = await import('figures')
+  const { default: colors } = await import('chalk')
 
   output.print(output.styles.debug(`Tests from ${global.codecept_dir}:`))
   output.print()