cucumber 2.99.0 → 3.0.0

data/features/docs/writing_support_code/hook_order.feature

@@ -46,6 +46,7 @@
           Given scenario step
       """
 
+  @todo-windows
   Scenario: Around hooks cover background steps
     When I run `cucumber -o /dev/null features/around_hook_covers_background.feature`
     Then the output should contain:
@@ -53,9 +54,10 @@
       Event order: around_begin background_step scenario_step around_end
       """
 
+  @todo-windows
   Scenario: All hooks execute in expected order
     When I run `cucumber -o /dev/null features/all_hook_order.feature`
     Then the output should contain:
       """
       Event order: around_begin before background_step scenario_step after around_end
-      """
+      """

data/features/docs/writing_support_code/parameter_types.feature

@@ -0,0 +1,53 @@
+Feature: Parameter Types
+
+  Parameter Types 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 parameter types.
+    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 Joe has gone home
+          When Sally contacts Joe
+      """
+    And a file named "features/step_definitions/steps.rb" with:
+      """
+      # It works with Regular Expressions
+      Given /([A-Z]\w+) has gone home/ do |person|
+        expect(person.name).to eq 'Joe'
+      end
+
+      # It works with Cucumber Expressions too
+      When "{person} contacts {person}" do |contacter, contactee|
+        expect(contacter.name).to eq 'Sally'
+        expect(contactee.name).to eq 'Joe'
+      end
+      """
+    And a file named "features/support/env.rb" with:
+      """
+      class Person
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+        end
+      end
+      """
+
+  Scenario: Parameter type defined with ParameterType method
+    This is the most basic way to use a parameter type.
+
+    Given a file named "features/support/parameter_types.rb" with:
+      """
+      ParameterType(
+        name: 'person',
+        regexp: /[A-Z]\w+/,
+        transformer: -> (name) { Person.new(name) }
+      )
+      """
+    When I run `cucumber features/foo.feature`
+    Then it should pass

data/features/docs/writing_support_code/tagged_hooks.feature

@@ -4,7 +4,7 @@ Feature: Tagged hooks
     Given the standard step definitions
     And a file named "features/support/hooks.rb" with:
       """
-      Before('~@no-boom') do 
+      Before('not @no-boom') do 
         raise 'boom'
       end
       """

data/features/docs/writing_support_code/world.feature

@@ -0,0 +1,129 @@
+Feature: World
+
+  In order to isolate each test scenario, the steps definitions belonging to the
+  same scenario will run in a isolated context, called 'world'. A world also
+  contains the helpers methods that will be used in the step definitions.
+
+  It is possible to add helpers methods to a world in three different ways:
+
+  1. Passing a module. In this case its methods will be added directly to the
+     world and be usable in the step definitions.
+
+  2. Passing a block, where the return value is the world object.
+
+  3. Passing a hash, where the keys are namespaces and the values are
+     modules. In this case, the methods of each module will be accessible using
+     the key as prefix.
+
+  Scenario: A world is extended using a module
+    Given a file named "features/support/helpers.rb" with:
+      """
+      module Helpers
+        def helper_method
+          42
+        end
+      end
+
+      World(Helpers)
+      """
+    And a file named "features/step_definitions/step.rb" with:
+      """
+      Then /^the helper method is called$/ do
+        expect(helper_method).to eql(42)
+      end
+      """
+    And a file named "features/f.feature" with:
+      """
+      Feature: Calling a method
+        Scenario: I call a method without namespaces
+          Then the helper method is called
+      """
+    When I run `cucumber features/f.feature`
+    Then it should pass
+
+  Scenario: A world is created using a block
+    Given a file named "features/support/helpers.rb" with:
+      """
+      class Helper
+        def helper_method
+          42
+        end
+      end
+
+      World do
+        Helper.new
+      end
+      """
+    And a file named "features/step_definitions/step.rb" with:
+      """
+      Then /^the helper method is called$/ do
+        expect(helper_method).to eql(42)
+      end
+      """
+    And a file named "features/f.feature" with:
+      """
+      Feature: Calling a method
+        Scenario: I call a method from a namespace
+          Then the helper method is called
+      """
+    When I run `cucumber features/f.feature`
+    Then it should pass
+
+  Scenario: A world is extended using a module with namespace
+    Given a file named "features/support/helpers.rb" with:
+      """
+      module Helpers
+        def helper_method
+          42
+        end
+      end
+
+      World(my_namespace: Helpers)
+      """
+    And a file named "features/step_definitions/step.rb" with:
+      """
+      Then /^the helper method is called$/ do
+        expect(my_namespace.helper_method).to eql(42)
+      end
+      """
+    And a file named "features/f.feature" with:
+      """
+      Feature: Calling a method
+        Scenario: I call a method from a namespace
+          Then the helper method is called
+      """
+    When I run `cucumber features/f.feature`
+    Then it should pass
+
+  Scenario: A world is extended using multiple modules with different namespaces
+    Given a file named "features/support/helpers.rb" with:
+      """
+      module ModuleOne
+        def forty_one
+          41
+        end
+      end
+
+      module ModuleTwo
+        def forty_two
+          42
+        end
+      end
+
+      World(module_one: ModuleOne, module_two: ModuleTwo)
+      """
+    And a file named "features/step_definitions/step.rb" with:
+      """
+      Then /^the helper method is called$/ do
+        expect(module_one.forty_one).to eql(41)
+        expect(module_two.forty_two).to eql(42)
+      end
+      """
+    And a file named "features/f.feature" with:
+      """
+      Feature: Calling a method
+        Scenario: I call a method from two namespaces
+          Then the helper method is called
+      """
+    When I run `cucumber features/f.feature`
+    Then it should pass

data/features/lib/step_definitions/aruba_steps.rb

@@ -1,26 +1,21 @@
-Given('a Gemfile with:') do |content|
-  path = File.expand_path(current_dir + "/Gemfile")
-  write_file path, content
-  set_env "BUNDLE_GEMFILE", path
-end
-
+# frozen_string_literal: true
 Then(/^it should (pass|fail)$/) do |result|
   assert_success result == 'pass'
 end
 
-Then(/^"([^"]*)" should not be required$/) do |file_name|
+Then('{string} should not be required') do |file_name|
   expect(all_output).not_to include("* #{file_name}")
 end
 
-Then(/^"([^"]*)" should be required$/) do |file_name|
+Then('{string} should be required') do |file_name|
   expect(all_output).to include("* #{file_name}")
 end
 
-Then /^it fails before running features with:$/ do |expected|
+Then('it fails before running features with:') do |expected|
   assert_matching_output("\\A#{expected}", all_output)
   assert_success(false)
 end
 
-Then(/^the output includes the message "(.*)"$/) do |message|
+Then('the output includes the message {string}') do |message|
   expect(all_output).to include(message)
 end

data/features/lib/step_definitions/cli_steps.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+Then('I should see the CLI help') do
+  expect(all_output).to include('Usage:')
+end

data/features/lib/step_definitions/cucumber_steps.rb

@@ -1,22 +1,23 @@
-Given /^a directory without standard Cucumber project directory structure$/ do
+# frozen_string_literal: true
+Given('a directory without standard Cucumber project directory structure') do
   in_current_dir do
     FileUtils.rm_rf 'features' if File.directory?('features')
   end
 end
 
-Given /^a scenario with a step that looks like this:$/ do |string|
+Given('a scenario with a step that looks like this:') do |string|
   create_feature do
     create_scenario { string }
   end
 end
 
-Given(/^a scenario with a step that looks like this in japanese:$/) do |string|
+Given('a scenario with a step that looks like this in japanese:') do |string|
   create_feature_ja do
     create_scenario_ja { string }
   end
 end
 
-Given(/^the standard step definitions$/) do
+Given('the standard step definitions') do
   write_file 'features/step_definitions/steps.rb',
 
   <<-STEPS
@@ -28,11 +29,11 @@ Given(/^the standard step definitions$/) do
   STEPS
 end
 
-Given /^a step definition that looks like this:$/ do |string|
+Given('a step definition that looks like this:') do |string|
   create_step_definition { string }
 end
 
-Given /^a scenario "([^\"]*)" that passes$/ do |name|
+Given('a scenario {string} that passes') do |name|
   write_file "features/#{name}.feature",
   <<-FEATURE
   Feature: #{name}
@@ -46,7 +47,7 @@ Given /^a scenario "([^\"]*)" that passes$/ do |name|
   STEPS
 end
 
-Given /^a scenario "([^\"]*)" that fails$/ do |name|
+Given('a scenario {string} that fails') do |name|
   write_file "features/#{name}.feature",
   <<-FEATURE
   Feature: #{name}
@@ -60,15 +61,11 @@ Given /^a scenario "([^\"]*)" that fails$/ do |name|
   STEPS
 end
 
-When /^I run the feature with the (\w+) formatter$/ do |formatter|
+When(/^I run the feature with the (\w+) formatter$/) do |formatter|
   expect(features.length).to eq 1
   run_feature features.first, formatter
 end
 
-Then /^the stderr should contain a warning message$/ do
-  expect(all_stderr).to include("[warning]")
-end
-
 module CucumberHelper
   def run_feature(filename = 'features/a_feature.feature', formatter = 'progress')
     run_simple "#{Cucumber::BINARY} #{filename} --format #{formatter}", false

data/features/lib/step_definitions/iso-8859-1_steps.rb

@@ -1,12 +1,16 @@
 # encoding: iso-8859-1
-# Ideally we would use Norwegian keywords here, but that won't work unless this file is UTF-8 encoded.
-# Alternatively it would be possible to use Norwegian keywords and encode the file as UTF-8.
+# frozen_string_literal: true
+# Ideally we would use Norwegian keywords here, but that won't work unless this
+# file is UTF-8 encoded.
+# Alternatively, it would be possible to use Norwegian keywords and encode the
+# file as UTF-8.
 #
-# In both cases, stepdef arguments will be sent in as UTF-8, regardless of what encoding is used.
-Given /^jeg drikker en "([^"]*)"$/ do |drink|
+# In both cases, stepdef arguments will be sent in as UTF-8, regardless of what
+# encoding is used.
+Given(/^jeg drikker en "([^"]*)"$/) do |drink|
   expect(drink).to eq '�l'.encode('UTF-8')
 end
 
-When /^skal de andre si "([^"]*)"$/ do |greeting|
+When(/^skal de andre si "([^"]*)"$/) do |greeting|
   expect(greeting).to eq 'sk�l'.encode('UTF-8')
 end

data/features/lib/step_definitions/json_steps.rb

@@ -1,4 +1,5 @@
-Then /^it should (pass|fail) with JSON:$/ do |pass_fail, json|
+# frozen_string_literal: true
+Then(/^it should (pass|fail) with JSON:$/) do |pass_fail, json|
   actual = normalise_json(MultiJson.load(all_stdout))
   expected = MultiJson.load(json)
 

data/features/lib/step_definitions/junit_steps.rb

@@ -1,4 +1,5 @@
-Then(/^the junit output file "(.*?)" should contain:$/) do |actual_file, text|
+# frozen_string_literal: true
+Then('the junit output file {string} should contain:') do |actual_file, text|
   actual = IO.read(current_dir + '/' + actual_file)
   actual = replace_junit_time(actual)
   expect(actual).to eq text

data/features/lib/step_definitions/language_steps.rb

@@ -1,7 +1,8 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
-Then(/^cucumber lists all the supported languages$/) do
-  sample_languages = ["Arabic", "български", "Pirate", "English", "日本語"]
+Then('cucumber lists all the supported languages') do
+  sample_languages = %w(Arabic български Pirate English 日本語)
   sample_languages.each do |language|
     expect(all_output.force_encoding('utf-8')).to include(language)
   end

data/features/lib/step_definitions/profile_steps.rb

@@ -1,15 +1,16 @@
-Given /^the following profiles? (?:are|is) defined:$/ do |profiles|
+# frozen_string_literal: true
+Given('the following profile(s) are/is defined:') do |profiles|
   write_file 'cucumber.yml', profiles
 end
 
-Then /^the (.*) profile should be used$/ do |profile|
+Then('the {word} profile should be used') do |profile|
   step 'the stdout should contain:', profile
 end
 
-Then /^exactly these files should be loaded:\s*(.*)$/ do |files|
-  expect(all_stdout.scan(/^  \* (.*\.rb)$/).flatten).to eq files.split(/,\s+/)
+Then('exactly these files should be loaded: {list}') do |files|
+  expect(all_stdout.scan(/^  \* (.*\.rb)$/).flatten).to eq files
 end
 
-Then /^exactly these features should be run:\s*(.*)$/ do |files|
-  expect(all_stdout.scan(/^  \* (.*\.feature)$/).flatten).to eq files.split(/,\s+/)
+Then('exactly these features should be run: {list}') do |files|
+  expect(all_stdout.scan(/^  \* (.*\.feature)$/).flatten).to eq files
 end

data/features/lib/step_definitions/retry_steps.rb

@@ -1,35 +1,55 @@
-Given /^a scenario "([^\"]*)" that fails once, then passes$/ do |name|
+# frozen_string_literal: true
+Given('a scenario {string} that fails once, then passes') do |full_name|
+  name = snake_case(full_name)
   write_file "features/#{name}.feature",
   <<-FEATURE
-  Feature: #{name}
-    Scenario: #{name}
+  Feature: #{full_name} feature
+    Scenario: #{full_name}
       Given it fails once, then passes
   FEATURE
 
-  write_file "features/step_defnitions/#{name}_steps.rb",
+  write_file "features/step_definitions/#{name}_steps.rb",
   <<-STEPS
   Given(/^it fails once, then passes$/) do
-    $#{name.downcase} ||= 0
-    $#{name.downcase} += 1
-    expect($#{name.downcase}).to eql 2
+    $#{name} += 1
+    expect($#{name}).to be > 1
   end
   STEPS
+
+  write_file "features/support/#{name}_init.rb",
+  <<-INIT
+  $#{name} = 0
+  INIT
 end
 
-Given /^a scenario "([^\"]*)" that fails twice, then passes$/ do |name|
+Given('a scenario {string} that fails twice, then passes') do |full_name|
+  name = snake_case(full_name)
   write_file "features/#{name}.feature",
   <<-FEATURE
-  Feature: #{name}
-    Scenario: #{name}
+  Feature: #{full_name} feature
+    Scenario: #{full_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
+    $#{name} ||= 0
+    $#{name} += 1
+    expect($#{name}).to be > 2
   end
   STEPS
+
+  write_file "features/support/#{name}_init.rb",
+  <<-INIT
+  $#{name} = 0
+  INIT
 end
+
+module SnakeCase
+  def snake_case(name)
+    name.downcase.gsub(/\W/, '_')
+  end
+end
+
+World(SnakeCase)

data/features/lib/step_definitions/ruby_steps.rb

@@ -1,3 +1,4 @@
-When(/^I run the following Ruby code:$/) do |code|
+# frozen_string_literal: true
+When('I run the following Ruby code:') do |code|
   run_simple %{ruby -e "#{code}"}
 end

data/features/lib/support/env.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'aruba/cucumber'
 require 'aruba/in_process'
 require 'aruba/spawn_process'
@@ -7,7 +8,7 @@ Before('@spawn') do
   Aruba.process = Aruba::SpawnProcess
 end
 
-Before('~@spawn') do
+Before('not @spawn') do
   Aruba::InProcess.main_class = Cucumber::Cli::Main
   Aruba.process = Aruba::InProcess
 end
@@ -17,5 +18,5 @@ Before do
   # set_env('SIMPLECOV', 'true')
 
   # Set a longer timeout for aruba, and a really long one if running on JRuby
-  @aruba_timeout_seconds = Cucumber::JRUBY ? 35 : 15
+  @aruba_timeout_seconds = Cucumber::JRUBY ? 60 : 15
 end

data/features/lib/support/fake_wire_server.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'multi_json'
 require 'socket'
 
@@ -42,15 +43,20 @@ class FakeWireServer
     end
 
     def start
-      while message = @socket.gets
+      message = @socket.gets
+
+      while message
         handle(message)
+        message = @socket.gets
       end
     end
 
     private
 
     def handle(data)
-      if protocol_entry = response_to(data.strip)
+      protocol_entry = response_to(data.strip)
+
+      if protocol_entry
         sleep delay(data)
         @on_message.call(MultiJson.load(protocol_entry['request'])[0])
         send_response(protocol_entry['response'])
@@ -59,7 +65,15 @@ class FakeWireServer
         send_response(['fail', serialized_exception ].to_json)
       end
     rescue => e
-      send_response(['fail', { :message => e.message, :backtrace => e.backtrace, :exception => e.class } ].to_json)
+      response = [
+                    'fail',
+                    {
+                      :message => e.message,
+                      :backtrace => e.backtrace,
+                      :exception => e.class
+                    }
+                  ].to_json
+      send_response(response)
     end
 
     def response_to(data)

data/features/lib/support/feature_factory.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+# frozen_string_literal: true
 module FeatureFactory
   def create_feature(name = generate_feature_name)
     gherkin = <<-GHERKIN
@@ -54,7 +55,7 @@ Feature: #{name}
   end
 
   def filename(name)
-    "features/#{name.downcase.gsub(' ', '_')}.feature"
+    "features/#{name.downcase.tr(' ', '_')}.feature"
   end
 
   def features

data/features/lib/support/normalise_output.rb

@@ -1,15 +1,20 @@
+# frozen_string_literal: true
 # override aruba to filter out some stuff
 module NormaliseArubaOutput
   def all_stdout
     normalise_output(super)
   end
 
+  def sanitize_text(text)
+    normalise_output(super)
+  end
+
   def normalise_output(out)
-    out = out.gsub(/#{Dir.pwd}\/tmp\/aruba/, '.') # Remove absolute paths
-    out = out.gsub(/tmp\/aruba\//, '')            # Fix aruba path
-    out = out.gsub(/^.*cucumber_process\.rb.*$\n/, '')
-    out = out.gsub(/^\d+m\d+\.\d+s$/, '0m0.012s') # Make duration predictable
-    out = out.gsub(/Coverage report generated .+$\n/, '') # Remove SimpleCov message
+    out.gsub(/#{Dir.pwd}\/tmp\/aruba/, '.') # Remove absolute paths
+       .gsub(/tmp\/aruba\//, '')            # Fix aruba path
+       .gsub(/^.*cucumber_process\.rb.*$\n/, '')
+       .gsub(/^\d+m\d+\.\d+s$/, '0m0.012s') # Make duration predictable
+       .gsub(/Coverage report generated .+$\n/, '') # Remove SimpleCov message
   end
 
   def normalise_json(json)
@@ -19,7 +24,7 @@ module NormaliseArubaOutput
       elements = feature.fetch('elements') { [] }
       elements.each do |scenario|
         scenario['steps'].each do |step|
-          ['steps', 'before', 'after'].each do |type|
+          %w(steps before after).each do |type|
             if scenario[type]
               scenario[type].each do |step_or_hook|
                 normalise_json_step_or_hook(step_or_hook)
@@ -37,12 +42,9 @@ module NormaliseArubaOutput
   end
 
   def normalise_json_step_or_hook(step_or_hook)
-    if step_or_hook['result']
-      if step_or_hook['result']['duration']
-        expect(step_or_hook['result']['duration']).to be >= 0
-        step_or_hook['result']['duration'] = 1
-      end
-    end
+    return unless step_or_hook['result'] && step_or_hook['result']['duration']
+    expect(step_or_hook['result']['duration']).to be >= 0
+    step_or_hook['result']['duration'] = 1
   end
 
 end

data/features/lib/support/parameter_types.rb

@@ -0,0 +1,5 @@
+ParameterType(
+  name: 'list',
+  regexp: /.*/,
+  transformer: ->(s) { s.split(/,\s+/)}
+)

data/gem_tasks/contributors.rake

@@ -1,15 +1,19 @@
 # encoding: utf-8
+# frozen_string_literal: true
+
 desc 'List contributors'
 task :contributors do
-  contributors = `git log --pretty=short --no-merges | git shortlog -ne | egrep -ve '^ +' | egrep -ve '^$'`.split("\n")
-  puts contributors
-  puts "Total: #{contributors.length}"
+  IO.popen("git log --pretty=short --no-merges | git shortlog -ne | egrep -ve '^ +' | egrep -ve '^$'") do |f|
+    contributors = f.readlines
+    puts contributors
+    puts "Total: #{contributors.length}"
+  end
 end
 
 task :codeswarm do
-  sh "code_swarm --reload" rescue nil # Fails because of encoding - which we'll fix
-  sh "iconv -f latin1 -t utf-8 .git/.code_swarm/log.xml > tmp.xml && mv tmp.xml .git/.code_swarm/log.xml"
+  sh 'code_swarm --reload' rescue nil # Fails because of encoding - which we'll fix
+  sh 'iconv -f latin1 -t utf-8 .git/.code_swarm/log.xml > tmp.xml && mv tmp.xml .git/.code_swarm/log.xml'
   sh "sed -e 's/Aslak\ Hellesøy@.BEKK.no/aslak.hellesoy@gmail.com/g' .git/.code_swarm/log.xml > tmp.xml && mv tmp.xml .git/.code_swarm/log.xml"
   sh "sed -e 's/josephwilk@joesniff.co.uk/joe@josephwilk.net/g' .git/.code_swarm/log.xml > tmp.xml && mv tmp.xml .git/.code_swarm/log.xml"
-  sh "code_swarm"
+  sh 'code_swarm'
 end

data/gem_tasks/cov.rake

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 desc 'Run all tests and collect code coverage'
 task :cov do
   ENV['SIMPLECOV'] = 'features'

data/gem_tasks/downloads.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'httparty'
 require 'multi_json'
 

data/gem_tasks/environment.rake

@@ -1,7 +1,4 @@
+# frozen_string_literal: true
 task :ruby_env do
-  RUBY_APP = if RUBY_PLATFORM =~ /java/
-    "jruby"
-  else
-    "ruby"
-  end unless defined? RUBY_APP
+  RUBY_APP ||= RUBY_PLATFORM =~ /java/ ? 'jruby' : 'ruby'
 end