Add support for tagged hooks (close #32)

Author: jbpros

features/cucumber-tck

@@ -0,0 +1,9 @@
+Feature: Environment Hooks
+
+  The following scenario is a regression test for special "around" hooks which
+  deserve a bit more of attention.
+
+  Scenario: Tagged around hook with untagged scenario
+    Given an around hook tagged with "@foo"
+    When Cucumber executes a scenario with no tags
+    Then the hook is not fired

features/hooks.feature

@@ -6,6 +6,7 @@ module CucumberJsMappings
   WORLD_FUNCTION_LOG_FILE        = "world_function.log"
   DATA_TABLE_LOG_FILE            = "data_table.log"
   CYCLE_LOG_FILE                 = "cycle.log"
+  CYCLE_SEQUENCE_SEPARATOR       = " -> "
 
   attr_accessor :support_code
 
@@ -135,23 +136,34 @@ def write_world_function
 EOF
   end
 
-  def write_passing_hook hook_type
+  def write_passing_hook options = {}
+    log_string = options[:log_cycle_event_as]
+    if options[:type]
+      hook_type  = options[:type]
+      log_string ||= hook_type
+    else
+      hook_type  = "before"
+      log_string ||= "hook"
+    end
+    tags        = options[:tags] || []
     provide_cycle_logging_facilities
     define_hook = hook_type.capitalize
+    params      = tags.any? ? "'#{tags.join("', '")}', " : ""
+
     if hook_type == "around"
       append_support_code <<-EOF
-this.#{define_hook}(function(runScenario) {
-  this.logCycleEvent('#{hook_type}-pre');
+this.#{define_hook}(#{params}function(runScenario) {
+  this.logCycleEvent('#{log_string}-pre');
   runScenario(function(callback) {
-    this.logCycleEvent('#{hook_type}-post');
+    this.logCycleEvent('#{log_string}-post');
     callback();
   });
 });
 EOF
     else
       append_support_code <<-EOF
-this.#{define_hook}(function(callback) {
-  this.logCycleEvent('#{hook_type}');
+this.#{define_hook}(#{params}function(callback) {
+  this.logCycleEvent('#{log_string}');
   callback();
 });
 EOF
@@ -178,7 +190,7 @@ def provide_cycle_logging_facilities
       append_support_code <<-EOF
 this.World.prototype.logCycleEvent = function logCycleEvent(name) {
   fd = fs.openSync('#{CYCLE_LOG_FILE}', 'a');
-  fs.writeSync(fd, " -> " + name, null);
+  fs.writeSync(fd, "#{CYCLE_SEQUENCE_SEPARATOR}" + name, null);
   fs.closeSync(fd);
 };
 EOF
@@ -224,12 +236,18 @@ def assert_world_function_called
   end
 
   def assert_cycle_sequence *args
-    expected_string = args.join " -> "
+    expected_string = args.join CYCLE_SEQUENCE_SEPARATOR
     check_file_content(CucumberJsMappings::CYCLE_LOG_FILE, expected_string, true)
   end
 
+  def assert_cycle_sequence_excluding *args
+    args.each do |unexpected_string|
+      check_file_content(CucumberJsMappings::CYCLE_LOG_FILE, unexpected_string, false)
+    end
+  end
+
   def assert_complete_cycle_sequence *args
-    expected_string = args.join " -> "
+    expected_string = "#{CYCLE_SEQUENCE_SEPARATOR}#{args.join(CYCLE_SEQUENCE_SEPARATOR)}"
     check_exact_file_content(CucumberJsMappings::CYCLE_LOG_FILE, expected_string)
   end
 
@@ -259,10 +277,10 @@ def assert_suggested_step_definition_snippet(stepdef_keyword, stepdef_pattern, p
   end
 
   def assert_executed_scenarios *scenario_offsets
-    sequence = scenario_offsets.inject('') do |sequence, scenario_offset|
-      "#{sequence} -> #{nth_step_name(scenario_offset)}"
+    sequence = scenario_offsets.inject([]) do |sequence, scenario_offset|
+      sequence << nth_step_name(scenario_offset)
     end
-    assert_complete_cycle_sequence sequence
+    assert_complete_cycle_sequence *sequence
   end
 
   def failed_output

features/step_definitions/cucumber_js_mappings.rb

@@ -28,7 +28,7 @@ var cucumberSteps = function() {
   });
 
   Given(/^a passing around hook$/, function(callback) {
-    this.stepDefinitions += "this.Around(function(runScenario) {\
+    this.stepDefinitions += "Around(function(runScenario) {\
   world.logCycleEvent('around-pre');\
   runScenario(function(callback) {\
     world.logCycleEvent('around-post');\
@@ -38,6 +38,33 @@ var cucumberSteps = function() {
     callback();
   });
 
+  Given(/^an untagged hook$/, function(callback) {
+    this.stepDefinitions += "Before(function(callback) {\
+  world.logCycleEvent('hook');\
+  callback();\
+});\n";
+    callback();
+  });
+
+  Given(/^a hook tagged with "([^"]*)"$/, function(tag, callback) {
+    this.stepDefinitions += "Before('" + tag +"', function(callback) {\
+  world.logCycleEvent('hook');\
+  callback();\
+});\n";
+    callback();
+  });
+
+  Given(/^an around hook tagged with "([^"]*)"$/, function(tag, callback) {
+    this.stepDefinitions += "Around('" + tag + "', function(runScenario) {\
+  world.logCycleEvent('hook-pre');\
+  runScenario(function(callback) {\
+    world.logCycleEvent('hook-post');\
+    callback();\
+  });\
+});\n";
+    callback();
+  });
+
   Given(/^the step "([^"]*)" has a failing mapping$/, function(stepName, callback) {
     this.stepDefinitions += "Given(/^" + stepName + "$/, function(callback) {\
   world.touchStep(\"" + stepName + "\");\
@@ -133,10 +160,15 @@ setTimeout(callback.pending, 10);\
     this.runFeature({}, callback);
   });
 
-  When(/^Cucumber executes a scenario$/, function(callback) {
+  When(/^Cucumber executes a scenario(?: with no tags)?$/, function(callback) {
     this.runAScenario(callback);
   });
 
+  When(/^Cucumber executes a scenario tagged with "([^"]*)"$/, function(tag, callback) {
+    this.addPassingScenarioWithTags(tag);
+    this.runFeature({}, callback);
+  });
+
   When(/^Cucumber runs the feature$/, function(callback) {
     this.runFeature({}, callback);
   });
@@ -267,6 +299,16 @@ callback();\
     callback();
   });
 
+  Then(/^the hook is fired$/, function(callback) {
+    this.assertCycleSequence('hook');
+    callback();
+  });
+
+  Then(/^the hook is not fired$/, function(callback) {
+    this.assertCycleSequenceExcluding('hook');
+    callback();
+  });
+
   Then(/^an error about the missing World instance is raised$/, function(callback) {
     this.assertFailureMessage("World constructor called back without World instance");
     callback();

features/step_definitions/cucumber_steps.js

@@ -17,6 +17,10 @@
   write_asynchronously_failing_mapping_with_message(step_name, message)
 end
 
+Given /^an around hook tagged with "([^"]*)"$/ do |tag|
+  write_passing_hook :type => "around", :tags => [tag], :log_cycle_event_as => "hook"
+end
+
 When /^Cucumber executes a scenario using that mapping$/ do
   write_feature <<-EOF
 Feature:

features/step_definitions/cucumber_steps.rb

@@ -15,7 +15,7 @@ var proto = World.prototype;
 proto.runFeature = function runFeature(options, callback) {
   var supportCode;
   var supportCodeSource = "supportCode = function() {\n  var Given = When = Then = this.defineStep;\n" +
-    "  var Before = this.Before, After = this.After;\n" +
+    "  var Around = this.Around, Before = this.Before, After = this.After;\n" +
     this.stepDefinitions + "};\n";
   var world = this;
   eval(supportCodeSource);
@@ -215,6 +215,15 @@ proto.assertCompleteCycleSequence = function assertCompleteCycleSequence() {
 
 }
 
+proto.assertCycleSequenceExcluding = function assertCycleSequenceExcluding() {
+  var self   = this;
+  var events = Array.prototype.slice.apply(arguments);
+  events.forEach(function(event) {
+    if (self.cycleEvents.indexOf(event) >= 0)
+      throw(new Error("Expected cycle sequence \"" + self.cycleEvents + "\" not to contain \"" + event + "\""));
+  });
+}
+
 proto.indentCode = function indentCode(code, levels) {
   var indented = '';
   var lines    = code.split("\n");

features/step_definitions/cucumber_world.js

@@ -1,5 +1,3 @@
-var _ = require('underscore');
-
 var ArgumentParser = function(argv) {
   var Cucumber = require('../../cucumber');
 
@@ -55,11 +53,7 @@ var ArgumentParser = function(argv) {
 
     getTagGroups: function getTagGroups() {
       var tagOptionValues = self.getOptionOrDefault(ArgumentParser.TAGS_OPTION_NAME, []);
-      var tagGroups = _.map(tagOptionValues, function(tagOptionValue) {
-        var tagGroupParser = Cucumber.TagGroupParser(tagOptionValue);
-        var tagGroup       = tagGroupParser.parse();
-        return tagGroup;
-      });
+      var tagGroups       = Cucumber.TagGroupParser.getTagGroupsFromStrings(tagOptionValues);
       return tagGroups;
     },
 

lib/cucumber/cli/argument_parser.js

@@ -45,8 +45,9 @@ var AstTreeWalker = function(features, supportCodeLibrary, listeners) {
         self.witnessNewScenario();
         var payload = { scenario: scenario };
         var event   = AstTreeWalker.Event(AstTreeWalker.SCENARIO_EVENT_NAME, payload);
-        var hookedUpScenarioVisit = supportCodeLibrary.hookUpFunctionWithWorld(
+        var hookedUpScenarioVisit = supportCodeLibrary.hookUpFunction(
           function(callback) { scenario.acceptVisitor(self, callback); },
+          scenario,
           world
         );
         self.broadcastEventAroundUserFunction(

lib/cucumber/runtime/ast_tree_walker.js

@@ -1,9 +1,31 @@
-var Hook = function(code) {
+var _ = require('underscore');
+
+var Hook = function(code, options) {
   var Cucumber = require('../../cucumber');
 
+  var tags = options['tags'] || [];
+
   var self = {
-    invoke: function(world, callback) {
-      code.call(world, callback);
+    invokeBesideScenario: function invokeBesideScenario(scenario, world, callback) {
+      if (self.appliesToScenario(scenario))
+        code.call(world, callback);
+      else
+        callback(function(endPostScenarioAroundHook) { endPostScenarioAroundHook(); });
+    },
+
+    appliesToScenario: function appliesToScenario(scenario) {
+      var astFilter = self.getAstFilter();
+      return astFilter.isScenarioEnrolled(scenario);
+    },
+
+    getAstFilter: function getAstFilter() {
+      var tagGroups = Cucumber.TagGroupParser.getTagGroupsFromStrings(tags);
+      var rules = _.map(tagGroups, function(tagGroup) {
+        var rule = Cucumber.Ast.Filter.AnyOfTagsRule(tagGroup);
+        return rule;
+      });
+      var astFilter = Cucumber.Ast.Filter(rules);
+      return astFilter;
     }
   };
   return self;

lib/cucumber/support_code/hook.js

@@ -23,21 +23,27 @@ var Library = function(supportCodeDefinition) {
       return (stepDefinition != undefined);
     },
 
-    hookUpFunctionWithWorld: function hookUpFunctionWithWorld(userFunction, world) {
-      var hookedUpFunction = hooker.hookUpFunctionWithWorld(userFunction, world);
+    hookUpFunction: function hookUpFunction(userFunction, scenario, world) {
+      var hookedUpFunction = hooker.hookUpFunction(userFunction, scenario, world);
       return hookedUpFunction;
     },
 
-    defineAroundHook: function defineAroundHook(code) {
-      hooker.addAroundHookCode(code);
+    defineAroundHook: function defineAroundHook() {
+      var tagGroupStrings = Cucumber.Util.Arguments(arguments);
+      var code            = tagGroupStrings.pop();
+      hooker.addAroundHookCode(code, {tags: tagGroupStrings});
     },
 
-    defineBeforeHook: function defineBeforeHook(code) {
-      hooker.addBeforeHookCode(code);
+    defineBeforeHook: function defineBeforeHook() {
+      var tagGroupStrings = Cucumber.Util.Arguments(arguments);
+      var code            = tagGroupStrings.pop();
+      hooker.addBeforeHookCode(code, {tags: tagGroupStrings});
     },
 
-    defineAfterHook: function defineAfterHook(code) {
-      hooker.addAfterHookCode(code);
+    defineAfterHook: function defineAfterHook() {
+      var tagGroupStrings = Cucumber.Util.Arguments(arguments);
+      var code            = tagGroupStrings.pop();
+      hooker.addAfterHookCode(code, {tags: tagGroupStrings});
     },
 
     defineStep: function defineStep(name, code) {

lib/cucumber/support_code/library.js

@@ -6,43 +6,43 @@ var Hooker = function() {
   var afterHooks  = Cucumber.Type.Collection();
 
   var self = {
-    addAroundHookCode: function addAroundHookCode(code) {
-      var aroundHook = Cucumber.SupportCode.Hook(code);
+    addAroundHookCode: function addAroundHookCode(code, options) {
+      var aroundHook = Cucumber.SupportCode.Hook(code, options);
       aroundHooks.add(aroundHook);
     },
 
-    addBeforeHookCode: function addBeforeHookCode(code) {
-      var beforeHook = Cucumber.SupportCode.Hook(code);
+    addBeforeHookCode: function addBeforeHookCode(code, options) {
+      var beforeHook = Cucumber.SupportCode.Hook(code, options);
       beforeHooks.add(beforeHook);
     },
 
-    addAfterHookCode: function addAfterHookCode(code) {
-      var afterHook = Cucumber.SupportCode.Hook(code);
+    addAfterHookCode: function addAfterHookCode(code, options) {
+      var afterHook = Cucumber.SupportCode.Hook(code, options);
       afterHooks.unshift(afterHook);
     },
 
-    hookUpFunctionWithWorld: function hookUpFunctionWithWorld(userFunction, world) {
+    hookUpFunction: function hookUpFunction(userFunction, scenario, world) {
       var hookedUpFunction = function(callback) {
         var postScenarioAroundHookCallbacks = Cucumber.Type.Collection();
         aroundHooks.forEach(callPreScenarioAroundHook, callBeforeHooks);
 
         function callPreScenarioAroundHook(aroundHook, preScenarioAroundHookCallback) {
-          aroundHook.invoke(world, function(postScenarioAroundHookCallback) {
+          aroundHook.invokeBesideScenario(scenario, world, function(postScenarioAroundHookCallback) {
             postScenarioAroundHookCallbacks.unshift(postScenarioAroundHookCallback);
             preScenarioAroundHookCallback();
           });
         }
 
         function callBeforeHooks() {
-          self.triggerBeforeHooks(world, callUserFunction);
+          self.triggerBeforeHooks(scenario, world, callUserFunction);
         }
 
         function callUserFunction() {
           userFunction(callAfterHooks);
         }
 
         function callAfterHooks() {
-          self.triggerAfterHooks(world, callPostScenarioAroundHooks);
+          self.triggerAfterHooks(scenario, world, callPostScenarioAroundHooks);
         }
 
         function callPostScenarioAroundHooks() {
@@ -59,15 +59,15 @@ var Hooker = function() {
       return hookedUpFunction;
     },
 
-    triggerBeforeHooks: function triggerBeforeHooks(world, callback) {
+    triggerBeforeHooks: function triggerBeforeHooks(scenario, world, callback) {
       beforeHooks.forEach(function(beforeHook, callback) {
-        beforeHook.invoke(world, callback);
+        beforeHook.invokeBesideScenario(scenario, world, callback);
       }, callback);
     },
 
-    triggerAfterHooks: function triggerAfterHooks(world, callback) {
+    triggerAfterHooks: function triggerAfterHooks(scenario, world, callback) {
       afterHooks.forEach(function(afterHook, callback) {
-        afterHook.invoke(world, callback);
+        afterHook.invokeBesideScenario(scenario, world, callback);
       }, callback);
     }
   };