Before and After hooks.

features/step_definitions/cucumber_js_mappings.rb

@@ -5,6 +5,8 @@ module CucumberJsMappings
   WORLD_VARIABLE_LOG_FILE        = "world_variable.log"
   WORLD_FUNCTION_LOG_FILE        = "world_function.log"
   DATA_TABLE_LOG_FILE            = "data_table.log"
+  CYCLE_LOG_FILE                 = "cycle.log"
+
   attr_accessor :support_code
 
   def features_dir
@@ -195,10 +197,25 @@ def append_support_code(code)
 
   def write_main_step_definitions_file
     append_to_file(STEP_DEFINITIONS_FILE, "var fs = require('fs');\nvar stepDefinitions = function() {\n");
+    append_to_file(STEP_DEFINITIONS_FILE, world_code)
     append_to_file(STEP_DEFINITIONS_FILE, support_code);
     append_to_file(STEP_DEFINITIONS_FILE, "};\nmodule.exports = stepDefinitions;")
   end
 
+  def world_code
+    <<-EOF
+  this.World = function() {
+    this.callCount = 0;
+  };
+
+  this.World.prototype.logCycleEvent = function logCycleEvent(name) {
+    fd = fs.openSync('#{CYCLE_LOG_FILE}', 'a');
+    fs.writeSync(fd, " -> " + name, null);
+    fs.closeSync(fd);
+  };
+EOF
+  end
+
   def write_coffee_script_definition_file
     append_to_file COFFEE_SCRIPT_DEFINITIONS_FILE, <<-EOF
 fs = require('fs')

features/step_definitions/cucumber_steps.js

@@ -18,6 +18,15 @@ var cucumberSteps = function() {
     callback();
   });
 
+  Given(/^a passing (before|after) hook$/, function(hookType, callback) {
+    var defineHook = (hookType == 'before' ? 'Before' : 'After');
+    this.stepDefinitions += defineHook + "(function(callback) {\
+  world.touchStep('" + hookType + "-hook');\
+  callback();\
+});\n";
+    callback();
+  });
+
   Given(/^the step "([^"]*)" has a failing mapping$/, function(stepName, callback) {
     this.stepDefinitions += "Given(/^" + stepName + "$/, function(callback) {\
   world.touchStep(\"" + stepName + "\");\

features/step_definitions/cucumber_steps.rb

@@ -5,6 +5,17 @@
   write_coffee_script_definition_file
 end
 
+# TODO: encapsulate and move to cucumber-features
+Given /^a passing (before|after) hook$/ do |hook_type|
+  define_hook = hook_type.capitalize
+  append_support_code <<-EOF
+this.#{define_hook}(function(callback) {
+  this.logCycleEvent('#{hook_type}');
+  callback();
+});
+EOF
+end
+
 When /^Cucumber executes a scenario using that mapping$/ do
   write_feature <<-EOF
 Feature:
@@ -14,6 +25,20 @@
   run_feature
 end
 
+# TODO: encapsulate and move to cucumber-features
+When /^Cucumber executes a scenario$/ do
+  append_step_definition("a step", "this.logCycleEvent('step');\ncallback();")
+  scenario_with_steps "A scenario", "Given Cucumber executes a step definition"
+  run_feature
+end
+
+# TODO: encapsulate and move to cucumber-features
+Then /^the (after|before) hook is fired (?:after|before) the scenario$/ do |hook_type|
+  expected_string = (hook_type == 'before' ? 'before -> step' : 'step -> after')
+  check_file_content(CucumberJsMappings::CYCLE_LOG_FILE, expected_string, true)
+end
+
+# TODO: encapsulate and move to cucumber-features
 Then /^the mapping is run$/ do
   assert_passed "a mapping"
 end

features/step_definitions/cucumber_world.js

@@ -12,6 +12,7 @@ var proto = CucumberWorld.prototype;
 proto.runFeature = function runFeature(callback) {
   var supportCode;
   var supportCodeSource = "supportCode = function() {\n  var Given = When = Then = this.defineStep;\n" +
+    "  var Before = this.Before, After = this.After;\n" +
     this.stepDefinitions + "};\n";
   var world = this;
   eval(supportCodeSource);

lib/cucumber/runtime/ast_tree_walker.js

@@ -46,7 +46,17 @@ var AstTreeWalker = function(features, supportCodeLibrary, listeners) {
       var event   = AstTreeWalker.Event(AstTreeWalker.SCENARIO_EVENT_NAME, payload);
       self.broadcastEventAroundUserFunction(
         event,
-        function(callback) { scenario.acceptVisitor(self, callback); },
+        function(callback) {
+          supportCodeLibrary.triggerBeforeHooks(world, function() {
+            scenario.acceptVisitor(self, function() {
+              supportCodeLibrary.triggerAfterHooks(world, function() {
+                if (callback) {
+                  callback();
+                }
+              });
+            });
+          });
+        },
         callback
       );
     },

lib/cucumber/support_code.js

@@ -1,4 +1,5 @@
 var SupportCode                          = {};
+SupportCode.Hook                         = require('./support_code/hook');
 SupportCode.Library                      = require('./support_code/library');
 SupportCode.StepDefinition               = require('./support_code/step_definition');
 SupportCode.StepDefinitionSnippetBuilder = require('./support_code/step_definition_snippet_builder');

lib/cucumber/support_code/hook.js

@@ -0,0 +1,11 @@
+var Hook = function(type, code) {
+  var Cucumber = require('../../cucumber');
+
+  var self = {
+    invoke: function(world, callback) {
+      code.apply(world, [callback]);
+    }
+  };
+  return self;
+};
+module.exports = Hook;

lib/cucumber/support_code/library.js

@@ -1,7 +1,9 @@
 var Library = function(supportCodeDefinition) {
   var Cucumber = require('../../cucumber');
 
-  var stepDefinitions = Cucumber.Type.Collection();
+  var beforeHooks      = Cucumber.Type.Collection();
+  var afterHooks       = Cucumber.Type.Collection();
+  var stepDefinitions  = Cucumber.Type.Collection();
   var worldConstructor = Cucumber.SupportCode.WorldConstructor();
 
   var self = {
@@ -21,6 +23,28 @@ var Library = function(supportCodeDefinition) {
       return (stepDefinition != undefined);
     },
 
+    defineBeforeHook: function defineBeforeHook(code) {
+      var beforeHook = Cucumber.SupportCode.Hook('before', code);
+      beforeHooks.add(beforeHook);
+    },
+
+    triggerBeforeHooks: function(world, callback) {
+      beforeHooks.forEach(function(beforeHook, callback) {
+        beforeHook.invoke(world, callback);
+      }, callback);
+    },
+
+    defineAfterHook: function defineAfterHook(code) {
+      var afterHook = Cucumber.SupportCode.Hook('after', code);
+      afterHooks.unshift(afterHook);
+    },
+
+    triggerAfterHooks: function(world, callback) {
+      afterHooks.forEach(function(afterHook, callback) {
+        afterHook.invoke(world, callback);
+      }, callback);
+    },
+
     defineStep: function defineStep(name, code) {
       var stepDefinition = Cucumber.SupportCode.StepDefinition(name, code);
       stepDefinitions.add(stepDefinition);
@@ -32,6 +56,8 @@ var Library = function(supportCodeDefinition) {
   };
 
   var supportCodeHelper = {
+    Before     : self.defineBeforeHook,
+    After      : self.defineAfterHook,
     Given      : self.defineStep,
     When       : self.defineStep,
     Then       : self.defineStep,

lib/cucumber/type/collection.js

@@ -2,6 +2,7 @@ var Collection = function() {
   var items = new Array();
   var self = {
     add:         function add(item)                       { items.push(item); },
+    unshift:     function unshift(item)                   { items.unshift(item); },
     getLast:     function getLast()                       { return items[items.length-1]; },
     syncForEach: function syncForEach(userFunction)       { items.forEach(userFunction); },
     forEach:     function forEach(userFunction, callback) {

spec/cucumber/runtime/ast_tree_walker_spec.js

@@ -97,10 +97,10 @@ describe("Cucumber.Runtime.AstTreeWalker", function() {
     var feature, callback, event, payload;
 
     beforeEach(function() {
-      feature  = createSpyWithStubs("Feature AST element", {acceptVisitor: null});
-      callback = createSpy("Callback");
-      event    = createSpy("Event");
-      payload  = {feature: feature};
+      feature     = createSpyWithStubs("Feature AST element", {acceptVisitor: null});
+      callback    = createSpy("Callback");
+      event       = createSpy("Event");
+      payload     = {feature: feature};
       spyOn(Cucumber.Runtime.AstTreeWalker, 'Event').andReturn(event);
       spyOn(treeWalker, 'broadcastEventAroundUserFunction');
     });
@@ -165,13 +165,16 @@ describe("Cucumber.Runtime.AstTreeWalker", function() {
     var world;
 
     beforeEach(function() {
-      scenario = createSpyWithStubs("Scenario AST element", {acceptVisitor: null});
-      callback = createSpy("Callback");
-      event    = createSpy("Event");
-      payload  = {scenario: scenario};
-      world    = createSpy("world instance");
+      scenario    = createSpyWithStubs("Scenario AST element", {acceptVisitor: null});
+      callback    = createSpy("Callback");
+      event       = createSpy("Event");
+      payload     = {scenario: scenario};
+      world       = createSpy("world instance");
+      triggerHookFake = function(world, callback) { callback(); };
       spyOn(Cucumber.Runtime.AstTreeWalker, 'Event').andReturn(event);
       spyOnStub(supportCodeLibrary, 'instantiateNewWorld').andReturn(world);
+      spyOnStub(supportCodeLibrary, 'triggerBeforeHooks').andCallFake(triggerHookFake);
+      spyOnStub(supportCodeLibrary, 'triggerAfterHooks').andCallFake(triggerHookFake);
       spyOn(treeWalker, 'broadcastEventAroundUserFunction');
       spyOn(treeWalker, 'witnessNewScenario');
       spyOn(treeWalker, 'setWorld');
@@ -208,6 +211,27 @@ describe("Cucumber.Runtime.AstTreeWalker", function() {
         toHaveBeenCalledWithValueAsNthParameter(callback, 3);
     });
 
+    it("invokes before hooks", function() {
+      treeWalker.visitScenario(scenario, callback);
+      treeWalker.broadcastEventAroundUserFunction.mostRecentCall.args[1]();
+
+      expect(supportCodeLibrary.triggerBeforeHooks).
+        toHaveBeenCalledWithValueAsNthParameter(world, 1);
+      expect(supportCodeLibrary.triggerBeforeHooks).
+        toHaveBeenCalledWithAFunctionAsNthParameter(2);
+    });
+
+    it("invokes after hooks", function() {
+      treeWalker.visitScenario(scenario, callback);
+      treeWalker.broadcastEventAroundUserFunction.mostRecentCall.args[1]();
+      scenario.acceptVisitor.mostRecentCall.args[1]();
+
+      expect(supportCodeLibrary.triggerAfterHooks).
+        toHaveBeenCalledWithValueAsNthParameter(world, 1);
+      expect(supportCodeLibrary.triggerAfterHooks).
+        toHaveBeenCalledWithAFunctionAsNthParameter(2);
+    });
+
     describe("user function", function() {
       var userFunction, userFunctionCallback;
 
@@ -217,7 +241,13 @@ describe("Cucumber.Runtime.AstTreeWalker", function() {
         userFunction = treeWalker.broadcastEventAroundUserFunction.mostRecentCall.args[1];
       });
 
-      it("visits the scenario, passing it the received callback", function() {
+      it("visits the scenario, passing it the tree walker", function() {
+        userFunction(userFunctionCallback);
+        expect(scenario.acceptVisitor).
+          toHaveBeenCalledWithValueAsNthParameter(treeWalker, 1);
+      });
+
+      xit("visits the scenario, passing it the received callback", function() {
         userFunction(userFunctionCallback);
         expect(scenario.acceptVisitor).toHaveBeenCalledWith(treeWalker, userFunctionCallback);
       });