codeceptjs 3.6.6 → 4.0.0-beta.1

package/lib/interfaces/featureConfig.js

@@ -1,7 +1,7 @@
 /** @class */
 class FeatureConfig {
   constructor(suite) {
-    this.suite = suite
+    this.suite = suite;
   }
 
   /**
@@ -11,8 +11,8 @@ class FeatureConfig {
    * @returns {this}
    */
   retry(retries) {
-    this.suite.retries(retries)
-    return this
+    this.suite.retries(retries);
+    return this;
   }
 
   /**
@@ -22,11 +22,11 @@ class FeatureConfig {
    * @deprecated
    */
   timeout(timeout) {
-    console.log(`Feature('${this.suite.title}').timeout(${timeout}) is deprecated!`)
-    console.log(`Please use Feature('${this.suite.title}', { timeout: ${timeout / 1000} }) instead`)
-    console.log('Timeout should be set in seconds')
-    this.suite.timeout(timeout)
-    return this
+    console.log(`Feature('${this.suite.title}').timeout(${timeout}) is deprecated!`);
+    console.log(`Please use Feature('${this.suite.title}', { timeout: ${timeout / 1000} }) instead`);
+    console.log('Timeout should be set in seconds');
+    this.suite.timeout(timeout);
+    return this;
   }
 
   /**
@@ -38,17 +38,17 @@ class FeatureConfig {
    */
   config(helper, obj) {
     if (!obj) {
-      obj = helper
-      helper = 0
+      obj = helper;
+      helper = 0;
     }
     if (typeof obj === 'function') {
-      obj = obj(this.suite)
+      obj = obj(this.suite);
     }
     if (!this.suite.config) {
-      this.suite.config = {}
+      this.suite.config = {};
     }
-    this.suite.config[helper] = obj
-    return this
+    this.suite.config[helper] = obj;
+    return this;
   }
 
   /**
@@ -58,12 +58,12 @@ class FeatureConfig {
    */
   tag(tagName) {
     if (tagName[0] !== '@') {
-      tagName = `@${tagName}`
+      tagName = `@${tagName}`;
     }
-    this.suite.tags.push(tagName)
-    this.suite.title = `${this.suite.title.trim()} ${tagName}`
-    return this
+    this.suite.tags.push(tagName);
+    this.suite.title = `${this.suite.title.trim()} ${tagName}`;
+    return this;
   }
 }
 
-module.exports = FeatureConfig
+export default FeatureConfig;

package/lib/interfaces/gherkin.js

@@ -1,201 +1,195 @@
-const Gherkin = require('@cucumber/gherkin')
-const Messages = require('@cucumber/messages')
-const { Context, Suite, Test } = require('mocha')
-const debug = require('debug')('codeceptjs:bdd')
-
-const { matchStep } = require('./bdd')
-const event = require('../event')
-const scenario = require('../scenario')
-const Step = require('../step')
-const DataTableArgument = require('../data/dataTableArgument')
-const transform = require('../transform')
-
-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
-
-module.exports = (text, file) => {
-  const ast = parser.parse(text)
-  let currentLanguage
+import * as Gherkin from '@cucumber/gherkin';
+import * as Messages from '@cucumber/messages';
+import { Context, Suite, Test } from 'mocha';
+
+import debug from 'debug';
+
+import { matchStep } from './bdd.js';
+import * as event from '../event.js';
+import * as scenario from '../scenario.js';
+import * as Step from '../step.js';
+import DataTableArgument from '../data/dataTableArgument.js';
+import transform from '../transform.js';
+
+import * as translations0 from '../../translations/index.js';
+
+debug('codeceptjs:bdd');
+
+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;
+
+export default (text, file) => {
+  const ast = parser.parse(text);
+  let currentLanguage;
 
   if (ast.feature) {
-    currentLanguage = getTranslation(ast.feature.language)
+    currentLanguage = getTranslation(ast.feature.language);
   }
 
   if (!ast.feature) {
-    throw new Error(`No 'Features' available in Gherkin '${file}' provided!`)
+    throw new Error(`No 'Features' available in Gherkin '${file}' provided!`);
   }
-  const suite = new Suite(ast.feature.name, new Context())
-  const tags = ast.feature.tags.map((t) => t.name)
-  suite.title = `${suite.title} ${tags.join(' ')}`.trim()
-  suite.tags = tags || []
-  suite.comment = ast.feature.description
-  suite.feature = ast.feature
-  suite.file = file
-  suite.timeout(0)
-
-  suite.beforeEach('codeceptjs.before', () => scenario.setup(suite))
-  suite.afterEach('codeceptjs.after', () => scenario.teardown(suite))
-  suite.beforeAll('codeceptjs.beforeSuite', () => scenario.suiteSetup(suite))
-  suite.afterAll('codeceptjs.afterSuite', () => scenario.suiteTeardown(suite))
+  const suite = new Suite(ast.feature.name, new Context());
+  const tags = ast.feature.tags.map(t => t.name);
+  suite.title = `${suite.title} ${tags.join(' ')}`.trim();
+  suite.tags = tags || [];
+  suite.comment = ast.feature.description;
+  suite.feature = ast.feature;
+  suite.file = file;
+  suite.timeout(0);
+
+  suite.beforeEach('codeceptjs.before', () => scenario.setup(suite));
+  suite.afterEach('codeceptjs.after', () => scenario.teardown(suite));
+  suite.beforeAll('codeceptjs.beforeSuite', () => scenario.suiteSetup(suite));
+  suite.afterAll('codeceptjs.afterSuite', () => scenario.suiteTeardown(suite));
 
   const runSteps = async (steps) => {
     for (const step of steps) {
-      const metaStep = new Step.MetaStep(null, step.text)
-      metaStep.actor = step.keyword.trim()
-      let helperStep
+      const metaStep = new Step.MetaStep(null, step.text);
+      metaStep.actor = step.keyword.trim();
+      let helperStep;
       const setMetaStep = (step) => {
-        helperStep = step
+        helperStep = step;
         if (step.metaStep) {
           if (step.metaStep === metaStep) {
-            return
+            return;
           }
-          setMetaStep(step.metaStep)
-          return
+          setMetaStep(step.metaStep);
+          return;
         }
-        step.metaStep = metaStep
-      }
-      const fn = matchStep(step.text)
+        step.metaStep = metaStep;
+      };
+      const fn = matchStep(step.text);
 
       if (step.dataTable) {
         fn.params.push({
           ...step.dataTable,
           parse: () => new DataTableArgument(step.dataTable),
-        })
-        metaStep.comment = `\n${transformTable(step.dataTable)}`
+        });
+        metaStep.comment = `\n${transformTable(step.dataTable)}`;
       }
 
       if (step.docString) {
-        fn.params.push(step.docString)
-        metaStep.comment = `\n"""\n${step.docString.content}\n"""`
+        fn.params.push(step.docString);
+        metaStep.comment = `\n"""\n${step.docString.content}\n"""`;
       }
 
-      step.startTime = Date.now()
-      step.match = fn.line
-      event.emit(event.bddStep.before, step)
-      event.emit(event.bddStep.started, metaStep)
-      event.dispatcher.prependListener(event.step.before, setMetaStep)
+      step.startTime = Date.now();
+      step.match = fn.line;
+      event.emit(event.bddStep.before, step);
+      event.emit(event.bddStep.started, metaStep);
+      event.dispatcher.prependListener(event.step.before, setMetaStep);
       try {
-        debug(`Step '${step.text}' started...`)
-        await fn(...fn.params)
-        debug('Step passed')
-        step.status = 'passed'
+        debug(`Step '${step.text}' started...`);
+        await fn(...fn.params);
+        debug('Step passed');
+        step.status = 'passed';
       } catch (err) {
-        debug(`Step failed: ${err?.message}`)
-        step.status = 'failed'
-        step.err = err
-        throw err
+        debug(`Step failed: ${err?.message}`);
+        step.status = 'failed';
+        step.err = err;
+        throw err;
       } finally {
-        step.endTime = Date.now()
-        event.dispatcher.removeListener(event.step.before, setMetaStep)
+        step.endTime = Date.now();
+        event.dispatcher.removeListener(event.step.before, setMetaStep);
       }
-      event.emit(event.bddStep.finished, metaStep)
-      event.emit(event.bddStep.after, step)
+      event.emit(event.bddStep.finished, metaStep);
+      event.emit(event.bddStep.after, step);
     }
-  }
+  };
 
   for (const child of ast.feature.children) {
     if (child.background) {
-      suite.beforeEach(
-        'Before',
-        scenario.injected(async () => runSteps(child.background.steps), suite, 'before'),
-      )
-      continue
+      suite.beforeEach('Before', scenario.injected(async () => runSteps(child.background.steps), suite, 'before'));
+      continue;
     }
-    if (
-      child.scenario &&
-      (currentLanguage
-        ? child.scenario.keyword === currentLanguage.contexts.ScenarioOutline
-        : child.scenario.keyword === 'Scenario Outline')
-    ) {
+    if (child.scenario && (currentLanguage ? child.scenario.keyword === currentLanguage.contexts.ScenarioOutline : child.scenario.keyword === 'Scenario Outline')) {
       for (const examples of child.scenario.examples) {
-        const fields = examples.tableHeader.cells.map((c) => c.value)
+        const fields = examples.tableHeader.cells.map(c => c.value);
         for (const example of examples.tableBody) {
-          let exampleSteps = [...child.scenario.steps]
-          const current = {}
+          let exampleSteps = [...child.scenario.steps];
+          const current = {};
           for (const index in example.cells) {
-            const placeholder = fields[index]
-            const value = transform('gherkin.examples', example.cells[index].value)
-            example.cells[index].value = value
-            current[placeholder] = value
+            const placeholder = fields[index];
+            const value = transform('gherkin.examples', example.cells[index].value);
+            example.cells[index].value = value;
+            current[placeholder] = value;
             exampleSteps = exampleSteps.map((step) => {
-              step = { ...step }
-              step.text = step.text.split(`<${placeholder}>`).join(value)
-              return step
-            })
+              step = { ...step };
+              step.text = step.text.split(`<${placeholder}>`).join(value);
+              return step;
+            });
           }
-          const tags = child.scenario.tags.map((t) => t.name).concat(examples.tags.map((t) => t.name))
-          let title = `${child.scenario.name} ${JSON.stringify(current)} ${tags.join(' ')}`.trim()
+          const tags = child.scenario.tags.map(t => t.name).concat(examples.tags.map(t => t.name));
+          let title = `${child.scenario.name} ${JSON.stringify(current)} ${tags.join(' ')}`.trim();
 
           for (const [key, value] of Object.entries(current)) {
             if (title.includes(`<${key}>`)) {
-              title = title.replace(JSON.stringify(current), '').replace(`<${key}>`, value)
+              title = title.replace(JSON.stringify(current), '').replace(`<${key}>`, value);
             }
           }
 
-          const test = new Test(title, async () => runSteps(addExampleInTable(exampleSteps, current)))
-          test.tags = suite.tags.concat(tags)
-          test.file = file
-          suite.addTest(scenario.test(test))
+          const test = new Test(title, async () => runSteps(addExampleInTable(exampleSteps, current)));
+          test.tags = suite.tags.concat(tags);
+          test.file = file;
+          suite.addTest(scenario.test(test));
         }
       }
-      continue
+      continue;
     }
 
     if (child.scenario) {
-      const tags = child.scenario.tags.map((t) => t.name)
-      const title = `${child.scenario.name} ${tags.join(' ')}`.trim()
-      const test = new Test(title, async () => runSteps(child.scenario.steps))
-      test.tags = suite.tags.concat(tags)
-      test.file = file
-      suite.addTest(scenario.test(test))
+      const tags = child.scenario.tags.map(t => t.name);
+      const title = `${child.scenario.name} ${tags.join(' ')}`.trim();
+      const test = new Test(title, async () => runSteps(child.scenario.steps));
+      test.tags = suite.tags.concat(tags);
+      test.file = file;
+      suite.addTest(scenario.test(test));
     }
   }
 
-  return suite
-}
+  return suite;
+};
 
 function transformTable(table) {
-  let str = ''
+  let str = '';
   for (const id in table.rows) {
-    const cells = table.rows[id].cells
-    str += cells
-      .map((c) => c.value)
-      .map((c) => c.padEnd(15))
-      .join(' | ')
-    str += '\n'
+    const cells = table.rows[id].cells;
+    str += cells.map(c => c.value).map(c => c.padEnd(15)).join(' | ');
+    str += '\n';
   }
-  return str
+  return str;
 }
 function addExampleInTable(exampleSteps, placeholders) {
-  const steps = JSON.parse(JSON.stringify(exampleSteps))
+  const steps = JSON.parse(JSON.stringify(exampleSteps));
   for (const placeholder in placeholders) {
     steps.map((step) => {
-      step = { ...step }
+      step = { ...step };
       if (step.dataTable) {
         for (const id in step.dataTable.rows) {
-          const cells = step.dataTable.rows[id].cells
-          cells.map((c) => (c.value = c.value.replace(`<${placeholder}>`, placeholders[placeholder])))
+          const cells = step.dataTable.rows[id].cells;
+          cells.map(c => (c.value = c.value.replace(`<${placeholder}>`, placeholders[placeholder])));
         }
       }
-      return step
-    })
+      return step;
+    });
   }
-  return steps
+  return steps;
 }
 
 function getTranslation(language) {
-  const translations = Object.keys(require('../../translations'))
+  const translations = Object.keys(translations0);
 
   for (const availableTranslation of translations) {
     if (!language) {
-      break
+      break;
     }
 
     if (availableTranslation.includes(language)) {
-      return require('../../translations')[availableTranslation]
+      return translations0[availableTranslation];
     }
   }
 }

package/lib/interfaces/scenarioConfig.js

@@ -1,7 +1,7 @@
 /** @class */
 class ScenarioConfig {
   constructor(test) {
-    this.test = test
+    this.test = test;
   }
 
   /**
@@ -12,8 +12,8 @@ class ScenarioConfig {
    * @returns {this}
    */
   throws(err) {
-    this.test.throws = err
-    return this
+    this.test.throws = err;
+    return this;
   }
 
   /**
@@ -24,8 +24,8 @@ class ScenarioConfig {
    * @returns {this}
    */
   fails() {
-    this.test.throws = new Error()
-    return this
+    this.test.throws = new Error();
+    return this;
   }
 
   /**
@@ -35,9 +35,9 @@ class ScenarioConfig {
    * @returns {this}
    */
   retry(retries) {
-    if (process.env.SCENARIO_ONLY) retries = -retries
-    this.test.retries(retries)
-    return this
+    if (process.env.SCENARIO_ONLY) retries = -retries;
+    this.test.retries(retries);
+    return this;
   }
 
   /**
@@ -46,12 +46,12 @@ class ScenarioConfig {
    * @returns {this}
    */
   timeout(timeout) {
-    console.log(`Scenario('${this.test.title}', () => {}).timeout(${timeout}) is deprecated!`)
-    console.log(`Please use Scenario('${this.test.title}', { timeout: ${timeout / 1000} }, () => {}) instead`)
-    console.log('Timeout should be set in seconds')
+    console.log(`Scenario('${this.test.title}', () => {}).timeout(${timeout}) is deprecated!`);
+    console.log(`Please use Scenario('${this.test.title}', { timeout: ${timeout / 1000} }, () => {}) instead`);
+    console.log('Timeout should be set in seconds');
 
-    this.test.timeout(timeout)
-    return this
+    this.test.timeout(timeout);
+    return this;
   }
 
   /**
@@ -60,8 +60,8 @@ class ScenarioConfig {
    * @returns {this}
    */
   inject(obj) {
-    this.test.inject = obj
-    return this
+    this.test.inject = obj;
+    return this;
   }
 
   /**
@@ -73,17 +73,17 @@ class ScenarioConfig {
    */
   async config(helper, obj) {
     if (!obj) {
-      obj = helper
-      helper = 0
+      obj = helper;
+      helper = 0;
     }
     if (typeof obj === 'function') {
-      obj = await obj(this.test)
+      obj = await obj(this.test);
     }
     if (!this.test.config) {
-      this.test.config = {}
+      this.test.config = {};
     }
-    this.test.config[helper] = obj
-    return this
+    this.test.config[helper] = obj;
+    return this;
   }
 
   /**
@@ -92,10 +92,10 @@ class ScenarioConfig {
    * @returns {this}
    */
   tag(tagName) {
-    if (tagName[0] !== '@') tagName = `@${tagName}`
-    this.test.tags.push(tagName)
-    this.test.title = `${this.test.title.trim()} ${tagName}`
-    return this
+    if (tagName[0] !== '@') tagName = `@${tagName}`;
+    this.test.tags.push(tagName);
+    this.test.title = `${this.test.title.trim()} ${tagName}`;
+    return this;
   }
 
   /**
@@ -105,10 +105,10 @@ class ScenarioConfig {
    */
   injectDependencies(dependencies) {
     Object.keys(dependencies).forEach((key) => {
-      this.test.inject[key] = dependencies[key]
-    })
-    return this
+      this.test.inject[key] = dependencies[key];
+    });
+    return this;
   }
 }
 
-module.exports = ScenarioConfig
+export default ScenarioConfig;

package/lib/listener/artifacts.js

@@ -1,19 +1,19 @@
-const event = require('../event')
-const recorder = require('../recorder')
+import * as event from '../event.js';
+import recorder from '../recorder.js';
 
 /**
  * Create and clean up empty artifacts
  */
-module.exports = function () {
+export default function () {
   event.dispatcher.on(event.test.before, (test) => {
-    test.artifacts = {}
-  })
+    test.artifacts = {};
+  });
 
   event.dispatcher.on(event.test.after, (test) => {
     recorder.add('clean up empty artifacts', () => {
-      for (const key in test.artifacts || {}) {
-        if (!test.artifacts[key]) delete test.artifacts[key]
+      for (const key in (test.artifacts || {})) {
+        if (!test.artifacts[key]) delete test.artifacts[key];
       }
-    })
-  })
+    });
+  });
 }

package/lib/listener/config.js

@@ -1,46 +1,46 @@
-const event = require('../event')
-const container = require('../container')
-const recorder = require('../recorder')
-const { deepMerge, deepClone, ucfirst } = require('../utils')
-const { debug } = require('../output')
+import * as event from '../event.js';
+import container from '../container.js';
+import recorder from '../recorder.js';
+import { deepMerge, deepClone, ucfirst } from '../utils.js';
+import * as output from '../output.js';
+
 /**
  * Enable Helpers to listen to test events
  */
-module.exports = function () {
-  const helpers = container.helpers()
+export default function () {
+  const helpers = container.helpers();
 
-  enableDynamicConfigFor('suite')
-  enableDynamicConfigFor('test')
+  enableDynamicConfigFor('suite');
+  enableDynamicConfigFor('test');
 
   function enableDynamicConfigFor(type) {
     event.dispatcher.on(event[type].before, (context = {}) => {
       function updateHelperConfig(helper, config) {
-        const oldConfig = { ...helper.options }
+        const oldConfig = { ...helper.options };
         try {
-          helper._setConfig(deepMerge(deepClone(oldConfig), config))
-          debug(`[${ucfirst(type)} Config] ${helper.constructor.name} ${JSON.stringify(config)}`)
+          helper._setConfig(deepMerge(deepClone(oldConfig), config));
+          debug(`[${ucfirst(type)} Config] ${helper.constructor.name} ${JSON.stringify(config)}`);
         } catch (err) {
-          recorder.throw(err)
-          return
+          recorder.throw(err);
+          return;
         }
         event.dispatcher.once(event[type].after, () => {
-          helper._setConfig(oldConfig)
-          debug(`[${ucfirst(type)} Config] Reverted for ${helper.constructor.name}`)
-        })
+          helper._setConfig(oldConfig);
+          debug(`[${ucfirst(type)} Config] Reverted for ${helper.constructor.name}`);
+        });
       }
 
       // change config
       if (context.config) {
         for (let name in context.config) {
-          const config = context.config[name]
-          if (name === '0') {
-            // first helper
-            name = Object.keys(helpers)[0]
+          const config = context.config[name];
+          if (name === '0') { // first helper
+            name = Object.keys(helpers)[0];
           }
-          const helper = helpers[name]
-          updateHelperConfig(helper, config)
+          const helper = helpers[name];
+          updateHelperConfig(helper, config);
         }
       }
-    })
+    });
   }
 }

package/lib/listener/exit.js

@@ -1,30 +1,30 @@
-const event = require('../event')
+import * as event from '../event.js';
 
-module.exports = function () {
-  let failedTests = []
+export default function () {
+  let failedTests = [];
 
   event.dispatcher.on(event.test.failed, (testOrSuite) => {
     // NOTE When an error happens in one of the hooks (BeforeAll/BeforeEach...) the event object
     // is a suite and not a test
-    const id = testOrSuite.uid || (testOrSuite.ctx && testOrSuite.ctx.test.uid) || 'empty'
-    failedTests.push(id)
-  })
+    const id = testOrSuite.uid || (testOrSuite.ctx && testOrSuite.ctx.test.uid) || 'empty';
+    failedTests.push(id);
+  });
 
   // if test was successful after retries
   event.dispatcher.on(event.test.passed, (testOrSuite) => {
     // NOTE When an error happens in one of the hooks (BeforeAll/BeforeEach...) the event object
     // is a suite and not a test
-    const id = testOrSuite.uid || (testOrSuite.ctx && testOrSuite.ctx.test.uid) || 'empty'
-    failedTests = failedTests.filter((failed) => id !== failed)
-  })
+    const id = testOrSuite.uid || (testOrSuite.ctx && testOrSuite.ctx.test.uid) || 'empty';
+    failedTests = failedTests.filter(failed => id !== failed);
+  });
 
   process.on('beforeExit', (code) => {
     if (failedTests.length) {
-      code = 1
+      code = 1;
     }
 
     if (code) {
-      process.exit(code)
+      process.exit(code);
     }
-  })
+  });
 }