cucumber 2.0.0.rc.4 → 4.0.0.rc.2

data/features/docs/wire_protocol_tags.feature

@@ -1,86 +0,0 @@
-@wire
-Feature: Wire protocol tags
-  In order to use Before and After hooks in a wire server, we send tags with the 
-  scenario in the begin_scenario and end_scenario messages
-
-  Background:
-    And a file named "features/step_definitions/some_remote_place.wire" with:
-      """
-      host: localhost
-      port: 54321
-
-      """
-
-  Scenario: Run a scenario
-    Given a file named "features/wired.feature" with:
-      """
-        @foo @bar
-        Feature: Wired
-        
-          @baz
-          Scenario: Everybody's Wired
-            Given we're all wired
-
-      """
-    And there is a wire server running on port 54321 which understands the following protocol:
-      | request                                              | response                            |
-      | ["step_matches",{"name_to_match":"we're all wired"}] | ["success",[{"id":"1", "args":[]}]] |
-      | ["begin_scenario", {"tags":["bar","baz","foo"]}]     | ["success"]                         |
-      | ["invoke",{"id":"1","args":[]}]                      | ["success"]                         |
-      | ["end_scenario", {"tags":["bar","baz","foo"]}]       | ["success"]                         |
-    When I run `cucumber -f pretty -q`
-    Then the stderr should not contain anything
-    And it should pass with:
-      """
-      @foo @bar
-      Feature: Wired
-      
-        @baz
-        Scenario: Everybody's Wired
-          Given we're all wired
-
-      1 scenario (1 passed)
-      1 step (1 passed)
-
-      """
-
-  Scenario: Run a scenario outline example
-  Given a file named "features/wired.feature" with:
-    """
-      @foo @bar
-      Feature: Wired
-      
-        @baz
-        Scenario Outline: Everybody's Wired
-          Given we're all <something>
-          
-        Examples:
-          | something |
-          | wired     |
-
-    """
-  And there is a wire server running on port 54321 which understands the following protocol:
-    | request                                              | response                            |
-    | ["step_matches",{"name_to_match":"we're all wired"}] | ["success",[{"id":"1", "args":[]}]] |
-    | ["begin_scenario", {"tags":["bar","baz","foo"]}]     | ["success"]                         |
-    | ["invoke",{"id":"1","args":[]}]                      | ["success"]                         |
-    | ["end_scenario", {"tags":["bar","baz","foo"]}]       | ["success"]                         |
-  When I run `cucumber -f pretty -q`
-  Then the stderr should not contain anything
-  And it should pass with:
-    """
-    @foo @bar
-    Feature: Wired
-    
-      @baz
-      Scenario Outline: Everybody's Wired
-        Given we're all <something>
-
-        Examples: 
-          | something |
-          | wired     |
-
-    1 scenario (1 passed)
-    1 step (1 passed)
-
-    """

data/features/docs/wire_protocol_timeouts.feature

@@ -1,63 +0,0 @@
-@wire
-Feature: Wire protocol timeouts
-  We don't want Cucumber to hang forever on a wire server that's not even there,
-  but equally we need to give the user the flexibility to allow step definitions
-  to take a while to execute, if that's what they need.
-
-  Background:
-    And a file named "features/wired.feature" with:
-      """
-      Feature: Telegraphy
-        Scenario: Wired
-          Given we're all wired
-
-      """
-
-  Scenario: Try to talk to a server that's not there
-    Given a file named "features/step_definitions/some_remote_place.wire" with:
-      """
-      host: localhost
-      port: 54321
-
-      """
-    When I run `cucumber -f progress`
-    Then the stderr should contain:
-      """
-      Unable to contact the wire server at localhost:54321
-      """
-
-  @spawn
-  Scenario: Invoke a step definition that takes longer than its timeout
-    Given a file named "features/step_definitions/some_remote_place.wire" with:
-      """
-      host: localhost
-      port: 54321
-      timeout:
-        invoke: 0.1
-
-      """
-    And there is a wire server on port 54321 which understands the following protocol:
-      | request                                              | response                                                     |
-      | ["step_matches",{"name_to_match":"we're all wired"}] | ["success",[{"id":"1", "args":[{"val":"wired", "pos":10}]}]] |
-      | ["begin_scenario"]                                   | ["success"]                                                  |
-      | ["invoke",{"id":"1","args":["wired"]}]               | ["success"]                                                  |
-      | ["end_scenario"]                                     | ["success"]                                                  |
-    And the wire server takes 0.2 seconds to respond to the invoke message
-    When I run `cucumber -f pretty`
-    Then the stderr should not contain anything
-    And it should fail with:
-      """
-      Feature: Telegraphy
-
-        Scenario: Wired         # features/wired.feature:2
-          Given we're all wired # Unknown
-            Timed out calling wire server with message 'invoke' (Timeout::Error)
-            features/wired.feature:3:in `Given we're all wired'
-
-      Failing Scenarios:
-      cucumber features/wired.feature:2 # Scenario: Wired
-
-      1 scenario (1 failed)
-      1 step (1 failed)
-
-      """

data/features/docs/work_in_progress.feature

@@ -1,154 +0,0 @@
-@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
-            - will fail if any scenario passes completely
-            - will not fail otherwise
-
-  Background: A passing and a pending feature
-    Given the standard step definitions
-    And a file named "features/wip.feature" with:
-      """
-      Feature: WIP
-        @failing
-        Scenario: Failing
-          Given this step raises an error
-
-        @undefined
-        Scenario: Undefined
-          Given this step is undefined
-
-        @pending
-        Scenario: Pending
-          Given this step is pending
-
-        @passing
-        Scenario: Passing
-          Given this step passes
-      """
-    And a file named "features/passing_outline.feature" with:
-      """
-      Feature: Not WIP
-        Scenario Outline: Passing
-          Given this step <what>
-
-          Examples:
-            | what   |
-            | passes |
-      """
-
-  Scenario: Pass with Failing Scenarios
-    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 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:
-      """
-      Feature: WIP
-
-        @undefined
-        Scenario: Undefined
-          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:
-      """
-      Feature: WIP
-
-        @pending
-        Scenario: Pending
-          Given this step is pending
-            TODO (Cucumber::Pending)
-            ./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:
-      """
-      Feature: WIP
-
-        @passing
-        Scenario: Passing
-          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 (::)
-
-      features/wip.feature:15:in `Scenario: Passing'
-
-
-      """
-
-  Scenario: Fail with Passing Scenario Outline
-    When I run `cucumber -q -w features/passing_outline.feature`
-    Then it should fail with:
-      """
-      Feature: Not WIP
-
-        Scenario Outline: Passing
-          Given this step <what>
-
-          Examples: 
-            | 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 `Scenario Outline: Passing, Examples (row 1)'
-
-
-      """

data/features/docs/writing_support_code/after_hooks.feature

@@ -1,56 +0,0 @@
-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'
-      """
-

data/features/docs/writing_support_code/around_hooks.feature

@@ -1,229 +0,0 @@
-@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 file named "features/step_definitions/steps.rb" with:
-      """
-      Then /^the hook is called$/ do
-        expect($hook_called).to be true
-      end
-      """
-    And a file named "features/support/hooks.rb" with:
-      """
-      Around do |scenario, block|
-        $hook_called = true
-        block.call
-      end
-      """
-    And a file named "features/f.feature" with:
-      """
-      Feature: Around hooks
-        Scenario: using hook
-          Then the hook is called
-      """
-    When I run `cucumber features/f.feature`
-    Then it should pass with:
-      """
-      Feature: Around hooks
-
-        Scenario: using hook      # features/f.feature:2
-          Then the hook is called # features/step_definitions/steps.rb:1
-
-      1 scenario (1 passed)
-      1 step (1 passed)
-
-      """
-
-  Scenario: Multiple Around hooks
-    Given a file named "features/step_definitions/steps.rb" with:
-      """
-      Then /^the hooks are called in the correct order$/ do
-        expect($hooks_called).to eq ['A', 'B', 'C']
-      end
-      """
-    And a file named "features/support/hooks.rb" with:
-      """
-      Around do |scenario, block|
-        $hooks_called ||= []
-        $hooks_called << 'A'
-        block.call
-      end
-
-      Around do |scenario, block|
-        $hooks_called ||= []
-        $hooks_called << 'B'
-        block.call
-      end
-
-      Around do |scenario, block|
-        $hooks_called ||= []
-        $hooks_called << 'C'
-        block.call
-      end
-      """
-    And a file named "features/f.feature" with:
-      """
-      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:
-      """
-      Feature: Around hooks
-
-        Scenario: using multiple hooks                   # features/f.feature:2
-          Then the hooks are called in the correct order # features/step_definitions/steps.rb:1
-
-      1 scenario (1 passed)
-      1 step (1 passed)
-
-      """
-
-  Scenario: Mixing Around, Before, and After hooks
-    Given a file named "features/step_definitions/steps.rb" with:
-      """
-      Then /^the Around hook is called around Before and After hooks$/ do
-        expect($hooks_called).to eq ['Around', 'Before']
-      end
-      """
-    And a file named "features/support/hooks.rb" with:
-      """
-      Around do |scenario, block|
-        $hooks_called ||= []
-        $hooks_called << 'Around'
-        block.call
-        $hooks_called << 'Around'
-        $hooks_called.should == ['Around', 'Before', 'After', 'Around'] #TODO: Find out why this fails using the new rspec expect syntax.
-      end
-
-      Before do |scenario|
-        $hooks_called ||= []
-        $hooks_called << 'Before'
-      end
-
-      After do |scenario|
-        $hooks_called ||= []
-        $hooks_called << 'After'
-        expect($hooks_called).to eq ['Around', 'Before', 'After']
-      end
-      """
-    And a file named "features/f.feature" with:
-      """
-      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:
-      """
-      Feature: Around hooks
-
-        Scenario: Mixing Around, Before, and After hooks               # features/f.feature:2
-          Then the Around hook is called around Before and After hooks # features/step_definitions/steps.rb:1
-
-      1 scenario (1 passed)
-      1 step (1 passed)
-
-      """
-
-  Scenario: Around hooks with tags
-    Given a file named "features/step_definitions/steps.rb" with:
-      """
-      Then /^the Around hooks with matching tags are called$/ do
-        expect($hooks_called).to eq ['one', 'one or two']
-      end
-      """
-    And a file named "features/support/hooks.rb" with:
-      """
-      Around('@one') do |scenario, block|
-        $hooks_called ||= []
-        $hooks_called << 'one'
-        block.call
-      end
-
-      Around('@one,@two') do |scenario, block|
-        $hooks_called ||= []
-        $hooks_called << 'one or two'
-        block.call
-      end
-
-      Around('@one', '@two') do |scenario, block|
-        $hooks_called ||= []
-        $hooks_called << 'one and two'
-        block.call
-      end
-
-      Around('@two') do |scenario, block|
-        $hooks_called ||= []
-        $hooks_called << 'two'
-        block.call
-      end
-      """
-    And a file named "features/f.feature" with:
-      """
-      Feature: Around hooks
-        @one
-        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:
-      """
-      Feature: Around hooks
-
-        @one
-        Scenario: Around hooks with tags
-          Then the Around hooks with matching tags are called
-
-      1 scenario (1 passed)
-      1 step (1 passed)
-
-      """
-
-  Scenario: Around hooks with scenario outlines
-    Given a file named "features/step_definitions/steps.rb" with:
-      """
-      Then /^the hook is called$/ do
-        expect($hook_called).to be true
-      end
-      """
-    And a file named "features/support/hooks.rb" with:
-      """
-      Around do |scenario, block|
-        $hook_called = true
-        block.call
-      end
-      """
-    And a file named "features/f.feature" with:
-      """
-      Feature: Around hooks with scenario outlines
-        Scenario Outline: using hook
-          Then the hook is called
-
-          Examples:
-            | Number |
-            | one    |
-            | two    |
-      """
-    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/f.feature:3
-
-          Examples: 
-            | Number |
-            | one    |
-            | two    |
-
-      2 scenarios (2 passed)
-      2 steps (2 passed)
-
-      """