cucumber 0.9.4 → 0.10.0

data/gem_tasks/{features.rake → cucumber.rake}

@@ -2,7 +2,10 @@ $:.unshift(File.dirname(__FILE__) + '/../lib')
 require 'cucumber/rake/task'
 require 'cucumber/platform'
 
-Cucumber::Rake::Task.new do |t|
+Cucumber::Rake::Task.new(:features)
+
+Cucumber::Rake::Task.new(:legacy_features) do |t|
+  t.cucumber_opts = %w{legacy_features}
   if(Cucumber::JRUBY)
     t.profile = Cucumber::WINDOWS ? 'jruby_win' : 'jruby'
   elsif(Cucumber::WINDOWS_MRI)
@@ -12,3 +15,5 @@ Cucumber::Rake::Task.new do |t|
   end
   t.rcov = ENV['RCOV']
 end
+
+task :cucumber => [:features, :legacy_features]

data/{features → legacy_features}/cucumber_cli.feature

@@ -90,7 +90,7 @@ Feature: Cucumber command line
       """
 
   Scenario: Require missing step definition from elsewhere
-    When I run cucumber -q -r ../../features/step_definitions/extra_steps.rb features/sample.feature:5
+    When I run cucumber -q -r ../../legacy_features/step_definitions/extra_steps.rb features/sample.feature:5
     Then it should pass with
       """
       # Feature comment
@@ -196,18 +196,18 @@ Feature: Cucumber command line
       Feature: multiline
 
         Background: I'm a multiline name
-          which goes on and on and on for three lines
-          yawn
+                    which goes on and on and on for three lines
+                    yawn
           Given passing without a table
 
         Scenario: I'm a multiline name
-          which goes on and on and on for three lines
-          yawn
+                  which goes on and on and on for three lines
+                  yawn
           Given passing without a table
 
         Scenario Outline: I'm a multiline name
-          which goes on and on and on for three lines
-          yawn
+                          which goes on and on and on for three lines
+                          yawn
           Given <state> without a table
 
           Examples: 
@@ -218,8 +218,8 @@ Feature: Cucumber command line
           Given <state> without a table
 
           Examples: I'm a multiline name
-            which goes on and on and on for three lines
-            yawn
+                    which goes on and on and on for three lines
+                    yawn
             | state   |
             | passing |
 

data/legacy_features/multiline_names.feature

@@ -0,0 +1,44 @@
+Feature: Multiline description names
+  In order to accurately document feature elements
+  As a cucumberist
+  I want to have multiline names
+
+  Scenario: multiline scenario
+    When I run cucumber features/multiline_name.feature --no-snippets
+    Then STDERR should be empty
+    Then it should pass with
+    """
+    Feature: multiline
+
+      Background: I'm a multiline name                        # features/multiline_name.feature:3
+                  which goes on and on and on for three lines
+                  yawn
+        Given passing without a table                         # features/step_definitions/sample_steps.rb:12
+
+      Scenario: I'm a multiline name                        # features/multiline_name.feature:8
+                which goes on and on and on for three lines
+                yawn
+        Given passing without a table                       # features/step_definitions/sample_steps.rb:12
+
+      Scenario Outline: I'm a multiline name                        # features/multiline_name.feature:13
+                        which goes on and on and on for three lines
+                        yawn
+        Given <state> without a table                               # features/step_definitions/sample_steps.rb:12
+
+        Examples: 
+          | state   |
+          | passing |
+
+      Scenario Outline: name          # features/multiline_name.feature:21
+        Given <state> without a table # features/step_definitions/sample_steps.rb:12
+
+        Examples: I'm a multiline name
+                  which goes on and on and on for three lines
+                  yawn
+          | state   |
+          | passing |
+
+    3 scenarios (3 passed)
+    6 steps (6 passed)
+
+    """

data/legacy_features/step_definitions/cucumber_steps.rb

@@ -0,0 +1,168 @@
+# encoding: utf-8
+require 'tempfile'
+
+Given /^I am in (.*)$/ do |example_dir_relative_path|
+  @current_dir = fixtures_dir(example_dir_relative_path)
+end
+
+Given /^a standard Cucumber project directory structure$/ do
+  @current_dir = working_dir
+  in_current_dir do
+    FileUtils.rm_rf 'features' if File.directory?('features')
+    FileUtils.mkdir_p 'features/support'
+    FileUtils.mkdir 'features/step_definitions'
+  end
+end
+
+Given /^the (.*) directory is empty$/ do |directory|
+  in_current_dir do
+    FileUtils.remove_dir(directory) rescue nil
+    FileUtils.mkdir 'tmp'
+  end
+end
+
+Given /^a file named "([^"]*)"$/ do |file_name|
+  create_file(file_name, '')
+end
+
+Given /^a file named "([^"]*)" with:$/ do |file_name, file_content|
+  create_file(file_name, file_content)
+end
+
+Given /^the following profiles? (?:are|is) defined:$/ do |profiles|
+  create_file('cucumber.yml', profiles)
+end
+
+Given /^I am running spork in the background$/ do
+  run_spork_in_background
+end
+
+Given /^I am running spork in the background on port (\d+)$/ do |port|
+  run_spork_in_background(port.to_i)
+end
+
+Given /^I am not running (?:.*) in the background$/ do
+  # no-op
+end
+
+Given /^I have environment variable (\w+) set to "([^"]*)"$/ do |variable, value|
+  set_env_var(variable, value)
+end
+
+When /^I run cucumber (.*)$/ do |cucumber_opts|
+  run "#{Cucumber::RUBY_BINARY} -I rubygems #{cucumber_bin} --no-color #{cucumber_opts} CUCUMBER_OUTPUT_ENCODING=UTF-8"
+end
+
+When /^I run rake (.*)$/ do |rake_opts|
+  run "rake #{rake_opts} --trace"
+end
+
+When /^I run the following Ruby code:$/ do |code|
+  run %{#{Cucumber::RUBY_BINARY} -r rubygems -I #{cucumber_lib_dir} -e "#{code}"}
+end
+
+Then /^it should (fail|pass)$/ do |success|
+  if success == 'fail'
+    last_exit_status.should_not == 0
+  else
+    if last_exit_status != 0
+      raise "Failed with exit status #{last_exit_status}\nSTDOUT:\n#{last_stdout}\nSTDERR:\n#{last_stderr}"
+    end
+  end
+end
+
+Then /^it should (fail|pass) with$/ do |success, output|
+  unless combined_output.index(output)
+    combined_output.should == output
+  end
+  Then("it should #{success}")
+end
+
+Then /^the output should contain:?$/ do |text|
+  last_stdout.should include(text)
+end
+
+Then /^the output should not contain$/ do |text|
+  last_stdout.should_not include(text)
+end
+
+Then /^the output should be$/ do |text|
+  last_stdout.should == text
+end
+
+Then /^it should (fail|pass) with JSON$/ do |success, text|
+  JSON.parse(last_stdout).should == JSON.parse(text)
+  Then("it should #{success}")
+end
+
+Then /^"([^"]*)" should contain$/ do |file, text|
+  strip_duration(IO.read(file)).should == text
+end
+
+Then /^"([^"]*)" with junit duration "([^"]*)" should contain$/ do |actual_file, duration_replacement, text|
+  actual = IO.read(actual_file)
+  actual = replace_junit_duration(actual, duration_replacement) 
+  actual = strip_ruby186_extra_trace(actual)
+  actual.should == text
+end
+
+Then /^"([^"]*)" should match "(.+?)"$/ do |file, text|
+  File.open(file, Cucumber.file_mode('r')).read.should =~ Regexp.new(text)
+end
+
+Then /^"([^"]*)" should have the same contents as "([^"]*)"$/ do |actual_file, expected_file|
+  actual = IO.read(actual_file)
+  actual = replace_duration(actual, '0m30.005s')
+  # Comment out to replace expected file. Use with care!
+  # File.open(expected_file, "w") {|io| io.write(actual)}
+  actual.should == IO.read(expected_file)
+end
+
+Then /^STDERR should match$/ do |text|
+  last_stderr.should =~ /#{text}/
+end
+
+Then /^STDERR should not match$/ do |text|
+  last_stderr.should_not =~ /#{text}/
+end
+
+Then /^STDERR should be$/ do |text|
+  last_stderr.should == text
+end
+
+Then /^STDERR should be empty$/ do
+  last_stderr.should == ""
+end
+
+Then /^"([^"]*)" should exist$/ do |file|
+  File.exists?(file).should be_true
+  FileUtils.rm(file)
+end
+
+Then /^"([^"]*)" should not be required$/ do |file_name|
+  last_stdout.should_not include("* #{file_name}")
+end
+
+Then /^"([^"]*)" should be required$/ do |file_name|
+  last_stdout.should include("* #{file_name}")
+end
+
+Then /^exactly these files should be loaded:\s*(.*)$/ do |files|
+  last_stdout.scan(/^  \* (.*\.rb)$/).flatten.should == files.split(/,\s+/)
+end
+
+Then /^exactly these features should be ran:\s*(.*)$/ do |files|
+  last_stdout.scan(/^  \* (.*\.feature)$/).flatten.should == files.split(/,\s+/)
+end
+
+Then /^the (.*) profile should be used$/ do |profile|
+  last_stdout.should =~ /Using the #{profile} profile/
+end
+
+Then /^print output$/ do
+  puts last_stdout
+end
+
+Then /^the output should contain the following JSON:$/ do |json_string|
+  JSON.parse(last_stdout).should == JSON.parse(json_string)
+end

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

@@ -1,4 +1,5 @@
 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
   @server = FakeWireServer.new(port.to_i, protocol)
   start_wire_server if running.strip == "running"

data/legacy_features/support/env.rb

@@ -0,0 +1,157 @@
+require 'rubygems'
+
+require 'tempfile'
+require 'rspec/expectations'
+require 'fileutils'
+require 'forwardable'
+require 'cucumber/formatter/unicode'
+# This is to force miniunit to be loaded on 1.9.2, and verify that we can still run with --profile. See:
+# * disable_mini_test_autorun.rb and 
+# * http://groups.google.com/group/cukes/browse_thread/thread/5682d41436e235d7
+# * https://rspec.lighthouseapp.com/projects/16211/tickets/677-cucumber-093-prevents-testunit-from-running
+require 'test/unit'
+
+class CucumberWorld
+  extend Forwardable
+  def_delegators CucumberWorld, :fixtures_dir, :self_test_dir, :working_dir, :cucumber_lib_dir
+
+  def self.fixtures_dir(subdir=nil)
+    @fixtures_dir ||= File.expand_path(File.join(File.dirname(__FILE__), '../../fixtures'))
+    subdir ? File.join(@fixtures_dir, subdir) : @fixtures_dir
+  end
+
+  def self.self_test_dir
+    @self_test_dir ||= fixtures_dir('self_test')
+  end
+
+  def self.working_dir
+    @working_dir ||= fixtures_dir('self_test/tmp')
+  end
+
+  def cucumber_lib_dir
+    @cucumber_lib_dir ||= File.expand_path(File.join(File.dirname(__FILE__), '../../lib'))
+  end
+  
+  # Don't use Cucumber::BINARY (which is the binary used to start the "outer" cucumber)
+  # Instead we force the use of this codebase's cucumber bin script.
+  # This allows us to run cucumber's cukes with an older, stable cucumber.
+  def cucumber_bin
+    File.expand_path(File.dirname(__FILE__) + '/../../bin/cucumber')
+  end
+
+  def initialize
+    @current_dir = self_test_dir
+  end
+
+  private
+  attr_reader :last_exit_status, :last_stderr
+
+  # The last standard out, with the duration line taken out (unpredictable)
+  def last_stdout
+    strip_1_9_paths(strip_duration(@last_stdout))
+  end
+
+  def combined_output
+    last_stdout + "\n" + last_stderr
+  end
+
+  def strip_duration(s)
+    s.gsub(/^\d+m\d+\.\d+s\n/m, "")
+  end
+
+  def strip_1_9_paths(s)
+    s.gsub(/#{Dir.pwd}\/fixtures\/self_test\/tmp/m, ".").gsub(/#{Dir.pwd}\/fixtures\/self_test/m, ".")
+  end
+
+  def replace_duration(s, replacement)
+    s.gsub(/\d+m\d+\.\d+s/m, replacement)
+  end
+
+  def replace_junit_duration(s, replacement)
+    s.gsub(/\d+\.\d\d+/m, replacement)
+  end
+
+  def strip_ruby186_extra_trace(s)  
+    s.gsub(/^.*\.\/features\/step_definitions(.*)\n/, "")
+  end
+
+  def create_file(file_name, file_content)
+    file_content.gsub!("CUCUMBER_LIB", "'#{cucumber_lib_dir}'") # Some files, such as Rakefiles need to use the lib dir
+    in_current_dir do
+      FileUtils.mkdir_p(File.dirname(file_name)) unless File.directory?(File.dirname(file_name))
+      File.open(file_name, 'w') { |f| f << file_content }
+    end
+  end
+
+  def set_env_var(variable, value)
+    @original_env_vars ||= {}
+    @original_env_vars[variable] = ENV[variable] 
+    ENV[variable]  = value
+  end
+
+  def background_jobs
+    @background_jobs ||= []
+  end
+
+  def in_current_dir(&block)
+    Dir.chdir(@current_dir, &block)
+  end
+
+  def run(command)
+    stderr_file = Tempfile.new('cucumber')
+    stderr_file.close
+    in_current_dir do
+      mode = Cucumber::RUBY_1_9 ? {:external_encoding=>"UTF-8"} : 'r'
+      IO.popen("#{command} 2> #{stderr_file.path}", mode) do |io|
+        @last_stdout = io.read
+      end
+
+      @last_exit_status = $?.exitstatus
+    end
+    @last_stderr = IO.read(stderr_file.path)
+  end
+
+  def run_spork_in_background(port = nil)
+    require 'spork'
+
+    pid = fork
+    in_current_dir do
+      if pid
+        background_jobs << pid
+      else
+        # STDOUT.close
+        # STDERR.close
+        port_arg = port ? "-p #{port}" : ''
+        cmd = "#{Cucumber::RUBY_BINARY} -I #{Cucumber::LIBDIR} #{Spork::BINARY} cuc #{port_arg}"
+        exec cmd
+      end
+    end
+    sleep 1.0
+  end
+
+  def terminate_background_jobs
+    background_jobs.each do |pid|
+      Process.kill(Signal.list['TERM'], pid)
+    end
+  end
+
+  def restore_original_env_vars
+    @original_env_vars.each { |variable, value| ENV[variable] = value } if @original_env_vars
+  end
+
+end
+
+World do
+  CucumberWorld.new
+end
+
+Before do
+  FileUtils.rm_rf CucumberWorld.working_dir
+  FileUtils.mkdir CucumberWorld.working_dir
+end
+
+After do
+  FileUtils.rm_rf CucumberWorld.working_dir unless ENV['KEEP_FILES']
+  terminate_background_jobs
+  restore_original_env_vars
+end