codeceptjs 3.6.7 → 4.0.0-beta.1

package/lib/command/definitions.js

@@ -1,11 +1,12 @@
-const fs = require('fs')
-const path = require('path')
+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';
 
-const { getConfig, getTestRoot } = require('./utils')
-const Codecept = require('../codecept')
-const container = require('../container')
-const output = require('../output')
-const actingHelpers = [...require('../plugin/standardActingHelpers'), 'REST']
+const actingHelpers = [...(plugin), 'REST'];
 
 /**
  * Prepare data and generate content of definitions file
@@ -29,27 +30,32 @@ const getDefinitionsFileContent = ({
   importPaths,
   translations,
 }) => {
-  const getHelperListFragment = ({ hasCustomHelper, hasCustomStepsFile }) => {
+  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,
@@ -57,8 +63,8 @@ const getDefinitionsFileContent = ({
     supportObjectsTypeFragment,
     methodsTypeFragment,
     translatedActionsFragment,
-  })
-}
+  });
+};
 
 /**
  * Generate content for definitions file from fragments
@@ -91,83 +97,83 @@ declare namespace CodeceptJS {
     interface Actions ${translatedActionsFragment}
   }
 }
-`
-}
+`;
+};
 
 /** @type {Array<string>} */
-const helperNames = []
+const helperNames = [];
 /** @type {Array<string>} */
-const customHelpers = []
+const customHelpers = [];
 
-module.exports = function (genPath, options) {
-  const configFile = options.config || genPath
+export default 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 = 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, {});
+  codecept.init(testsPath);
 
-  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({
@@ -177,33 +183,30 @@ module.exports = 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};`)
-      })
+      Object.keys(translations.vocabulary.contexts).forEach(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')
+  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');
 }
 
 /**
@@ -213,13 +216,13 @@ module.exports = 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(
@@ -227,9 +230,9 @@ function getPath(originalPath, targetFolderPath, testsPath) {
       parsedPath.dir.split(path.sep).join(path.posix.sep),
       parsedPath.base.split(path.sep).join(path.posix.sep),
     ),
-  )
+  );
 
-  return relativePath.startsWith('.') ? relativePath : `./${relativePath}`
+  return relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
 }
 
 /**
@@ -243,19 +246,19 @@ 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);
+    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;
 }
 
 /**
@@ -264,7 +267,5 @@ 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(', ')} }`;
 }

package/lib/command/dryRun.js

@@ -1,122 +1,119 @@
-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) {
-  if (options.grep) process.env.grep = options.grep.toLowerCase()
-  const configFile = options.config
-  let codecept
-
-  const testRoot = getTestRoot(configFile)
-  let config = getConfig(configFile)
+import { getConfig, getTestRoot } from './utils.js';
+import Config from '../config.js';
+import Codecept from '../codecept.js';
+import { output } from '../output.js';
+import * as event from '../event.js';
+import { store } from '../store.js';
+import container from '../container.js';
+import colors from "chalk";
+import figures from "figures";
+
+export default async function (test, options) {
+  if (options.grep) process.env.grep = options.grep.toLowerCase();
+  const configFile = options.config;
+  let codecept;
+
+  const testRoot = getTestRoot(configFile);
+  let config = getConfig(configFile);
   if (options.override) {
-    config = Config.append(JSON.parse(options.override))
+    config = Config.append(JSON.parse(options.override));
   }
 
   if (config.plugins) {
     // disable all plugins by default, they can be enabled with -p option
     for (const plugin in config.plugins) {
       // if `-p all` is passed, then enabling all plugins, otherwise plugins could be enabled by `-p customLocator,commentStep,tryTo`
-      config.plugins[plugin].enabled = options.plugins === 'all'
+      config.plugins[plugin].enabled = options.plugins === 'all';
     }
   }
 
   try {
-    codecept = new Codecept(config, options)
-    codecept.init(testRoot)
+    codecept = new Codecept(config, options);
+    codecept.init(testRoot);
 
-    if (options.bootstrap) await codecept.bootstrap()
+    if (options.bootstrap) await codecept.bootstrap();
 
-    codecept.loadTests()
-    store.dryRun = true
+    codecept.loadTests();
+    store.dryRun = true;
 
     if (!options.steps && !options.verbose && !options.debug) {
-      printTests(codecept.testFiles)
-      return
+      printTests(codecept.testFiles);
+      return;
     }
-    event.dispatcher.on(event.all.result, printFooter)
-    codecept.run(test)
+    event.dispatcher.on(event.all.result, printFooter);
+    codecept.run(test);
   } catch (err) {
-    console.error(err)
-    process.exit(1)
+    console.error(err);
+    process.exit(1);
   }
 }
 
 function printTests(files) {
-  const figures = require('figures')
-  const colors = require('chalk')
+  output.print(output.styles.debug(`Tests from ${global.codecept_dir}:`));
+  output.print();
 
-  output.print(output.styles.debug(`Tests from ${global.codecept_dir}:`))
-  output.print()
+  const mocha = container.mocha();
+  mocha.files = files;
+  mocha.loadFiles();
 
-  const mocha = Container.mocha()
-  mocha.files = files
-  mocha.loadFiles()
-
-  let numOfTests = 0
-  let numOfSuites = 0
-  let outputString = ''
-  const filterBy = process.env.grep ? process.env.grep.toLowerCase() : undefined
+  let numOfTests = 0;
+  let numOfSuites = 0;
+  let outputString = '';
+  const filterBy = process.env.grep ? process.env.grep.toLowerCase() : undefined;
 
   if (filterBy) {
     for (const suite of mocha.suite.suites) {
-      const currentSuite = suite.title
+      const currentSuite = suite.title;
       if (suite.title.toLowerCase().includes(filterBy)) {
-        outputString += `${colors.white.bold(suite.title)} -- ${output.styles.log(suite.file || '')} -- ${mocha.suite.suites.length} tests\n`
-        numOfSuites++
+        outputString += `${colors.white.bold(suite.title)} -- ${output.styles.log(suite.file || '')} -- ${mocha.suite.suites.length} tests\n`;
+        numOfSuites++;
       }
 
-      for (test of suite.tests) {
+      for (const test of suite.tests) {
         if (test.title.toLowerCase().includes(filterBy)) {
-          numOfTests++
-          outputString += `${colors.white.bold(test.parent.title)} -- ${output.styles.log(test.parent.file || '')} -- ${mocha.suite.suites.length} tests\n`
-          outputString += `  ${output.styles.scenario(figures.checkboxOff)} ${test.title}\n`
+          numOfTests++;
+          outputString += `${colors.white.bold(test.parent.title)} -- ${output.styles.log(test.parent.file || '')} -- ${mocha.suite.suites.length} tests\n`;
+          outputString += `  ${output.styles.scenario(figures.checkboxOff)} ${test.title}\n`;
         }
       }
     }
-    numOfSuites = countSuites(outputString)
+    numOfSuites = countSuites(outputString);
   } else {
     for (const suite of mocha.suite.suites) {
-      output.print(
-        `${colors.white.bold(suite.title)} -- ${output.styles.log(suite.file || '')} -- ${mocha.suite.suites.length} tests`,
-      )
-      numOfSuites++
-
-      for (test of suite.tests) {
-        numOfTests++
-        output.print(`  ${output.styles.scenario(figures.checkboxOff)} ${test.title}`)
+      output.print(`${colors.white.bold(suite.title)} -- ${output.styles.log(suite.file || '')} -- ${mocha.suite.suites.length} tests`);
+      numOfSuites++;
+
+      for (const test of suite.tests) {
+        numOfTests++;
+        output.print(`  ${output.styles.scenario(figures.checkboxOff)} ${test.title}`);
       }
     }
   }
 
-  output.print(removeDuplicates(outputString))
-  output.print('')
-  output.success(`  Total: ${numOfSuites} suites | ${numOfTests} tests  `)
-  printFooter()
-  process.exit(0)
+  output.print(removeDuplicates(outputString));
+  output.print('');
+  output.success(`  Total: ${numOfSuites} suites | ${numOfTests} tests  `);
+  printFooter();
+  process.exit(0);
 }
 
 function printFooter() {
-  output.print()
-  output.print('--- DRY MODE: No tests were executed ---')
+  output.print();
+  output.print('--- DRY MODE: No tests were executed ---');
 }
 
 function removeDuplicates(inputString) {
-  const array = inputString.split('\n')
-  const uniqueLines = [...new Set(array)]
-  const resultString = uniqueLines.join('\n')
+  const array = inputString.split('\n');
+  const uniqueLines = [...new Set(array)];
+  const resultString = uniqueLines.join('\n');
 
-  return resultString
+  return resultString;
 }
 
 function countSuites(inputString) {
-  const array = inputString.split('\n')
+  const array = inputString.split('\n');
 
-  const uniqueLines = [...new Set(array)]
-  const res = uniqueLines.filter((item) => item.includes('-- '))
-  return res.length
+  const uniqueLines = [...new Set(array)];
+  const res = uniqueLines.filter(item => item.includes('-- '));
+  return res.length;
 }