fix(featuresloader): make bundling feature work with repeated non-glo… (#234)

* fix(featuresloader): make bundling feature work with repeated non-global steps

* fix(featuresloader): work with hooks

fixes #230

Author: lgandecki

.scripts/runOnExample.bash

@@ -5,4 +5,4 @@ cd cypress-cucumber-example
 npm install
 rm -rf node_modules/cypress-cucumber-preprocessor
 npm link cypress-cucumber-preprocessor
-npm run test
+npm run test:all

lib/createTestFromScenario.js

@@ -21,7 +21,8 @@ const stepTest = function(state, stepDetails, exampleRowData) {
         this,
         stepDetails,
         replaceParameterTags,
-        exampleRowData
+        exampleRowData,
+        state.feature.name
       )
     )
     .then(() => state.onFinishStep(stepDetails, statuses.PASSED));
@@ -37,11 +38,15 @@ const runTest = (scenario, stepsToRun, rowData) => {
     const state = window.testState;
     return cy
       .then(() => state.onStartScenario(scenario, indexedSteps))
-      .then(() => resolveAndRunBeforeHooks.call(this, scenario.tags))
+      .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))
+      .then(() =>
+        resolveAndRunAfterHooks.call(this, scenario.tags, state.feature.name)
+      )
       .then(() => state.onFinishScenario(scenario));
   });
 };

lib/featuresLoader.js

@@ -20,15 +20,31 @@ const createCucumber = (
 ) =>
   `
     ${cucumberTemplate}
-    
   window.cucumberJson = ${JSON.stringify(cucumberJson)};
 
+  var moduleCache = arguments[5];
+
+  // Stolen from https://github.com/browserify/browserify/issues/1444
+  function clearFromCache(instance)
+  {
+      for(var key in moduleCache)
+      {
+          if(moduleCache[key].exports == instance)
+          {
+              delete moduleCache[key];
+              return;
+          }
+      }
+      throw "could not clear instance from module cache";
+  }
+
   ${globalToRequire.join("\n")}
 
   ${specs
     .map(
       ({ spec, filePath, name }) => `
         describe(\`${name}\`, function() {
+        window.currentFeatureName = \`${name}\`
         ${nonGlobalToRequire &&
           nonGlobalToRequire
             .find(fileSteps => fileSteps[filePath])
@@ -54,7 +70,7 @@ module.exports = function(_, filePath) {
   if (isNonGlobalStepDefinitionsMode()) {
     nonGlobalStepDefinitionsToRequire = features.map(featurePath => ({
       [featurePath]: getStepDefinitionsPaths(featurePath).map(
-        sdPath => `require('${sdPath}')`
+        sdPath => `clearFromCache(require('${sdPath}'))`
       )
     }));
   } else {

lib/resolveStepDefinition.js

@@ -31,11 +31,21 @@ class StepDefinitionRegistry {
           this.options.parameterTypeRegistry
         );
       }
-      this.definitions.push({ implementation, expression });
+
+      this.definitions.push({
+        implementation,
+        expression,
+        featureName: window.currentFeatureName || "___GLOBAL_EXECUTION___"
+      });
     };
 
-    this.resolve = (type, text) =>
-      this.definitions.filter(({ expression }) => expression.match(text))[0];
+    this.resolve = (type, text, runningFeatureName) =>
+      this.definitions.filter(
+        ({ expression, featureName }) =>
+          expression.match(text) &&
+          (runningFeatureName === featureName ||
+            featureName === "___GLOBAL_EXECUTION___")
+      )[0];
   }
 }
 
@@ -45,15 +55,21 @@ class HookRegistry {
     this.runtime = {};
 
     this.runtime = (tags, implementation) => {
-      this.definitions.push({ tags, implementation });
+      this.definitions.push({
+        tags,
+        implementation,
+        featureName: window.currentFeatureName || "___GLOBAL_EXECUTION___"
+      });
     };
 
-    this.resolve = scenarioTags =>
+    this.resolve = (scenarioTags, runningFeatureName) =>
       this.definitions.filter(
-        ({ tags }) =>
-          !tags ||
-          tags.length === 0 ||
-          shouldProceedCurrentStep(scenarioTags, tags)
+        ({ tags, featureName }) =>
+          (!tags ||
+            tags.length === 0 ||
+            shouldProceedCurrentStep(scenarioTags, tags)) &&
+          (runningFeatureName === featureName ||
+            featureName === "___GLOBAL_EXECUTION___")
       );
   }
 }
@@ -62,10 +78,11 @@ const stepDefinitionRegistry = new StepDefinitionRegistry();
 const beforeHookRegistry = new HookRegistry();
 const afterHookRegistry = new HookRegistry();
 
-function resolveStepDefinition(step) {
+function resolveStepDefinition(step, featureName) {
   const stepDefinition = stepDefinitionRegistry.resolve(
     step.keyword.toLowerCase().trim(),
-    step.text
+    step.text,
+    featureName
   );
   return stepDefinition || {};
 }
@@ -126,9 +143,9 @@ function resolveStepArgument(argument, exampleRowData, replaceParameterTags) {
   return argument;
 }
 
-function resolveAndRunHooks(hookRegistry, scenarioTags) {
+function resolveAndRunHooks(hookRegistry, scenarioTags, featureName) {
   return window.Cypress.Promise.each(
-    hookRegistry.resolve(scenarioTags),
+    hookRegistry.resolve(scenarioTags, featureName),
     ({ implementation }) => implementation.call(this)
   );
 }
@@ -161,15 +178,23 @@ function parseHookArgs(args) {
 }
 
 module.exports = {
-  resolveAndRunBeforeHooks(scenarioTags) {
-    return resolveAndRunHooks(beforeHookRegistry, scenarioTags);
+  resolveAndRunBeforeHooks(scenarioTags, featureName) {
+    return resolveAndRunHooks(beforeHookRegistry, scenarioTags, featureName);
   },
-  resolveAndRunAfterHooks(scenarioTags) {
-    return resolveAndRunHooks(afterHookRegistry, scenarioTags);
+  resolveAndRunAfterHooks(scenarioTags, featureName) {
+    return resolveAndRunHooks(afterHookRegistry, scenarioTags, featureName);
   },
   // eslint-disable-next-line func-names
-  resolveAndRunStepDefinition(step, replaceParameterTags, exampleRowData) {
-    const { expression, implementation } = resolveStepDefinition(step);
+  resolveAndRunStepDefinition(
+    step,
+    replaceParameterTags,
+    exampleRowData,
+    featureName
+  ) {
+    const { expression, implementation } = resolveStepDefinition(
+      step,
+      featureName
+    );
     const stepText = step.text;
     if (expression && implementation) {
       const argument = resolveStepArgument(