Merge branch 'master' of https://github.com/TheBrainFamily/cypress-cucumber-preprocessor into configurable-loc-non-global-steps

Author: lgandecki

README.md

@@ -18,7 +18,7 @@ You can follow the documentation below, or if you prefer to hack on a working ex
   * [Step definitions](#step-definitions)
     * [Step definitions creation](#step-definitions-creation)
     * [Reusable step definitions](#reusable-step-definitions)
-* [How to write tests](#excluding-tests)
+* [How to write tests](#how-to-write-tests)
   * [Cucumber Expressions](#cucumber-expressions)
   * [Given/When/Then functions](#cucumber-functions)
   * [Custom Parameter Type Resolves](#custom-parameter-type-resolves)
@@ -28,6 +28,7 @@ You can follow the documentation below, or if you prefer to hack on a working ex
   * [Smart tagging](#smart-tagging)
 * [How to run the tests](#excluding-tests)
   * [Running tagged tests](#running-tagged-tests)
+  * [Ignoring specific scenarios using tags when executing test runner](#ignoring-specific-scenarios-using-tags-when-executing-test-runner)
   * [Output](#output)
 * [IDE support](#ide-support)
   * [Webstorm](#webstorm)
@@ -328,8 +329,28 @@ Example:
 ```
 
 Please note - we use our own cypress-tags wrapper to speed things up.
+This wrapper calls the cypress executable from local modules and if not found it falls back to the globally installed one.
 For more details and examples please take a look to the [example repo](https://github.com/TheBrainFamily/cypress-cucumber-example).
 
+### Ignoring specific scenarios using tags when executing test runner
+You can also use tags to skip or ignore specific tests/scenarios when running cypress test runner (where you don't have the abilitiy to pass parameters like in the examples above for the execution)
+
+The trick consists in adding the "env" property with the "TAGS" subproperty in the cypress.json configuration file. It would look something like this:
+
+```javascript
+{
+    "env": {
+        "TAGS": "not @ignore"
+    },
+    //rest of configuration options
+    "baseUrl": "yourBaseUrl",       
+    "ignoreTestFiles": "*.js",
+    //etc
+}
+```
+
+Then, any scenarios tagged with @ignore will be skipped when running the tests using the cypress test runner
+
 ### Limiting to a subset of feature files
 You can use a glob expression to select which feature files should be included.
 
@@ -389,6 +410,14 @@ Note, that unlike WebStorm which will correctly identify multiple implementation
 
 ## TypeScript Support
 
+### Install
+
+Install the plug-in type definitions:
+
+```shell
+npm install --save-dev @types/cypress-cucumber-preprocessor
+```
+
 ### With Webpack
 You can also use a Webpack loader to process feature files (TypeScript supported). To see how it is done please take 
 a look here: [cypress-cucumber-webpack-typescript-example](https://github.com/TheBrainFamily/cypress-cucumber-webpack-typescript-example)

cypress-tags.js

@@ -12,32 +12,44 @@ const debug = (message, ...rest) =>
     ? console.log(`DEBUG: ${message}`, rest.length ? rest : "")
     : null;
 
+function parseArgsOrDefault(argPrefix, defaultValue) {
+  const matchedArg = process.argv
+    .slice(2)
+    .find(arg => arg.includes(`${argPrefix}=`));
+
+  // Cypress requires env vars to be passed as comma separated list
+  // otherwise it only accepts the last provided variable,
+  // the way we replace here accomodates for that.
+  const argValue = matchedArg
+    ? matchedArg.replace(new RegExp(`.*${argPrefix}=`), "").replace(/,.*/, "")
+    : "";
+
+  return argValue !== "" ? argValue : defaultValue;
+}
+
 // TODO currently we only work with feature files in cypress/integration folder.
 // It should be easy to base this on the cypress.json configuration - we are happy to take a PR
 // here if you need this functionality!
 const defaultGlob = "cypress/integration/**/*.feature";
 
-const specArg = process.argv.slice(2).find(arg => arg.indexOf("GLOB=") === 0);
-
-const specGlob = specArg ? specArg.replace(/.*=/, "") : defaultGlob;
-
-if (specArg) {
-  debug("Found glob", specGlob);
-}
+const specGlob = parseArgsOrDefault("GLOB", defaultGlob);
+debug("Found glob", specGlob);
+const envTags = parseArgsOrDefault("TAGS", "");
+debug("Found tag expression", envTags);
 
 const paths = glob.sync(specGlob);
 
 const featuresToRun = [];
 
-const found = process.argv.slice(2).find(arg => arg.indexOf("TAGS=") === 0);
-
-const envTags = found.replace(/.*=/, "");
-debug("Found tag expression", envTags);
-
 paths.forEach(featurePath => {
   const spec = `${fs.readFileSync(featurePath)}`;
   const parsedFeature = new Parser().parse(spec);
 
+  if (!parsedFeature.feature) {
+    debug(`Feature: ${featurePath} is empty`);
+    return;
+  }
+
   const featureTags = parsedFeature.feature.tags;
   const featureShouldRun = shouldProceedCurrentStep(featureTags, envTags);
   const taggedScenarioShouldRun = parsedFeature.feature.children.some(
@@ -54,12 +66,20 @@ paths.forEach(featurePath => {
   }
 });
 
+function getOsSpecificExecutable(command) {
+  return process.platform === "win32" ? `${command}.cmd` : command;
+}
+
+function getCypressExecutable() {
+  const command = getOsSpecificExecutable(`${__dirname}/../.bin/cypress`);
+  // fallback to the globally installed cypress instead
+  return fs.existsSync(command) ? command : getOsSpecificExecutable("cypress");
+}
+
 try {
   if (featuresToRun.length || envTags === "") {
     execFileSync(
-      process.platform === "win32"
-        ? `${__dirname}/../.bin/cypress.cmd`
-        : `${__dirname}/../.bin/cypress`,
+      getCypressExecutable(),
       [...process.argv.slice(2), "--spec", featuresToRun.join(",")],
       {
         stdio: [process.stdin, process.stdout, process.stderr]

lib/createTestFromScenario.js

@@ -1,6 +1,7 @@
 /* eslint-disable prefer-template */
-const statuses = require("cucumber").Status;
+const statuses = require("cucumber/lib/status").default;
 const {
+  resolveStepDefinition,
   resolveAndRunStepDefinition,
   resolveAndRunBeforeHooks,
   resolveAndRunAfterHooks
@@ -15,8 +16,13 @@ const replaceParameterTags = (rowData, text) =>
 
 // eslint-disable-next-line func-names
 const stepTest = function(state, stepDetails, exampleRowData) {
+  const step = resolveStepDefinition.call(
+    this,
+    stepDetails,
+    state.feature.name
+  );
   cy.then(() => state.onStartStep(stepDetails))
-    .then(() =>
+    .then((step && step.config) || {}, () =>
       resolveAndRunStepDefinition.call(
         this,
         stepDetails,
@@ -33,22 +39,42 @@ const runTest = (scenario, stepsToRun, rowData) => {
     Object.assign({}, step, { index })
   );
 
-  // eslint-disable-next-line func-names
-  it(scenario.name, function() {
-    const state = window.testState;
-    return cy
-      .then(() => state.onStartScenario(scenario, indexedSteps))
-      .then(() =>
-        resolveAndRunBeforeHooks.call(this, scenario.tags, state.feature.name)
-      )
-      .then(() =>
-        indexedSteps.forEach(step => stepTest.call(this, state, step, rowData))
-      )
-      .then(() =>
-        resolveAndRunAfterHooks.call(this, scenario.tags, state.feature.name)
-      )
-      .then(() => state.onFinishScenario(scenario));
-  });
+  // should we actually run this scenario
+  // or just mark it as skipped
+  if (scenario.shouldRun) {
+    // eslint-disable-next-line func-names
+    it(scenario.name, function() {
+      const state = window.testState;
+      return cy
+        .then(() => state.onStartScenario(scenario, indexedSteps))
+        .then(() =>
+          resolveAndRunBeforeHooks.call(this, scenario.tags, state.feature.name)
+        )
+        .then(() =>
+          indexedSteps.forEach(step =>
+            stepTest.call(this, state, step, rowData)
+          )
+        )
+        .then(() =>
+          resolveAndRunAfterHooks.call(this, scenario.tags, state.feature.name)
+        )
+        .then(() => state.onFinishScenario(scenario));
+    });
+  } else {
+    // eslint-disable-next-line func-names,prefer-arrow-callback
+    it(scenario.name, function() {
+      // register this scenario with the cucumber data collector
+      // but don't run it
+      // Tell mocha this is a skipped test so it also shows correctly in Cypress
+      const state = window.testState;
+      cy.then(() => state.onStartScenario(scenario, indexedSteps))
+        .then(() => state.onFinishScenario(scenario))
+        // eslint-disable-next-line func-names
+        .then(function() {
+          return this.skip();
+        });
+    });
+  }
 };
 
 const cleanupFilename = s => s.split(".")[0];
@@ -64,7 +90,7 @@ const writeCucumberJsonFile = json => {
 };
 
 const createTestFromScenarios = (
-  scenariosToRun,
+  allScenarios,
   backgroundSection,
   testState
 ) => {
@@ -87,7 +113,7 @@ const createTestFromScenarios = (
     Cypress.on("fail", failHandler);
   });
 
-  scenariosToRun.forEach(section => {
+  allScenarios.forEach(section => {
     if (section.examples) {
       section.examples.forEach(example => {
         const exampleValues = [];

lib/createTestsFromFeature.js

@@ -6,58 +6,37 @@ const createTestsFromFeature = (filePath, spec) => {
   const testState = new CucumberDataCollector(filePath, spec);
   const featureTags = testState.feature.tags;
   const hasEnvTags = !!getEnvTags();
-  const sectionsWithTags = testState.feature.children.filter(
-    section => section.tags && section.tags.length
+  const anyFocused =
+    testState.feature.children.filter(
+      section => section.tags && section.tags.find(t => t.name === "@focus")
+    ).length > 0;
+  const backgroundSection = testState.feature.children.find(
+    section => section.type === "Background"
+  );
+  const allScenarios = testState.feature.children.filter(
+    section => section.type !== "Background"
   );
 
-  const sectionsWithTagsExist = sectionsWithTags.length > 0;
-
-  let everythingShouldRun = false;
-  let featureShouldRun = false;
-  let taggedScenarioShouldRun = false;
-  let anyFocused = false;
-  if (hasEnvTags) {
-    featureShouldRun = shouldProceedCurrentStep(featureTags);
-    taggedScenarioShouldRun = testState.feature.children.some(
-      section =>
-        section.tags &&
-        section.tags.length &&
-        shouldProceedCurrentStep(section.tags.concat(featureTags))
-    );
-  } else if (!sectionsWithTagsExist) {
-    everythingShouldRun = true;
-  } else {
-    anyFocused = sectionsWithTags.some(section =>
-      section.tags.find(t => t.name === "@focus")
-    );
-    if (anyFocused) {
-      taggedScenarioShouldRun = true;
+  const scenariosToRun = allScenarios.filter(section => {
+    let shouldRun;
+    // only just run focused if no env tags set
+    // https://github.com/TheBrainFamily/cypress-cucumber-example#smart-tagging
+    if (!hasEnvTags && anyFocused) {
+      shouldRun = section.tags.find(t => t.name === "@focus");
     } else {
-      everythingShouldRun = true;
+      shouldRun =
+        !hasEnvTags ||
+        shouldProceedCurrentStep(section.tags.concat(featureTags)); // Concat handles inheritance of tags from feature
     }
-  }
-
-  // eslint-disable-next-line prefer-arrow-callback
-  if (everythingShouldRun || featureShouldRun || taggedScenarioShouldRun) {
-    const backgroundSection = testState.feature.children.find(
-      section => section.type === "Background"
-    );
-    const otherSections = testState.feature.children.filter(
-      section => section.type !== "Background"
-    );
-    const scenariosToRun = otherSections.filter(section => {
-      let shouldRun;
-      if (anyFocused) {
-        shouldRun = section.tags.find(t => t.name === "@focus");
-      } else {
-        shouldRun =
-          everythingShouldRun ||
-          shouldProceedCurrentStep(section.tags.concat(featureTags)); // Concat handles inheritance of tags from feature
-      }
-      return shouldRun;
-    });
-    createTestFromScenarios(scenariosToRun, backgroundSection, testState);
-  }
+    return shouldRun;
+  });
+  // create tests for all the scenarios
+  // but flag only the ones that should be run
+  scenariosToRun.forEach(section => {
+    // eslint-disable-next-line no-param-reassign
+    section.shouldRun = true;
+  });
+  createTestFromScenarios(allScenarios, backgroundSection, testState);
 };
 
 module.exports = {

lib/cukejson/cucumberDataCollector.js

@@ -1,5 +1,5 @@
 const { Parser } = require("gherkin");
-const statuses = require("cucumber").Status;
+const statuses = require("cucumber/lib/status").default;
 
 class CucumberDataCollector {
   constructor(uri, spec) {
@@ -72,6 +72,14 @@ class CucumberDataCollector {
           status: statuses.UNDEFINED,
           duration: this.timeTaken()
         };
+      } else if (err.constructor.name === "Pending") {
+        // cypress marks skipped mocha tests as pending
+        // https://github.com/cypress-io/cypress/issues/3092
+        // don't record this error and mark the step as skipped
+        this.stepResults[this.currentStep] = {
+          status: statuses.SKIPPED,
+          duration: this.timeTaken()
+        };
       } else {
         this.stepResults[this.currentStep] = {
           status: statuses.FAILED,
@@ -122,9 +130,13 @@ class CucumberDataCollector {
       });
     };
     this.recordScenarioResult = scenario => {
-      this.runTests[scenario.name].result = this.anyStepsHaveFailed(scenario)
-        ? statuses.FAILED
-        : statuses.PASSED;
+      const allSkipped = this.areAllStepsSkipped(scenario.name);
+      const anyFailed = this.anyStepsHaveFailed(scenario.name);
+      if (allSkipped) this.runTests[scenario.name].result = statuses.SKIPPED;
+      else
+        this.runTests[scenario.name].result = anyFailed
+          ? statuses.FAILED
+          : statuses.PASSED;
     };
 
     this.setStepToPending = step => {
@@ -138,8 +150,11 @@ class CucumberDataCollector {
       };
     };
 
-    this.anyStepsHaveFailed = () =>
-      Object.values(this.stepResults).find(e => e.status !== statuses.PASSED);
+    this.areAllStepsSkipped = name =>
+      this.runTests[name].every(e => e.status === statuses.SKIPPED);
+
+    this.anyStepsHaveFailed = name =>
+      this.runTests[name].find(e => e.status === statuses.FAILED) !== undefined;
   }
 }
 

lib/cukejson/cucumberDataCollector.test.js

@@ -1,5 +1,5 @@
 const fs = require("fs");
-const statuses = require("cucumber").Status;
+const statuses = require("cucumber/lib/status").default;
 const { CucumberDataCollector } = require("./cucumberDataCollector");
 const { generateCucumberJson } = require("./generateCucumberJson");
 

lib/cukejson/generateCucumberJson.js

@@ -1,6 +1,7 @@
 const { EventEmitter } = require("events");
 const { generateEvents } = require("gherkin");
-const { JsonFormatter, formatterHelpers } = require("cucumber");
+const JsonFormatter = require("cucumber/lib/formatter/json_formatter").default;
+const formatterHelpers = require("cucumber/lib/formatter/helpers");
 
 function generateCucumberJson(state) {
   let output = "";