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

package/lib/history.js

@@ -10,6 +10,9 @@ const output = require('./output');
  */
 class ReplHistory {
   constructor() {
+    if (global.output_dir) {
+      this.historyFile = path.join(global.output_dir, 'cli-history');
+    }
     this.commands = [];
   }
 
@@ -21,16 +24,26 @@ class ReplHistory {
     this.commands.pop();
   }
 
+  load() {
+    if (!this.historyFile) return;
+    if (!fs.existsSync(this.historyFile)) {
+      return;
+    }
+
+    const history = fs.readFileSync(this.historyFile, 'utf-8');
+    return history.split('\n').reverse().filter(line => line.startsWith('I.')).map(line => line.slice(2));
+  }
+
   save() {
+    if (!this.historyFile) return;
     if (this.commands.length === 0) {
       return;
     }
 
-    const historyFile = path.join(global.output_dir, 'cli-history');
     const commandSnippet = `\n\n<<< Recorded commands on ${new Date()}\n${this.commands.join('\n')}`;
-    fs.appendFileSync(historyFile, commandSnippet);
+    fs.appendFileSync(this.historyFile, commandSnippet);
 
-    output.print(colors.yellow(` Commands have been saved to ${historyFile}`));
+    output.print(colors.yellow(` Commands have been saved to ${this.historyFile}`));
 
     this.commands = [];
   }

package/lib/interfaces/bdd.js

@@ -1,86 +1,73 @@
-const { CucumberExpression, ParameterTypeRegistry, ParameterType } = require('@cucumber/cucumber-expressions');
-const Config = require('../config');
+const { CucumberExpression, ParameterTypeRegistry, ParameterType } = require('@cucumber/cucumber-expressions')
+const Config = require('../config')
 
-let steps = {};
+let steps = {}
 
-const STACK_POSITION = 2;
+const STACK_POSITION = 2
 
 /**
  * @param {*} step
  * @param {*} fn
  */
 const addStep = (step, fn) => {
-  const avoidDuplicateSteps = Config.get('gherkin', {}).avoidDuplicateSteps || false;
-  const stack = (new Error()).stack;
+  const avoidDuplicateSteps = Config.get('gherkin', {}).avoidDuplicateSteps || false
+  const stack = new Error().stack
   if (avoidDuplicateSteps && steps[step]) {
-    throw new Error(`Step '${step}' is already defined`);
+    throw new Error(`Step '${step}' is already defined`)
   }
-  steps[step] = fn;
-  fn.line = stack && stack.split('\n')[STACK_POSITION];
+  steps[step] = fn
+  fn.line = stack && stack.split('\n')[STACK_POSITION]
   if (fn.line) {
     fn.line = fn.line
       .trim()
       .replace(/^at (.*?)\(/, '(')
-      .replace(codecept_dir, '.');
+      .replace(codecept_dir, '.')
   }
-};
+}
 
-const parameterTypeRegistry = new ParameterTypeRegistry();
+const parameterTypeRegistry = new ParameterTypeRegistry()
 
 const matchStep = (step) => {
   for (const stepName in steps) {
     if (stepName.indexOf('/') === 0) {
-      const regExpArr = stepName.match(/^\/(.*?)\/([gimy]*)$/) || [];
-      const res = step.match(new RegExp(regExpArr[1], regExpArr[2]));
+      const regExpArr = stepName.match(/^\/(.*?)\/([gimy]*)$/) || []
+      const res = step.match(new RegExp(regExpArr[1], regExpArr[2]))
       if (res) {
-        const fn = steps[stepName];
-        fn.params = res.slice(1);
-        return fn;
+        const fn = steps[stepName]
+        fn.params = res.slice(1)
+        return fn
       }
-      continue;
+      continue
     }
-    const expression = new CucumberExpression(stepName, parameterTypeRegistry);
-    const res = expression.match(step);
+    const expression = new CucumberExpression(stepName, parameterTypeRegistry)
+    const res = expression.match(step)
     if (res) {
-      const fn = steps[stepName];
-      fn.params = res.map(arg => arg.getValue());
-      return fn;
+      const fn = steps[stepName]
+      fn.params = res.map((arg) => arg.getValue())
+      return fn
     }
   }
-  throw new Error(`No steps matching "${step.toString()}"`);
-};
+  throw new Error(`No steps matching "${step.toString()}"`)
+}
 
 const clearSteps = () => {
-  steps = {};
-};
+  steps = {}
+}
 
 const getSteps = () => {
-  return steps;
-};
+  return steps
+}
 
 const defineParameterType = (options) => {
-  const parameterType = buildParameterType(options);
-  parameterTypeRegistry.defineParameterType(parameterType);
-};
+  const parameterType = buildParameterType(options)
+  parameterTypeRegistry.defineParameterType(parameterType)
+}
 
-const buildParameterType = ({
-  name,
-  regexp,
-  transformer,
-  useForSnippets,
-  preferForRegexpMatch,
-}) => {
-  if (typeof useForSnippets !== 'boolean') useForSnippets = true;
-  if (typeof preferForRegexpMatch !== 'boolean') preferForRegexpMatch = false;
-  return new ParameterType(
-    name,
-    regexp,
-    null,
-    transformer,
-    useForSnippets,
-    preferForRegexpMatch,
-  );
-};
+const buildParameterType = ({ name, regexp, transformer, useForSnippets, preferForRegexpMatch }) => {
+  if (typeof useForSnippets !== 'boolean') useForSnippets = true
+  if (typeof preferForRegexpMatch !== 'boolean') preferForRegexpMatch = false
+  return new ParameterType(name, regexp, null, transformer, useForSnippets, preferForRegexpMatch)
+}
 
 module.exports = {
   Given: addStep,
@@ -91,4 +78,4 @@ module.exports = {
   getSteps,
   clearSteps,
   defineParameterType,
-};
+}

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;
+module.exports = FeatureConfig

package/lib/interfaces/gherkin.js

@@ -1,190 +1,201 @@
-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;
+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;
+  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(require('../../translations'))
 
   for (const availableTranslation of translations) {
     if (!language) {
-      break;
+      break
     }
 
     if (availableTranslation.includes(language)) {
-      return require('../../translations')[availableTranslation];
+      return require('../../translations')[availableTranslation]
     }
   }
 }