cucumber 3.0.1 → 3.0.2

data/features/docs/defining_steps/ambiguous_steps.feature

@@ -1,89 +0,0 @@
-Feature: Ambiguous Steps
-
-  When Cucumber searches for a step definition for a step, it might find multiple step
-  definitions that could match. In that case, it will give you an error that the step
-  definitions are ambiguous.
-
-  You can also use a `--guess` mode, where it uses magic powers to try and figure
-  out which of those two step definitions is most likely to be the one you meant it
-  to use. Use it with caution!
-
-
-  Scenario: Ambiguous steps
-
-    Given a file named "features/ambiguous.feature" with:
-    """
-    Feature:
-
-      Scenario:
-      When a step
-      Then an ambiguous step
-
-    """
-    And a file named "features/step_definitions.rb" with:
-    """
-      When(/^a.*step$/) do
-        'foo'
-      end
-
-      Then(/^an ambiguous step$/) do
-        'bar'
-      end
-
-    """
-    When I run `cucumber`
-    Then it should fail with:
-    """
-          Ambiguous match of "an ambiguous step":
-          
-          features/step_definitions.rb:1:in `/^a.*step$/'
-          features/step_definitions.rb:5:in `/^an ambiguous step$/'
-          
-          You can run again with --guess to make Cucumber be more smart about it
-           (Cucumber::Ambiguous)
-          features/ambiguous.feature:5:in `Then an ambiguous step'
-
-    Failing Scenarios:
-    cucumber features/ambiguous.feature:3 # Scenario: 
-
-    1 scenario (1 failed)
-    2 steps (1 failed, 1 passed)
-    0m0.012s
-
-    """
-
-
-  Scenario: Ambiguous steps with guess mode
-
-    Given a file named "features/ambiguous.feature" with:
-    """
-    Feature:
-
-      Scenario:
-      When a step
-      Then an ambiguous step
-    """
-    And a file named "features/step_definitions.rb" with:
-    """
-      When(/^a.*step$/) do
-        'foo'
-      end
-
-      Then(/^an ambiguous step$/) do
-        'bar'
-      end
-    """
-    When I run `cucumber -g`
-    Then it should pass with exactly:
-    """
-    Feature: 
-
-      Scenario:                # features/ambiguous.feature:3
-        When a step            # features/step_definitions.rb:1
-        Then an ambiguous step # features/step_definitions.rb:5
-
-    1 scenario (1 passed)
-    2 steps (2 passed)
-    0m0.012s
-
-    """

data/features/docs/defining_steps/nested_steps.feature

@@ -1,181 +0,0 @@
-Feature: Nested Steps
-
-  Background:
-    Given a scenario with a step that looks like this:
-      """gherkin
-      Given two turtles
-      """
-    And a step definition that looks like this:
-      """ruby
-      Given /a turtle/ do
-        puts "turtle!"
-      end
-      """
-
-  @todo-windows
-  Scenario: Use #steps to call several steps at once
-    Given a step definition that looks like this:
-      """ruby
-      Given /two turtles/ do
-        steps %{
-          Given a turtle
-          And a turtle
-        }
-      end
-      """
-    When I run the feature with the progress formatter
-    Then the output should contain:
-      """
-      turtle!
-
-      turtle!
-
-      """
-
-  @todo-windows
-  Scenario: Use #step to call a single step
-    Given a step definition that looks like this:
-      """ruby
-      Given /two turtles/ do
-        step "a turtle"
-        step "a turtle"
-      end
-      """
-    When I run the feature with the progress formatter
-    Then the output should contain:
-      """
-      turtle!
-
-      turtle!
-
-      """
-
-  @todo-windows
-  Scenario: Use #steps to call a table
-    Given a step definition that looks like this:
-      """ruby
-      Given /turtles:/ do |table|
-        table.hashes.each do |row|
-          puts row[:name]
-        end
-      end
-      """
-    And a step definition that looks like this:
-      """ruby
-      Given /two turtles/ do
-        steps %{
-          Given turtles:
-            | name      |
-            | Sturm     |
-            | Liouville |
-        }
-      end
-      """
-    When I run the feature with the progress formatter
-    Then the output should contain:
-      """
-      Sturm
-
-      Liouville
-
-      """
-
-  @todo-windows
-  Scenario: Use #steps to call a multi-line string
-    Given a step definition that looks like this:
-      """ruby
-        Given /two turtles/ do
-          steps %Q{
-            Given turtles:
-               \"\"\"
-               Sturm
-               Liouville
-               \"\"\"
-          }
-        end
-      """
-    And a step definition that looks like this:
-      """ruby
-      Given /turtles:/ do |string|
-        puts string
-      end
-      """
-    When I run the feature with the progress formatter
-    Then the output should contain:
-      """
-      Sturm
-      Liouville
-      """
-
-  @spawn @todo-windows
-  Scenario: Backtrace doesn't skip nested steps
-    Given a step definition that looks like this:
-      """ruby
-      Given /two turtles/ do
-        step "I have a couple turtles"
-      end
-
-      When(/I have a couple turtles/) { raise 'error' }
-      """
-    When I run the feature with the progress formatter
-    Then it should fail with:
-      """
-      error (RuntimeError)
-      ./features/step_definitions/steps2.rb:5:in `/I have a couple turtles/'
-      ./features/step_definitions/steps2.rb:2:in `/two turtles/'
-      features/test_feature_1.feature:3:in `Given two turtles'
-
-      Failing Scenarios:
-      cucumber features/test_feature_1.feature:2 # Scenario: Test Scenario 1
-
-      1 scenario (1 failed)
-      1 step (1 failed)
-      """
-
-  Scenario: Undefined nested step
-    Given a file named "features/call_undefined_step_from_step_def.feature" with:
-      """
-      Feature: Calling undefined step
-
-        Scenario: Call directly
-          Given a step that calls an undefined step
-
-        Scenario: Call via another
-          Given a step that calls a step that calls an undefined step
-      """
-    And a file named "features/step_definitions/steps.rb" with:
-      """
-      Given /^a step that calls an undefined step$/ do
-        step 'this does not exist'
-      end
-
-      Given /^a step that calls a step that calls an undefined step$/ do
-        step 'a step that calls an undefined step'
-      end
-      """
-    When I run `cucumber -q features/call_undefined_step_from_step_def.feature`
-    Then it should fail with exactly:
-      """
-      Feature: Calling undefined step
-
-        Scenario: Call directly
-          Given a step that calls an undefined step
-            Undefined dynamic step: "this does not exist" (Cucumber::UndefinedDynamicStep)
-            ./features/step_definitions/steps.rb:2:in `/^a step that calls an undefined step$/'
-            features/call_undefined_step_from_step_def.feature:4:in `Given a step that calls an undefined step'
-
-        Scenario: Call via another
-          Given a step that calls a step that calls an undefined step
-            Undefined dynamic step: "this does not exist" (Cucumber::UndefinedDynamicStep)
-            ./features/step_definitions/steps.rb:2:in `/^a step that calls an undefined step$/'
-            ./features/step_definitions/steps.rb:6:in `/^a step that calls a step that calls an undefined step$/'
-            features/call_undefined_step_from_step_def.feature:7:in `Given a step that calls a step that calls an undefined step'
-
-      Failing Scenarios:
-      cucumber features/call_undefined_step_from_step_def.feature:3
-      cucumber features/call_undefined_step_from_step_def.feature:6
-
-      2 scenarios (2 failed)
-      2 steps (2 failed)
-
-      """

data/features/docs/defining_steps/nested_steps_i18n.feature

@@ -1,37 +0,0 @@
-Feature: Nested Steps in I18n
-
-  Background:
-    Given a scenario with a step that looks like this in japanese:
-      """gherkin
-      前提 two turtles
-      """
-    And a step definition that looks like this:
-      """ruby
-      # -*- coding: utf-8 -*-
-      # frozen_string_literal: true
-      前提 /a turtle/ do
-        puts "turtle!"
-      end
-      """
-
-  @todo-windows
-  Scenario: Use #steps to call several steps at once
-    Given a step definition that looks like this:
-      """ruby
-      # -*- coding: utf-8 -*-
-      # frozen_string_literal: true
-      前提 /two turtles/ do
-        steps %{
-          前提 a turtle
-          かつ a turtle
-        }
-      end
-      """
-    When I run the feature with the progress formatter
-    Then the output should contain:
-      """
-      turtle!
-
-      turtle!
-
-      """

data/features/docs/defining_steps/nested_steps_with_second_arg.feature

@@ -1,56 +0,0 @@
-Feature: Nested Steps with either table or doc string
-
-  Background:
-    Given a scenario with a step that looks like this:
-      """gherkin
-      Given two turtles
-      """
-
-  @todo-windows
-  Scenario: Use #step with table
-    Given a step definition that looks like this:
-      """ruby
-      Given /turtles:/ do |table|
-        table.hashes.each do |row|
-          puts row[:name]
-        end
-      end
-      """
-    And a step definition that looks like this:
-      """ruby
-      Given /two turtles/ do
-        step %{turtles:}, table(%{
-        | name      |
-        | Sturm     |
-        | Liouville |
-        })
-      end
-      """
-    When I run the feature with the progress formatter
-    Then the output should contain:
-      """
-      Sturm
-
-      Liouville
-
-      """
-
-  @todo-windows
-  Scenario: Use #step with Doc String
-    Given a step definition that looks like this:
-      """ruby
-      Given /two turtles/ do
-        step %{turtles:}, "Sturm and Lioville"
-      end
-      """
-    And a step definition that looks like this:
-      """ruby
-      Given /turtles:/ do |text|
-        puts "#{text}:#{text.class}"
-      end
-      """
-    When I run the feature with the progress formatter
-    Then the output should contain:
-      """
-      Sturm and Lioville:String
-      """

data/features/docs/defining_steps/one_line_step_definitions.feature

@@ -1,65 +0,0 @@
-Feature: One line step definitions
-
-  Everybody knows you can do step definitions in Cucumber
-  but did you know you can do this?
-
-  Scenario: Call a method in World directly from a step def
-    Given a file named "features/step_definitions/steps.rb" with:
-      """
-      module Driver
-        def do_action
-          @done = true
-        end
-
-        def assert_done
-          expect(@done).to be true
-        end
-      end
-      World(Driver)
-
-      When /I do the action/, :do_action
-      Then /The action should be done/, :assert_done
-      """
-    And a file named "features/action.feature" with:
-      """
-      Feature:
-        Scenario:
-          When I do the action
-          Then the action should be done
-      """
-    When I run `cucumber`
-    Then it should pass
-
-  Scenario: Call a method on an actor in the World directly from a step def
-    Given a file named "features/step_definitions/steps.rb" with:
-      """
-      class Thing
-        def do_action
-          @done = true
-        end
-
-        def assert_done
-          expect(@done).to be true
-        end
-      end
-
-      module Driver
-        def thing
-          @thing ||= Thing.new
-        end
-      end
-      World(Driver)
-
-      When /I do the action to the thing/, :do_action, :on => lambda { thing }
-      Then /The thing should be done/, :assert_done, :on => lambda { thing }
-      """
-    And a file named "features/action.feature" with:
-      """
-      Feature:
-        Scenario:
-          When I do the action to the thing
-          Then the thing should be done
-      """
-    When I run `cucumber`
-    Then it should pass
-

data/features/docs/defining_steps/printing_messages.feature

@@ -1,147 +0,0 @@
-Feature: Pretty formatter - Printing messages
-
-  When you want to print to Cucumber's output, just call `puts` from
-  a step definition. Cucumber will grab the output and print it via
-  the formatter that you're using.
-  
-  Your message will be printed out after the step has run.
-
-  Background:
-    Given the standard step definitions
-    And a file named "features/step_definitions/puts_steps.rb" with:
-      """
-      Given /^I use puts with text "(.*)"$/ do |ann|
-        puts(ann)
-      end
-
-      Given /^I use multiple putss$/ do
-        puts("Multiple")
-        puts("Announce","Me")
-      end
-
-      Given /^I use message (.+) in line (.+) (?:with result (.+))$/ do |ann, line, result|
-        puts("Last message") if line == "3"
-        puts("Line: #{line}: #{ann}")
-        fail if result =~ /fail/i
-      end
-
-      Given /^I use puts and step fails$/ do
-        puts("Announce with fail")
-        fail
-      end
-
-      Given /^I puts the world$/ do
-        puts(self)
-      end
-      """
-    And a file named "features/f.feature" with:
-      """
-      Feature:
-
-        Scenario:
-          Given I use puts with text "Ann"
-          And this step passes
-
-        Scenario:
-          Given I use multiple putss
-          And this step passes
-
-        Scenario Outline:
-          Given I use message <ann> in line <line>
-
-          Examples:
-            | line | ann   |
-            | 1    | anno1 |
-            | 2    | anno2 |
-            | 3    | anno3 |
-
-        Scenario:
-          Given I use puts and step fails
-          And this step passes
-
-        Scenario Outline:
-          Given I use message <ann> in line <line> with result <result>
-
-          Examples:
-            | line | ann   | result |
-            | 1    | anno1 | fail   |
-            | 2    | anno2 | pass   |
-      """
-
-    And a file named "features/puts_world.feature" with:
-      """
-      Feature: puts_world
-        Scenario: puts_world
-          Given I puts the world
-      """
-
-    # Don't know why, but we need to spawn this for JRuby otherwise it gives wierd errors
-    @spawn @todo-windows
-    Scenario: Delayed messages feature
-      When I run `cucumber --quiet --format pretty features/f.feature`
-      Then the stderr should not contain anything
-      And the output should contain:
-      """
-      Feature: 
-
-        Scenario: 
-          Given I use puts with text "Ann"
-            Ann
-          And this step passes
-
-        Scenario: 
-          Given I use multiple putss
-            Multiple
-            Announce
-            Me
-          And this step passes
-
-        Scenario Outline: 
-          Given I use message <ann> in line <line>
-
-          Examples: 
-            | line | ann   |
-            | 1    | anno1 |
-            | 2    | anno2 |
-            | 3    | anno3 |
-
-        Scenario: 
-          Given I use puts and step fails
-            Announce with fail
-             (RuntimeError)
-            ./features/step_definitions/puts_steps.rb:18:in `/^I use puts and step fails$/'
-            features/f.feature:21:in `Given I use puts and step fails'
-          And this step passes
-
-        Scenario Outline: 
-          Given I use message <ann> in line <line> with result <result>
-
-          Examples: 
-            | line | ann   | result |
-            | 1    | anno1 | fail   |  Line: 1: anno1
-             (RuntimeError)
-            ./features/step_definitions/puts_steps.rb:13:in `/^I use message (.+) in line (.+) (?:with result (.+))$/'
-            features/f.feature:29:in `Given I use message anno1 in line 1 with result fail'
-            features/f.feature:25:in `Given I use message <ann> in line <line> with result <result>'
-            | 2    | anno2 | pass   |  Line: 2: anno2
-      """
-
-    Scenario: Non-delayed messages feature (progress formatter)
-      When I run `cucumber --format progress features/f.feature`
-      Then the output should contain:
-        """
-        Ann
-        ..
-        Multiple
-        
-        Announce
-        Me
-        ..UUU
-        Announce with fail
-        F-
-        Line: 1: anno1
-        F
-        Line: 2: anno2
-        .
-        """
-