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

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

@@ -0,0 +1,206 @@
+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(() => {
+    output.error("Something went wrong. Checks didn't pass and timed out. Please check your config and helpers.")
+    process.exit(1)
+  }, options.timeout || 50000)
+
+  const checks = {
+    config: false,
+    container: false,
+    pageObjects: false,
+    plugins: false,
+    ai: true, // we don't need to check AI
+    helpers: false,
+    setup: false,
+    teardown: false,
+    tests: false,
+    def: false,
+  }
+
+  const testRoot = getTestRoot(configFile)
+  let config = await getConfig(configFile)
+
+  try {
+    config = await getConfig(configFile)
+    checks['config'] = true
+  } catch (err) {
+    checks['config'] = err
+  }
+
+  printCheck('config', checks['config'], config.name)
+
+  let codecept
+  try {
+    codecept = new Codecept(config, options)
+    await codecept.init(testRoot)
+    await Container.started()
+    checks.container = true
+  } catch (err) {
+    checks.container = err
+  }
+
+  const standardActingHelpers = Container.STANDARD_ACTING_HELPERS
+
+  printCheck('container', checks['container'])
+
+  if (codecept) {
+    try {
+      if (options.bootstrap) await codecept.bootstrap()
+      checks.bootstrap = true
+    } catch (err) {
+      checks.bootstrap = err
+    }
+    printCheck('bootstrap', checks['bootstrap'], options.bootstrap ? 'Bootstrap was executed' : 'No bootstrap command')
+  }
+
+  let numTests = 0
+  if (codecept) {
+    try {
+      codecept.loadTests()
+      const files = codecept.testFiles
+      const mocha = Container.mocha()
+      mocha.files = files
+      mocha.loadFiles()
+
+      for (const suite of mocha.suite.suites) {
+        if (suite && suite.tests) {
+          numTests += suite.tests.length
+        }
+      }
+
+      if (numTests > 0) {
+        checks.tests = true
+      } else {
+        throw new Error('No tests found')
+      }
+    } catch (err) {
+      checks.tests = err
+    }
+  }
+
+  if (config?.ai?.request) {
+    checks.ai = true
+    printCheck('ai', checks['ai'], 'Configuration is enabled, request function is set')
+  } else {
+    printCheck('ai', checks['ai'], 'Disabled')
+  }
+
+  printCheck('tests', checks['tests'], `Total: ${numTests} tests`)
+
+  store.dryRun = true
+
+  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) await helper._init()
+    }
+    checks.helpers = true
+  } catch (err) {
+    checks.helpers = err
+  }
+
+  printCheck('helpers', checks['helpers'], `${Object.keys(helpers).join(', ')}`)
+
+  const pageObjects = Container.support()
+
+  try {
+    if (Object.keys(pageObjects).length) {
+      for (const pageObject of Object.values(pageObjects)) {
+        pageObject.name
+      }
+    }
+    checks.pageObjects = true
+  } catch (err) {
+    checks.pageObjects = err
+  }
+  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(', '))
+
+  if (Object.keys(helpers).length) {
+    const suite = Container.mocha().suite
+    const test = createTest('test', () => {})
+    checks.setup = true
+    for (const helper of Object.values(helpers)) {
+      try {
+        if (helper._beforeSuite) await helper._beforeSuite(suite)
+        if (helper._before) await helper._before(test)
+      } catch (err) {
+        err.message = `${helper.constructor.name} helper: ${err.message}`
+        if (checks.setup instanceof Error) err.message = `${err.message}\n\n${checks.setup?.message || ''}`.trim()
+        checks.setup = err
+      }
+    }
+
+    printCheck('Helpers Before', checks['setup'], standardActingHelpers.some(h => Object.keys(helpers).includes(h)) ? 'Initializing browser' : '')
+
+    checks.teardown = true
+    for (const helper of Object.values(helpers).reverse()) {
+      try {
+        if (helper._passed) await helper._passed(test)
+        if (helper._after) await helper._after(test)
+        if (helper._finishTest) await helper._finishTest(suite)
+        if (helper._afterSuite) await helper._afterSuite(suite)
+      } catch (err) {
+        err.message = `${helper.constructor.name} helper: ${err.message}`
+        if (checks.teardown instanceof Error) err.message = `${err.message}\n\n${checks.teardown?.message || ''}`.trim()
+        checks.teardown = err
+      }
+    }
+
+    printCheck('Helpers After', checks['teardown'], standardActingHelpers.some(h => Object.keys(helpers).includes(h)) ? 'Closing browser' : '')
+  }
+
+  try {
+    definitions(configFile, { dryRun: true })
+    checks.def = true
+  } catch (err) {
+    checks.def = err
+  }
+
+  printCheck('TypeScript Definitions', checks['def'])
+
+  output.print('')
+
+  if (!Object.values(checks).every(check => check === true)) {
+    output.error("Something went wrong. Checks didn't pass.")
+    output.print()
+    await getMachineInfo()
+    process.exit(1)
+  }
+
+  output.print(output.styles.success('All checks passed'.toUpperCase()), 'Ready to run your tests 🚀')
+  process.exit(0)
+}
+
+function printCheck(name, value, comment = '') {
+  let status = ''
+  if (value == true) {
+    status += chalk.bold.green(figures.tick)
+  } else {
+    status += chalk.bold.red(figures.cross)
+  }
+
+  if (value instanceof Error) {
+    comment = `${comment} ${chalk.red(value.message)}`.trim()
+  }
+
+  output.print(status, name.toUpperCase(), chalk.dim(comment))
+}

package/lib/command/configMigrate.js

@@ -1,22 +1,21 @@
-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()
   print(`  Welcome to ${colors.magenta.bold('CodeceptJS')} configuration migration tool`)
-  print(
-    `  It will help you switch from ${colors.cyan.bold('.json')} to ${colors.magenta.bold('.js')} config format at ease`,
-  )
+  print(`  It will help you switch from ${colors.cyan.bold('.json')} to ${colors.magenta.bold('.js')} config format at ease`)
   print()
 
   if (!path) {
@@ -53,7 +52,7 @@ module.exports = function (initPath) {
         default: true,
       },
     ])
-    .then((result) => {
+    .then(result => {
       if (result.configFile) {
         const jsonConfigFile = path.join(testsPath, 'codecept.js')
         const config = JSON.parse(fs.readFileSync(jsonConfigFile, 'utf8'))

package/lib/command/definitions.js

@@ -1,11 +1,11 @@
-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')
-const actingHelpers = [...require('../plugin/standardActingHelpers'), 'REST']
+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']
 
 /**
  * Prepare data and generate content of definitions file
@@ -21,14 +21,7 @@ const actingHelpers = [...require('../plugin/standardActingHelpers'), 'REST']
  *
  * @returns {string}
  */
-const getDefinitionsFileContent = ({
-  hasCustomHelper,
-  hasCustomStepsFile,
-  helperNames,
-  supportObject,
-  importPaths,
-  translations,
-}) => {
+const getDefinitionsFileContent = ({ hasCustomHelper, hasCustomStepsFile, helperNames, supportObject, importPaths, translations }) => {
   const getHelperListFragment = ({ hasCustomHelper, hasCustomStepsFile }) => {
     if (hasCustomHelper && hasCustomStepsFile) {
       return `${['ReturnType<steps_file>', 'WithTranslation<Methods>'].join(', ')}`
@@ -73,13 +66,7 @@ const getDefinitionsFileContent = ({
  *
  * @returns {string}
  */
-const generateDefinitionsContent = ({
-  importPathsFragment,
-  supportObjectsTypeFragment,
-  methodsTypeFragment,
-  helpersListFragment,
-  translatedActionsFragment,
-}) => {
+const generateDefinitionsContent = ({ importPathsFragment, supportObjectsTypeFragment, methodsTypeFragment, helpersListFragment, translatedActionsFragment }) => {
   return `/// <reference types='codeceptjs' />
 ${importPathsFragment}
 
@@ -99,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>} */
@@ -119,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()
@@ -185,15 +173,12 @@ module.exports = function (genPath, options) {
     namespaceTranslationAliases.push(`interface ${translations.vocabulary.I} extends WithTranslation<Methods> {}`)
 
     namespaceTranslationAliases.push('  namespace Translation {')
-    definitionsFileContent = definitionsFileContent.replace(
-      'namespace Translation {',
-      namespaceTranslationAliases.join('\n'),
-    )
+    definitionsFileContent = definitionsFileContent.replace('namespace Translation {', namespaceTranslationAliases.join('\n'))
 
     const translationAliases = []
 
     if (translations.vocabulary.contexts) {
-      Object.keys(translations.vocabulary.contexts).forEach((k) => {
+      Object.keys(translations.vocabulary.contexts).forEach(k => {
         translationAliases.push(`declare const ${translations.vocabulary.contexts[k]}: typeof ${k};`)
       })
     }
@@ -201,6 +186,8 @@ module.exports = function (genPath, options) {
     definitionsFileContent += `\n${translationAliases.join('\n')}`
   }
 
+  if (options.dryRun) return
+
   fs.writeFileSync(path.join(targetFolderPath, 'steps.d.ts'), definitionsFileContent)
   output.print('TypeScript Definitions provide autocompletion in Visual Studio Code and other IDEs')
   output.print('Definitions were generated in steps.d.ts')
@@ -222,11 +209,7 @@ function getPath(originalPath, targetFolderPath, testsPath) {
   if (!parsedPath.dir.startsWith('.')) return path.posix.join(parsedPath.dir, parsedPath.base)
   const relativePath = path.posix.relative(
     targetFolderPath.split(path.sep).join(path.posix.sep),
-    path.posix.join(
-      testsPath.split(path.sep).join(path.posix.sep),
-      parsedPath.dir.split(path.sep).join(path.posix.sep),
-      parsedPath.base.split(path.sep).join(path.posix.sep),
-    ),
+    path.posix.join(testsPath.split(path.sep).join(path.posix.sep), parsedPath.dir.split(path.sep).join(path.posix.sep), parsedPath.base.split(path.sep).join(path.posix.sep)),
   )
 
   return relativePath.startsWith('.') ? relativePath : `./${relativePath}`
@@ -247,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()