mobiusloop 0.1.2

data/features/docs/cli/require.feature

@@ -0,0 +1,27 @@
+Feature: Requiring extra step files
+
+  Cucumber allows you to require extra files using the `-r` option.
+
+  Scenario:
+    Given a file named "features/test.feature" with:
+      """
+      Feature: Sample
+        Scenario: Sample
+          Given found in extra file
+      """
+    And a file named "tmp/extras.rb" with:
+      """
+      Given(/^found in extra file$/) { }
+      """
+    When I run `cucumber -q -r tmp/extras.rb features/test.feature`
+    Then it should pass with:
+      """
+      Feature: Sample
+
+        Scenario: Sample
+          Given found in extra file
+
+      1 scenario (1 passed)
+      1 step (1 passed)
+      """
+

data/features/docs/cli/retry_failing_tests.feature

@@ -0,0 +1,32 @@
+@wip
+Feature: Retry failing tests
+
+  Retry gives you a way to get through flaky tests that usually pass after a few runs.
+  This gives a development team a way forward other than disabling a valuable test.
+  
+  - Specify max retry count in option
+  - Output information to the screen
+  - Output retry information in test report
+  
+  Questions:
+  use a tag for flaky tests?  Global option to retry any test that fails?
+  
+  Background:
+    Given a scenario "Flakey" that fails once, then passes
+    And a scenario "Shakey" that fails twice, then passes
+    And a scenario "Solid" that passes
+    And a scenario "No Dice" that fails
+  
+  Scenario:
+    When I run `cucumber -q --retry 1`
+    Then it should fail with:
+      """
+      4 scenarios (2 passed, 2 failed)
+      """
+
+  Scenario:
+    When I run `cucumber -q --retry 2`
+    Then it should pass with:
+      """
+      4 scenarios (3 passed, 1 failed)
+      """

data/features/docs/cli/run_scenarios_matching_name.feature

@@ -0,0 +1,104 @@
+Feature: Run feature elements matching a name with --name/-n
+
+  The `--name NAME` option runs only scenarios which match a certain
+  name. The NAME can be a substring of the names of Features, Scenarios,
+  Scenario Outlines or Example blocks.
+
+  Background:
+    Given a file named "features/first.feature" with:
+      """
+      Feature: first feature
+        Scenario: foo first
+          Given missing
+        Scenario: bar first
+          Given missing
+      """
+    Given a file named "features/second.feature" with:
+      """
+      Feature: second
+        Scenario: foo second
+          Given missing
+        Scenario: bar second
+          Given missing
+      """
+    Given a file named "features/outline.feature" with:
+      """
+      Feature: outline
+        Scenario Outline: baz outline
+          Given outline step <name>
+
+          Examples: quux example
+            | name |
+            | a    |
+            | b    |
+      """
+
+  Scenario: Matching Feature names
+    When I run `cucumber -q --name feature`
+    Then it should pass with:
+      """
+      Feature: first feature
+
+        Scenario: foo first
+          Given missing
+
+        Scenario: bar first
+          Given missing
+
+      2 scenarios (2 undefined)
+      2 steps (2 undefined)
+      """
+
+  Scenario: Matching Scenario names
+    When I run `cucumber -q --name foo`
+    Then it should pass with:
+      """
+      Feature: first feature
+
+        Scenario: foo first
+          Given missing
+
+      Feature: second
+
+        Scenario: foo second
+          Given missing
+
+      2 scenarios (2 undefined)
+      2 steps (2 undefined)
+      """
+
+  Scenario: Matching Scenario Outline names
+    When I run `cucumber -q --name baz`
+    Then it should pass with:
+      """
+      Feature: outline
+
+        Scenario Outline: baz outline
+          Given outline step <name>
+
+          Examples: quux example
+            | name |
+            | a    |
+            | b    |
+
+      2 scenarios (2 undefined)
+      2 steps (2 undefined)
+      """
+
+  Scenario: Matching Example block names
+    When I run `cucumber -q --name quux`
+    Then it should pass with:
+      """
+      Feature: outline
+
+        Scenario Outline: baz outline
+          Given outline step <name>
+
+          Examples: quux example
+            | name |
+            | a    |
+            | b    |
+
+      2 scenarios (2 undefined)
+      2 steps (2 undefined)
+      """

data/features/docs/cli/run_specific_scenarios.feature

@@ -0,0 +1,77 @@
+Feature: Run specific scenarios
+
+  You can choose to run a specific scenario using the file:line format,
+  or you can pass in a file with a list of scenarios using @-notation.
+
+  The line number can fall anywhere within the body of a scenario, including
+  steps, tags, comments, description, data tables or doc strings.
+
+  For scenario outlines, if the line hits one example row, just that one
+  will be run. Otherwise all examples in the table or outline will be run.
+
+  Background:
+    Given the standard step definitions
+
+  Scenario: Two scenarios, run just one of them
+    Given a file named "features/test.feature" with:
+      """
+      Feature: 
+
+        Scenario: Miss
+          Given this step is undefined
+
+        Scenario: Hit
+          Given this step passes
+      """
+    When I run `cucumber features/test.feature:7 --format pretty --quiet`
+    Then it should pass with exactly:
+      """
+      Feature: 
+
+        Scenario: Hit
+          Given this step passes
+
+      1 scenario (1 passed)
+      1 step (1 passed)
+      
+      """
+
+  Scenario: Use @-notation to specify a file containing feature file list
+    Given a file named "features/test.feature" with:
+      """
+      Feature: Sample
+        Scenario: Passing
+          Given this step passes
+      """
+    And a file named "list-of-features.txt" with:
+      """
+      features/test.feature:2
+      """
+    When I run `cucumber -q @list-of-features.txt`
+    Then it should pass with:
+      """
+      Feature: Sample
+
+        Scenario: Passing
+          Given this step passes
+
+      1 scenario (1 passed)
+      1 step (1 passed)
+      """
+
+  Scenario: Specify order of scenarios
+    Given a file named "features/test.feature" with:
+      """
+      Feature: 
+        Scenario:
+          Given this step passes
+
+        Scenario:
+          Given this step fails
+      """
+    When I run `cucumber features/test.feature:5 features/test.feature:3 -f progress`
+    Then it should fail with:
+      """
+      F.
+      """
+

data/features/docs/cli/showing_differences.feature

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,65 @@
+@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

@@ -0,0 +1,64 @@
+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

@@ -0,0 +1,177 @@
+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)
+
+      """