cucumber 3.0.0 → 3.1.0

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
-        .
-        """
-

data/features/docs/defining_steps/skip_scenario.feature

@@ -1,31 +0,0 @@
-Feature: Skip Scenario
-
-  @todo-windows
-  Scenario: With a passing step
-    Given a file named "features/test.feature" with:
-      """
-      Feature: test
-        Scenario: test
-          Given this step says to skip
-          And this step passes
-      """
-    And the standard step definitions
-    And a file named "features/step_definitions/skippy.rb" with:
-      """
-      Given /skip/ do
-        skip_this_scenario
-      end
-      """
-    When I run `cucumber -q`
-    Then it should pass with exactly:
-      """
-      Feature: test
-
-        Scenario: test
-          Given this step says to skip
-          And this step passes
-
-      1 scenario (1 skipped)
-      2 steps (2 skipped)
-
-      """

data/features/docs/defining_steps/snippets.feature

@@ -1,56 +0,0 @@
-Feature: Snippets
-
-  Cucumber helpfully prints out any undefined step definitions as a code
-  snippet suggestion, which you can then paste into a step definitions
-  file of your choosing.
-
-  Scenario: Snippet for undefined step with a Doc String
-    Given a file named "features/undefined_steps.feature" with:
-      """
-      Feature:
-        Scenario: Doc String
-          Given a Doc String
-          \"\"\"
-            example with <html> entities
-          \"\"\"
-          When 1 simple when step
-          And another "when" step
-          Then a simple then step
-      """
-    When I run `cucumber features/undefined_steps.feature -s`
-    Then the output should contain:
-      """
-      Given("a Doc String") do |string|
-        pending # Write code here that turns the phrase above into concrete actions
-      end
-
-      When("{int} simple when step") do |int|
-        pending # Write code here that turns the phrase above into concrete actions
-      end
-
-      When("another {string} step") do |string|
-        pending # Write code here that turns the phrase above into concrete actions
-      end
-
-      Then("a simple then step") do
-        pending # Write code here that turns the phrase above into concrete actions
-      end
-      """
-
-  Scenario: Snippet for undefined step with a step table
-    Given a file named "features/undefined_steps.feature" with:
-      """
-      Feature:
-        Scenario: table
-          Given a table
-            | table |
-            |example|
-      """
-    When I run `cucumber features/undefined_steps.feature -s`
-    Then the output should contain:
-      """
-      Given("a table") do |table|
-        # table is a Cucumber::MultilineArgument::DataTable
-        pending # Write code here that turns the phrase above into concrete actions
-      end
-      """

data/features/docs/defining_steps/table_diffing.feature

@@ -1,50 +0,0 @@
-Feature: Table diffing
-
-  To allow you to more easily compare data in tables, you are able
-  to easily diff a table with expected data and see the diff in your
-  output.
-
-  Scenario: Extra row
-    Given a file named "features/tables.feature" with:
-      """
-      Feature: Tables
-        Scenario: Extra row
-          Then the table should be:
-            | x | y |
-            | a | b |
-      """
-    And a file named "features/step_definitions/steps.rb" with:
-      """
-      Then /the table should be:/ do |expected| x=1
-        expected.diff!(table(%{
-          | x | y |
-          | a | c |
-        }))
-      end
-      """
-    When I run `cucumber features/tables.feature`
-    Then it should fail with exactly:
-      """
-      Feature: Tables
-
-        Scenario: Extra row         # features/tables.feature:2
-          Then the table should be: # features/step_definitions/steps.rb:1
-            | x | y |
-            | a | b |
-            Tables were not identical:
-            
-              |     x |     y |
-              | (-) a | (-) b |
-              | (+) a | (+) c |
-             (Cucumber::MultilineArgument::DataTable::Different)
-            ./features/step_definitions/steps.rb:2:in `/the table should be:/'
-            features/tables.feature:3:in `Then the table should be:'
-
-      Failing Scenarios:
-      cucumber features/tables.feature:2 # Scenario: Extra row
-
-      1 scenario (1 failed)
-      1 step (1 failed)
-      0m0.012s
-
-      """

data/features/docs/events/gherkin_source_read_event.feature

@@ -1,43 +0,0 @@
-Feature: Gherkin Source Read Event
-
-  This event is fired when Cucumber reads a Gherkin document.
-
-  See [the API documentation](http://www.rubydoc.info/github/cucumber/cucumber-ruby/Cucumber/Events/GherkinSourceRead)
-  for more information about the data available on this event.
-
-  @todo-windows
-  Scenario: Read two documents
-    Given a file named "features/one.feature" with:
-      """
-      Feature: One
-        This is the first feature
-
-      """
-    And a file named "features/two.feature" with:
-      """
-      Feature: Two
-        This is the other feature
-
-      """
-    And a file named "features/support/events.rb" with:
-      """
-      AfterConfiguration do |config|
-        config.on_event :gherkin_source_read do |event|
-          config.out_stream.puts "path: #{event.path}"
-          config.out_stream.puts "body:\n#{event.body}"
-        end
-      end
-      """
-    When I run `cucumber --dry-run`
-    Then it should pass with:
-      """
-      path: features/one.feature
-      body:
-      Feature: One
-        This is the first feature
-      path: features/two.feature
-      body:
-      Feature: Two
-        This is the other feature
-      """
-