Extract features result logic

Author: charlierudolph

features/dryrun_mode.feature

@@ -71,31 +71,20 @@ Feature: Dryrun mode
     When I run cucumber.js with `-f progress features/a.feature --dry-run`
     Then it outputs this text:
       """
-      -
+      U
 
-      1 scenario (1 skipped)
-      1 step (1 skipped)
+      1 scenario (1 undefined)
+      1 step (1 undefined)
       <duration-stat>
-      """
-    And the exit status should be 0
 
-  Scenario: Skipped Scenario with pending step with --dry-run
-    Given a file named "features/step_definitions/cucumber_steps.js" with:
-      """
-      var cucumberSteps = function() {
-        this.Given(/^this step passes$/, function(callback) { callback.pending(); });
-      };
-      module.exports = cucumberSteps;
-      """
-    When I run cucumber.js with `-f progress features/a.feature --dry-run`
-    Then it outputs this text:
-      """
-      -
+      You can implement step definitions for undefined steps with these snippets:
 
-      1 scenario (1 skipped)
-      1 step (1 skipped)
-      <duration-stat>
+      this.Given(/^this step passes$/, function (callback) {
+        // Write code here that turns the phrase above into concrete actions
+        callback.pending();
+      });
       """
+    And the exit status should be 0
 
   Scenario: Skipped scenario with defined step with -d
     Given a file named "features/step_definitions/cucumber_steps.js" with:

lib/cucumber/runtime.js

@@ -50,6 +50,7 @@ function Runtime(configuration) {
 Runtime.START_MISSING_CALLBACK_ERROR = 'Cucumber.Runtime.start() expects a callback';
 Runtime.AstTreeWalker                = require('./runtime/ast_tree_walker');
 Runtime.Attachment                   = require('./runtime/attachment');
+Runtime.FeaturesResult               = require('./runtime/features_result');
 Runtime.ScenarioResult               = require('./runtime/scenario_result');
 Runtime.StackTraceFilter             = require('./runtime/stack_trace_filter');
 Runtime.StepResult                   = require('./runtime/step_result');

lib/cucumber/runtime/ast_tree_walker.js

@@ -4,7 +4,7 @@ function AstTreeWalker(features, supportCodeLibrary, listeners, options) {
   var Cucumber = require('../../cucumber');
 
   var world;
-  var allFeaturesSucceeded = true;
+  var featuresResult = Cucumber.Runtime.FeaturesResult(options.strict);
   var emptyHook = Cucumber.SupportCode.Hook(function (callback) { callback(); }, {});
   var beforeSteps = Cucumber.Type.Collection();
   var afterSteps = Cucumber.Type.Collection();
@@ -20,8 +20,7 @@ function AstTreeWalker(features, supportCodeLibrary, listeners, options) {
       self.visitFeatures(features, function () {
         if (walkDomain.exit)
           walkDomain.exit();
-        var featuresResult = self.didAllFeaturesSucceed();
-        callback(featuresResult);
+        callback(featuresResult.isSuccessful());
       });
     },
 
@@ -36,7 +35,7 @@ function AstTreeWalker(features, supportCodeLibrary, listeners, options) {
     },
 
     visitFeature: function visitFeature(feature, callback) {
-      if (!allFeaturesSucceeded && options.failFast) {
+      if (!featuresResult.isSuccessful() && options.failFast) {
         return callback();
       }
       var payload = { feature: feature };
@@ -55,7 +54,7 @@ function AstTreeWalker(features, supportCodeLibrary, listeners, options) {
  	  },
 
     visitScenario: function visitScenario(scenario, callback) {
-      if (!allFeaturesSucceeded && options.failFast) {
+      if (!featuresResult.isSuccessful() && options.failFast) {
         return callback();
       }
       supportCodeLibrary.instantiateNewWorld(function (world) {
@@ -140,10 +139,7 @@ function AstTreeWalker(features, supportCodeLibrary, listeners, options) {
 
     visitStepResult: function visitStepResult(stepResult, callback) {
       scenarioResult.witnessStepResult(stepResult);
-      var status = stepResult.getStatus();
-      if (status === Cucumber.Status.FAILED || (options.strict && (status === Cucumber.Status.PENDING))) {
-        allFeaturesSucceeded = false;
-      }
+      featuresResult.witnessStepResult(stepResult);
       var payload = { stepResult: stepResult };
       var event   = AstTreeWalker.Event(AstTreeWalker.STEP_RESULT_EVENT_NAME, payload);
       self.broadcastEvent(event, callback);
@@ -212,10 +208,6 @@ function AstTreeWalker(features, supportCodeLibrary, listeners, options) {
       return !supportCodeLibrary.isStepDefinitionNameDefined(stepName);
     },
 
-    didAllFeaturesSucceed: function didAllFeaturesSucceed() {
-      return allFeaturesSucceeded;
-    },
-
     getScenarioStatus: function getScenarioStatus() {
       return scenarioResult.getStatus();
     },
@@ -240,34 +232,13 @@ function AstTreeWalker(features, supportCodeLibrary, listeners, options) {
       attachments.clear();
     },
 
-    witnessUndefinedStep: function witnessUndefinedStep() {
-      if (options.strict) {
-        allFeaturesSucceeded = false;
-      }
-      scenarioResult.witnessStepStatus(Cucumber.Status.UNDEFINED);
-    },
-
-    witnessSkippedStep: function witnessSkippedStep() {
-      scenarioResult.witnessStepStatus(Cucumber.Status.SKIPPED);
-    },
-
     witnessNewScenario: function witnessNewScenario(scenario) {
       apiScenario    = Cucumber.Api.Scenario(self, scenario);
       scenarioResult = Cucumber.Runtime.ScenarioResult();
       beforeSteps.clear();
       afterSteps.clear();
     },
 
-    processDryRunStep: function processDryRunStep(step, callback) {
-      if (options.strict && self.isStepUndefined(step)) {
-        self.witnessUndefinedStep();
-        self.skipUndefinedStep(step, callback);
-      } else {
-        self.witnessSkippedStep();
-        self.skipStep(step, callback);
-      }
-    },
-
     getScenario: function getScenario() {
       return apiScenario;
     },
@@ -281,12 +252,9 @@ function AstTreeWalker(features, supportCodeLibrary, listeners, options) {
     },
 
     processStep: function processStep(step, callback) {
-      if (options.dryRun) {
-        self.processDryRunStep(step, callback);
-      } else if (self.isStepUndefined(step)) {
-        self.witnessUndefinedStep();
+      if (self.isStepUndefined(step)) {
         self.skipUndefinedStep(step, callback);
-      } else if (self.isSkippingSteps()) {
+      } else if (options.dryRun || self.isSkippingSteps()) {
         self.skipStep(step, callback);
       } else {
         self.executeStep(step, callback);
@@ -299,16 +267,12 @@ function AstTreeWalker(features, supportCodeLibrary, listeners, options) {
 
     skipStep: function skipStep(step, callback) {
       var skippedStepResult = Cucumber.Runtime.StepResult({step: step, status: Cucumber.Status.SKIPPED});
-      var payload           = { stepResult: skippedStepResult };
-      var event             = AstTreeWalker.Event(AstTreeWalker.STEP_RESULT_EVENT_NAME, payload);
-      self.broadcastEvent(event, callback);
+      self.visitStepResult(skippedStepResult, callback);
     },
 
     skipUndefinedStep: function skipUndefinedStep(step, callback) {
       var undefinedStepResult = Cucumber.Runtime.StepResult({step: step, status: Cucumber.Status.UNDEFINED});
-      var payload = { stepResult: undefinedStepResult };
-      var event   = AstTreeWalker.Event(AstTreeWalker.STEP_RESULT_EVENT_NAME, payload);
-      self.broadcastEvent(event, callback);
+      self.visitStepResult(undefinedStepResult, callback);
     }
   };
   return self;

lib/cucumber/runtime/features_result.js

@@ -0,0 +1,30 @@
+function FeaturesResult(strict) {
+  var Cucumber = require('../../cucumber');
+
+  var success = true;
+
+  var self = {
+    isSuccessful: function isSuccessful() {
+      return success;
+    },
+
+    witnessStepResult: function witnessStepResult(stepResult) {
+      var stepStatus = stepResult.getStatus();
+      switch (stepStatus) {
+        case Cucumber.Status.FAILED:
+          success = false;
+          break;
+        case Cucumber.Status.PENDING:
+        case Cucumber.Status.UNDEFINED:
+          if (strict) {
+            success = false;
+          }
+          break;
+      }
+    }
+  };
+
+  return self;
+}
+
+module.exports = FeaturesResult;