cucumber 3.0.0.pre.1 → 4.0.0.rc.4

data/features/docs/cli/showing_differences.feature

@@ -1,43 +0,0 @@
-Feature: Showing differences to expected output
-
-  Cucumber will helpfully show you the expectation error that your
-  testing library gives you, in the context of the failing scenario.
-  When using RSpec, for example, this will show the difference between
-  the expected and the actual output.
-
-  Scenario: Run single failing scenario with default diff enabled
-    Given a file named "features/failing_expectation.feature" with:
-      """
-      Feature: Failing expectation
-
-        Scenario: Failing expectation
-          Given failing expectation
-      """
-    And a file named "features/step_definitions/steps.rb" with:
-      """
-      Given /^failing expectation$/ do x=1
-        expect('this').to eq 'that'
-      end
-      """
-    When I run `cucumber -q features/failing_expectation.feature`
-    Then it should fail with:
-      """
-      Feature: Failing expectation
-      
-        Scenario: Failing expectation
-          Given failing expectation
-            
-            expected: "that"
-                 got: "this"
-            
-            (compared using ==)
-             (RSpec::Expectations::ExpectationNotMetError)
-            ./features/step_definitions/steps.rb:2:in `/^failing expectation$/'
-            features/failing_expectation.feature:4:in `Given failing expectation'
-
-      Failing Scenarios:
-      cucumber features/failing_expectation.feature:3
-
-      1 scenario (1 failed)
-      1 step (1 failed)
-      """

data/features/docs/cli/specifying_multiple_formatters.feature

@@ -1,65 +0,0 @@
-@spawn
-Feature: Running multiple formatters
-
-  When running cucumber, you are able to using multiple different
-  formatters and redirect the output to text files.
-  Two formatters cannot both print to the same file (or to STDOUT)
-
-  Background:
-    Given a file named "features/test.feature" with:
-    """
-    Feature: Lots of undefined
-
-      Scenario: Implement me
-        Given it snows in Sahara
-        Given it's 40 degrees in Norway
-        And it's 40 degrees in Norway
-        When I stop procrastinating
-        And there is world peace
-    """
-
-  Scenario: Multiple formatters and outputs
-    When I run `cucumber --no-color --format progress --out progress.txt --format pretty --out pretty.txt --no-source --dry-run --no-snippets features/test.feature`
-    Then the stderr should not contain anything
-    Then the file "progress.txt" should contain:
-      """
-      UUUUU
-
-      1 scenario (1 undefined)
-      5 steps (5 undefined)
-
-      """
-    And the file "pretty.txt" should contain:
-      """
-      Feature: Lots of undefined
-
-        Scenario: Implement me
-          Given it snows in Sahara
-          Given it's 40 degrees in Norway
-          And it's 40 degrees in Norway
-          When I stop procrastinating
-          And there is world peace
-
-      1 scenario (1 undefined)
-      5 steps (5 undefined)
-
-      """
-
-  Scenario: Two formatters to stdout
-    When I run `cucumber -f progress -f pretty features/test.feature`
-    Then it should fail with:
-      """
-      All but one formatter must use --out, only one can print to each stream (or STDOUT) (RuntimeError)
-      """
-
-  Scenario: Two formatters to stdout when using a profile
-    Given the following profiles are defined:
-      """
-      default: -q
-      """
-    When I run `cucumber -f progress -f pretty features/test.feature`
-    Then it should fail with:
-      """
-      All but one formatter must use --out, only one can print to each stream (or STDOUT) (RuntimeError)
-      """
-

data/features/docs/cli/strict_mode.feature

@@ -1,64 +0,0 @@
-Feature: Strict mode
-
-  Using the `--strict` flag will cause cucumber to fail unless all the
-  step definitions have been defined.
-
-  Background:
-    Given a file named "features/missing.feature" with:
-    """
-    Feature: Missing
-      Scenario: Missing
-        Given this step passes
-    """
-    And a file named "features/pending.feature" with:
-    """
-    Feature: Pending
-      Scenario: Pending
-        Given this step is pending
-    """
-
-  Scenario: Fail with --strict due to undefined step
-    When I run `cucumber -q features/missing.feature --strict`
-    Then it should fail with:
-      """
-      Feature: Missing
-
-        Scenario: Missing
-          Given this step passes
-            Undefined step: "this step passes" (Cucumber::Undefined)
-            features/missing.feature:3:in `Given this step passes'
-
-      1 scenario (1 undefined)
-      1 step (1 undefined)
-      """
-
-  Scenario: Fail with --strict due to pending step
-    Given the standard step definitions
-    When I run `cucumber -q features/pending.feature --strict`
-    Then it should fail with:
-      """
-      Feature: Pending
-
-        Scenario: Pending
-          Given this step is pending
-            TODO (Cucumber::Pending)
-            ./features/step_definitions/steps.rb:3:in `/^this step is pending$/'
-            features/pending.feature:3:in `Given this step is pending'
-
-      1 scenario (1 pending)
-      1 step (1 pending)
-      """
-
-  Scenario: Succeed with --strict
-    Given the standard step definitions
-    When I run `cucumber -q features/missing.feature --strict`
-    Then it should pass with:
-    """
-    Feature: Missing
-
-      Scenario: Missing
-        Given this step passes
-
-    1 scenario (1 passed)
-    1 step (1 passed)
-    """

data/features/docs/defining_steps/nested_steps.feature

@@ -1,177 +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
-      """
-
-  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!
-
-      """
-
-  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!
-
-      """
-
-  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
-
-      """
-
-  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
-  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,36 +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
-      """
-
-  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,54 +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
-      """
-
-  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
-
-      """
-
-  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
-