@ohlori/gherkin-lint 4.3.0

package/src/rules/no-scenario-outlines-without-examples.js

@@ -0,0 +1,30 @@
+const _ = require('lodash');
+const gherkinUtils = require('./utils/gherkin.js');
+const rule = 'no-scenario-outlines-without-examples';
+
+function run(feature) {
+  if (!feature) {
+    return [];
+  }
+
+  let errors = [];
+  feature.children.forEach(child => {
+    if (child.scenario) {
+      const scenario = child.scenario;
+      const nodeType = gherkinUtils.getNodeType(scenario, feature.language);
+      if (nodeType === 'Scenario Outline' &&  (!_.find(scenario.examples, 'tableBody') || !_.find(scenario.examples, 'tableBody')['tableBody'].length)) {
+        errors.push({
+          message: 'Scenario Outline does not have any Examples',
+          rule   : rule,
+          line   : scenario.location.line
+        });
+      }
+    }
+  });
+  return errors;  
+}
+
+module.exports = {
+  name: rule,
+  run: run
+};

package/src/rules/no-superfluous-tags.js

@@ -0,0 +1,44 @@
+const _ = require('lodash');
+const gherkinUtils = require('./utils/gherkin.js');
+
+const rule = 'no-superfluous-tags';
+
+function run(feature) {
+  if (!feature) {
+    return [];
+  }
+
+  let errors = [];
+
+  feature.children.forEach(child => {
+    const node = child.rule || child.background || child.scenario;
+    checkTags(node, feature, feature.language, errors);
+
+    if (node.examples) {
+      node.examples.forEach(example => {
+        checkTags(example, feature, feature.language, errors);
+        checkTags(example, node, feature.language, errors);
+      });
+    }
+  });
+  return errors;
+}
+
+function checkTags(child, parent, language, errors) {
+  const superfluousTags = _.intersectionBy(child.tags, parent.tags, 'name');
+  const childType = gherkinUtils.getNodeType(child, language);
+  const parentType = gherkinUtils.getNodeType(parent, language);
+
+  superfluousTags.forEach(tag => {
+    errors.push({
+      message: `Tag duplication between ${childType} and its corresponding ${parentType}: ${tag.name}`,
+      rule   : rule,
+      line   : tag.location.line
+    });
+  });
+}
+
+module.exports = {
+  name: rule,
+  run: run
+};

package/src/rules/no-trailing-spaces.js

@@ -0,0 +1,22 @@
+const rule = 'no-trailing-spaces';
+
+function run(unused, file) {
+  let errors = [];
+  let lineNo = 1;
+  file.lines.forEach(line => {
+    if (/[\t ]+$/.test(line)) {
+      errors.push({message: 'Trailing spaces are not allowed',
+        rule   : rule,
+        line   : lineNo});
+    }
+
+    lineNo++;
+  });
+  
+  return errors;
+}
+
+module.exports = {
+  name: rule,
+  run: run
+};

package/src/rules/no-unnamed-features.js

@@ -0,0 +1,20 @@
+const rule = 'no-unnamed-features';
+
+function run(feature) {
+  let errors = [];
+
+  if (!feature || !feature.name) {
+    const location = feature ? feature.location.line : 0;
+    errors.push({
+      message: 'Missing Feature name',
+      rule   : rule,
+      line   : location
+    });
+  }
+  return errors;
+}
+
+module.exports = {
+  name: rule,
+  run: run
+};

package/src/rules/no-unnamed-scenarios.js

@@ -0,0 +1,23 @@
+const rule = 'no-unnamed-scenarios';
+const gherkinUtils = require('./utils/gherkin.js');
+
+function run(feature) {
+  if (!feature) {
+    return [];
+  }
+  let errors = [];
+  gherkinUtils.getScenarios(feature).forEach(scenario => {
+    if (!scenario.name) {
+      errors.push({
+        message: 'Missing Scenario name',
+        rule   : rule,
+        line   : scenario.location.line});
+    }
+  });
+  return errors;
+}
+
+module.exports = {
+  name: rule,
+  run: run
+};

package/src/rules/no-unused-variables.js

@@ -0,0 +1,108 @@
+const rule = 'no-unused-variables';
+
+function run(feature) {
+  if(!feature) {
+    return [];
+  }
+
+  let errors = [];
+  const stepVariableRegex = /<([^>]*)>/gu;
+
+  feature.children.forEach(child => {
+    if (!child.scenario) {
+      // Variables are a feature of Scenarios (as of Gherkin 9?) and Scenario Outlines only
+      return;
+    }
+
+    const examples = child.scenario.examples;
+
+    if (!examples.length) {
+      // If there is no examples table, the rule doesn't apply
+      return;
+    }
+
+    // Maps of variableName -> lineNo
+    const examplesVariables = {};
+    const scenarioVariables = {};
+    let match;
+
+    // Collect all the entries of the examples table
+    examples.forEach(example => {
+      if (example.tableHeader && example.tableHeader.cells) {
+        example.tableHeader.cells.forEach(cell => {
+          if (cell.value) {
+            examplesVariables[cell.value] = cell.location.line;
+          }
+        });
+      }
+    });
+
+
+    // Collect the variables used in the scenario outline
+
+    // Scenario names can include variables
+    while ((match = stepVariableRegex.exec(child.scenario.name)) != null) {
+      scenarioVariables[match[1]] = child.scenario.location.line;
+    }
+
+
+    child.scenario.steps.forEach(step => {
+
+      // Steps can take arguments and their argument can include variables.
+      // The arguments can be of type:
+      // - DocString
+      // - DataTable
+      // For more details, see https://docs.cucumber.io/gherkin/reference/#step-arguments
+
+      // Collect variables from step arguments
+      if (step.dataTable) {
+        step.dataTable.rows.forEach(row => {
+          row.cells.forEach(cell => {
+            if (cell.value) {
+              while ((match = stepVariableRegex.exec(cell.value)) != null) {
+                scenarioVariables[match[1]] = cell.location.line;
+              }
+            }
+          });
+        });
+      } else if (step.docString) {
+        while ((match = stepVariableRegex.exec(step.docString.content)) != null) {
+          scenarioVariables[match[1]] = step.location.line;
+        }
+      }
+
+      // Collect variables from the steps themselves
+      while ((match = stepVariableRegex.exec(step.text)) != null) {
+        scenarioVariables[match[1]] = step.location.line;
+      }
+    });
+    
+
+    for (const exampleVariable in examplesVariables) {
+      if (!scenarioVariables[exampleVariable]) {
+        errors.push({
+          message: 'Examples table variable "' + exampleVariable + '" is not used in any step',
+          rule   : rule,
+          line   : examplesVariables[exampleVariable]
+        });
+      }
+    }
+
+    for (const scenarioVariable in scenarioVariables) {
+      if (!examplesVariables[scenarioVariable]) {
+        errors.push({
+          message: 'Step variable "' + scenarioVariable + '" does not exist in the examples table',
+          rule   : rule,
+          line   : scenarioVariables[scenarioVariable]
+        });
+      }
+    }
+  });
+
+  return errors;
+}
+
+module.exports = {
+  name: rule,
+  run: run
+};

package/src/rules/one-space-between-tags.js

@@ -0,0 +1,41 @@
+const _ = require('lodash');
+const gherkinUtils = require('./utils/gherkin.js');
+
+const rule = 'one-space-between-tags';
+
+function run(feature) {
+  if (!feature) {
+    return;
+  }
+  let errors = [];
+  
+  gherkinUtils.getTaggableNodes(feature).forEach(node => {
+    testTags(node, errors);
+  });
+  
+  return errors;
+}
+
+function testTags(node, errors) {
+  _(node.tags)
+    .groupBy('location.line')
+    .sortBy('location.column')
+    .forEach(tags => {
+      _.range(tags.length - 1)
+        .map(i => {
+          if (tags[i].location.column + tags[i].name.length < tags[i + 1].location.column - 1) {
+            errors.push({
+              line: tags[i].location.line,
+              rule: rule,
+              message: 'There is more than one space between the tags ' +
+                        tags[i].name + ' and ' + tags[i + 1].name
+            });
+          }
+        });
+    });
+}
+
+module.exports = {
+  run: run,
+  name: rule
+};

package/src/rules/only-one-when.js

@@ -0,0 +1,68 @@
+const gherkinUtils = require('./utils/gherkin.js');
+
+const rule = 'only-one-when';
+
+function run(feature) {
+  if (!feature) {
+    return [];
+  }
+
+  let errors = [];
+
+  function getScenarios(featureChildren) {
+    let simpleScenarios = featureChildren
+      .filter(child => child.scenario)
+      .map(child => child.scenario);
+
+    let ruleScenarios = featureChildren
+      .filter(child => child.rule)
+      .map(child => child.rule.children)
+      .reduce((flattened, element) => flattened.concat(element), [])
+      .filter(grandchild => grandchild.scenario)
+      .map(grandchild => grandchild.scenario);
+
+    return simpleScenarios.concat(ruleScenarios);
+  }
+
+  let scenarios = getScenarios(feature.children);
+
+  scenarios.forEach(scenario => {
+    let lastRealKeyword = '';
+    let whenCount = 0;
+    let firstViolationLine = 0;
+
+    scenario.steps.forEach(step => {
+      let keyword = gherkinUtils.getLanguageInsitiveKeyword(step, feature.language);
+      if (keyword === 'when' || (keyword === 'and' && lastRealKeyword === 'when')) {
+        lastRealKeyword = 'when';
+        whenCount++;
+        if (whenCount > 1 && firstViolationLine === 0) {
+          firstViolationLine = step.location.line;
+        }
+
+      } else {
+        lastRealKeyword = keyword;
+      }
+    });
+
+    if (whenCount > 1) {
+      errors.push(createError(scenario, whenCount, firstViolationLine));
+    }
+  });
+
+  return errors;
+}
+
+
+function createError(scenario, whenCount, lineNumber) {
+  return {
+    message: `Scenario "${scenario.name}" contains ${whenCount} When statements (max 1)`,
+    rule: rule,
+    line: lineNumber,
+  };
+}
+
+module.exports = {
+  name: rule,
+  run: run,
+};

package/src/rules/required-tags.js

@@ -0,0 +1,56 @@
+const _ = require('lodash');
+const gherkinUtils = require('./utils/gherkin.js');
+
+const rule = 'required-tags';
+const availableConfigs = {
+  tags: [],
+  ignoreUntagged: true
+};
+
+
+function checkTagExists(requiredTag, ignoreUntagged, scenarioTags, scenarioType, scenarioLine) {
+  const result = (ignoreUntagged && scenarioTags.length == 0)
+    || scenarioTags.some((tagObj) => RegExp(requiredTag).test(tagObj.name));
+  if (!result) {
+    return {
+      message: `No tag found matching ${requiredTag} for ${scenarioType}`,
+      rule,
+      line: scenarioLine
+    };
+  }
+  return result;
+}
+
+function run(feature, unused, config) {
+  if (!feature) {
+    return [];
+  }
+
+  const mergedConfig = _.merge({}, availableConfigs, config);
+
+  let errors = [];
+  feature.children.forEach((child) => {
+    if (child.scenario) {
+      const type = gherkinUtils.getNodeType(child.scenario, feature.language);
+      const line = child.scenario.location.line;
+
+      // Check each Scenario for the required tags
+      const requiredTagErrors = mergedConfig.tags
+        .map((requiredTag) => checkTagExists(requiredTag, mergedConfig.ignoreUntagged, child.scenario.tags || [], type, line))
+        .filter((item) =>
+          typeof item === 'object' && item.message
+        );
+
+      // Update errors
+      errors = errors.concat(requiredTagErrors);
+    }
+  });
+  
+  return errors;
+}
+
+module.exports = {
+  name: rule,
+  run: run,
+  availableConfigs: availableConfigs
+};

package/src/rules/scenario-size.js

@@ -0,0 +1,46 @@
+const _ = require('lodash');
+const gherkinUtils = require('./utils/gherkin.js');
+
+const rule = 'scenario-size';
+const availableConfigs = {
+  'steps-length': {
+    'Rule': 15,
+    'Background': 15,
+    'Scenario': 15
+  }
+};
+
+function run(feature, unused, configuration) {
+  if (!feature) {
+    return;
+  }
+
+  if (_.isEmpty(configuration)) {
+    configuration = availableConfigs;
+  }
+
+  let errors = [];
+  feature.children.forEach((child) => {
+    const node = child.rule || child.background || child.scenario;
+    const nodeType = gherkinUtils.getNodeType(node, feature.language);
+    const configKey = child.rule ? 'Rule' : child.background ? 'Background' : 'Scenario';
+    const maxSize = configuration['steps-length'][configKey];
+
+    if (maxSize && node.steps.length > maxSize) {
+      errors.push({
+        message: `Element ${nodeType} too long: actual ${node.steps.length}, expected ${maxSize}`,
+        rule   : 'scenario-size',
+        line   : node.location.line
+      });
+    }
+  });
+
+  return errors;
+}
+
+
+module.exports = {
+  name: rule,
+  run: run,
+  availableConfigs: availableConfigs
+};

package/src/rules/use-and.js

@@ -0,0 +1,41 @@
+const gherkinUtils = require('./utils/gherkin.js');
+
+const rule = 'use-and';
+
+function run(feature) {
+  if (!feature) {
+    return [];
+  }
+
+  let errors = [];
+  
+  gherkinUtils.getStepContainers(feature).forEach(node => {
+    let previousKeyword = undefined;
+    node.steps.forEach(step => {
+      const keyword = gherkinUtils.getLanguageInsitiveKeyword(step, feature.language);
+
+      if (keyword === 'and') {
+        return;
+      }
+      if (keyword === previousKeyword) {
+        errors.push(createError(step));
+      }
+
+      previousKeyword = keyword;
+    });
+  });
+  return errors;
+}
+
+function createError(step) {
+  return {
+    message: 'Step "' + step.keyword + step.text + '" should use And instead of ' + step.keyword,
+    rule   : rule,
+    line   : step.location.line
+  };
+}
+
+module.exports = {
+  name: rule,
+  run: run
+};

package/src/rules/utils/gherkin.js

@@ -0,0 +1,91 @@
+const _ = require('lodash');
+const {dialects} = require('@cucumber/gherkin');
+
+// We use the node's keyword to determine the node's type
+// because it's the only way to distinguish a scenario with a scenario outline
+function getNodeType(node, language) {
+  const key = getLanguageInsitiveKeyword(node, language).toLowerCase();
+  const stepKeys = [
+    'given',
+    'when',
+    'then',
+    'and',
+    'but',
+  ];
+
+  if (key === 'feature') {
+    return 'Feature';
+  } else if (key === 'rule') {
+    return 'Rule';
+  } else if (key === 'background') {
+    return 'Background';
+  } else if (key === 'scenario') {
+    return 'Scenario';
+  } else if (key === 'scenariooutline') {
+    return 'Scenario Outline';
+  } else if (key === 'examples') {
+    return 'Examples';
+  } else if (stepKeys.includes(key)) {
+    return 'Step';
+  }
+  return '';
+}
+ 
+
+function getLanguageInsitiveKeyword(node, language) {
+  const languageMapping = dialects[language];
+
+  return _.findKey(languageMapping, values => values instanceof Array && values.includes(node.keyword));
+}
+
+function getRuleChildren(feature) {
+  return (feature.children || [])
+    .filter(child => child.rule)
+    .reduce((children, child) => children.concat(child.rule.children || []), []);
+}
+
+function getAllChildren(feature) {
+  return (feature.children || []).concat(getRuleChildren(feature));
+}
+
+function getRules(feature) {
+  return (feature.children || [])
+    .filter(child => child.rule)
+    .map(child => child.rule);
+}
+
+function getScenarios(feature) {
+  return getAllChildren(feature)
+    .filter(child => child.scenario)
+    .map(child => child.scenario);
+}
+
+function getBackgrounds(feature) {
+  return getAllChildren(feature)
+    .filter(child => child.background)
+    .map(child => child.background);
+}
+
+function getStepContainers(feature) {
+  return getBackgrounds(feature).concat(getScenarios(feature));
+}
+
+function getTaggableNodes(feature) {
+  const nodes = [feature].concat(getRules(feature), getScenarios(feature));
+  getScenarios(feature).forEach(scenario => {
+    nodes.push(...(scenario.examples || []));
+  });
+  return nodes;
+}
+
+
+module.exports = {
+  getNodeType: getNodeType,
+  getLanguageInsitiveKeyword: getLanguageInsitiveKeyword,
+  getAllChildren: getAllChildren,
+  getRules: getRules,
+  getScenarios: getScenarios,
+  getBackgrounds: getBackgrounds,
+  getStepContainers: getStepContainers,
+  getTaggableNodes: getTaggableNodes,
+};

package/src/rules.js

@@ -0,0 +1,60 @@
+// Operations on rules
+const glob = require('glob');
+const path = require('path');
+
+function getAllRules(additionalRulesDirs) {
+  let rules = {};
+  
+  const rulesDirs = [
+    path.join(__dirname, 'rules')
+  ].concat(additionalRulesDirs || []);
+
+  rulesDirs.forEach(rulesDir => {
+    rulesDir = path.resolve(rulesDir);
+    glob.sync(`${rulesDir}/*.js`).forEach(file => {
+      const rule = require(file);
+      rules[rule.name] = rule;
+    });
+  });
+  return rules;
+}
+
+function getRule(rule, additionalRulesDirs) {
+  return getAllRules(additionalRulesDirs)[rule];
+}
+
+function doesRuleExist(rule, additionalRulesDirs) {
+  return getRule(rule, additionalRulesDirs) !== undefined;
+}
+
+function isRuleEnabled(ruleConfig) {
+  if (Array.isArray(ruleConfig)) {
+    return ruleConfig[0] === 'on';
+  }
+  return ruleConfig === 'on';
+}
+
+function runAllEnabledRules(feature, file, configuration, additionalRulesDirs) {
+  let errors = [];
+  const rules = getAllRules(additionalRulesDirs);
+  Object.keys(rules).forEach(ruleName => {
+    let rule = rules[ruleName];
+    if (isRuleEnabled(configuration[rule.name])) {
+      const ruleConfig = Array.isArray(configuration[rule.name]) ? configuration[rule.name][1] : {};
+      const error = rule.run(feature, file, ruleConfig);
+      if (error) {
+        errors = errors.concat(error);
+      }
+    }
+  });
+  return errors;
+}
+
+
+module.exports = {
+  doesRuleExist: doesRuleExist,
+  isRuleEnabled: isRuleEnabled,
+  runAllEnabledRules: runAllEnabledRules,
+  getRule: getRule,
+  getAllRules: getAllRules
+};