cucumber 1.3.10 → 2.0.0

data/{legacy_features → features/docs}/work_in_progress.feature

@@ -1,3 +1,4 @@
+@spawn
 Feature: Cucumber --work-in-progress switch
   In order to ensure that feature scenarios do not pass until they are expected to
   Developers should be able to run cucumber in a mode that
@@ -5,124 +6,119 @@ Feature: Cucumber --work-in-progress switch
             - will not fail otherwise
 
   Background: A passing and a pending feature
-    Given a standard Cucumber project directory structure
-    Given a file named "features/wip.feature" with:
+    Given the standard step definitions
+    And a file named "features/wip.feature" with:
       """
       Feature: WIP
         @failing
         Scenario: Failing
-          Given a failing step
+          Given this step raises an error
 
         @undefined
         Scenario: Undefined
-          Given an undefined step
+          Given this step is undefined
 
         @pending
         Scenario: Pending
-          Given a pending step
+          Given this step is pending
 
         @passing
         Scenario: Passing
-          Given a passing step
+          Given this step passes
       """
     And a file named "features/passing_outline.feature" with:
       """
       Feature: Not WIP
         Scenario Outline: Passing
-          Given a <what> step
-          
-          Examples:
-            | what    |
-            | passing |
-      """
-    And a file named "features/step_definitions/steps.rb" with:
-      """
-      Given /^a failing step$/ do
-        raise "I fail"
-      end
+          Given this step <what>
 
-      Given /^a passing step$/ do
-      end
-
-      Given /^a pending step$/ do
-        pending
-      end
+          Examples:
+            | what   |
+            | passes |
       """
 
   Scenario: Pass with Failing Scenarios
-    When I run cucumber -q -w -t @failing features/wip.feature
-    Then STDERR should be empty
-    Then it should pass with
+    When I run `cucumber -q -w -t @failing features/wip.feature`
+    Then the stderr should not contain anything
+    Then it should pass with:
       """
       Feature: WIP
 
         @failing
         Scenario: Failing
-          Given a failing step
-            I fail (RuntimeError)
-            ./features/step_definitions/steps.rb:2:in `/^a failing step$/'
-            features/wip.feature:4:in `Given a failing step'
-      
+          Given this step raises an error
+            error (RuntimeError)
+            ./features/step_definitions/steps.rb:2:in `/^this step raises an error$/'
+            features/wip.feature:4:in `Given this step raises an error'
+
       Failing Scenarios:
       cucumber features/wip.feature:3
 
       1 scenario (1 failed)
       1 step (1 failed)
-
+      """
+    And the output should contain:
+      """
       The --wip switch was used, so the failures were expected. All is good.
 
       """
 
   Scenario: Pass with Undefined Scenarios
-    When I run cucumber -q -w -t @undefined features/wip.feature
-    Then it should pass with
+    When I run `cucumber -q -w -t @undefined features/wip.feature`
+    Then it should pass with:
       """
       Feature: WIP
 
         @undefined
         Scenario: Undefined
-          Given an undefined step
+          Given this step is undefined
 
       1 scenario (1 undefined)
       1 step (1 undefined)
-
+      """
+    And the output should contain:
+      """
       The --wip switch was used, so the failures were expected. All is good.
 
       """
 
   Scenario: Pass with Undefined Scenarios
-    When I run cucumber -q -w -t @pending features/wip.feature
-    Then it should pass with
+    When I run `cucumber -q -w -t @pending features/wip.feature`
+    Then it should pass with:
       """
       Feature: WIP
 
         @pending
         Scenario: Pending
-          Given a pending step
+          Given this step is pending
             TODO (Cucumber::Pending)
-            ./features/step_definitions/steps.rb:9:in `/^a pending step$/'
-            features/wip.feature:12:in `Given a pending step'
+            ./features/step_definitions/steps.rb:3:in `/^this step is pending$/'
+            features/wip.feature:12:in `Given this step is pending'
 
       1 scenario (1 pending)
       1 step (1 pending)
-
+      """
+    And the output should contain:
+      """
       The --wip switch was used, so the failures were expected. All is good.
 
       """
 
   Scenario: Fail with Passing Scenarios
-    When I run cucumber -q -w -t @passing features/wip.feature
-    Then it should fail with
+    When I run `cucumber -q -w -t @passing features/wip.feature`
+    Then it should fail with:
       """
       Feature: WIP
 
         @passing
         Scenario: Passing
-          Given a passing step
+          Given this step passes
 
       1 scenario (1 passed)
       1 step (1 passed)
-
+      """
+    And the output should contain:
+      """
       The --wip switch was used, so I didn't expect anything to pass. These scenarios passed:
       (::) passed scenarios (::)
 
@@ -132,25 +128,27 @@ Feature: Cucumber --work-in-progress switch
       """
 
   Scenario: Fail with Passing Scenario Outline
-    When I run cucumber -q -w features/passing_outline.feature
-    Then it should fail with
+    When I run `cucumber -q -w features/passing_outline.feature`
+    Then it should fail with:
       """
       Feature: Not WIP
 
         Scenario Outline: Passing
-          Given a <what> step
-      
+          Given this step <what>
+
           Examples: 
-            | what    |
-            | passing |
+            | what   |
+            | passes |
 
       1 scenario (1 passed)
       1 step (1 passed)
-
+      """
+    And the output should contain:
+      """
       The --wip switch was used, so I didn't expect anything to pass. These scenarios passed:
       (::) passed scenarios (::)
 
-      features/passing_outline.feature:7:in `| passing |'
+      features/passing_outline.feature:7:in `Scenario Outline: Passing, Examples (#1)'
 
 
       """

data/features/docs/writing_support_code/after_hooks.feature

@@ -0,0 +1,80 @@
+Feature: After Hooks
+
+  After hooks can be used to clean up any state you've altered during your
+  scenario, or to check the status of the scenario and act accordingly.
+
+  You can ask a scenario whether it has failed, for example.
+
+  Mind you, even if it hasn't failed yet, you can still make the scenario
+  fail if your After hook throws an error.
+
+  Background:
+    Given the standard step definitions
+
+  Scenario: Check the failed status of a scenario in a hook
+    Given a file named "features/support/debug_hook.rb" with:
+      """
+      After do |scenario|
+        if scenario.failed?
+          puts "eek"
+        end
+      end
+      """
+    And a file named "features/fail.feature" with:
+      """
+      Feature:
+        Scenario:
+          Given this step fails
+      """
+    When I run `cucumber -f progress`
+    Then the output should contain:
+      """
+      eek
+      """
+
+  Scenario: Make a scenario fail from an After hook
+    Given a file named "features/support/bad_hook.rb" with:
+      """
+      After do
+        fail 'yikes'
+      end
+      """
+    And a file named "features/pass.feature" with:
+      """
+      Feature:
+        Scenario:
+          Given this step passes
+      """
+    When I run `cucumber -f pretty`
+    Then it should fail with:
+      """
+        Scenario:                # features/pass.feature:2
+          Given this step passes # features/step_definitions/steps.rb:1
+            yikes (RuntimeError)
+            ./features/support/bad_hook.rb:2:in `After'
+      """
+
+  Scenario: After hooks are executed in reverse order of definition
+    Given a file named "features/support/hooks.rb" with:
+      """
+      After do
+        puts "First"
+      end
+
+      After do
+        puts "Second"
+      end
+      """
+    And a file named "features/pass.feature" with:
+      """
+      Feature:
+        Scenario:
+          Given this step passes
+      """
+    When I run `cucumber -f progress`
+    Then the output should contain:
+      """
+      Second
+
+      First
+      """

data/{legacy_features → features/docs/writing_support_code}/around_hooks.feature

@@ -1,14 +1,15 @@
+@spawn
 Feature: Around hooks
+
   In order to support transactional scenarios for database libraries
   that provide only a block syntax for transactions, Cucumber should
   permit definition of Around hooks.
 
   Scenario: A single Around hook
-    Given a standard Cucumber project directory structure
-    And a file named "features/step_definitions/steps.rb" with:
+    Given a file named "features/step_definitions/steps.rb" with:
       """
       Then /^the hook is called$/ do
-        $hook_called.should == true
+        expect($hook_called).to be true
       end
       """
     And a file named "features/support/hooks.rb" with:
@@ -24,8 +25,8 @@ Feature: Around hooks
         Scenario: using hook
           Then the hook is called
       """
-    When I run cucumber features/f.feature
-    Then it should pass with
+    When I run `cucumber features/f.feature`
+    Then it should pass with:
       """
       Feature: Around hooks
 
@@ -38,11 +39,10 @@ Feature: Around hooks
       """
 
   Scenario: Multiple Around hooks
-    Given a standard Cucumber project directory structure
-    And a file named "features/step_definitions/steps.rb" with:
+    Given a file named "features/step_definitions/steps.rb" with:
       """
       Then /^the hooks are called in the correct order$/ do
-        $hooks_called.should == ['A', 'B', 'C']
+        expect($hooks_called).to eq ['A', 'B', 'C']
       end
       """
     And a file named "features/support/hooks.rb" with:
@@ -71,8 +71,8 @@ Feature: Around hooks
         Scenario: using multiple hooks
           Then the hooks are called in the correct order
       """
-    When I run cucumber features/f.feature
-    Then it should pass with
+    When I run `cucumber features/f.feature`
+    Then it should pass with:
       """
       Feature: Around hooks
 
@@ -85,11 +85,10 @@ Feature: Around hooks
       """
 
   Scenario: Mixing Around, Before, and After hooks
-    Given a standard Cucumber project directory structure
-    And a file named "features/step_definitions/steps.rb" with:
+    Given a file named "features/step_definitions/steps.rb" with:
       """
       Then /^the Around hook is called around Before and After hooks$/ do
-        $hooks_called.should == ['Around', 'Before']
+        expect($hooks_called).to eq ['Around', 'Before']
       end
       """
     And a file named "features/support/hooks.rb" with:
@@ -99,7 +98,7 @@ Feature: Around hooks
         $hooks_called << 'Around'
         block.call
         $hooks_called << 'Around'
-        $hooks_called.should == ['Around', 'Before', 'After', 'Around']
+        $hooks_called.should == ['Around', 'Before', 'After', 'Around'] #TODO: Find out why this fails using the new rspec expect syntax.
       end
 
       Before do |scenario|
@@ -110,7 +109,7 @@ Feature: Around hooks
       After do |scenario|
         $hooks_called ||= []
         $hooks_called << 'After'
-        $hooks_called.should == ['Around', 'Before', 'After']
+        expect($hooks_called).to eq ['Around', 'Before', 'After']
       end
       """
     And a file named "features/f.feature" with:
@@ -119,8 +118,8 @@ Feature: Around hooks
         Scenario: Mixing Around, Before, and After hooks
           Then the Around hook is called around Before and After hooks
       """
-    When I run cucumber features/f.feature
-    Then it should pass with
+    When I run `cucumber features/f.feature`
+    Then it should pass with:
       """
       Feature: Around hooks
 
@@ -133,11 +132,10 @@ Feature: Around hooks
       """
 
   Scenario: Around hooks with tags
-    Given a standard Cucumber project directory structure
-    And a file named "features/step_definitions/steps.rb" with:
+    Given a file named "features/step_definitions/steps.rb" with:
       """
       Then /^the Around hooks with matching tags are called$/ do
-        $hooks_called.should == ['one', 'one or two']
+        expect($hooks_called).to eq ['one', 'one or two']
       end
       """
     And a file named "features/support/hooks.rb" with:
@@ -173,8 +171,8 @@ Feature: Around hooks
         Scenario: Around hooks with tags
           Then the Around hooks with matching tags are called
       """
-    When I run cucumber -q -t @one features/f.feature
-    Then it should pass with
+    When I run `cucumber -q -t @one features/f.feature`
+    Then it should pass with:
       """
       Feature: Around hooks
 
@@ -188,11 +186,10 @@ Feature: Around hooks
       """
 
   Scenario: Around hooks with scenario outlines
-    Given a standard Cucumber project directory structure
-    And a file named "features/step_definitions/steps.rb" with:
+    Given a file named "features/step_definitions/steps.rb" with:
       """
       Then /^the hook is called$/ do
-        $hook_called.should == true
+        expect($hook_called).to be true
       end
       """
     And a file named "features/support/hooks.rb" with:
@@ -213,13 +210,13 @@ Feature: Around hooks
             | one    |
             | two    |
       """
-    When I run cucumber features/f.feature
-    Then it should pass with
+    When I run `cucumber features/f.feature`
+    Then it should pass with:
       """
       Feature: Around hooks with scenario outlines
 
         Scenario Outline: using hook # features/f.feature:2
-          Then the hook is called    # features/step_definitions/steps.rb:1
+          Then the hook is called    # features/f.feature:3
 
           Examples: 
             | Number |
@@ -230,3 +227,34 @@ Feature: Around hooks
       2 steps (2 passed)
 
       """
+
+  Scenario: Around Hooks and the Custom World
+    Given a file named "features/step_definitions/steps.rb" with:
+      """
+      Then /^the world should be available in the hook$/ do
+        $previous_world = self
+        expect($hook_world).to eq(self)
+      end
+
+      Then /^what$/ do
+        expect($hook_world).not_to eq($previous_world)
+      end
+      """
+    And a file named "features/support/hooks.rb" with:
+      """
+      Around do |scenario, block|
+        $hook_world = self
+        block.call
+      end
+      """
+    And a file named "features/f.feature" with:
+      """
+      Feature: Around hooks
+        Scenario: using hook
+          Then the world should be available in the hook
+
+        Scenario: using the same hook
+          Then what
+      """
+    When I run `cucumber features/f.feature`
+    Then it should pass

data/features/docs/writing_support_code/before_hook.feature

@@ -0,0 +1,65 @@
+Feature: Before Hook
+
+  Scenario: Examine names of scenario and feature
+    Given a file named "features/foo.feature" with:
+      """
+      Feature: Feature name
+
+        Scenario: Scenario name
+          Given a step
+      """
+    And a file named "features/support/hook.rb" with:
+      """
+      names = []
+      Before do |scenario|
+        expect(scenario).to_not respond_to(:scenario_outline)
+        names << scenario.feature.name.split("\n").first
+        names << scenario.name.split("\n").first
+        if(names.size == 2)
+          raise "NAMES:\n" + names.join("\n") + "\n"
+        end
+      end
+      """
+    When I run `cucumber`
+    Then the output should contain:
+      """
+        NAMES:
+        Feature name
+        Scenario name
+
+      """
+
+  Scenario: Examine names of scenario outline and feature
+    Given a file named "features/foo.feature" with:
+      """
+      Feature: Feature name
+
+        Scenario Outline: Scenario Outline name
+          Given a <placeholder>
+
+          Examples: Examples Table name
+            | <placeholder> |
+            | step          |
+      """
+    And a file named "features/support/hook.rb" with:
+      """
+      names = []
+      Before do |scenario|
+        names << scenario.scenario_outline.feature.name.split("\n").first
+        names << scenario.scenario_outline.name.split("\n").first
+        names << scenario.name.split("\n").first
+        if(names.size == 3)
+          raise "NAMES:\n" + names.join("\n") + "\n"
+        end
+      end
+      """
+    When I run `cucumber`
+    Then the output should contain:
+      """
+            NAMES:
+            Feature name
+            Scenario Outline name, Examples Table name (#1)
+            Scenario Outline name, Examples Table name (#1)
+
+      """
+

data/features/docs/writing_support_code/hook_order.feature

@@ -0,0 +1,61 @@
+  @spawn
+  Feature: Hooks execute in defined order
+
+  Background:
+    Given a file named "features/step_definitions/steps.rb" with:
+      """
+      Given /^background step$/ do; $EventOrder.push(:background_step) end
+      Given /^scenario step$/ do; $EventOrder.push(:scenario_step) end
+      """
+    And a file named "features/support/hooks.rb" with:
+      """
+      $EventOrder = []
+      Around('@around') do |scenario,block|
+        $EventOrder.push :around_begin
+        block.call
+        $EventOrder.push :around_end
+      end
+      Before('@before') do
+        $EventOrder.push :before
+      end
+      After('@after') do |scenario|
+        $EventOrder.push :after
+      end
+      at_exit {
+        puts "Event order: #{$EventOrder.join(' ')}"
+      }
+      """
+    And a file named "features/around_hook_covers_background.feature" with:
+      """
+      @around
+      Feature: Around hooks cover background steps
+        Background:
+          Given background step
+        Scenario:
+          Given scenario step
+      """
+    And a file named "features/all_hook_order.feature" with:
+      """
+      @around
+      @before
+      @after
+      Feature: All hooks execute in expected order
+        Background:
+          Given background step
+        Scenario:
+          Given scenario step
+      """
+
+  Scenario: Around hooks cover background steps
+    When I run `cucumber -o /dev/null features/around_hook_covers_background.feature`
+    Then the output should contain:
+      """
+      Event order: around_begin background_step scenario_step around_end
+      """
+
+  Scenario: All hooks execute in expected order
+    When I run `cucumber -o /dev/null features/all_hook_order.feature`
+    Then the output should contain:
+      """
+      Event order: around_begin before background_step scenario_step after around_end
+      """

data/features/{load_path.feature → docs/writing_support_code/load_path.feature}

@@ -1,5 +1,8 @@
 Feature: Set up a default load path
 
+  When you're developing a gem, it's convenient if your project's `lib` directory
+  is already in the load path. Cucumber does this for you.
+
   Scenario: ./lib is included in the $LOAD_PATH
     Given a file named "features/support/env.rb" with:
       """

data/features/docs/writing_support_code/state.feature

@@ -0,0 +1,32 @@
+Feature: State
+
+  You can pass state between step by setting instance variables,
+  but those instance variables will be gone when the next scenario runs.
+
+  Scenario: Set an ivar in one scenario, use it in the next step
+    Given a file named "features/test.feature" with:
+      """
+      Feature:
+        Scenario:
+          Given I have set @flag = true
+          Then @flag should be true
+
+        Scenario:
+          Then @flag should be nil
+      """
+    And a file named "features/step_definitions/steps.rb" with:
+      """
+      Given /set @flag/ do
+        @flag = true
+      end
+      Then /flag should be true/ do
+        expect(@flag).to be_truthy
+      end
+      Then /flag should be nil/ do
+        expect(@flag).to be_nil
+      end
+      """
+    When I run `cucumber`
+    Then it should pass
+
+