Stuck because of 'after' events fired too late -- on hold until refactoring is finished

Author: jbpros

features/progress_formatter.feature

@@ -0,0 +1,21 @@
+Feature: Progress formatter
+  In order to have concise information about the execution of my features
+  As a cucumber user
+  I want a so-called "progress" formatter
+
+  Scenario: Running a one-scenario feature
+    Given a step definition matching /^a step passes$/
+    When I run the following feature with the "progress" formatter:
+      """
+      Feature: Progress formatter on one-scenario feature
+        Scenario: A few passing steps
+          When a step passes
+          Then a step passes
+      """
+    Then the listener should output the following:
+      """
+      ..
+      
+      1 scenario (1 passed)
+      2 steps (2 passed)
+      """

features/step_definitions/cucumber_steps.js

@@ -124,26 +124,8 @@ var stepDefinitions = function() {
   // Matching groups: none.
   // Multiline parameter: the feature to execute.
   When(/^I run the following feature:$/, function(featureSource, callback) {
-    _listener = Cucumber.Debug.SimpleAstListener();
-    _listener.beforeEachScenarioDo(function() {
-      _stepDefs               = [];
-      _recordedStepParameters = [];
-      _stepCallCount          = 0;
-    });
-    var cucumber = Cucumber(featureSource, _getSupportCode);
-    cucumber.attachListener(_listener);
-    try {
-      cucumber.start(function() {
-        _finishedCuking = true;
-        _featureSource = featureSource;
-        callback();
-      });
-    } catch(error) {
-      printInsideFeatureError(error);
-      setTimeout(function() {
-        throw(new Error("Step failed: Could not run the 'inside' feature successfully."));
-      }, 10);
-    };
+    _buildListener(Cucumber.Debug.SimpleAstListener);
+    _runFeature(featureSource, callback);
   });
 
   // Checks that the feature previously run succeeded.
@@ -154,17 +136,13 @@ var stepDefinitions = function() {
   Then(/^the feature should have run successfully$/, function(callback) {
     if (!_finishedCuking)
       throw(new Error("Expected Cucumber to run the feature successfully."));
-
     var actualOutput   = _normalizeString(_listener.getLogs());
     var expectedOutput = _normalizeString(_featureSource);
     if (!actualOutput.match(expectedOutput))
-      throw(new Error("Expected listener to output the feature source.\n\n<<<<<<< EXPECTED\n" +
-                      expectedOutput + "\n======= ACTUAL:\n" + actualOutput + "\n>>>>>>>"));
-
+      throw(UnexpectedOutputError(expectedOutput, actualOutput));
     callback();
   });
 
-
   // =======================================================
   // ======= Cucumber.js-specific step definitions =========
   // =======================================================
@@ -177,11 +155,51 @@ var stepDefinitions = function() {
     callback();
   });
 
+  When(/^I run the following feature with the "progress" formatter:$/, function(featureSource, callback) {
+    _buildListener(Cucumber.Listener.ProgressFormatter);
+    _runFeature(featureSource, callback);
+  });
+
+  Then(/^the listener should output the following:$/, function(expectedOutput, callback) {
+    var actualOutput   = _listener.getLogs();
+    var expectedOutput = expectedOutput;
+    if (!actualOutput.match(expectedOutput))
+      throw(UnexpectedOutputError(expectedOutput, actualOutput));
+    callback();
+  });
 
   // =======================================================
   // =====================  Helpers ========================
   // =======================================================
 
+  function _runFeature(featureSource, callback) {
+    console.log(featureSource);
+
+    var cucumber = Cucumber(featureSource, _getSupportCode);
+    cucumber.attachListener(_listener);
+    try {
+      cucumber.start(function() {
+        _finishedCuking = true;
+        _featureSource = featureSource;
+        callback();
+      });
+    } catch(error) {
+      printInsideFeatureError(error);
+      setTimeout(function() {
+        throw(new Error("Step failed: Could not run the 'inside' feature successfully."));
+      }, 10);
+    };
+  };
+
+  function _buildListener(listenerConstructor) {
+    _listener = listenerConstructor();
+    _listener.beforeEachScenarioDo(function() {
+      _stepDefs               = [];
+      _recordedStepParameters = [];
+      _stepCallCount          = 0;
+    });
+  };
+
   function _addStepDefinition(keyword, name, content) {
     var _stepName = RegExp(name);
     var stepDefinition;
@@ -218,6 +236,11 @@ var stepDefinitions = function() {
   function translateParameterOffsetToIndex(offset) {
     return parseInt(offset) - 1;
   };
+
+  function UnexpectedOutputError(expected, actual) {
+    return(new Error("Expected listener output is not met.\n\n<<<<<<< EXPECTED\n" +
+                     expected + "\n======= ACTUAL:\n" + actual + "\n>>>>>>>"));
+  };
 };
 
 module.exports = stepDefinitions;

lib/cucumber.js

@@ -292,7 +292,9 @@ Cucumber.Ast.TreeWalker = function(features, supportCodeLibrary, listeners) {
       };
       listeners.syncForEach(function(listener) {
         var hearMethodName = Cucumber.Ast.TreeWalker.HEAR_METHOD_PREFIX + message;
-        listener[hearMethodName].apply(this, parameters);
+        var hearMethod     = listener[hearMethodName];
+	if (hearMethod)
+	  hearMethod.apply(this, parameters);
       });
     },
 
@@ -398,7 +400,6 @@ Cucumber.SupportCode.StepDefinition = function(regexp, code) {
 };
 
 Cucumber.Runtime = {};
-
 Cucumber.Runtime.StepResult = function(status) {
   var self = {
     isSuccessful: function isSuccessful() {
@@ -408,6 +409,40 @@ Cucumber.Runtime.StepResult = function(status) {
   return self;
 };
 
+Cucumber.Listener = {};
+Cucumber.Listener.ProgressFormatter = function() {
+  var beforeEachScenarioUserFunctions = Cucumber.Types.Collection();
+  var logs                            = "";
+  var passingScenarios                = 0;
+  var totalScenarios                  = 0;
+
+  var self = {
+    beforeEachScenarioDo: function beforeEachScenarioDo(userFunction) {
+      beforeEachScenarioUserFunctions.add(userFunction);
+    },
+
+    log: function log(string) {
+      logs += string;
+    },
+
+    getLogs: function getLogs() {
+      return logs;
+    },
+
+    hearStepResult: function hearStepResult(stepResult) {
+      self.log(Cucumber.Listener.ProgressFormatter.PASSING_STEP_CHARACTER);
+    },
+
+    hearAfterFeatures: function heafAfterFeatures() {
+      self.logSummary();
+    },
+
+    logSummary: TODO("logSummary()")
+  };
+  return self;
+};
+Cucumber.Listener.ProgressFormatter.PASSING_STEP_CHARACTER = '.';
+
 Cucumber.Types = {};
 Cucumber.Types.Collection = function() {
   var items = new Array();
@@ -524,50 +559,10 @@ Cucumber.Debug.SimpleAstListener = function(options) {
     return indented;
   };
 };
-Cucumber.Debug.SgmlAstListener = function() {
-  var self = {
-    hearBeforeFeatures: function hearBeforeFeatures() {
-      console.log("<features>");
-    },
-
-    hearAfterFeatures: function hearAfterFeatures() {
-      console.log("</features>");
-    },
-
-    hearBeforeFeature: function hearBeforeFeature() {
-      console.log("  <feature>");
-    },
-
-    hearAfterFeature: function hearAfterFeature() {
-      console.log("  </feature>");
-    },
-
-    hearBeforeScenario: function hearBeforeScenario() {
-      console.log("    <scenario>");
-    },
-
-    hearAfterScenario: function hearAfterScenario() {
-      console.log("    </scenario>");
-    },
-
-    hearBeforeStep: function hearBeforeStep() {
-      console.log("      <step>");
-    },
-
-    hearStepResult: function hearStepResult(stepResult) {
-      console.log("        <result success='" + (stepResult.isSuccessful() ? "true" : "false") + "'></result>");
-    },
-
-    hearAfterStep: function hearAfterStep() {
-      console.log("      </step>");
-    }
-  };
-  return self;
-};
 
 if(typeof exports != 'undefined') { module.exports = Cucumber; }
 if(typeof window != 'undefined') { for (var p in Cucumber) { window[p] = Cucumber[p]; } }
 
 var TODO = function(description) {
-  return function() { throw("IMPLEMENT ME: "+description) };
+  return function() { throw("IMPLEMENT ME: " + description); };
 };

spec/cucumber/ast/tree_walker_spec.js

@@ -278,6 +278,18 @@ describe("Cucumber.Ast.TreeWalker", function() {
         expect(listener[hearMethod]).toHaveBeenCalledWith(parameter1, parameter2, parameter3);
       });
     });
+
+    it("does not tell a listener when it is not interested in that message", function() {
+      var dumbListener = createSpy("A listener listening to nothing (it has no headXXX() method");
+      var failed       = false;
+      listeners.push(dumbListener);
+      try {
+	treeWalker.broadcastMessage(message);
+      } catch(err) {
+	failed = true;
+      }
+      expect(failed).toBeFalsy();
+    });
   });
 
   describe("lookupStepDefinitionByName()", function() {

spec/cucumber/listener/progress_formatter_spec.js

@@ -0,0 +1,86 @@
+require('../../support/spec_helper');
+
+describe("Cucumber.Listener.ProgressFormatter", function() {
+  var Cucumber = require('cucumber');
+  var listener, beforeEachScenarioUserFunctions;
+
+  beforeEach(function() {
+    beforeEachScenarioUserFunctions = createSpy("User Functions to call before each scenario");
+    spyOn(Cucumber.Types, 'Collection').andReturn(beforeEachScenarioUserFunctions);
+    listener = Cucumber.Listener.ProgressFormatter();
+  });
+
+  describe("constructor", function() {
+    it("creates a new collection to store user functions to call before each scenario", function() {
+      expect(Cucumber.Types.Collection).toHaveBeenCalled();
+    });
+  });
+
+  describe("beforeEachScenarioDo()", function() {
+    beforeEach(function() {
+      spyOnStub(beforeEachScenarioUserFunctions, 'add');
+    });
+
+    it("adds the user function to the collection of 'before each scenario' user functions", function() {
+      var userFunction = createSpy("A user function to call before each scenario");
+      listener.beforeEachScenarioDo(userFunction);
+      expect(beforeEachScenarioUserFunctions.add).toHaveBeenCalledWith(userFunction);
+    });
+  });
+
+  describe("log()", function() {
+    it("records logged strings", function() {
+      var logged       = "this was logged";
+      var alsoLogged   = "this was also logged";
+      var loggedBuffer = logged + alsoLogged;
+      listener.log(logged);
+      listener.log(alsoLogged);
+      expect(listener.getLogs()).toBe(loggedBuffer);
+    });
+  });
+
+  describe("getLogs()", function() {
+    it("returns the logged buffer", function() {
+      var logged       = "this was logged";
+      var alsoLogged   = "this was also logged";
+      var loggedBuffer = logged + alsoLogged;
+      listener.log(logged);
+      listener.log(alsoLogged);
+      expect(listener.getLogs()).toBe(loggedBuffer);
+    });
+
+    it("returns an empty string when the listener did not log anything yet", function() {
+      expect(listener.getLogs()).toBe("");
+    });
+  });
+
+  describe("hearStepResult", function() {
+    var stepResult;
+
+    beforeEach(function() {
+      spyOn(listener, 'log');
+      stepResult = createSpy("AST step result");
+    });
+
+    describe("when the step has passed", function() {
+      it("logs the passing step character if the step succeeded", function() {
+	listener.hearStepResult(stepResult);
+	expect(listener.log).toHaveBeenCalledWith(Cucumber.Listener.ProgressFormatter.PASSING_STEP_CHARACTER);
+      });
+    });
+  });
+
+  describe("hearAfterFeatures()", function() {
+    var features;
+
+    beforeEach(function() {
+      features = createSpy("Features AST element");
+      spyOn(listener, "logSummary");
+    });
+
+    it("displays a summary", function() {
+      listener.hearAfterFeatures(features);
+      expect(listener.logSummary).toHaveBeenCalled();
+    });
+  });
+});