added cucumber.json output

updated README for cucumber.json generation

Author: bn-jcundill

.gitignore

@@ -61,6 +61,8 @@ typings/
 
 cypress/videos
 cypress/screenshots
+cypress/cucumber-json
+target
 
 #optional .vscode settings directory
 .vscode

README.md

@@ -25,6 +25,7 @@ module.exports = (on, config) => {
 }
 ```
 
+
 ### Feature files
 
 Put your feature files in cypress/integration/
@@ -279,6 +280,42 @@ Here is an [example](cypress/support/step_definitions/customParameterTypes.js) w
 
 We use https://docs.cucumber.io/cucumber/cucumber-expressions/ to parse your .feature file, please use that document as your reference 
 
+## cucumber.json file generation
+
+The cypress-cucumber-preprocessor can generate cucumber.json file output as it runs the features files. This is separate from, and in addition to, any mocha reporter configured in cypress.
+
+These files are intended to be used with one of the many available cucumber report generator packages. 
+Seems to work fine with both https://github.com/jenkinsci/cucumber-reports-plugin and https://github.com/wswebcreation/multiple-cucumber-html-reporter
+
+
+Output, by default, is written to the folder cypress/cucumber-json/, and one file is generated per feature.
+
+ 
+This behaviour is configurable. Use cosmiconfig to create a configuration for the plugin, see step definition discussion above, 
+and add the following to the cypress-cucumber-preprocessor section in package.json to turn it off or change the defaults:
+
+```
+  "cypress-cucumber-preprocessor": {
+    "cucumberJson": {
+      "generate": true,
+      "outputFolder": "cucumber-json",
+      "filePrefix": "cucumber-",
+      "fileSuffix": ""
+    }
+  }
+```
+
+Here:
+
+outputFolder: The folder to write the files to, defaults to ```./cypress/cucumber-json```
+
+filePrefix: A separate json file is generated for each feature based on the name of the feature file. All generated file names will be prefixed with this option if specified.
+
+fileSuffix: A suffix to add to each generated filename, defaults to '.cucumber'
+
+generate: Flag, output cucumber.json or not, defaults to true.
+
+
 ## Development
 
 Install all dependencies:

fixJson.js

@@ -0,0 +1,74 @@
+const fs = require("fs");
+const path = require("path");
+
+const args = process.argv;
+
+const cucumberJsonDir = args[2] || "./cypress/cucumber-json";
+const screenshotsDir = args[3] || "./cypress/screenshots";
+const videosDir = args[4] || "./cypress/videos";
+
+const featureToFileMap = {};
+const cukeMap = {};
+const videosMap = {};
+const jsonNames = {};
+
+const jsonPath = path.join(__dirname, "..", cucumberJsonDir);
+const screenshotsPath = path.join(__dirname, "..", screenshotsDir);
+const videosPath = path.join(__dirname, "..", videosDir);
+const files = fs.readdirSync(jsonPath);
+
+const videos = fs.readdirSync(videosPath);
+videos.forEach(vid => {
+  const arr = vid.split(".");
+  const featureName = `${arr[0]}.${arr[1]}`;
+  videosMap[featureName] = vid;
+});
+
+files.forEach(file => {
+  const json = JSON.parse(
+    fs.readFileSync(path.join(jsonPath, file)).toString()
+  );
+  const feature = json[0].uri.split("/").reverse()[0];
+  jsonNames[feature] = file;
+  cukeMap[feature] = json;
+  featureToFileMap[feature] = file;
+});
+
+const failingFeatures = fs.readdirSync(screenshotsPath);
+failingFeatures.forEach(feature => {
+  const screenshots = fs.readdirSync(path.join(screenshotsPath, feature));
+  screenshots.forEach(screenshot => {
+    const scenarioName = screenshot
+      .match(/[\S]+\sScenario\s([\w|\s]+)\([\S]+/)[1]
+      .trim();
+    const myScenario = cukeMap[feature][0].elements.find(
+      e => e.name === scenarioName
+    );
+    const myStep = myScenario.steps.find(
+      step => step.result.status !== "passed"
+    );
+    const data = fs.readFileSync(
+      path.join(screenshotsPath, feature, screenshot)
+    );
+    if (data) {
+      const base64Image = Buffer.from(data, "binary").toString("base64");
+      myStep.embeddings.push({ data: base64Image, mime_type: "image/png" });
+    }
+
+    // find my video
+    const vidData = fs
+      .readFileSync(path.join(videosPath, videosMap[feature]))
+      .toString("base64");
+    if (vidData) {
+      const html = `<video controls width="500"><source type="video/mp4" src="data:video/mp4;base64,${vidData}"> </video>`;
+      const encodedHtml = Buffer.from(html, "binary").toString("base64");
+      myStep.embeddings.push({ data: encodedHtml, mime_type: "text/html" });
+    }
+
+    // write me back out again
+    fs.writeFileSync(
+      path.join(jsonPath, jsonNames[feature]),
+      JSON.stringify(cukeMap[feature], null, 2)
+    );
+  });
+});

lib/createTestFromScenario.js

@@ -1,64 +1,143 @@
 /* eslint-disable prefer-template */
+const statuses = require("cucumber").Status;
 const { resolveAndRunStepDefinition } = require("./resolveStepDefinition");
+const { generateCucumberJson } = require("./cukejson/generateCucumberJson");
 
 const replaceParameterTags = (rowData, text) =>
   Object.keys(rowData).reduce(
     (value, key) => value.replace(`<${key}>`, rowData[key]),
     text
   );
 
-const stepTest = function(stepDetails, exampleRowData) {
-  cy.log(`${stepDetails.keyword} ${stepDetails.text}`);
-  resolveAndRunStepDefinition.call(
-    this,
-    stepDetails,
-    replaceParameterTags,
-    exampleRowData
+// eslint-disable-next-line func-names
+const stepTest = function(state, stepDetails, exampleRowData) {
+  cy.then(() => state.onStartStep(stepDetails))
+    .then(() =>
+      resolveAndRunStepDefinition.call(
+        this,
+        stepDetails,
+        replaceParameterTags,
+        exampleRowData
+      )
+    )
+    .then(() => state.onFinishStep(stepDetails, statuses.PASSED));
+};
+
+const runTest = (scenario, stepsToRun, rowData) => {
+  const indexedSteps = stepsToRun.map((step, index) =>
+    Object.assign({}, step, { index })
   );
+
+  // eslint-disable-next-line func-names
+  it(`Scenario: ${scenario.name}`, function() {
+    const state = window.testState;
+    return cy
+      .then(() => state.onStartScenario(scenario, indexedSteps))
+      .then(() =>
+        indexedSteps.forEach(step => stepTest.call(this, state, step, rowData))
+      )
+      .then(() => state.onFinishScenario(scenario));
+  });
 };
 
-const createTestFromScenario = (scenario, backgroundSection) => {
-  if (scenario.examples) {
-    scenario.examples.forEach(example => {
-      const exampleValues = [];
+const writeCucumberJsonFile = json => {
+  const outputFolder =
+    window.cucumberJson.outputFolder || "cypress/cucumber-json";
+  const outputPrefix = window.cucumberJson.filePrefix || "";
+  const outputSuffix = window.cucumberJson.fileSuffix || ".cucumber";
+  const fileName = json[0] ? json[0].uri : "empty";
+  const outFile = `${outputFolder}/${outputPrefix}${fileName}${outputSuffix}.json`;
+  cy.writeFile(outFile, json, { log: false });
+};
+
+const createTestFromScenarios = (
+  scenariosToRun,
+  backgroundSection,
+  testState
+) => {
+  // eslint-disable-next-line func-names
+  describe(`Feature: ${testState.feature.name}`, function() {
+    before(() => {
+      cy.then(() => testState.onStartTest());
+    });
+
+    // ctx is cleared between each 'it'
+    // eslint-disable-next-line func-names, prefer-arrow-callback
+    beforeEach(function() {
+      window.testState = testState;
+
+      const failHandler = err => {
+        Cypress.off("fail", failHandler);
+        testState.onFail(err);
+        throw err;
+      };
+
+      Cypress.on("fail", failHandler);
+    });
+
+    scenariosToRun.forEach(section => {
+      if (section.examples) {
+        section.examples.forEach(example => {
+          const exampleValues = [];
+          const exampleLocations = [];
 
-      example.tableBody.forEach((row, rowIndex) => {
-        example.tableHeader.cells.forEach((header, headerIndex) => {
-          exampleValues[rowIndex] = Object.assign({}, exampleValues[rowIndex], {
-            [header.value]: row.cells[headerIndex].value
+          example.tableBody.forEach((row, rowIndex) => {
+            exampleLocations[rowIndex] = row.location;
+            example.tableHeader.cells.forEach((header, headerIndex) => {
+              exampleValues[rowIndex] = Object.assign(
+                {},
+                exampleValues[rowIndex],
+                {
+                  [header.value]: row.cells[headerIndex].value
+                }
+              );
+            });
           });
-        });
-      });
 
-      exampleValues.forEach((rowData, index) => {
-        // eslint-disable-next-line prefer-arrow-callback
-        const scenarioName = replaceParameterTags(rowData, scenario.name);
-        it(`${scenarioName} (example #${index + 1})`, function() {
-          if (backgroundSection) {
-            backgroundSection.steps.forEach(step => {
-              stepTest.call(this, step);
+          exampleValues.forEach((rowData, index) => {
+            // eslint-disable-next-line prefer-arrow-callback
+            const scenarioName = replaceParameterTags(rowData, section.name);
+            const uniqueScenarioName = `${scenarioName} (example #${index +
+              1})`;
+            const exampleSteps = section.steps.map(step => {
+              const newStep = Object.assign({}, step);
+              newStep.text = replaceParameterTags(rowData, newStep.text);
+              return newStep;
             });
-          }
 
-          scenario.steps.forEach(step => {
-            const newStep = Object.assign({}, step);
-            newStep.text = replaceParameterTags(rowData, newStep.text);
+            const stepsToRun = backgroundSection
+              ? backgroundSection.steps.concat(exampleSteps)
+              : exampleSteps;
 
-            stepTest.call(this, newStep, rowData);
+            const scenarioExample = Object.assign({}, section, {
+              name: uniqueScenarioName,
+              example: exampleLocations[index]
+            });
+
+            runTest.call(this, scenarioExample, stepsToRun, rowData);
           });
         });
-      });
-    });
-  } else {
-    it(scenario.name, function() {
-      if (backgroundSection) {
-        backgroundSection.steps.forEach(step => stepTest.call(this, step));
+      } else {
+        const stepsToRun = backgroundSection
+          ? backgroundSection.steps.concat(section.steps)
+          : section.steps;
+
+        runTest.call(this, section, stepsToRun);
       }
-      scenario.steps.forEach(step => stepTest.call(this, step));
     });
-  }
+
+    // eslint-disable-next-line func-names, prefer-arrow-callback
+    after(function() {
+      cy.then(() => testState.onFinishTest()).then(() => {
+        if (window.cucumberJson.generate) {
+          const json = generateCucumberJson(testState);
+          writeCucumberJsonFile(json);
+        }
+      });
+    });
+  });
 };
 
 module.exports = {
-  createTestFromScenario
+  createTestFromScenarios
 };

lib/createTestsFromFeature.js

@@ -1,10 +1,12 @@
-const { createTestFromScenario } = require("./createTestFromScenario");
+const { CucumberDataCollector } = require("./cukejson/cucumberDataCollector");
+const { createTestFromScenarios } = require("./createTestFromScenario");
 const { shouldProceedCurrentStep, getEnvTags } = require("./tagsHelper");
 
-const createTestsFromFeature = parsedFeature => {
-  const featureTags = parsedFeature.feature.tags;
+const createTestsFromFeature = (filePath, spec) => {
+  const testState = new CucumberDataCollector(filePath, spec);
+  const featureTags = testState.feature.tags;
   const hasEnvTags = !!getEnvTags();
-  const sectionsWithTags = parsedFeature.feature.children.filter(
+  const sectionsWithTags = testState.feature.children.filter(
     section => section.tags && section.tags.length
   );
 
@@ -16,7 +18,7 @@ const createTestsFromFeature = parsedFeature => {
   let anyFocused = false;
   if (hasEnvTags) {
     featureShouldRun = shouldProceedCurrentStep(featureTags);
-    taggedScenarioShouldRun = parsedFeature.feature.children.some(
+    taggedScenarioShouldRun = testState.feature.children.some(
       section =>
         section.tags &&
         section.tags.length &&
@@ -36,29 +38,26 @@ const createTestsFromFeature = parsedFeature => {
   }
 
   // eslint-disable-next-line prefer-arrow-callback
-  describe(parsedFeature.feature.name, function() {
-    if (everythingShouldRun || featureShouldRun || taggedScenarioShouldRun) {
-      const backgroundSection = parsedFeature.feature.children.find(
-        section => section.type === "Background"
-      );
-      const otherSections = parsedFeature.feature.children.filter(
-        section => section.type !== "Background"
-      );
-      otherSections.forEach(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
-        }
-        if (shouldRun) {
-          createTestFromScenario(section, backgroundSection);
-        }
-      });
-    }
-  });
+  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);
+  }
 };
 
 module.exports = {