cucumber 2.3.3 → 2.4.0

data/features/docs/defining_steps/snippets.feature

@@ -50,7 +50,7 @@ Feature: Snippets
     Then the output should contain:
       """
       Given(/^a table$/) do |table|
-        # table is a Cucumber::Core::Ast::DataTable
+        # table is a Cucumber::MultilineArgument::DataTable
         pending # Write code here that turns the phrase above into concrete actions
       end
       """

data/features/docs/formatters/json_formatter.feature

@@ -286,7 +286,6 @@ Feature: JSON output formatter
 
       """
 
-  @spawn
   Scenario: DocString
     Given a file named "features/doc_string.feature" with:
       """
@@ -349,9 +348,8 @@ Feature: JSON output formatter
       ]
       """
 
-  @spawn
   Scenario: embedding screenshot
-    When I run `cucumber -b --format json features/embed.feature`
+    When I run `cucumber --format json features/embed.feature`
     Then it should pass with JSON:
     """
     [
@@ -630,9 +628,8 @@ Feature: JSON output formatter
 
     """
 
-  @spawn
   Scenario: embedding data directly
-    When I run `cucumber -b --format json -x features/embed_data_directly.feature`
+    When I run `cucumber --format json -x features/embed_data_directly.feature`
     Then it should pass with JSON:
     """
     [
@@ -733,7 +730,6 @@ Feature: JSON output formatter
     ]
 
     """
-  @spawn
   Scenario: handle output from hooks
      Given a file named "features/step_definitions/output_steps.rb" with:
       """

data/features/docs/formatters/junit_formatter.feature

@@ -1,4 +1,3 @@
-@spawn
 Feature: JUnit output formatter
   In order for developers to create test reports with ant
   Cucumber should be able to output JUnit xml files
@@ -60,6 +59,7 @@ Feature: JUnit output formatter
             | is undefined |
       """
 
+  @spawn
   Scenario: one feature, one passing scenario, one failing scenario
     When I run `cucumber --format junit --out tmp/ features/one_passing_one_failing.feature`
     Then it should fail with:
@@ -101,6 +101,7 @@ Feature: JUnit output formatter
 
       """
 
+  @spawn
   Scenario: one feature in a subdirectory, one passing scenario, one failing scenario
     When I run `cucumber --format junit --out tmp/ features/some_subdirectory/one_passing_one_failing.feature --require features`
     Then it should fail with:
@@ -245,6 +246,7 @@ can't convert .* into String \(TypeError\)
 You *must* specify --out DIR for the junit formatter
       """
 
+  @spawn
   Scenario: strict mode, one feature, one scenario outline, four examples: one passing, one failing, one pending, one undefined
     When I run `cucumber --strict --format junit --out tmp/ features/scenario_outline.feature`
     Then it should fail with:
@@ -326,6 +328,7 @@ You *must* specify --out DIR for the junit formatter
 
       """ 
 
+  @spawn
   Scenario: strict mode with --expand option, one feature, one scenario outline, four examples: one passing, one failing, one pending, one undefined
     When I run `cucumber --strict --expand --format junit --out tmp/ features/scenario_outline.feature`
     Then it should fail with exactly:
@@ -406,3 +409,46 @@ You *must* specify --out DIR for the junit formatter
       </testsuite>
 
       """ 
+
+  @spawn
+  Scenario: run test cases from different features interweaved
+    When I run `cucumber --format junit --out tmp/ features/one_passing_one_failing.feature:3 features/pending.feature:3 features/one_passing_one_failing.feature:6`
+    Then it should fail with:
+      """
+
+      """
+    And the junit output file "tmp/TEST-features-one_passing_one_failing.xml" should contain:
+      """
+      <?xml version="1.0" encoding="UTF-8"?>
+      <testsuite failures="1" errors="0" skipped="0" tests="2" time="0.05" name="One passing scenario, one failing scenario">
+      <testcase classname="One passing scenario, one failing scenario" name="Passing" time="0.05">
+        <system-out>
+          <![CDATA[]]>
+        </system-out>
+        <system-err>
+          <![CDATA[]]>
+        </system-err>
+      </testcase>
+      <testcase classname="One passing scenario, one failing scenario" name="Failing" time="0.05">
+        <failure message="failed Failing" type="failed">
+          <![CDATA[Scenario: Failing
+
+      Given this step fails
+
+      Message:
+	]]>
+          <![CDATA[ (RuntimeError)
+	./features/step_definitions/steps.rb:4:in `/^this step fails$/'
+	features/one_passing_one_failing.feature:7:in `Given this step fails']]>
+        </failure>
+        <system-out>
+          <![CDATA[]]>
+        </system-out>
+        <system-err>
+          <![CDATA[]]>
+        </system-err>
+      </testcase>
+      </testsuite>
+
+      """
+    And a file named "tmp/TEST-features-pending.xml" should exist

data/features/docs/writing_support_code/after_step_hooks.feature

@@ -0,0 +1,53 @@
+Feature: AfterStep Hooks
+  AfterStep hooks can be used to further inspect the Step object of the step
+  that has just run, or to simply check the step's result.
+
+  Background:
+    Given the standard step definitions
+    And a file named "features/sample.feature" with:
+      """
+      Feature: Sample
+
+        Scenario: Success
+          Given this step passes
+      """
+
+  Scenario: Access Test Step object in AfterStep Block
+    Given a file named "features/support/env.rb" with:
+      """
+      AfterStep do |result, test_step|
+        expect(test_step).to be_a(Cucumber::Core::Test::Step)
+      end
+      """
+    When I run `cucumber features`
+    Then it should pass with:
+      """
+      Feature: Sample
+
+        Scenario: Success        # features/sample.feature:3
+          Given this step passes # features/step_definitions/steps.rb:1
+
+      1 scenario (1 passed)
+      1 step (1 passed)
+
+      """
+
+  Scenario: An AfterStep with one named argument receives only the result
+    Given a file named "features/support/env.rb" with:
+      """
+      AfterStep do |result|
+        expect(result).to be_a(Cucumber::Core::Test::Result::Passed)
+      end
+      """
+    When I run `cucumber features`
+    Then it should pass with:
+      """
+      Feature: Sample
+
+        Scenario: Success        # features/sample.feature:3
+          Given this step passes # features/step_definitions/steps.rb:1
+
+      1 scenario (1 passed)
+      1 step (1 passed)
+
+      """

data/features/docs/{defining_steps → writing_support_code}/transforms.feature

@@ -1,12 +1,12 @@
 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.
-  
+  Transforms allow you to convert primitive string arguments captured in step definitions
+  into more meaningful data types.
+
   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:
@@ -26,8 +26,9 @@ Feature: Transforms
 
   Scenario: Basic Transform
     This is the most basic way to use a transform. Notice that the regular
-    expression is pretty much duplicated.
-    
+    expression is pretty much duplicated between the step defintion and the 
+    transform itself.
+
     And a file named "features/step_definitions/steps.rb" with:
       """
       Transform(/a Person aged (\d+)/) do |age|
@@ -42,7 +43,7 @@ Feature: Transforms
       """
     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.
@@ -61,3 +62,37 @@ Feature: Transforms
       """
     When I run `cucumber features/foo.feature`
     Then it should pass
+
+  Scenario: Use Transform from code
+    You can also call the `Transform` method from within a step definition to
+    dynamically run a tranform.
+
+    Note that this is rather useless at present, unless the transform itself has a side-effect, since the `Transform`
+    function still returns the regular expression pattern.
+
+    Given a file named "features/people.feature" with:
+      """
+      Feature:
+        Scenario:
+          Given people with these ages:
+            | name  | age |
+            | sue   | 25  |
+            | sally | 77  |
+      """
+    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(/^people with these ages:$/) do |table|
+        table.rows.each do |name, age|
+          Transform("a Person aged #{age}")
+          expect($person.age).to eq age.to_i
+        end
+      end
+      """
+    When I run `cucumber features/people.feature`
+    Then it should pass

data/features/lib/step_definitions/cucumber_steps.rb

@@ -32,6 +32,34 @@ Given /^a step definition that looks like this:$/ do |string|
   create_step_definition { string }
 end
 
+Given /^a scenario "([^\"]*)" that passes$/ do |name|
+  write_file "features/#{name}.feature",
+  <<-FEATURE
+  Feature: #{name}
+    Scenario: #{name}
+      Given it passes
+  FEATURE
+
+  write_file "features/step_definitions/#{name}_steps.rb",
+  <<-STEPS
+  Given(/^it passes$/) { expect(true).to be true }
+  STEPS
+end
+
+Given /^a scenario "([^\"]*)" that fails$/ do |name|
+  write_file "features/#{name}.feature",
+  <<-FEATURE
+  Feature: #{name}
+    Scenario: #{name}
+      Given it fails
+  FEATURE
+
+  write_file "features/step_definitions/#{name}_steps.rb",
+  <<-STEPS
+  Given(/^it fails$/) { expect(false).to be true }
+  STEPS
+end
+
 When /^I run the feature with the (\w+) formatter$/ do |formatter|
   expect(features.length).to eq 1
   run_feature features.first, formatter

data/features/lib/step_definitions/retry_steps.rb

@@ -0,0 +1,35 @@
+Given /^a scenario "([^\"]*)" that fails once, then passes$/ do |name|
+  write_file "features/#{name}.feature",
+  <<-FEATURE
+  Feature: #{name}
+    Scenario: #{name}
+      Given it fails once, then passes
+  FEATURE
+
+  write_file "features/step_defnitions/#{name}_steps.rb",
+  <<-STEPS
+  Given(/^it fails once, then passes$/) do
+    $#{name.downcase} ||= 0
+    $#{name.downcase} += 1
+    expect($#{name.downcase}).to eql 2
+  end
+  STEPS
+end
+
+Given /^a scenario "([^\"]*)" that fails twice, then passes$/ do |name|
+  write_file "features/#{name}.feature",
+  <<-FEATURE
+  Feature: #{name}
+    Scenario: #{name}
+      Given it fails twice, then passes
+  FEATURE
+
+  write_file "features/step_definitions/#{name}_steps.rb",
+  <<-STEPS
+  Given(/^it fails twice, then passes$/) do
+    $#{name.downcase} ||= 0
+    $#{name.downcase} += 1
+    expect($#{name.downcase}).to eql 3
+  end
+  STEPS
+end

data/lib/cucumber/cli/configuration.rb

@@ -67,6 +67,10 @@ module Cucumber
         !!@options[:fail_fast]
       end
 
+      def retry_attempts
+        @options[:retry]
+      end
+
       def snippet_type
         @options[:snippet_type] || :regexp
       end

data/lib/cucumber/cli/options.rb

@@ -44,9 +44,10 @@ module Cucumber
       PROFILE_LONG_FLAG = '--profile'
       NO_PROFILE_LONG_FLAG = '--no-profile'
       FAIL_FAST_FLAG = '--fail-fast'
+      RETRY_FLAG = '--retry'
       OPTIONS_WITH_ARGS = ['-r', '--require', '--i18n', '-f', '--format', '-o', '--out',
                                   '-t', '--tags', '-n', '--name', '-e', '--exclude',
-                                  PROFILE_SHORT_FLAG, PROFILE_LONG_FLAG,
+                                  PROFILE_SHORT_FLAG, PROFILE_LONG_FLAG, RETRY_FLAG,
                                   '-l', '--lines', '--port',
                                   '-I', '--snippet-type']
       ORDER_TYPES = %w{defined random}
@@ -188,6 +189,9 @@ module Cucumber
             "Disables all profile loading to avoid using the 'default' profile.") do |v|
             @disable_profile_loading = true
           end
+          opts.on("#{RETRY_FLAG} ATTEMPTS", "Specify the number of times to retry failing tests (default: 0)") do |v|
+            @options[:retry] = v.to_i
+          end
           opts.on("-c", "--[no-]color",
             "Whether or not to use ANSI color in the output. Cucumber decides",
             "based on your platform and the output destination if not specified.") do |v|
@@ -450,7 +454,8 @@ TEXT
           :diff_enabled => true,
           :snippets     => true,
           :source       => true,
-          :duration     => true
+          :duration     => true,
+          :retry        => 0
         }
       end
     end

data/lib/cucumber/cli/rerun_file.rb

@@ -16,7 +16,7 @@ module Cucumber
       end
 
       def features
-        lines.map { |l| l.scan(/(?:^| )(.*?\.feature(?:(?::\d+)*))/) }.flatten
+        lines.map { |l| l.scan(/(?:^| |)(.*?\.feature(?:(?::\d+)*))/) }.flatten
       end
 
       private

data/lib/cucumber/configuration.rb

@@ -65,6 +65,10 @@ module Cucumber
       @options[:fail_fast]
     end
 
+    def retry_attempts
+      @options[:retry]
+    end
+
     def guess?
       @options[:guess]
     end

data/lib/cucumber/events/finished_testing.rb

@@ -0,0 +1,9 @@
+module Cucumber
+  module Events
+
+    # Event fired after aall test cases have finished executing
+    class FinishedTesting
+    end
+
+  end
+end

data/lib/cucumber/filters/randomizer.rb

@@ -1,3 +1,5 @@
+require 'digest/sha2'
+
 module Cucumber
   module Filters
 
@@ -29,7 +31,10 @@ module Cucumber
       private
 
       def shuffled_test_cases
-        @test_cases.shuffle(random: Random.new(seed))
+        digester = Digest::SHA2.new(256)
+        @test_cases.map.with_index.
+          sort_by { |_, index| digester.digest((@seed + index).to_s) }.
+          map { |test_case, _| test_case }
       end
 
       attr_reader :seed

data/lib/cucumber/filters/retry.rb

@@ -0,0 +1,32 @@
+require 'cucumber/core/filter'
+require 'cucumber/running_test_case'
+require 'cucumber/events/bus'
+require 'cucumber/events/after_test_case'
+
+module Cucumber
+  module Filters
+    class Retry < Core::Filter.new(:configuration)
+
+      def test_case(test_case)
+        configuration.on_event(:after_test_case) do |event|
+          next unless retry_required?(test_case, event)
+
+          test_case_counts[test_case] += 1
+          event.test_case.describe_to(receiver)
+        end
+
+        super
+      end
+
+      private
+
+      def retry_required?(test_case, event)
+        event.test_case == test_case && event.result.failed? && test_case_counts[test_case] < configuration.retry_attempts
+      end
+
+      def test_case_counts
+        @test_case_counts ||= Hash.new {|h,k| h[k] = 0 }
+      end
+    end
+  end
+end