cucumber 0.8.5 → 0.8.6

data/features/wire_protocol_table_diffing.feature

@@ -1,119 +0,0 @@
-@wire
-Feature: Wire protocol table diffing
-  In order to use the amazing functionality in the Cucumber table object
-  As a wire server
-  I want to be able to ask for a table diff during a step definition invocation
-
-  Background:
-    Given a standard Cucumber project directory structure
-    And a file named "features/wired.feature" with:
-      """
-      Feature: Hello
-        Scenario: Wired
-          Given we're all wired
-
-      """
-    And a file named "features/step_definitions/some_remote_place.wire" with:
-      """
-      host: localhost
-      port: 54321
-
-      """
-
-  Scenario: Invoke a step definition tries to diff the table and fails
-    Given 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"]                                   | ["success"]                                                                                          |
-      | ["invoke",{"id":"1","args":[]}]                      | ["diff",[[["a","b"],["c","d"]],[["x","y"],["z","z"]]]]                                               |
-      | ["diff_failed"]                                      | ["fail",{"message":"Not same", "exception":"DifferentException", "backtrace":["a.cs:12","b.cs:34"]}] |
-      | ["end_scenario"]                                     | ["success"]                                                                                          |
-    When I run cucumber -f progress --backtrace
-    Then STDERR should be empty
-    And it should fail with
-      """
-      F
-
-      (::) failed steps (::)
-
-      Not same (DifferentException from localhost:54321)
-      a.cs:12
-      b.cs:34
-      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)
-
-      """
-
-  Scenario: Invoke a step definition tries to diff the table and passes
-    Given 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"]                                   | ["success"]                            |
-      | ["invoke",{"id":"1","args":[]}]                      | ["diff",[[["a"],["b"]],[["a"],["b"]]]] |
-      | ["diff_ok"]                                          | ["success"]                            |
-      | ["end_scenario"]                                     | ["success"]                            |
-    When I run cucumber -f progress
-    And it should pass with
-      """
-      .
-
-      1 scenario (1 passed)
-      1 step (1 passed)
-
-      """
-
-  Scenario: Invoke a step definition which successfully diffs a table but then fails
-    Given 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"]                                   | ["success"]                                                   |
-      | ["invoke",{"id":"1","args":[]}]                      | ["diff",[[["a"],["b"]],[["a"],["b"]]]]                        |
-      | ["diff_ok"]                                          | ["fail",{"message":"I wanted things to be different for us"}] |
-      | ["end_scenario"]                                     | ["success"]                                                   |
-    When I run cucumber -f progress
-    And it should fail with
-      """
-      F
-
-      (::) failed steps (::)
-
-      I wanted things to be different for us (Cucumber::WireSupport::WireException)
-      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)
-
-      """
-
-  Scenario: Invoke a step definition which asks for an immediate diff that fails
-    Given 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"]                                   | ["success"]                         |
-      | ["invoke",{"id":"1","args":[]}]                      | ["diff!",[[["a"]],[["b"]]]]         |
-      | ["end_scenario"]                                     | ["success"]                         |
-    When I run cucumber -f progress
-    And it should fail with
-      """
-      F
-
-      (::) failed steps (::)
-
-      Tables were not identical (Cucumber::Ast::Table::Different)
-      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/wire_protocol_tags.feature

@@ -1,87 +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:
-    Given a standard Cucumber project directory structure
-    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 STDERR should be empty
-    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 STDERR should be empty
-  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/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:
-    Given a standard Cucumber project directory structure
-    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 STDERR should match
-      """
-      Unable to contact the wire server at localhost:54321
-      """
-
-  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 STDERR should be empty
-    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/work_in_progress.feature

@@ -1,156 +0,0 @@
-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 a standard Cucumber project directory structure
-    Given a file named "features/wip.feature" with:
-      """
-      Feature: WIP
-        @failing
-        Scenario: Failing
-          Given a failing step
-
-        @undefined
-        Scenario: Undefined
-          Given an undefined step
-
-        @pending
-        Scenario: Pending
-          Given a pending step
-
-        @passing
-        Scenario: Passing
-          Given a passing step
-      """
-    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 /^a passing step$/ do
-      end
-
-      Given /^a pending step$/ do
-        pending
-      end
-      """
-
-  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
-      """
-      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'
-      
-      Failing Scenarios:
-      cucumber features/wip.feature:3 # Scenario: Failing
-
-      1 scenario (1 failed)
-      1 step (1 failed)
-
-      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 an undefined step
-
-      1 scenario (1 undefined)
-      1 step (1 undefined)
-
-      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 a pending step
-            TODO (Cucumber::Pending)
-            ./features/step_definitions/steps.rb:9:in `/^a pending step$/'
-            features/wip.feature:12:in `Given a pending step'
-
-      1 scenario (1 pending)
-      1 step (1 pending)
-
-      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 a passing step
-
-      1 scenario (1 passed)
-      1 step (1 passed)
-
-      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 a <what> step
-      
-          Examples: 
-            | what    |
-            | passing |
-
-      1 scenario (1 passed)
-      1 step (1 passed)
-
-      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 |'
-
-
-      """

data/fixtures/json/features/pystring.feature

@@ -1,8 +0,0 @@
-Feature: A py string feature
-
-  Scenario: 
-    Then I should see
-    """
-    a string
-    """
-  

data/fixtures/self_test/features/background/background_tagged_before_on_outline.feature

@@ -1,12 +0,0 @@
-@background_tagged_before_on_outline
-Feature: Background tagged Before on Outline
-
-  Background: 
-    Given passing without a table
-
-  Scenario Outline: passing background
-    Then I should have '<count>' cukes
-
-    Examples: 
-      | count |
-      | 888   |