Merge pull request #219 from TheBrainFamily/pr/217

Add Ability to combine multiple feature files into one spec by Darrinholst

Author: lgandecki

circle.yml

@@ -17,6 +17,9 @@ jobs:
       - run:
           name: run tests
           command: npm test
+      - run:
+          name: slow test run, for sanity
+          command: npm run test:each
       - run:
           name: release
           command: npm run semantic-release || true

cypress/integration/All.features

@@ -1,10 +1,10 @@
-Feature: Using And and but
-Scenario: With an And everything is find
+Feature: Using And and But
+  Scenario: With an And everything is fine
     Given I do something
     And Something else
     Then I happily work
 
-Scenario: With a But also the step definition 
+  Scenario: With a But
     Given I dont do something
     And it is sunday
     Then I stream on twitch

cypress/integration/AndAndButSteps.feature

@@ -0,0 +1,24 @@
+exports.cucumberTemplate = `  
+const {
+  resolveAndRunStepDefinition,
+  defineParameterType,
+  given,
+  when,
+  then,
+  and,
+  but,
+  Before,
+  After,
+  defineStep
+} = require("cypress-cucumber-preprocessor/lib/resolveStepDefinition");
+const Given = (window.Given = window.given = given);
+const When = (window.When = window.when = when);
+const Then = (window.Then = window.then = then);
+const And = (window.And = window.and = and);
+const But = (window.But = window.but = but);
+window.defineParameterType = defineParameterType;
+window.defineStep = defineStep;
+const {
+  createTestsFromFeature
+} = require("cypress-cucumber-preprocessor/lib/createTestsFromFeature");
+`;

cypress/integration/UsingAnd.feature

@@ -0,0 +1,90 @@
+const glob = require("glob");
+const path = require("path");
+const fs = require("fs");
+const { Parser } = require("gherkin");
+const log = require("debug")("cypress:cucumber");
+
+const { getStepDefinitionsPaths } = require("./getStepDefinitionsPaths");
+const { cucumberTemplate } = require("./cucumberTemplate");
+const { getCucumberJsonConfig } = require("./getCucumberJsonConfig");
+const {
+  isNonGlobalStepDefinitionsMode
+} = require("./isNonGlobalStepDefinitionsMode");
+
+const createCucumber = (
+  specs,
+  globalToRequire,
+  nonGlobalToRequire,
+  cucumberJson
+) =>
+  `
+    ${cucumberTemplate}
+    
+  window.cucumberJson = ${JSON.stringify(cucumberJson)};
+
+  ${globalToRequire.join("\n")}
+
+  ${specs
+    .map(
+      ({ spec, filePath, name }) => `
+        describe(\`${name}\`, function() {
+        ${nonGlobalToRequire &&
+          nonGlobalToRequire
+            .find(fileSteps => fileSteps[filePath])
+            [filePath].join("\n")}
+            
+        createTestsFromFeature('${path.basename(filePath)}', \`${spec}\`);
+        })
+        `
+    )
+    .join("\n")}
+  `;
+
+module.exports = function(_, filePath) {
+  log("compiling", filePath);
+
+  const features = glob.sync(`${path.dirname(filePath)}/**/*.feature`);
+
+  let globalStepDefinitionsToRequire = [];
+  let nonGlobalStepDefinitionsToRequire;
+
+  if (isNonGlobalStepDefinitionsMode()) {
+    nonGlobalStepDefinitionsToRequire = features.map(featurePath => ({
+      [featurePath]: getStepDefinitionsPaths(featurePath).map(
+        sdPath => `require('${sdPath}')`
+      )
+    }));
+  } else {
+    globalStepDefinitionsToRequire = [
+      ...new Set(
+        features.reduce(
+          requires =>
+            requires.concat(
+              getStepDefinitionsPaths(filePath).map(
+                sdPath => `require('${sdPath}')`
+              )
+            ),
+          []
+        )
+      )
+    ];
+  }
+
+  const specs = features
+    .map(featurePath => ({
+      spec: fs.readFileSync(featurePath).toString(),
+      filePath: featurePath
+    }))
+    .map(feature =>
+      Object.assign({}, feature, {
+        name: new Parser().parse(feature.spec.toString()).feature.name
+      })
+    );
+
+  return createCucumber(
+    specs,
+    globalStepDefinitionsToRequire,
+    nonGlobalStepDefinitionsToRequire,
+    getCucumberJsonConfig()
+  );
+};

cypress/support/step_definitions/usingAnd.js

@@ -0,0 +1,15 @@
+const cosmiconfig = require("cosmiconfig");
+const log = require("debug")("cypress:cucumber");
+
+exports.getCucumberJsonConfig = () => {
+  const explorer = cosmiconfig("cypress-cucumber-preprocessor", { sync: true });
+  const loaded = explorer.load();
+
+  const cucumberJson =
+    loaded && loaded.config && loaded.config.cucumberJson
+      ? loaded.config.cucumberJson
+      : { generate: false };
+  log("cucumber.json", JSON.stringify(cucumberJson));
+
+  return cucumberJson;
+};

lib/cucumberTemplate.js

@@ -11,7 +11,6 @@ const getStepDefinitionsPaths = filePath => {
     const nonGlobalPattern = `${getStepDefinitionPathsFrom(
       filePath
     )}/**/*.+(js|ts)`;
-
     const commonPath =
       loaded.config.commonPath || `${stepDefinitionPath()}/common/`;
     const commonDefinitionsPattern = `${commonPath}**/*.+(js|ts)`;

lib/featuresLoader.js

@@ -5,6 +5,7 @@ const browserify = require("@cypress/browserify-preprocessor");
 const log = require("debug")("cypress:cucumber");
 const chokidar = require("chokidar");
 const compile = require("./loader.js");
+const compileFeatures = require("./featuresLoader.js");
 const stepDefinitionPath = require("./stepDefinitionPath.js");
 
 const transform = file => {
@@ -15,7 +16,10 @@ const transform = file => {
   }
 
   function end() {
-    if (file.match(".feature$")) {
+    if (file.match(".features$")) {
+      log("compiling features ", file);
+      this.queue(compileFeatures(data, file));
+    } else if (file.match(".feature$")) {
       log("compiling feature ", file);
       this.queue(compile(data, file));
     } else {