kbaum-cucumber 0.4.5.pre

data/features/unicode_table.feature

@@ -0,0 +1,35 @@
+Feature: Unicode in tables
+  In order to please the whole world,
+  unicode characters in tables should be
+  properly aligned
+  
+  Scenario: All sorts of weird stuff
+    Given a standard Cucumber project directory structure
+    And a file named "features/unicode.feature" with:
+      """
+      Feature: Featuring unicode
+
+        Scenario: So what, whatever
+          Given passing
+            | Brüno | abc |
+            | Bruno | æøå |
+      """
+    And a file named "features/env.rb" with:
+      """
+      $KCODE='u'
+      """
+    When I run cucumber -q --dry-run features/unicode.feature
+    Then it should pass with
+      """
+      Feature: Featuring unicode
+
+        Scenario: So what, whatever
+          Given passing
+            | Brüno | abc |
+            | Bruno | æøå |
+
+      1 scenario (1 undefined)
+      1 step (1 undefined)
+
+      """
+    

data/features/usage_and_stepdefs_formatter.feature

@@ -0,0 +1,169 @@
+Feature: Cucumber command line
+  In order to be able to write an editor plugin that can jump between
+  steps and step definitions, Cucumber must provide a way to
+  display how they are related.
+
+  Scenario: List usage of step definitions
+    When I run cucumber features --format usage --dry-run
+    Then STDERR should be empty
+    And it should pass with
+      """
+      -------------------------------------UU-U--------------UUUUU---------U-------U--------------U-UU-------------------------------------------------UU
+      
+      /^'(.+)' cukes$/                                                   # features/step_definitions/sample_steps.rb:27
+        Given '10' cukes                                                 # features/background/background_with_name.feature:4
+        Given '10' cukes                                                 # features/background/background_with_name.feature:4
+        And '10' cukes                                                   # features/background/failing_background.feature:6
+        And '10' cukes                                                   # features/background/failing_background.feature:6
+        And '10' cukes                                                   # features/background/failing_background.feature:6
+        Given '10' cukes                                                 # features/background/passing_background.feature:4
+        Given '10' cukes                                                 # features/background/passing_background.feature:4
+        Given '10' cukes                                                 # features/background/passing_background.feature:4
+        Given '10' cukes                                                 # features/background/scenario_outline_passing_background.feature:4
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:4
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:5
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:6
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:7
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:8
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:9
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:10
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:11
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:12
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:13
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:14
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:15
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:16
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:17
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:18
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:19
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:20
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:21
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:22
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:23
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:24
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:25
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:26
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:27
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:28
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:29
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:30
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:31
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:32
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:33
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:34
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:35
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:36
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:37
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:38
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:39
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:40
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:41
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:42
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:43
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:44
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:45
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:46
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:47
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:48
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:49
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:50
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:51
+        Given '2' cukes                                                  # features/tons_of_cukes.feature:52
+      /^'(.+)' global cukes$/                                            # features/step_definitions/sample_steps.rb:35
+        And '10' global cukes                                            # features/background/failing_background_after_success.feature:5
+        And '10' global cukes                                            # features/background/failing_background_after_success.feature:5
+        And '10' global cukes                                            # features/background/failing_background_after_success.feature:5
+      /^I should have '(.+)' cukes$/                                     # features/step_definitions/sample_steps.rb:31
+        Then I should have '10' cukes                                    # features/background/background_with_name.feature:7
+        Then I should have '10' cukes                                    # features/background/failing_background.feature:9
+        Then I should have '10' cukes                                    # features/background/failing_background.feature:12
+        Then I should have '10' cukes                                    # features/background/passing_background.feature:7
+        Then I should have '10' cukes                                    # features/background/passing_background.feature:10
+        Then I should have '10' cukes                                    # features/background/pending_background.feature:7
+        Then I should have '10' cukes                                    # features/background/pending_background.feature:10
+      /^I should have '(.+)' global cukes$/                              # features/step_definitions/sample_steps.rb:42
+        Then I should have '10' global cukes                             # features/background/failing_background_after_success.feature:8
+        Then I should have '10' global cukes                             # features/background/failing_background_after_success.feature:11
+      /^a step definition that calls an undefined step$/                 # features/step_definitions/sample_steps.rb:19
+        Given a step definition that calls an undefined step             # features/call_undefined_step_from_step_def.feature:4
+      /^another unused$/                                                 # features/step_definitions/sample_steps.rb:69
+        NOT MATCHED BY ANY STEPS
+      /^call step "(.*)"$/                                               # features/step_definitions/sample_steps.rb:23
+        Given call step "a step definition that calls an undefined step" # features/call_undefined_step_from_step_def.feature:7
+      /^failing expectation$/                                            # features/step_definitions/sample_steps.rb:62
+        Given failing expectation                                        # features/failing_expectation.feature:4
+      /^failing without a table$/                                        # features/step_definitions/sample_steps.rb:15
+        Given failing without a table                                    # features/background/failing_background.feature:5
+        Given failing without a table                                    # features/background/failing_background.feature:5
+        Given failing without a table                                    # features/background/failing_background.feature:5
+        Given failing without a table                                    # features/background/scenario_outline_failing_background.feature:4
+        Given failing without a table                                    # features/search_sample.feature:10
+      /^failing$/                                                        # features/step_definitions/sample_steps.rb:8
+        Given failing                                                    # features/sample.feature:18
+      /^multiline string$/                                               # features/step_definitions/sample_steps.rb:50
+        And multiline string                                             # features/background/multiline_args_background.feature:7
+        And multiline string                                             # features/background/multiline_args_background.feature:7
+        And multiline string                                             # features/background/multiline_args_background.feature:7
+      /^passing without a table$/                                        # features/step_definitions/sample_steps.rb:12
+        Given passing without a table                                    # features/background/background_tagged_before_on_outline.feature:5
+        Given passing without a table                                    # features/background/failing_background_after_success.feature:4
+        Given passing without a table                                    # features/background/failing_background_after_success.feature:4
+        Given passing without a table                                    # features/background/failing_background_after_success.feature:4
+        Given passing without a table                                    # features/multiline_name.feature:6
+        Given passing without a table                                    # features/multiline_name.feature:6
+        Given passing without a table                                    # features/multiline_name.feature:11
+        Given passing without a table                                    # features/search_sample.feature:4
+        Given passing without a table                                    # features/search_sample.feature:4
+        Given passing without a table                                    # features/search_sample.feature:7
+        Given passing without a table                                    # features/search_sample.feature:4
+      /^passing$/                                                        # features/step_definitions/sample_steps.rb:5
+        Given passing                                                    # features/sample.feature:12
+      /^table$/                                                          # features/step_definitions/sample_steps.rb:46
+        Given table                                                      # features/background/multiline_args_background.feature:4
+        Given table                                                      # features/background/multiline_args_background.feature:4
+        Given table                                                      # features/background/multiline_args_background.feature:4
+      /^the multiline string should be$/                                 # features/step_definitions/sample_steps.rb:58
+        Then the multiline string should be                              # features/background/multiline_args_background.feature:17
+        Then the multiline string should be                              # features/background/multiline_args_background.feature:27
+      /^the table should be$/                                            # features/step_definitions/sample_steps.rb:54
+        Then the table should be                                         # features/background/multiline_args_background.feature:14
+        Then the table should be                                         # features/background/multiline_args_background.feature:24
+      /^unused$/                                                         # features/step_definitions/sample_steps.rb:66
+        NOT MATCHED BY ANY STEPS
+      
+      43 scenarios (32 skipped, 10 undefined, 1 passed)
+      131 steps (117 skipped, 14 undefined)
+
+      """
+
+      Scenario: --format steps
+      When I run cucumber features --format stepdefs --dry-run
+      Then STDERR should be empty
+      And it should pass with
+        """
+        -------------------------------------UU-U--------------UUUUU---------U-------U--------------U-UU-------------------------------------------------UU
+        
+        /^'(.+)' cukes$/                                      # features/step_definitions/sample_steps.rb:27
+        /^'(.+)' global cukes$/                               # features/step_definitions/sample_steps.rb:35
+        /^I should have '(.+)' cukes$/                        # features/step_definitions/sample_steps.rb:31
+        /^I should have '(.+)' global cukes$/                 # features/step_definitions/sample_steps.rb:42
+        /^a step definition that calls an undefined step$/    # features/step_definitions/sample_steps.rb:19
+        /^another unused$/                                    # features/step_definitions/sample_steps.rb:69
+          NOT MATCHED BY ANY STEPS
+        /^call step "(.*)"$/                                  # features/step_definitions/sample_steps.rb:23
+        /^failing expectation$/                               # features/step_definitions/sample_steps.rb:62
+        /^failing without a table$/                           # features/step_definitions/sample_steps.rb:15
+        /^failing$/                                           # features/step_definitions/sample_steps.rb:8
+        /^multiline string$/                                  # features/step_definitions/sample_steps.rb:50
+        /^passing without a table$/                           # features/step_definitions/sample_steps.rb:12
+        /^passing$/                                           # features/step_definitions/sample_steps.rb:5
+        /^table$/                                             # features/step_definitions/sample_steps.rb:46
+        /^the multiline string should be$/                    # features/step_definitions/sample_steps.rb:58
+        /^the table should be$/                               # features/step_definitions/sample_steps.rb:54
+        /^unused$/                                            # features/step_definitions/sample_steps.rb:66
+          NOT MATCHED BY ANY STEPS
+        
+        43 scenarios (32 skipped, 10 undefined, 1 passed)
+        131 steps (117 skipped, 14 undefined)
+
+        """

data/features/wire_protocol.feature

@@ -0,0 +1,177 @@
+@wire
+Feature: Wire Protocol
+  In order to be allow Cucumber to touch my app in intimate places
+  As a developer on platform which doesn't support Ruby
+  I want a low-level protocol which Cucumber can use to run steps within my app
+
+  #
+  # Cucumber's wire protocol is an implementation of Cucumber's internal 'programming language' abstraction,
+  # and allows step definitions to be implemented and invoked on any platform.
+  #
+  # Communication is over a TCP socket, which Cucumber connects to when it finds a definition file with the
+  # .wire extension in the step_definitions folder (or other load path).
+  #
+  # There are currently two messages which Cucumber sends over the wire:
+  #
+  #   * step_matches : this is used to find out whether the wire end has a definition for a given step
+  #   * invoke       : this is used to ask for a step definition to be invoked
+  #
+  # Message packets are formatted as JSON-encoded strings, with a newline character signalling the end of a
+  # packet. These messages are described below, with examples.
+  #
+
+  Background:
+    Given a standard Cucumber project directory structure
+    And a file named "features/wired.feature" with:
+      """
+        Scenario: Wired
+          Given we're all wired
+
+      """
+    And a file named "features/step_definitions/some_remote_place.wire" with:
+      """
+      host: localhost
+      port: 54321
+
+      """
+
+
+  #
+  # step_matches
+  #
+  # When the features have been parsed, Cucumber will send a step_matches message to ask the wire end
+  # if it can match a step name. This happens for each of the steps in each of the features.
+  # The wire end replies with a step_match array, containing the IDs of any step definitions that could
+  # be invoked for the given step name.
+
+  Scenario: Dry run finds no step match
+    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"}] | ["step_matches",[]] |
+    When I run cucumber --dry-run -f progress features
+    And it should pass with
+      """
+      U
+
+      1 scenario (1 undefined)
+      1 step (1 undefined)
+
+      """
+
+  # When a step match is returned, it contains an identifier for the step definition to be used
+  # later when referring to this step definition again if it needs to be invoked. The identifier
+  # can take any form (as long as it's within a string) and is simply used for the wire end's own
+  # reference.
+  # The step match also contains any argument values as parsed out by the wire end's own regular
+  # expression or other argument matching process.
+  Scenario: Dry run finds a step match
+    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"}] | ["step_matches",[{"id":"1", "args":[]}]] |
+    When I run cucumber --dry-run -f progress features
+    And it should pass with
+      """
+      -
+
+      1 scenario (1 skipped)
+      1 step (1 skipped)
+
+      """
+
+
+  #
+  # invoke
+  #
+  # Assuming a step_match was returned for a given step name, when it's time to invoke that
+  # step definition, Cucumber will send an invoke message.
+  # The message contains the ID of the step definition, as returned by the wire end from the
+  # step_matches call, along with the arguments that were parsed from the step name during the
+  # same step_matches call.
+  # The wire end will reply with either a step_failed or a success message.
+
+  Scenario: Invoke a step definition which 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"}] | ["step_matches",[{"id":"1", "args":[]}]] |
+      | ["begin_scenario",null]                              | ["success",null]                         |
+      | ["invoke",{"id":"1","args":[]}]                      | ["success",null]                         |
+      | ["end_scenario",null]                                | ["success",null]                         |
+    When I run cucumber -f progress --backtrace features
+    And it should pass with
+      """
+      .
+
+      1 scenario (1 passed)
+      1 step (1 passed)
+
+      """
+
+  # When a step definition fails, it can return details of the exception in the reply to invoke. These
+  # will then be passed by Cucumber to the formatters for display to the user.
+  #
+  Scenario: Invoke a step definition which 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"}] | ["step_matches",[{"id":"1", "args":[]}]]         |
+      | ["begin_scenario",null]                              | ["success",null]                                 |
+      | ["invoke",{"id":"1","args":[]}]                      | ["step_failed",{"message":"The wires are down"}] |
+      | ["end_scenario",null]                                | ["success",null]                                 |
+    When I run cucumber -f progress features
+    Then STDERR should be empty
+    And it should fail with
+      """
+      F
+
+      (::) failed steps (::)
+
+      The wires are down (Cucumber::WireSupport::WireException)
+      features/wired.feature:2:in `Given we're all wired'
+
+      Failing Scenarios:
+      cucumber features/wired.feature:1 # Scenario: Wired
+
+      1 scenario (1 failed)
+      1 step (1 failed)
+
+      """
+
+  # Imagine we have a step definition like:
+  #
+  #     Given /we're all (.*)/ do |what_we_are|
+  #     end
+  #
+  # When this step definition matches the step name in our feature, the word 'wired' will be parsed as an
+  # argument.
+  #
+  # Cucumber expects this StepArgument to be returned in the StepMatch. The keys have the following meanings:
+  #   * val : the value of the string captured for that argument from the step name passed in step_matches
+  #   * pos : the position within the step name that the argument was matched (used for formatter highlighting)
+  #
+  Scenario: Invoke a step definition which takes arguments (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"}] | ["step_matches",[{"id":"1", "args":[{"val":"wired", "pos":10}]}]] |
+      | ["begin_scenario",null]                              | ["success",null]                                                  |
+      | ["invoke",{"id":"1","args":["wired"]}]               | ["success",null]                                                  |
+      | ["end_scenario",null]                                | ["success",null]                                                  |
+    When I run cucumber -f progress --backtrace features
+    Then STDERR should be empty
+    And it should pass with
+      """
+      .
+
+      1 scenario (1 passed)
+      1 step (1 passed)
+
+      """
+
+
+  Scenario: Unexpected response
+    Given there is a wire server running on port 54321 which understands the following protocol:
+      | request                                              | response   |
+      | ["begin_scenario",null]                              | ["yikes"]  |
+    When I run cucumber -f progress features
+    Then STDERR should match
+      """
+      undefined method `handle_yikes'
+      """

data/features/work_in_progress.feature

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