cucumber 1.3.20 → 2.0.0.beta.1

data/features/docs/writing_support_code/before_hook.feature

@@ -0,0 +1,61 @@
+Feature: Before Hook
+
+  Scenario: Examine names of scenario and feature
+    Given a file named "features/foo.feature" with:
+      """
+      Feature: Feature name
+
+        Scenario: Scenario name
+          Given a step
+      """
+    And a file named "features/support/hook.rb" with:
+      """
+      names = []
+      Before do |scenario|
+        expect(scenario).to_not respond_to(:scenario_outline)
+        names << scenario.feature.name.split("\n").first
+        names << scenario.name.split("\n").first
+        if(names.size == 2)
+          raise "NAMES:\n" + names.join("\n") + "\n"
+        end
+      end
+      """
+    When I run `cucumber`
+    Then the output should contain:
+      """
+        NAMES:
+        Feature name
+        Scenario: Scenario name
+      """
+
+  Scenario: Examine names of scenario outline and feature
+    Given a file named "features/foo.feature" with:
+      """
+      Feature: Feature name
+
+        Scenario Outline: Scenario Outline name
+          Given a <placeholder>
+
+          Examples: Examples Table name
+            | <placeholder> |
+            | step          |
+      """
+    And a file named "features/support/hook.rb" with:
+      """
+      names = []
+      Before do |scenario|
+        names << scenario.scenario_outline.feature.name.split("\n").first
+        names << scenario.scenario_outline.name.split("\n").first
+        if(names.size == 2)
+          raise "NAMES:\n" + names.join("\n") + "\n"
+        end
+      end
+      """
+    When I run `cucumber`
+    Then the output should contain:
+      """
+            NAMES:
+            Feature name
+            Scenario Outline: Scenario Outline name
+      """
+

data/features/docs/writing_support_code/hook_order.feature

@@ -0,0 +1,61 @@
+  @spawn
+  Feature: Hooks execute in defined order
+
+  Background:
+    Given a file named "features/step_definitions/steps.rb" with:
+      """
+      Given /^background step$/ do; $EventOrder.push(:background_step) end
+      Given /^scenario step$/ do; $EventOrder.push(:scenario_step) end
+      """
+    And a file named "features/support/hooks.rb" with:
+      """
+      $EventOrder = []
+      Around('@around') do |scenario,block|
+        $EventOrder.push :around_begin
+        block.call
+        $EventOrder.push :around_end
+      end
+      Before('@before') do
+        $EventOrder.push :before
+      end
+      After('@after') do |scenario|
+        $EventOrder.push :after
+      end
+      at_exit {
+        puts "Event order: #{$EventOrder.join(' ')}"
+      }
+      """
+    And a file named "features/around_hook_covers_background.feature" with:
+      """
+      @around
+      Feature: Around hooks cover background steps
+        Background:
+          Given background step
+        Scenario:
+          Given scenario step
+      """
+    And a file named "features/all_hook_order.feature" with:
+      """
+      @around
+      @before
+      @after
+      Feature: All hooks execute in expected order
+        Background:
+          Given background step
+        Scenario:
+          Given scenario step
+      """
+
+  Scenario: Around hooks cover background steps
+    When I run `cucumber -o /dev/null features/around_hook_covers_background.feature`
+    Then the output should contain:
+      """
+      Event order: around_begin background_step scenario_step around_end
+      """
+
+  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/{load_path.feature → docs/writing_support_code/load_path.feature}

@@ -1,5 +1,8 @@
 Feature: Set up a default load path
 
+  When you're developing a gem, it's convenient if your project's `lib` directory
+  is already in the load path. Cucumber does this for you.
+
   Scenario: ./lib is included in the $LOAD_PATH
     Given a file named "features/support/env.rb" with:
       """

data/features/docs/writing_support_code/state.feature

@@ -0,0 +1,32 @@
+Feature: State
+
+  You can pass state between step by setting instance variables,
+  but those instance variables will be gone when the next scenario runs.
+
+  Scenario: Set an ivar in one scenario, use it in the next step
+    Given a file named "features/test.feature" with:
+      """
+      Feature:
+        Scenario:
+          Given I have set @flag = true
+          Then @flag should be true
+
+        Scenario:
+          Then @flag should be nil
+      """
+    And a file named "features/step_definitions/steps.rb" with:
+      """
+      Given /set @flag/ do
+        @flag = true
+      end
+      Then /flag should be true/ do
+        expect(@flag).to be_truthy
+      end
+      Then /flag should be nil/ do
+        expect(@flag).to be_nil
+      end
+      """
+    When I run `cucumber`
+    Then it should pass
+
+

data/features/{tagged_hooks.feature → docs/writing_support_code/tagged_hooks.feature}

@@ -1,13 +1,10 @@
 Feature: Tagged hooks
 
   Background:
-    Given a file named "features/step_definitions/steps.rb" with:
-      """
-      Given /^this step works$/ do; end
-      """
+    Given the standard step definitions
     And a file named "features/support/hooks.rb" with:
       """
-      Before('~@no-boom') do 
+      Before('~@no-boom') do
         raise 'boom'
       end
       """
@@ -15,23 +12,24 @@ Feature: Tagged hooks
       """
       Feature: With and without hooks
         Scenario: using hook
-          Given this step works
+          Given this step passes
 
         @no-boom
         Scenario: omitting hook
-          Given this step works
+          Given this step passes
       """
+
   @spawn
-  Scenario: omit tagged hook
+  Scenario: Invoke tagged hook
     When I run `cucumber features/f.feature:2`
     Then it should fail with:
       """
       Feature: With and without hooks
       
-        Scenario: using hook    # features/f.feature:2
+        Scenario: using hook     # features/f.feature:2
         boom (RuntimeError)
         ./features/support/hooks.rb:2:in `Before'
-          Given this step works # features/step_definitions/steps.rb:1
+          Given this step passes # features/step_definitions/steps.rb:1
       
       Failing Scenarios:
       cucumber features/f.feature:2 # Scenario: using hook
@@ -41,15 +39,15 @@ Feature: Tagged hooks
 
       """
 
-    Scenario: omit tagged hook
+    Scenario: Omit tagged hook
       When I run `cucumber features/f.feature:6`
       Then it should pass with:
         """
         Feature: With and without hooks
 
           @no-boom
-          Scenario: omitting hook # features/f.feature:6
-            Given this step works # features/step_definitions/steps.rb:1
+          Scenario: omitting hook  # features/f.feature:6
+            Given this step passes # features/step_definitions/steps.rb:1
 
         1 scenario (1 passed)
         1 step (1 passed)

data/features/lib/step_definitions/aruba_steps.rb

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

data/features/lib/step_definitions/cucumber_steps.rb

@@ -0,0 +1,50 @@
+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|
+  create_feature do
+    create_scenario { string }
+  end
+end
+
+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
+  write_file 'features/step_definitions/steps.rb',
+
+  <<-STEPS
+  Given(/^this step passes$/)          { }
+  Given(/^this step raises an error$/) { raise 'error' }
+  Given(/^this step is pending$/)      { pending }
+  Given(/^this step fails$/)           { fail }
+  Given(/^this step is a table step$/) {|t| }
+  STEPS
+end
+
+Given /^a step definition that looks like this:$/ do |string|
+  create_step_definition { string }
+end
+
+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
+  end
+end
+
+World(CucumberHelper)

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

@@ -1,24 +1,12 @@
 # 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.
-# 
+#
 # In both cases, stepdef arguments will be sent in as UTF-8, regardless of what encoding is used.
 Given /^jeg drikker en "([^"]*)"$/ do |drink|
-  drink.should == utf8('�l', 'iso-8859-1')
+  expect(drink).to eq '�l'.encode('UTF-8')
 end
 
 When /^skal de andre si "([^"]*)"$/ do |greeting|
-  greeting.should == utf8('sk�l', 'iso-8859-1')
+  expect(greeting).to eq 'sk�l'.encode('UTF-8')
 end
-
-module EncodingHelper
-  def utf8(string, encoding)
-    if string.respond_to?(:encode) # Ruby 1.9
-      string.encode('UTF-8')
-    else # Ruby 1.8
-      require 'iconv'
-      Iconv.new('UTF-8', encoding).iconv(string)
-    end
-  end
-end
-World(EncodingHelper)

data/features/lib/step_definitions/json_steps.rb

@@ -0,0 +1,7 @@
+Then /^it should (pass|fail) with JSON:$/ do |pass_fail, json|
+  actual = normalise_json(MultiJson.load(all_stdout))
+  expected = MultiJson.load(json)
+
+  expect(actual).to eq expected
+  assert_success(pass_fail == 'pass')
+end

data/features/lib/step_definitions/junit_steps.rb

@@ -0,0 +1,13 @@
+Then(/^the junit output file "(.*?)" should contain:$/) do |actual_file, text|
+  actual = IO.read(current_dir + '/' + actual_file)
+  actual = replace_junit_time(actual)
+  expect(actual).to eq text.to_s
+end
+
+module JUnitHelper
+  def replace_junit_time(s)
+    s.gsub(/\d+\.\d\d+/m, '0.05')
+  end
+end
+
+World(JUnitHelper)

data/features/lib/step_definitions/language_steps.rb

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

data/features/lib/step_definitions/profile_steps.rb

@@ -0,0 +1,15 @@
+Given /^the following profiles? (?:are|is) defined:$/ do |profiles|
+  write_file 'cucumber.yml', profiles
+end
+
+Then /^the (.*) 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+/)
+end
+
+Then /^exactly these features should be ran:\s*(.*)$/ do |files|
+  expect(all_stdout.scan(/^  \* (.*\.feature)$/).flatten).to eq files.split(/,\s+/)
+end

data/features/lib/step_definitions/ruby_steps.rb

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

data/{legacy_features → features/lib}/step_definitions/wire_steps.rb

@@ -1,6 +1,9 @@
 Given /^there is a wire server (running |)on port (\d+) which understands the following protocol:$/ do |running, port, table|
-  table.map_column!('response') {|cell| cell.gsub(/\n/, '\n')}
-  protocol = table.hashes
+  protocol = table.hashes.map do |table_hash|
+    table_hash['response'] = table_hash['response'].gsub(/\n/, '\n')
+    table_hash
+  end
+
   @server = FakeWireServer.new(port.to_i, protocol)
   start_wire_server if running.strip == "running"
 end
@@ -10,18 +13,22 @@ Given /^the wire server takes (.*) seconds to respond to the invoke message$/ do
   start_wire_server
 end
 
+Given /^I have environment variable (\w+) set to "([^"]*)"$/ do |variable, value|
+  set_env(variable, value)
+end
+
 module WireHelper
   def start_wire_server
-    @wire_pid = fork do
-      at_exit { stop_wire_server }
-      @server.run
-    end
+    @wire_pid = fork { @server.run }
+    at_exit { stop_wire_server }
   end
-  
+
   def stop_wire_server
     return unless @wire_pid
     Process.kill('KILL', @wire_pid)
-    Process.wait
+    Process.wait(@wire_pid)
+  rescue Errno::ESRCH
+    # No such process - wire server has already been stopped by the After hook
   end
 end
 
@@ -31,4 +38,4 @@ end
 
 After('@wire') do
   stop_wire_server
-end
+end

data/features/lib/support/env.rb

@@ -0,0 +1,21 @@
+require 'aruba/cucumber'
+require 'aruba/in_process'
+require 'aruba/spawn_process'
+require 'cucumber/cli/main'
+
+Before('@spawn') do
+  Aruba.process = Aruba::SpawnProcess
+end
+
+Before('~@spawn') do
+  Aruba::InProcess.main_class = Cucumber::Cli::Main
+  Aruba.process = Aruba::InProcess
+end
+
+Before do
+  # Make sure bin/cucumber runs with SimpleCov enabled
+  # 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
+end