codeceptjs 4.0.0-beta.1 → 4.0.0-beta.3

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';
+const fs = require('fs')
+const path = require('path')
 
-const actingHelpers = [...(plugin), 'REST'];
+const { getConfig, getTestRoot } = require('./utils')
+const Codecept = require('../codecept')
+const container = require('../container')
+const output = require('../output')
+const actingHelpers = [...require('../plugin/standardActingHelpers'), 'REST']
 
 /**
  * Prepare data and generate content of definitions file
@@ -30,32 +29,27 @@ 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,
@@ -63,8 +57,8 @@ const getDefinitionsFileContent = ({
     supportObjectsTypeFragment,
     methodsTypeFragment,
     translatedActionsFragment,
-  });
-};
+  })
+}
 
 /**
  * Generate content for definitions file from fragments
@@ -97,83 +91,83 @@ 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;
+module.exports = 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({
@@ -183,30 +177,33 @@ 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};`);
-      });
+      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')
 }
 
 /**
@@ -216,13 +213,13 @@ 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(
@@ -230,9 +227,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}`
 }
 
 /**
@@ -246,19 +243,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
 }
 
 /**
@@ -267,5 +264,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(', ')} }`
 }

package/lib/command/dryRun.js

@@ -1,119 +1,122 @@
-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);
+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)
   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) {
-  output.print(output.styles.debug(`Tests from ${global.codecept_dir}:`));
-  output.print();
+  const figures = require('figures')
+  const colors = require('chalk')
 
-  const mocha = container.mocha();
-  mocha.files = files;
-  mocha.loadFiles();
+  output.print(output.styles.debug(`Tests from ${global.codecept_dir}:`))
+  output.print()
 
-  let numOfTests = 0;
-  let numOfSuites = 0;
-  let outputString = '';
-  const filterBy = process.env.grep ? process.env.grep.toLowerCase() : undefined;
+  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
 
   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 (const test of suite.tests) {
+      for (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 (const 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 (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
 }