codeceptjs 4.0.0-beta.2 → 4.0.0-beta.21

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,70 +1,75 @@
-import colors from 'chalk';
-import fs from 'fs';
-import inquirer from 'inquirer';
-import mkdirp from 'mkdirp';
-import path from 'path';
-import util from 'util';
-import * as outputLib from '../output.js';
-import { fileExists } from '../utils.js';
-import { getTestRoot } from './utils.js';
+import colors from 'chalk'
+import fs from 'fs'
+import inquirer from 'inquirer'
+import { mkdirp } from 'mkdirp'
+import path from 'path'
+import util from 'util'
+
+import output from '../output.js'
+const { print, success, error } = output
+import { fileExists } from '../utils.js'
+import { getTestRoot } from './utils.js'
 
 export default function (initPath) {
-  const testsPath = getTestRoot(initPath);
+  const testsPath = getTestRoot(initPath)
 
-  outputLib.print();
-  outputLib.print(`  Welcome to ${colors.magenta.bold('CodeceptJS')} configuration migration tool`);
-  outputLib.print(`  It will help you switch from ${colors.cyan.bold('.json')} to ${colors.magenta.bold('.js')} config format at ease`);
-  outputLib.print();
+  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()
 
   if (!path) {
-    outputLib.print('No config file is specified.');
-    outputLib.print(`Test root is assumed to be ${colors.yellow.bold(testsPath)}`);
-    outputLib.print('----------------------------------');
+    print('No config file is specified.')
+    print(`Test root is assumed to be ${colors.yellow.bold(testsPath)}`)
+    print('----------------------------------')
   } else {
-    outputLib.print(`Migrating ${colors.magenta.bold('.js')} config to ${colors.bold(testsPath)}`);
+    print(`Migrating ${colors.magenta.bold('.js')} config to ${colors.bold(testsPath)}`)
   }
 
   if (!fileExists(testsPath)) {
-    outputLib.print(`Directory ${testsPath} does not exist, creating...`);
-    mkdirp.sync(testsPath);
+    print(`Directory ${testsPath} does not exist, creating...`)
+    mkdirp.sync(testsPath)
   }
 
-  const configFile = path.join(testsPath, 'codecept.conf.js');
+  const configFile = path.join(testsPath, 'codecept.conf.js')
   if (fileExists(configFile)) {
-    outputLib.output.output.error(`Config is already created at ${configFile}`);
-    return;
+    error(`Config is already created at ${configFile}`)
+    return
   }
 
-  inquirer.prompt([{
-    name: 'configFile',
-    type: 'confirm',
-    message: `Would you like to switch from ${colors.cyan.bold('.json')} to ${colors.magenta.bold('.js')} config format?`,
-    default: true,
-  },
-  {
-    name: 'delete',
-    type: 'confirm',
-    message: `Would you like to delete ${colors.cyan.bold('.json')} config format afterwards?`,
-    default: true,
-  },
-  ]).then((result) => {
-    if (result.configFile) {
-      const jsonConfigFile = path.join(testsPath, 'codecept.js');
-      const config = JSON.parse(fs.readFileSync(jsonConfigFile, 'utf8'));
-      config.name = testsPath.split(path.sep).pop();
+  inquirer
+    .prompt([
+      {
+        name: 'configFile',
+        type: 'confirm',
+        message: `Would you like to switch from ${colors.cyan.bold('.json')} to ${colors.magenta.bold('.js')} config format?`,
+        default: true,
+      },
+      {
+        name: 'delete',
+        type: 'confirm',
+        message: `Would you like to delete ${colors.cyan.bold('.json')} config format afterwards?`,
+        default: true,
+      },
+    ])
+    .then(result => {
+      if (result.configFile) {
+        const jsonConfigFile = path.join(testsPath, 'codecept.js')
+        const config = JSON.parse(fs.readFileSync(jsonConfigFile, 'utf8'))
+        config.name = testsPath.split(path.sep).pop()
 
-      const finish = () => {
-        fs.writeFileSync(configFile, `exports.config = ${util.inspect(config, false, 4, false)}`, 'utf-8');
-        outputLib.output.success(`Config is successfully migrated at ${configFile}`);
+        const finish = () => {
+          fs.writeFileSync(configFile, `exports.config = ${util.inspect(config, false, 4, false)}`, 'utf-8')
+          success(`Config is successfully migrated at ${configFile}`)
 
-        if (result.delete) {
-          if (fileExists(jsonConfigFile)) {
-            fs.unlinkSync(jsonConfigFile);
-            outputLib.output.success('JSON config file is deleted!');
+          if (result.delete) {
+            if (fileExists(jsonConfigFile)) {
+              fs.unlinkSync(jsonConfigFile)
+              success('JSON config file is deleted!')
+            }
           }
         }
-      };
-      finish();
-    }
-  });
+        finish()
+      }
+    })
 }

package/lib/command/definitions.js

@@ -1,12 +1,11 @@
-import fs from 'fs';
-import path from 'path';
-import { getConfig, getTestRoot } from './utils.js';
-import Codecept from '../codecept.js';
-import container from '../container.js';
-import * as output from '../output.js';
-import plugin from '../plugin/standardActingHelpers.js';
+import fs from 'fs'
+import path from 'path'
 
-const actingHelpers = [...(plugin), '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
@@ -22,40 +21,28 @@ const actingHelpers = [...(plugin), 'REST'];
  *
  * @returns {string}
  */
-const getDefinitionsFileContent = ({
-  hasCustomHelper,
-  hasCustomStepsFile,
-  helperNames,
-  supportObject,
-  importPaths,
-  translations,
-}) => {
-  const getHelperListFragment = ({
-    hasCustomHelper,
-    hasCustomStepsFile,
-  }) => {
+const getDefinitionsFileContent = ({ hasCustomHelper, hasCustomStepsFile, helperNames, supportObject, importPaths, translations }) => {
+  const getHelperListFragment = ({ hasCustomHelper, hasCustomStepsFile }) => {
     if (hasCustomHelper && hasCustomStepsFile) {
-      return `${['ReturnType<steps_file>', 'WithTranslation<Methods>'].join(', ')}`;
+      return `${['ReturnType<steps_file>', 'WithTranslation<Methods>'].join(', ')}`
     }
 
     if (hasCustomStepsFile) {
-      return 'ReturnType<steps_file>';
+      return 'ReturnType<steps_file>'
     }
 
-    return 'WithTranslation<Methods>';
-  };
+    return 'WithTranslation<Methods>'
+  }
 
   const helpersListFragment = getHelperListFragment({
     hasCustomHelper,
     hasCustomStepsFile,
-  });
+  })
 
-  const importPathsFragment = importPaths.join('\n');
-  const supportObjectsTypeFragment = convertMapToType(supportObject);
-  const methodsTypeFragment = helperNames.length > 0
-    ? `interface Methods extends ${helperNames.join(', ')} {}`
-    : '';
-  const translatedActionsFragment = JSON.stringify(translations.vocabulary.actions, null, 2);
+  const importPathsFragment = importPaths.join('\n')
+  const supportObjectsTypeFragment = convertMapToType(supportObject)
+  const methodsTypeFragment = helperNames.length > 0 ? `interface Methods extends ${helperNames.join(', ')} {}` : ''
+  const translatedActionsFragment = JSON.stringify(translations.vocabulary.actions, null, 2)
 
   return generateDefinitionsContent({
     helpersListFragment,
@@ -63,8 +50,8 @@ const getDefinitionsFileContent = ({
     supportObjectsTypeFragment,
     methodsTypeFragment,
     translatedActionsFragment,
-  });
-};
+  })
+}
 
 /**
  * Generate content for definitions file from fragments
@@ -79,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}
 
@@ -97,83 +78,84 @@ declare namespace CodeceptJS {
     interface Actions ${translatedActionsFragment}
   }
 }
-`;
-};
+`
+}
 
 /** @type {Array<string>} */
-const helperNames = [];
+const helperNames = []
 /** @type {Array<string>} */
-const customHelpers = [];
+const customHelpers = []
 
-export default function (genPath, options) {
-  const configFile = options.config || genPath;
+export default async function (genPath, options) {
+  const configFile = options.config || genPath
   /** @type {string} */
-  const testsPath = getTestRoot(configFile);
-  const config = getConfig(configFile);
-  if (!config) return;
+  const testsPath = getTestRoot(configFile)
+  const config = await getConfig(configFile)
+  if (!config) return
 
   /** @type {Object<string, string>} */
-  const helperPaths = {};
+  const helperPaths = {}
   /** @type {Object<string, string>} */
-  const supportPaths = {};
+  const supportPaths = {}
   /** @type {boolean} */
-  let hasCustomStepsFile = false;
+  let hasCustomStepsFile = false
   /** @type {boolean} */
-  let hasCustomHelper = false;
+  let hasCustomHelper = false
 
   /** @type {string} */
-  const targetFolderPath = options.output && getTestRoot(options.output) || testsPath;
+  const targetFolderPath = (options.output && getTestRoot(options.output)) || testsPath
 
-  const codecept = new Codecept(config, {});
-  codecept.init(testsPath);
+  const codecept = new Codecept(config, {})
+  await codecept.init(testsPath)
+  await container.started()
 
-  const helpers = container.helpers();
-  const translations = container.translation();
+  const helpers = container.helpers()
+  const translations = container.translation()
   for (const name in helpers) {
-    const require = codecept.config.helpers[name].require;
+    const require = codecept.config.helpers[name].require
     if (require) {
-      helperPaths[name] = require;
-      helperNames.push(name);
+      helperPaths[name] = require
+      helperNames.push(name)
     } else {
-      const fullBasedPromised = codecept.config.fullPromiseBased;
-      helperNames.push(fullBasedPromised === true ? `${name}Ts` : name);
+      const fullBasedPromised = codecept.config.fullPromiseBased
+      helperNames.push(fullBasedPromised === true ? `${name}Ts` : name)
     }
 
     if (!actingHelpers.includes(name)) {
-      customHelpers.push(name);
+      customHelpers.push(name)
     }
   }
 
-  let autoLogin;
+  let autoLogin
   if (config.plugins.autoLogin) {
-    autoLogin = config.plugins.autoLogin.inject;
+    autoLogin = config.plugins.autoLogin.inject
   }
 
-  const supportObject = new Map();
-  supportObject.set('I', 'I');
-  supportObject.set('current', 'any');
+  const supportObject = new Map()
+  supportObject.set('I', 'I')
+  supportObject.set('current', 'any')
 
   if (translations.loaded) {
-    supportObject.set(translations.I, translations.I);
+    supportObject.set(translations.I, translations.I)
   }
 
   if (autoLogin) {
-    supportObject.set(autoLogin, 'any');
+    supportObject.set(autoLogin, 'any')
   }
 
   if (customHelpers.length > 0) {
-    hasCustomHelper = true;
+    hasCustomHelper = true
   }
 
   for (const name in codecept.config.include) {
-    const includePath = codecept.config.include[name];
+    const includePath = codecept.config.include[name]
     if (name === 'I' || name === translations.I) {
-      hasCustomStepsFile = true;
-      supportPaths.steps_file = includePath;
-      continue;
+      hasCustomStepsFile = true
+      supportPaths.steps_file = includePath
+      continue
     }
-    supportPaths[name] = includePath;
-    supportObject.set(name, name);
+    supportPaths[name] = includePath
+    supportObject.set(name, name)
   }
 
   let definitionsFileContent = getDefinitionsFileContent({
@@ -183,30 +165,32 @@ export default function (genPath, options) {
     translations,
     hasCustomStepsFile,
     hasCustomHelper,
-  });
+  })
 
   // add aliases for translations
   if (translations.loaded) {
-    const namespaceTranslationAliases = [];
-    namespaceTranslationAliases.push(`interface ${translations.vocabulary.I} extends WithTranslation<Methods> {}`);
+    const namespaceTranslationAliases = []
+    namespaceTranslationAliases.push(`interface ${translations.vocabulary.I} extends WithTranslation<Methods> {}`)
 
-    namespaceTranslationAliases.push('  namespace Translation {');
-    definitionsFileContent = definitionsFileContent.replace('namespace Translation {', namespaceTranslationAliases.join('\n'));
+    namespaceTranslationAliases.push('  namespace Translation {')
+    definitionsFileContent = definitionsFileContent.replace('namespace Translation {', namespaceTranslationAliases.join('\n'))
 
-    const translationAliases = [];
+    const translationAliases = []
 
     if (translations.vocabulary.contexts) {
       Object.keys(translations.vocabulary.contexts).forEach(k => {
-        translationAliases.push(`declare const ${translations.vocabulary.contexts[k]}: typeof ${k};`);
-      });
+        translationAliases.push(`declare const ${translations.vocabulary.contexts[k]}: typeof ${k};`)
+      })
     }
 
-    definitionsFileContent += `\n${translationAliases.join('\n')}`;
+    definitionsFileContent += `\n${translationAliases.join('\n')}`
   }
 
-  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');
+  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')
 }
 
 /**
@@ -216,23 +200,19 @@ export default function (genPath, options) {
  * @param {string} testsPath
  */
 function getPath(originalPath, targetFolderPath, testsPath) {
-  const parsedPath = path.parse(originalPath);
+  const parsedPath = path.parse(originalPath)
 
   // Remove typescript extension if exists.
-  if (parsedPath.base.endsWith('.d.ts')) parsedPath.base = parsedPath.base.substring(0, parsedPath.base.length - 5);
-  else if (parsedPath.ext === '.ts') parsedPath.base = parsedPath.name;
+  if (parsedPath.base.endsWith('.d.ts')) parsedPath.base = parsedPath.base.substring(0, parsedPath.base.length - 5)
+  else if (parsedPath.ext === '.ts') parsedPath.base = parsedPath.name
 
-  if (!parsedPath.dir.startsWith('.')) return path.posix.join(parsedPath.dir, parsedPath.base);
+  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),
-    ),
-  );
-
-  return relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
+    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}`
 }
 
 /**
@@ -246,19 +226,24 @@ function getPath(originalPath, targetFolderPath, testsPath) {
  * @returns {Array<string>}
  */
 function getImportString(testsPath, targetFolderPath, pathsToType, pathsToValue) {
-  const importStrings = [];
+  const importStrings = []
 
   for (const name in pathsToType) {
-    const relativePath = getPath(pathsToType[name], targetFolderPath, testsPath);
-    importStrings.push(`type ${name} = typeof import('${relativePath}');`);
+    const relativePath = getPath(pathsToType[name], targetFolderPath, testsPath)
+    // 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) {
-    const relativePath = getPath(pathsToValue[name], targetFolderPath, testsPath);
-    importStrings.push(`type ${name} = import('${relativePath}');`);
+    const relativePath = getPath(pathsToValue[name], targetFolderPath, testsPath)
+    importStrings.push(`type ${name} = import('${relativePath}');`)
   }
 
-  return importStrings;
+  return importStrings
 }
 
 /**
@@ -267,5 +252,7 @@ function getImportString(testsPath, targetFolderPath, pathsToType, pathsToValue)
  * @returns {string}
  */
 function convertMapToType(map) {
-  return `{ ${Array.from(map).map(([key, value]) => `${key}: ${value}`).join(', ')} }`;
+  return `{ ${Array.from(map)
+    .map(([key, value]) => `${key}: ${value}`)
+    .join(', ')} }`
 }