codeceptjs 3.6.4-beta.2 → 3.6.5-beta.1

package/lib/assert/throws.js

@@ -1,20 +1,22 @@
 function errorThrown(actual, expected) {
-  if (!expected) return null;
-  if (!actual) throw new Error(`Expected ${expected} error to be thrown`);
-  const msg = actual.inspect ? actual.inspect() : actual.toString();
+  if (!expected) return null
+  if (!actual) throw new Error(`Expected ${expected} error to be thrown`)
+  const msg = actual.inspect ? actual.inspect() : actual.toString()
   if (expected instanceof RegExp) {
-    if (msg.match(expected)) return null;
-    throw new Error(`Expected error to be thrown with message matching ${expected} while '${msg}' caught`);
+    if (msg.match(expected)) return null
+    throw new Error(`Expected error to be thrown with message matching ${expected} while '${msg}' caught`)
   }
   if (typeof expected === 'string') {
-    if (msg === expected) return null;
-    throw new Error(`Expected error to be thrown with message ${expected} while '${msg}' caught`);
+    if (msg === expected) return null
+    throw new Error(`Expected error to be thrown with message ${expected} while '${msg}' caught`)
   }
   if (typeof expected === 'object') {
-    if (actual.constructor.name !== expected.constructor.name) throw new Error(`Expected ${expected} error to be thrown but ${actual} was caught`);
-    if (expected.message && expected.message !== msg) throw new Error(`Expected error to be thrown with message ${expected.message} while '${msg}' caught`);
+    if (actual.constructor.name !== expected.constructor.name)
+      throw new Error(`Expected ${expected} error to be thrown but ${actual} was caught`)
+    if (expected.message && expected.message !== msg)
+      throw new Error(`Expected error to be thrown with message ${expected.message} while '${msg}' caught`)
   }
-  return null;
+  return null
 }
 
-module.exports = errorThrown;
+module.exports = errorThrown

package/lib/assert/truth.js

@@ -1,37 +1,36 @@
-const Assertion = require('../assert');
-const AssertionFailedError = require('./error');
-const { template } = require('../utils');
-const output = require('../output');
+const Assertion = require('../assert')
+const AssertionFailedError = require('./error')
+const { template } = require('../utils')
+const output = require('../output')
 
 class TruthAssertion extends Assertion {
   constructor(params) {
     super((value) => {
       if (Array.isArray(value)) {
-        return value.filter(val => !!val).length > 0;
+        return value.filter((val) => !!val).length > 0
       }
-      return !!value;
-    }, params);
-    this.params.type = this.params.type || 'to be true';
+      return !!value
+    }, params)
+    this.params.type = this.params.type || 'to be true'
   }
 
   getException() {
-    const err = new AssertionFailedError(this.params, '{{customMessage}}expected {{subject}} {{type}}');
+    const err = new AssertionFailedError(this.params, '{{customMessage}}expected {{subject}} {{type}}')
     err.cliMessage = () => {
-      const msg = err.template
-        .replace('{{subject}}', output.colors.bold('{{subject}}'));
-      return template(msg, this.params);
-    };
-    return err;
+      const msg = err.template.replace('{{subject}}', output.colors.bold('{{subject}}'))
+      return template(msg, this.params)
+    }
+    return err
   }
 
   addAssertParams() {
-    this.params.value = this.params.actual = arguments[0];
-    this.params.expected = true;
-    this.params.customMessage = arguments[1] ? `${arguments[1]}\n\n` : '';
+    this.params.value = this.params.actual = arguments[0]
+    this.params.expected = true
+    this.params.customMessage = arguments[1] ? `${arguments[1]}\n\n` : ''
   }
 }
 
 module.exports = {
   Assertion: TruthAssertion,
   truth: (subject, type) => new TruthAssertion({ subject, type }),
-};
+}

package/lib/command/configMigrate.js

@@ -1,71 +1,76 @@
-const colors = require('chalk');
-const fs = require('fs');
-const inquirer = require('inquirer');
-const mkdirp = require('mkdirp');
-const path = require('path');
-const util = require('util');
+const colors = require('chalk')
+const fs = require('fs')
+const inquirer = require('inquirer')
+const mkdirp = require('mkdirp')
+const path = require('path')
+const util = require('util')
 
-const { print, success, error } = require('../output');
-const { fileExists } = require('../utils');
-const { getTestRoot } = require('./utils');
+const { print, success, error } = require('../output')
+const { fileExists } = require('../utils')
+const { getTestRoot } = require('./utils')
 
 module.exports = function (initPath) {
-  const testsPath = getTestRoot(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();
+  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) {
-    print('No config file is specified.');
-    print(`Test root is assumed to be ${colors.yellow.bold(testsPath)}`);
-    print('----------------------------------');
+    print('No config file is specified.')
+    print(`Test root is assumed to be ${colors.yellow.bold(testsPath)}`)
+    print('----------------------------------')
   } else {
-    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)) {
-    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)) {
-    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');
-        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);
-            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,11 +1,11 @@
-const fs = require('fs');
-const path = require('path');
+const fs = require('fs')
+const path = require('path')
 
-const { getConfig, getTestRoot } = require('./utils');
-const Codecept = require('../codecept');
-const container = require('../container');
-const output = require('../output');
-const actingHelpers = [...require('../plugin/standardActingHelpers'), '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
@@ -29,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,
@@ -62,8 +57,8 @@ const getDefinitionsFileContent = ({
     supportObjectsTypeFragment,
     methodsTypeFragment,
     translatedActionsFragment,
-  });
-};
+  })
+}
 
 /**
  * Generate content for definitions file from fragments
@@ -96,83 +91,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;
+  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({
@@ -182,31 +177,34 @@ 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')
+}
 
 /**
  * Returns the relative path from the  to the targeted folder.
@@ -215,13 +213,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(
@@ -229,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}`
 }
 
 /**
@@ -245,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
 }
 
 /**
@@ -266,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(', ')} }`
 }