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

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,148 +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
-    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
-        ..-UUUUUU
-        Announce with fail
-        F--
-        Line: 1: anno1
-        FFF
-        Line: 2: anno2
-        ...
-        """
-

data/features/docs/defining_steps/skip_scenario.feature

@@ -1,62 +0,0 @@
-Feature: Skip Scenario
-
-  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)
-      0m0.012s
-
-      """
-
-  Scenario: Use legacy API from a hook
-    Given a file named "features/test.feature" with:
-      """
-      Feature: test
-        Scenario: test
-          Given this step passes
-          And this step passes
-      """
-    And the standard step definitions
-    And a file named "features/support/hook.rb" with:
-      """
-      Before do |scenario|
-        scenario.skip_invoke!
-      end
-      """
-    When I run `cucumber -q`
-    Then it should pass with:
-      """
-      Feature: test
-
-        Scenario: test
-          Given this step passes
-          And this step passes
-
-      1 scenario (1 skipped)
-      2 steps (2 skipped)
-      0m0.012s
-
-      """
-

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 pystring
-    Given a file named "features/undefined_steps.feature" with:
-      """
-      Feature:
-      Scenario: pystring
-        Given a pystring
-        \"\"\"
-          example with <html> entities
-        \"\"\"
-        When a 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 pystring$/) do |string|
-        pending # Write code here that turns the phrase above into concrete actions
-      end
-
-      When(/^a simple when step$/) do
-        pending # Write code here that turns the phrase above into concrete actions
-      end
-
-      When(/^another when step$/) do
-        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::Core::Ast::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/defining_steps/transforms.feature

@@ -1,63 +0,0 @@
-Feature: Transforms
-
-  If you see certain phrases repeated over and over in your step definitions, you can
-  use transforms to factor out that duplication, and make your step definitions simpler.
-  
-  Background:
-    Let's just create a simple feature for testing out Transforms.
-    We also have a Person class that we need to be able to build.
-    
-    Given a file named "features/foo.feature" with:
-      """
-      Feature:
-        Scenario:
-          Given a Person aged 15 with blonde hair
-      """
-    And a file named "features/support/person.rb" with:
-      """
-      class Person
-        attr_accessor :age
-      
-        def to_s
-          "I am #{age} years old"
-        end
-      end
-      """
-
-  Scenario: Basic Transform
-    This is the most basic way to use a transform. Notice that the regular
-    expression is pretty much duplicated.
-    
-    And a file named "features/step_definitions/steps.rb" with:
-      """
-      Transform(/a Person aged (\d+)/) do |age|
-        person = Person.new
-        person.age = age.to_i
-        person
-      end
-      
-      Given /^(a Person aged \d+) with blonde hair$/ do |person|
-        expect(person.age).to eq 15
-      end
-      """
-    When I run `cucumber features/foo.feature`
-    Then it should pass
-  
-  Scenario: Re-use Transform's Regular Expression
-    If you keep a reference to the transform, you can use it in your
-    regular expressions to avoid repeating the regular expression.
-
-    And a file named "features/step_definitions/steps.rb" with:
-      """
-      A_PERSON = Transform(/a Person aged (\d+)/) do |age|
-        person = Person.new
-        person.age = age.to_i
-        person
-      end
-
-      Given /^(#{A_PERSON}) with blonde hair$/ do |person|
-        expect(person.age).to eq 15
-      end
-      """
-    When I run `cucumber features/foo.feature`
-    Then it should pass