Scenario outlines redux

features/scenario_outlines.feature

@@ -0,0 +1,78 @@
+Feature: Scenario Outlines and Examples
+
+  Scenario: Basic outline
+    Given the following feature:
+      """
+      Feature: testing scenarios
+        Background:
+          Given a background step
+
+        Scenario Outline: outline
+          When a <some> step
+          Then i get <result>
+        Examples:
+          | some    | result  |
+          | passing | passed  |
+          | failing | skipped |
+      """
+    And the step "a background step" has a passing mapping
+    And the step "a passing step" has a passing mapping
+    And the step "a failing step" has a failing mapping
+    And the step "i get passed" has a passing mapping
+    And the step "i get skipped" has a passing mapping
+    When Cucumber runs the feature
+    Then the scenario called "outline" is reported as failing
+    And the step "a background step" passes
+    And the step "a passing step" passes
+    And the step "a failing step" passes
+    And the step "i get passed" passes
+    And the step "i get skipped" is skipped
+
+  Scenario: Outline with table
+    Given the following feature:
+    """
+      Feature: testing scenarios
+        Scenario Outline: outline
+          When a table step:
+            | first   | second   |
+            | <first> | <second> |
+        Examples:
+          | first   | second  |
+          | 1       | 2       |
+      """
+    And the step "a table step:" has a passing mapping that receives a data table
+    When Cucumber runs the feature
+    Then the received data table array equals the following:
+      """
+      [["first","second"],["1","2"]]
+      """
+
+  Scenario: Outline with doc string
+    Given the following feature:
+    """
+      Feature: testing scenarios
+        Scenario Outline: outline
+          When a doc string step:
+            \"\"\"
+            I am doc string in <example> example
+            And there are <string> string
+            \"\"\"
+        Examples:
+          | example | string |
+          | first   | some   |
+      """
+    And the step "a doc string step:" has a passing mapping that receives a doc string
+    When Cucumber runs the feature
+    Then the received doc string equals the following:
+    """
+    I am doc string in first example
+    And there are some string
+    """   
+
+    Scenario Outline: outline
+      When a <some> step
+      Then i get <result>
+    Examples:
+      | some    | result  |
+      | passing | passed  |
+      | failing | skipped |

features/step_definition_snippets.feature

@@ -25,3 +25,11 @@ Feature: step definition snippets
       """
     When Cucumber executes the scenario
     Then a "Given" step definition snippet for /^I have some "([^"]*)", "([^"]*)" and "([^"]*)" cucumbers$/ with 3 parameters is suggested
+
+  Scenario: outline steps with examples
+    Given a scenario with:
+      """
+      Given I have <some> cucumbers
+      """
+    When Cucumber executes the scenario
+    Then a "Given" example step definition snippet for /^I have "(.*)" cucumbers$/ with 1 parameters is suggested

features/step_definitions/cli_steps.js

@@ -79,9 +79,9 @@ var cliSteps = function cliSteps() {
     var actualError =  lastRun['error'];
     var actualStderr =  lastRun['stderr'];
 
-    expectedOutput = expectedOutput.replace(/<current-directory>/g, tmpDir);
+    expectedOutput = expectedOutput.replace(/<current-directory>/g, tmpDir.replace(/\\/g,'/'));
 
-    try { var actualJson = JSON.parse(actualOutput); }
+    try { var actualJson = JSON.parse(actualOutput.replace(/\\\\/g,'/')); }
     catch(err) { throw new Error("Error parsing actual JSON:\n" + actualOutput); }
 
     try { var expectedJson = JSON.parse(expectedOutput); }

features/step_definitions/cucumber_steps.js

@@ -1,5 +1,5 @@
 var cucumberSteps = function() {
-  var Given  = When = Then = this.defineStep;
+ var Given  = When = Then = this.defineStep;
   var World  = require('./cucumber_world').World;
   this.World = World;
 
@@ -21,18 +21,6 @@ var cucumberSteps = function() {
       this.addAroundHook(callback);
   });
 
-  Given(/^an untagged hook$/, function(callback) {
-    this.addUntaggedHook(callback);
-  });
-
-  Given(/^a hook tagged with "([^"]*)"$/, function(tags, callback) {
-    this.addHookWithTags(tags, callback);
-  });
-
-  Given(/^an around hook tagged with "([^"]*)"$/, function(tags, callback) {
-    this.addAroundHookWithTags(tags, callback);
-  });
-
   Given(/^the step "([^"]*)" has a failing mapping$/, function(stepName, callback) {
     this.addFailingMapping(stepName, {}, callback);
   });
@@ -96,6 +84,14 @@ setTimeout(callback.pending, 10);\
     callback();
   });
 
+  Given(/^the step "([^"]*)" has a passing mapping that receives a doc string$/, function(stepName, callback) {
+    this.stepDefinitions += "Given(/^" + stepName + "$/, function(docString, callback) {\
+  world.docString = docString;\
+  callback();\
+});";
+    callback();
+  });
+
   Given(/^the following data table in a step:$/, function(dataTable, callback) {
     this.featureSource += "Feature:\n";
     this.featureSource += "  Scenario:\n";
@@ -111,31 +107,6 @@ setTimeout(callback.pending, 10);\
     callback();
   });
 
-  Given(/^a scenario without any tags$/, function(callback) {
-    this.addPassingScenarioWithoutTags();
-    callback();
-  });
-
-  Given(/^a scenario tagged with "([^"]*)"$/, function(tag, callback) {
-    this.addPassingScenarioWithTags(tag);
-    callback();
-  });
-
-  Given(/^a scenario tagged with "([^"]*)" and "([^"]*)"$/, function(tag1, tag2, callback) {
-    this.addPassingScenarioWithTags(tag1, tag2);
-    callback();
-  });
-
-  Given(/^a scenario tagged with "([^"]*)", "([^"]*)" and "([^"]*)"$/, function(tag1, tag2, tag3, callback) {
-    this.addPassingScenarioWithTags(tag1, tag2, tag3);
-    callback();
-  });
-
-  Given(/^a feature tagged with "([^"]*)"$/, function(tag, callback) {
-    this.createEmptyFeature({tags: [tag]});
-    callback();
-  });
-
   Given(/^several features$/, function(callback) {
     this.features = [
       ["feature1", "Feature: One\n\n  Scenario:\n"],
@@ -149,10 +120,6 @@ setTimeout(callback.pending, 10);\
     this.runFeature({}, callback);
   });
 
-  When(/^Cucumber executes a scenario(?: with no tags)?$/, function(callback) {
-    this.runAScenario(callback);
-  });
-
   this.When(/^Cucumber executes a scenario using that mapping$/, function(callback) {
     this.runAScenarioCallingMapping(callback);
   });
@@ -165,13 +132,9 @@ setTimeout(callback.pending, 10);\
     this.runAScenarioCallingWorldFunction(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);
+    //callback.pending();
   });
 
   When(/^Cucumber runs the features$/, function(callback) {
@@ -200,38 +163,6 @@ callback();\
     this.runFeature({}, callback);
   });
 
-  When(/^Cucumber executes scenarios tagged with "([^"]*)"$/, function(tag, callback) {
-    this.runFeature({tags: [tag]}, callback);
-  });
-
-  When(/^Cucumber executes scenarios not tagged with "([^"]*)"$/, function(tag, callback) {
-    this.runFeature({tags: ['~'+tag]}, callback);
-  });
-
-  When(/^Cucumber executes scenarios tagged with "([^"]*)" or "([^"]*)"$/, function(tag1, tag2, callback) {
-    this.runFeature({tags: [tag1 + ', ' + tag2]}, callback);
-  });
-
-  When(/^Cucumber executes scenarios tagged with both "([^"]*)" and "([^"]*)"$/, function(tag1, tag2, callback) {
-    this.runFeature({tags: [tag1, tag2]}, callback);
-  });
-
-  When(/^Cucumber executes scenarios not tagged with "([^"]*)" nor "([^"]*)"$/, function(tag1, tag2, callback) {
-    this.runFeature({tags: ['~'+tag1, '~'+tag2]}, callback);
-  });
-
-  When(/^Cucumber executes scenarios not tagged with both "([^"]*)" and "([^"]*)"$/, function(tag1, tag2, callback) {
-    this.runFeature({tags: ['~' + tag1 + ', ~' + tag2]}, callback);
-  });
-
-  When(/^Cucumber executes scenarios tagged with "([^"]*)" or without "([^"]*)"$/, function(tag1, tag2, callback) {
-    this.runFeature({tags: [tag1 + ', ~' + tag2]}, callback);
-  });
-
-  When(/^Cucumber executes scenarios tagged with "([^"]*)" but not with both "([^"]*)" and "([^"]*)"$/, function(tag1, tag2, tag3, callback) {
-    this.runFeature({tags: [tag1, '~' + tag2, '~' + tag3]}, callback);
-});
-
   Then(/^the scenario passes$/, function(callback) {
     this.assertPassedScenario();
     callback();
@@ -309,6 +240,11 @@ callback();\
     callback();
   });
 
+  Then(/^the received doc string equals the following:$/, function(docString, callback) {
+    this.assertEqual(docString, World.mostRecentInstance.docString);
+    callback();
+  });
+
   this.Then(/^the explicit World object function should have been called$/, function(callback) {
     this.assertTrue(this.explicitWorldFunctionCalled);
     callback();
@@ -341,25 +277,5 @@ callback();\
     this.assertCycleSequenceExcluding('hook');
     callback();
   });
-
-  Then(/^(?:only the first|the) scenario is executed$/, function(callback) {
-    this.assertExecutedNumberedScenarios(1);
-    callback();
-  });
-
-  Then(/^only the first two scenarios are executed$/, function(callback) {
-    this.assertExecutedNumberedScenarios(1, 2);
-    callback();
-  });
-
-  Then(/^only the third scenario is executed$/, function(callback) {
-    this.assertExecutedNumberedScenarios(3);
-    callback();
-  });
-
-  Then(/^only the second, third and fourth scenarios are executed$/, function(callback) {
-    this.assertExecutedNumberedScenarios(2, 3, 4);
-    callback();
-  });
 };
 module.exports = cucumberSteps;

features/step_definitions/cucumber_world.js

@@ -292,7 +292,7 @@ proto.assertScenarioNotReportedAsFailing = function assertScenarioNotReportedAsF
 };
 
 proto.assertPassedStep = function assertPassedStep(stepName) {
-  if (!this.isStepTouched(stepName))
+  if (!this.isStepTouched(stepName))      
     throw(new Error("Expected step \"" + stepName + "\" to have passed."));
 };
 

features/step_definitions/scenario_execution_steps.js

@@ -0,0 +1,27 @@
+  var scenario_exection_steps = function() {
+  var Given  = When = Then = this.defineStep;
+  var World  = require('./cucumber_world').World;
+  this.World = World;
+
+
+  Then(/^(?:only the first|the) scenario is executed$/, function(callback) {
+    this.assertExecutedNumberedScenarios(1);
+    callback();
+  });
+
+  Then(/^only the first two scenarios are executed$/, function(callback) {
+    this.assertExecutedNumberedScenarios(1, 2);
+    callback();
+  });
+
+  Then(/^only the third scenario is executed$/, function(callback) {
+    this.assertExecutedNumberedScenarios(3);
+    callback();
+  });
+
+  Then(/^only the second, third and fourth scenarios are executed$/, function(callback) {
+    this.assertExecutedNumberedScenarios(2, 3, 4);
+    callback();
+  });
+};
+module.exports = scenario_exection_steps;

features/step_definitions/scenario_outline_steps.js

@@ -0,0 +1,17 @@
+var scenario_outline_steps = function() {
+	var Given  = When = Then = this.defineStep;
+	var World  = require('./cucumber_world').World;
+	this.World = World;
+
+	this.When(/^a (.*) step$/, function (some, callback) {
+	   	this.assertTrue(some === "passing" || some === "failing");
+	   	callback();
+	});                                                             
+
+	this.Then(/^i get (.*)$/, function (result, callback) {
+		this.assertTrue(result === "passed" || result === "skipped");
+   		callback();                                           
+	});            
+}
+
+module.exports = scenario_outline_steps;

features/step_definitions/step_definition_snippets_steps.js

@@ -0,0 +1,14 @@
+var stepDefinitionSnippetsSteps = function() {
+ var Given  = When = Then = this.defineStep;
+  var World  = require('./cucumber_world').World;
+  this.World = World;
+
+  this.Then(/^a "([^"]*)" example step definition snippet for \/\^I have "([^"]*)" cucumbers\$\/ with (\d+) parameters is suggested$/, function (stepName, snippetParameter, paramCount, callback) {
+    this.assertEqual(stepName, "Given");
+    this.assertEqual(snippetParameter,'(.*)');
+    this.assertEqual(paramCount,"1");
+    callback();
+  });
+}
+
+module.exports = stepDefinitionSnippetsSteps;