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

package/lib/command/generate.js

@@ -1,12 +1,12 @@
-const colors = require('chalk')
-const fs = require('fs')
-const inquirer = require('inquirer')
-const mkdirp = require('mkdirp')
-const path = require('path')
-const { fileExists, ucfirst, lcfirst, beautify } = require('../utils')
-const output = require('../output')
-const generateDefinitions = require('./definitions')
-const { getConfig, getTestRoot, safeFileWrite, readConfig } = require('./utils')
+import colors from 'chalk'
+import fs from 'fs'
+import inquirer from 'inquirer'
+import { mkdirp } from 'mkdirp'
+import path from 'path'
+import { fileExists, ucfirst, lcfirst, beautify } from '../utils.js'
+import output from '../output.js'
+import generateDefinitions from './definitions.js'
+import { getConfig, getTestRoot, safeFileWrite, readConfig } from './utils.js'
 
 let extension = 'js'
 
@@ -18,10 +18,10 @@ Scenario('test something', async ({ {{actor}} }) => {
 `
 
 // generates empty test
-module.exports.test = function (genPath) {
+export async function test(genPath) {
   const testsPath = getTestRoot(genPath)
   global.codecept_dir = testsPath
-  const config = getConfig(testsPath)
+  const config = await getConfig(testsPath)
   if (!config) return
 
   output.print('Creating a new test...')
@@ -35,7 +35,7 @@ module.exports.test = function (genPath) {
         type: 'input',
         name: 'feature',
         message: 'Feature which is being tested (ex: account, login, etc)',
-        validate: (val) => !!val,
+        validate: val => !!val,
       },
       {
         type: 'input',
@@ -46,7 +46,7 @@ module.exports.test = function (genPath) {
         },
       },
     ])
-    .then((result) => {
+    .then(async result => {
       const testFilePath = path.dirname(path.join(testsPath, config.tests)).replace(/\*\*$/, '')
       let testFile = path.join(testFilePath, result.filename)
       const ext = path.extname(testFile)
@@ -55,17 +55,16 @@ module.exports.test = function (genPath) {
       if (!fileExists(dir)) mkdirp.sync(dir)
       let testContent = testTemplate.replace('{{feature}}', result.feature)
 
-      const container = require('../container')
-      container.create(config, {})
+      const containerModule = await import('../container.js')
+      const container = containerModule.default || containerModule
+      await container.create(config, {})
       // translate scenario test
       if (container.translation().loaded) {
         const vocabulary = container.translation().vocabulary
         testContent = testContent.replace('{{actor}}', container.translation().I)
         if (vocabulary.contexts.Feature) testContent = testContent.replace('Feature', vocabulary.contexts.Feature)
         if (vocabulary.contexts.Scenario) testContent = testContent.replace('Scenario', vocabulary.contexts.Scenario)
-        output.print(
-          `Test was created in ${colors.bold(config.translation)} localization. See: https://codecept.io/translation/`,
-        )
+        output.print(`Test was created in ${colors.bold(config.translation)} localization. See: https://codecept.io/translation/`)
       } else {
         testContent = testContent.replace('{{actor}}', 'I')
       }
@@ -78,7 +77,7 @@ module.exports.test = function (genPath) {
 
 const pageObjectTemplate = `const { I } = inject();
 
-module.exports = {
+export default {
 
   // insert your locators and methods here
 }
@@ -103,13 +102,13 @@ class {{name}} {
 }
 
 // For inheritance
-module.exports = new {{name}}();
-export = {{name}};
+export default new {{name}}();
+export { {{name}} };
 `
 
-module.exports.pageObject = function (genPath, opts) {
+export async function pageObject(genPath, opts) {
   const testsPath = getTestRoot(genPath)
-  const config = getConfig(testsPath)
+  const config = await getConfig(testsPath)
   const kind = opts.T || 'page'
   if (!config) return
 
@@ -128,13 +127,13 @@ module.exports.pageObject = function (genPath, opts) {
         type: 'input',
         name: 'name',
         message: `Name of a ${kind} object`,
-        validate: (val) => !!val,
+        validate: val => !!val,
       },
       {
         type: 'input',
         name: 'filename',
         message: 'Where should it be stored',
-        default: (answers) => `./${kind}s/${answers.name}.${extension}`,
+        default: answers => `./${kind}s/${answers.name}.${extension}`,
       },
       {
         type: 'list',
@@ -144,7 +143,7 @@ module.exports.pageObject = function (genPath, opts) {
         default: 'module',
       },
     ])
-    .then((result) => {
+    .then(result => {
       const pageObjectFile = path.join(testsPath, result.filename)
       const dir = path.dirname(pageObjectFile)
       if (!fileExists(dir)) fs.mkdirSync(dir)
@@ -157,7 +156,7 @@ module.exports.pageObject = function (genPath, opts) {
           // relative path
           actorPath = path.relative(dir, path.dirname(path.join(testsPath, actorPath))) + actorPath.substring(1) // get an upper level
         }
-        actor = `require('${actorPath}')`
+        actor = `import('${actorPath}')`
       }
 
       const name = lcfirst(result.name) + ucfirst(kind)
@@ -194,14 +193,12 @@ module.exports.pageObject = function (genPath, opts) {
       try {
         generateDefinitions(testsPath, {})
       } catch (_err) {
-        output.print(
-          `Run ${colors.green('npx codeceptjs def')} to update your types to get auto-completion for object.`,
-        )
+        output.print(`Run ${colors.green('npx codeceptjs def')} to update your types to get auto-completion for object.`)
       }
     })
 }
 
-const helperTemplate = `const Helper = require('@codeceptjs/helper');
+const helperTemplate = `import Helper from '@codeceptjs/helper';
 
 class {{name}} extends Helper {
 
@@ -226,10 +223,10 @@ class {{name}} extends Helper {
 
 }
 
-module.exports = {{name}};
+export default {{name}};
 `
 
-module.exports.helper = function (genPath) {
+export async function helper(genPath) {
   const testsPath = getTestRoot(genPath)
 
   output.print('Creating a new helper')
@@ -241,16 +238,16 @@ module.exports.helper = function (genPath) {
         type: 'input',
         name: 'name',
         message: 'Name of a Helper',
-        validate: (val) => !!val,
+        validate: val => !!val,
       },
       {
         type: 'input',
         name: 'filename',
         message: 'Where should it be stored',
-        default: (answers) => `./${answers.name.toLowerCase()}_helper.${extension}`,
+        default: answers => `./${answers.name.toLowerCase()}_helper.${extension}`,
       },
     ])
-    .then((result) => {
+    .then(result => {
       const name = ucfirst(result.name)
       const helperFile = path.join(testsPath, result.filename)
       const dir = path.dirname(helperFile)
@@ -269,9 +266,11 @@ helpers: {
     })
 }
 
+import { fileURLToPath } from 'url'
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
 const healTemplate = fs.readFileSync(path.join(__dirname, '../template/heal.js'), 'utf8').toString()
 
-module.exports.heal = function (genPath) {
+export async function heal(genPath) {
   const testsPath = getTestRoot(genPath)
 
   let configFile = path.join(testsPath, `codecept.conf.${extension}`)
@@ -286,9 +285,9 @@ module.exports.heal = function (genPath) {
   output.print('Require this file in the config file and enable heal plugin:')
   output.print('--------------------------')
   output.print(`
-require('./heal')
+import './heal.js'
 
-exports.config = {
+export const config = {
   // ... 
   plugins: {
     heal: {

package/lib/command/gherkin/init.js

@@ -1,11 +1,9 @@
-const path = require('path');
-const mkdirp = require('mkdirp');
+import path from 'path'
+import { mkdirp } from 'mkdirp'
 
-const output = require('../../output');
-const { fileExists } = require('../../utils');
-const {
-  getConfig, getTestRoot, updateConfig, safeFileWrite, findConfigFile,
-} = require('../utils');
+import output from '../../output.js'
+import { fileExists } from '../../utils.js'
+import { getConfig, getTestRoot, updateConfig, safeFileWrite, findConfigFile } from '../utils.js'
 
 const featureFile = `Feature: Business rules
   In order to achieve my goals
@@ -14,7 +12,7 @@ const featureFile = `Feature: Business rules
 
   Scenario: do something
     Given I have a defined step
-`;
+`
 
 const stepsFile = `const { I } = inject();
 // Add in your custom step files
@@ -22,60 +20,60 @@ const stepsFile = `const { I } = inject();
 Given('I have a defined step', () => {
   // TODO: replace with your own step
 });
-`;
+`
 
-module.exports = function (genPath) {
-  const testsPath = getTestRoot(genPath);
-  const configFile = findConfigFile(testsPath);
+export default async function (genPath) {
+  const testsPath = getTestRoot(genPath)
+  const configFile = findConfigFile(testsPath)
 
   if (!configFile) {
-    output.error(
-      "Can't initialize Gherkin. This command must be run in an already initialized project.",
-    );
-    process.exit(1);
+    output.error("Can't initialize Gherkin. This command must be run in an already initialized project.")
+    process.exit(1)
   }
 
-  const config = getConfig(testsPath);
-  const extension = path.extname(configFile).substring(1);
+  const config = await getConfig(testsPath)
+  const extension = path.extname(configFile).substring(1)
 
-  output.print('Initializing Gherkin (Cucumber BDD) for CodeceptJS');
-  output.print('--------------------------');
+  output.print('Initializing Gherkin (Cucumber BDD) for CodeceptJS')
+  output.print('--------------------------')
 
   if (config.gherkin && config.gherkin.steps) {
-    output.error('Gherkin is already initialized in this project. See `gherkin` section in the config');
-    process.exit(1);
+    output.error('Gherkin is already initialized in this project. See `gherkin` section in the config')
+    process.exit(1)
   }
 
-  let dir;
-  dir = path.join(testsPath, 'features');
+  let dir
+  dir = path.join(testsPath, 'features')
   if (!fileExists(dir)) {
-    mkdirp.sync(dir);
-    output.success(`Created ${dir}, place your *.feature files in it`);
+    mkdirp.sync(dir)
+    // Use relative path for output
+    const relativeDir = path.relative(process.cwd(), dir)
+    output.success(`Created ${relativeDir}, place your *.feature files in it`)
   }
 
   if (safeFileWrite(path.join(dir, 'basic.feature'), featureFile)) {
-    output.success('Created sample feature file: features/basic.feature');
+    output.success('Created sample feature file: features/basic.feature')
   }
 
-  dir = path.join(testsPath, 'step_definitions');
+  dir = path.join(testsPath, 'step_definitions')
   if (!fileExists(dir)) {
-    mkdirp.sync(dir);
-    output.success(`Created ${dir}, place step definitions into it`);
+    mkdirp.sync(dir)
+    // Use relative path for output
+    const relativeDir = path.relative(process.cwd(), dir)
+    output.success(`Created ${relativeDir}, place step definitions into it`)
   }
 
   if (safeFileWrite(path.join(dir, `steps.${extension}`), stepsFile)) {
-    output.success(
-      `Created sample steps file: step_definitions/steps.${extension}`,
-    );
+    output.success(`Created sample steps file: step_definitions/steps.${extension}`)
   }
 
   config.gherkin = {
     features: './features/*.feature',
     steps: [`./step_definitions/steps.${extension}`],
-  };
+  }
 
-  updateConfig(testsPath, config, extension);
+  updateConfig(testsPath, config, extension)
 
-  output.success('Gherkin setup is done.');
-  output.success('Start writing feature files and implement corresponding steps.');
-};
+  output.success('Gherkin setup is done.')
+  output.success('Start writing feature files and implement corresponding steps.')
+}

package/lib/command/gherkin/snippets.js

@@ -1,132 +1,134 @@
-const escapeStringRegexp = require('escape-string-regexp');
-const fs = require('fs');
-const Gherkin = require('@cucumber/gherkin');
-const Messages = require('@cucumber/messages');
-const glob = require('glob');
-const fsPath = require('path');
+import escapeStringRegexp from 'escape-string-regexp'
+import fs from 'fs'
+import Gherkin from '@cucumber/gherkin'
+import { IdGenerator } from '@cucumber/messages'
+import { globSync } from 'glob'
+import fsPath from 'path'
 
-const { getConfig, getTestRoot } = require('../utils');
-const Codecept = require('../../codecept');
-const output = require('../../output');
-const { matchStep } = require('../../interfaces/bdd');
+import { getConfig, getTestRoot } from '../utils.js'
+import Codecept from '../../codecept.js'
+import output from '../../output.js'
+import { matchStep } from '../../mocha/bdd.js'
 
-const uuidFn = Messages.IdGenerator.uuid();
-const builder = new Gherkin.AstBuilder(uuidFn);
-const matcher = new Gherkin.GherkinClassicTokenMatcher();
-const parser = new Gherkin.Parser(builder, matcher);
-parser.stopAtFirstError = false;
+const uuidFn = IdGenerator.uuid()
+const builder = new Gherkin.AstBuilder(uuidFn)
+const matcher = new Gherkin.GherkinClassicTokenMatcher()
+const parser = new Gherkin.Parser(builder, matcher)
+parser.stopAtFirstError = false
 
-module.exports = function (genPath, options) {
-  const configFile = options.config || genPath;
-  const testsPath = getTestRoot(configFile);
-  const config = getConfig(configFile);
-  if (!config) return;
+export default async function (genPath, options) {
+  const configFile = options.config || genPath
+  const testsPath = getTestRoot(configFile)
+  const config = await getConfig(configFile)
+  if (!config) return
 
-  const codecept = new Codecept(config, {});
-  codecept.init(testsPath);
+  const codecept = new Codecept(config, {})
+  await codecept.init(testsPath)
 
   if (!config.gherkin) {
-    output.error('Gherkin is not enabled in config. Run `codecept gherkin:init` to enable it');
-    process.exit(1);
+    output.error('Gherkin is not enabled in config. Run `codecept gherkin:init` to enable it')
+    process.exit(1)
   }
   if (!config.gherkin.steps || !config.gherkin.steps[0]) {
-    output.error('No gherkin steps defined in config. Exiting');
-    process.exit(1);
+    output.error('No gherkin steps defined in config. Exiting')
+    process.exit(1)
   }
   if (!options.feature && !config.gherkin.features) {
-    output.error('No gherkin features defined in config. Exiting');
-    process.exit(1);
+    output.error('No gherkin features defined in config. Exiting')
+    process.exit(1)
   }
   if (options.path && !config.gherkin.steps.includes(options.path)) {
-    output.error(`You must include ${options.path} to the gherkin steps in your config file`);
-    process.exit(1);
+    output.error(`You must include ${options.path} to the gherkin steps in your config file`)
+    process.exit(1)
   }
 
-  const files = [];
-  glob.sync(options.feature || config.gherkin.features, { cwd: options.feature ? '.' : global.codecept_dir }).forEach((file) => {
+  const files = []
+  globSync(options.feature || config.gherkin.features, { cwd: options.feature ? '.' : global.codecept_dir }).forEach(file => {
     if (!fsPath.isAbsolute(file)) {
-      file = fsPath.join(global.codecept_dir, file);
+      file = fsPath.join(global.codecept_dir, file)
     }
-    files.push(fsPath.resolve(file));
-  });
-  output.print(`Loaded ${files.length} files`);
+    files.push(fsPath.resolve(file))
+  })
+  output.print(`Loaded ${files.length} files`)
 
-  const newSteps = new Map();
+  const newSteps = new Map()
 
-  const parseSteps = (steps) => {
-    const newSteps = [];
-    let currentKeyword = '';
+  const parseSteps = steps => {
+    const newSteps = []
+    let currentKeyword = ''
     for (const step of steps) {
       if (step.keyword.trim() === 'And') {
-        if (!currentKeyword) throw new Error(`There is no active keyword for step '${step.text}'`);
-        step.keyword = currentKeyword;
+        if (!currentKeyword) throw new Error(`There is no active keyword for step '${step.text}'`)
+        step.keyword = currentKeyword
       }
-      currentKeyword = step.keyword;
+      currentKeyword = step.keyword
       try {
-        matchStep(step.text);
+        matchStep(step.text)
       } catch (err) {
-        let stepLine;
+        let stepLine
         if (/[{}()/]/.test(step.text)) {
           stepLine = escapeStringRegexp(step.text)
             .replace(/\//g, '\\/')
             .replace(/\"(.*?)\"/g, '"(.*?)"')
             .replace(/(\d+\\\.\d+)/, '(\\d+\\.\\d+)')
-            .replace(/ (\d+) /, ' (\\d+) ');
-          stepLine = Object.assign(stepLine, { type: step.keyword.trim(), location: step.location, regexp: true });
+            .replace(/ (\d+) /, ' (\\d+) ')
+          stepLine = Object.assign(stepLine, { type: step.keyword.trim(), location: step.location, regexp: true })
         } else {
           stepLine = step.text
             .replace(/\"(.*?)\"/g, '{string}')
             .replace(/(\d+\.\d+)/, '{float}')
-            .replace(/ (\d+) /, ' {int} ');
-          stepLine = Object.assign(stepLine, { type: step.keyword.trim(), location: step.location, regexp: false });
+            .replace(/ (\d+) /, ' {int} ')
+          stepLine = Object.assign(stepLine, { type: step.keyword.trim(), location: step.location, regexp: false })
         }
-        newSteps.push(stepLine);
+        newSteps.push(stepLine)
       }
     }
-    return newSteps;
-  };
+    return newSteps
+  }
 
-  const parseFile = (file) => {
-    const ast = parser.parse(fs.readFileSync(file).toString());
+  const parseFile = file => {
+    const ast = parser.parse(fs.readFileSync(file).toString())
     for (const child of ast.feature.children) {
-      if (child.scenario.keyword === 'Scenario Outline') continue; // skip scenario outline
-      parseSteps(child.scenario.steps).map((step) => {
-        return Object.assign(step, { file: file.replace(global.codecept_dir, '').slice(1) });
-      }).map((step) => newSteps.set(`${step.type}(${step})`, step));
+      if (child.scenario.keyword === 'Scenario Outline') continue // skip scenario outline
+      parseSteps(child.scenario.steps)
+        .map(step => {
+          return Object.assign(step, { file: file.replace(global.codecept_dir, '').slice(1) })
+        })
+        .map(step => newSteps.set(`${step.type}(${step})`, step))
     }
-  };
+  }
 
-  files.forEach(file => parseFile(file));
+  files.forEach(file => parseFile(file))
 
-  let stepFile = options.path || config.gherkin.steps[0];
+  let stepFile = options.path || config.gherkin.steps[0]
   if (!fs.existsSync(stepFile)) {
-    output.error(`Please enter a valid step file path ${stepFile}`);
-    process.exit(1);
+    output.error(`Please enter a valid step file path ${stepFile}`)
+    process.exit(1)
   }
 
   if (!fsPath.isAbsolute(stepFile)) {
-    stepFile = fsPath.join(global.codecept_dir, stepFile);
+    stepFile = fsPath.join(global.codecept_dir, stepFile)
   }
 
   const snippets = [...newSteps.values()]
     .filter((value, index, self) => self.indexOf(value) === index)
-    .map((step) => {
+    .map(step => {
       return `
 ${step.type}(${step.regexp ? '/^' : "'"}${step}${step.regexp ? '$/' : "'"}, () => {
   // From "${step.file}" ${JSON.stringify(step.location)}
   throw new Error('Not implemented yet');
-});`;
-    });
+});`
+    })
 
   if (!snippets.length) {
-    output.print('No new snippets found');
-    return;
+    output.print('No new snippets found')
+    return
   }
-  output.success(`Snippets generated: ${snippets.length}`);
-  output.print(snippets.join('\n'));
+  output.success(`Snippets generated: ${snippets.length}`)
+  output.print(snippets.join('\n'))
 
   if (!options.dryRun) {
-    output.success(`Snippets added to ${output.colors.bold(stepFile)}`);
-    fs.writeFileSync(stepFile, fs.readFileSync(stepFile).toString() + snippets.join('\n') + '\n');
+    output.success(`Snippets added to ${output.colors.bold(stepFile)}`)
+    fs.writeFileSync(stepFile, fs.readFileSync(stepFile).toString() + snippets.join('\n') + '\n')
   }
-};
+}

package/lib/command/gherkin/steps.js

@@ -1,25 +1,28 @@
-const { getConfig, getTestRoot } = require('../utils');
-const Codecept = require('../../codecept');
-const output = require('../../output');
-const { getSteps } = require('../../interfaces/bdd');
+import { getConfig, getTestRoot } from '../utils.js'
+import Codecept from '../../codecept.js'
+import output from '../../output.js'
+import { getSteps, clearSteps } from '../../mocha/bdd.js'
 
-module.exports = function (genPath, options) {
-  const configFile = options.config || genPath;
-  const testsPath = getTestRoot(configFile);
-  const config = getConfig(configFile);
-  if (!config) return;
+export default async function (genPath, options) {
+  const configFile = options.config || genPath
+  const testsPath = getTestRoot(configFile)
+  const config = await getConfig(configFile)
+  if (!config) return
 
-  const codecept = new Codecept(config, {});
-  codecept.init(testsPath);
+  // Clear any previously loaded steps
+  clearSteps()
+  
+  const codecept = new Codecept(config, {})
+  await codecept.init(testsPath)
 
-  output.print('Gherkin Step Definitions:');
-  output.print();
-  const steps = getSteps();
+  output.print('Gherkin Step Definitions:')
+  output.print()
+  const steps = getSteps()
   for (const step of Object.keys(steps)) {
-    output.print(`  ${output.colors.bold(step)} ${output.colors.green(steps[step].line || '')}`);
+    output.print(`  ${output.colors.bold(step)} ${output.colors.green(steps[step].line || '')}`)
   }
-  output.print();
+  output.print()
   if (!Object.keys(steps).length) {
-    output.error('No Gherkin steps defined');
+    output.error('No Gherkin steps defined')
   }
-};
+}