cucumber 1.3.20 → 2.0.0.beta.1

data/legacy_features/language_from_header.feature

@@ -1,30 +0,0 @@
-Feature: Language from header
-  In order to simplify command line and
-  settings in IDEs, Cucumber should pick
-  up parser language from a header.
-  
-  Scenario: LOLCAT
-    Given a standard Cucumber project directory structure
-    And a file named "features/lolcat.feature" with:
-      """
-      # language: en-lol
-      OH HAI: STUFFING
-        B4: HUNGRY
-        MISHUN: CUKES
-          DEN KTHXBAI
-      """
-    When I run cucumber -i features/lolcat.feature
-    Then it should pass with
-      """
-      # language: en-lol
-      OH HAI: STUFFING
-
-        B4: HUNGRY # features/lolcat.feature:3
-
-        MISHUN: CUKES # features/lolcat.feature:4
-          DEN KTHXBAI # features/lolcat.feature:5
-
-      1 scenario (1 undefined)
-      1 step (1 undefined)
-
-      """

data/legacy_features/multiline_names.feature

@@ -1,44 +0,0 @@
-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/report_called_undefined_steps.feature

@@ -1,35 +0,0 @@
-Feature: Cucumber command line
-  In order to find out what step definitions need to be implemented
-  Developers should always see what step definition is missing
-
-  Scenario: Get info at arbitrary levels of nesting
-    When I run cucumber features/call_undefined_step_from_step_def.feature
-    Then it should pass with
-      """
-      Feature: Calling undefined step
-
-        Scenario: Call directly                                # features/call_undefined_step_from_step_def.feature:3
-          Given a step definition that calls an undefined step # features/step_definitions/sample_steps.rb:19
-            Undefined step: "this does not exist" (Cucumber::Undefined)
-            ./features/step_definitions/sample_steps.rb:19:in `/^a step definition that calls an undefined step$/'
-            features/call_undefined_step_from_step_def.feature:4:in `Given a step definition that calls an undefined step'
-
-        Scenario: Call via another                                         # features/call_undefined_step_from_step_def.feature:6
-          Given call step "a step definition that calls an undefined step" # features/step_definitions/sample_steps.rb:23
-            Undefined step: "this does not exist" (Cucumber::Undefined)
-            ./features/step_definitions/sample_steps.rb:19:in `/^a step definition that calls an undefined step$/'
-            ./features/step_definitions/sample_steps.rb:24:in `/^call step "(.*)"$/'
-            features/call_undefined_step_from_step_def.feature:7:in `Given call step "a step definition that calls an undefined step"'
-
-      2 scenarios (2 undefined)
-      2 steps (2 undefined)
-
-      You can implement step definitions for undefined steps with these snippets:
-
-      Given(/^this does not exist$/) do
-        pending # express the regexp above with the code you wish you had
-      end
-
-
-      """
-

data/legacy_features/rerun_formatter.feature

@@ -1,52 +0,0 @@
-Feature: Rerun Debugger
-  In order to save time
-  I want to run *only* failed, pending and missing features from previous runs
-  (with the help of a smart cucumber.yml)
-
-  Background:
-    Given a standard Cucumber project directory structure
-
-  Scenario: title
-    Given a file named "features/sample.feature" with:
-      """
-      Feature: Rerun
-
-        Scenario: Failing
-          Given failing
-
-        Scenario: Missing
-          Given missing
-
-        Scenario: Pending
-          Given pending
-
-        Scenario: Passing
-          Given passing
-      """
-    And a file named "features/all_good.feature" with:
-      """
-      Feature: Rerun
-
-        Scenario: Passing
-          Given passing
-      """
-    And a file named "features/step_definitions/steps.rb" with:
-      """
-      Given /failing/ do
-        raise 'FAIL'
-      end
-
-      Given /pending/ do
-        pending
-      end
-
-      Given /passing/ do
-      end
-      """
-
-    When I run cucumber -f rerun features/sample.feature features/all_good.feature
-    Then it should fail with
-      """
-      features/sample.feature:3:6:9
-
-      """

data/legacy_features/simplest.feature

@@ -1,11 +0,0 @@
-Feature: Sample
-
-Background:
-  Given this step works
-
-Scenario: Run a good step
-  Given this step works
-
-
-
-

data/legacy_features/snippet.feature

@@ -1,23 +0,0 @@
-Feature: Snippets
-  In order to help speed up writing step definitions
-  As a feature editor
-  I want snippet suggestions for undefined step definitions
-
-  Scenario: Snippet for undefined step with a pystring
-    When I run cucumber features/undefined_multiline_args.feature:3 -s
-    Then the output should contain
-      """
-      Given(/^a pystring$/) do |string|
-        pending # express the regexp above with the code you wish you had
-      end
-      """
-
-  Scenario: Snippet for undefined step with a step table
-    When I run cucumber features/undefined_multiline_args.feature:9 -s
-    Then the output should contain
-      """
-      Given(/^a table$/) do |table|
-        # table is a Cucumber::Ast::Table
-        pending # express the regexp above with the code you wish you had
-      end
-      """

data/legacy_features/snippets_when_using_star_keyword.feature

@@ -1,38 +0,0 @@
-Feature: Use * keywords and still get snippets
-  In order to make it possible to use * instead of
-  Given/When/Then, I should not get an exception
-  when I have undefined steps
-
-  @wip-jruby
-  Scenario: Use some *
-    Given a standard Cucumber project directory structure
-    And a file named "features/f.feature" with:
-      """
-      Feature: F
-        Scenario: S
-          * I have some cukes
-      """
-    When I run cucumber features/f.feature
-    Then STDERR should be empty
-    And it should pass with
-      """
-      Feature: F
-
-        Scenario: S           # features/f.feature:2
-          * I have some cukes # features/f.feature:3
-      
-      1 scenario (1 undefined)
-      1 step (1 undefined)
-      
-      You can implement step definitions for undefined steps with these snippets:
-      
-      Given(/^I have some cukes$/) do
-        pending # express the regexp above with the code you wish you had
-      end
-      
-      If you want snippets in a different programming language,
-      just make sure a file with the appropriate file extension
-      exists where cucumber looks for step definitions.
-
-      
-      """

data/legacy_features/step_definitions/cucumber_steps.rb

@@ -1,179 +0,0 @@
-# encoding: utf-8
-require 'multi_json'
-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'
-    if last_exit_status == 0
-      raise "Passed when expected to fail\nSTDOUT:\n#{last_stdout}\nSTDERR:\n#{last_stderr}"
-    end
-  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
-  step("it should #{success}")
-end
-
-Then /^the output should contain "([^"]*)"$/ do |text|
-  last_stdout.should include(text)
-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|
-  MultiJson.load(last_stdout).should == MultiJson.load(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 /^STDERR should have warning message$/ do
-  last_stderr.should include("[warning]")
-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|
-  MultiJson.load(last_stdout).should == MultiJson.load(json_string)
-end

data/legacy_features/step_definitions/extra_steps.rb

@@ -1,2 +0,0 @@
-Given /^missing$/ do
-end

data/legacy_features/step_definitions/simplest_steps.rb

@@ -1,3 +0,0 @@
-Given /^this step works$/ do
-end
-

data/legacy_features/support/env.rb

@@ -1,161 +0,0 @@
-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_8_7 ? 'r' : {:external_encoding=>"UTF-8"}
-      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)
-    if Cucumber::JRUBY
-      # TODO: this actually a workaround for cucumber/gherkin#238
-      @last_stderr.gsub!(/^.*java_package_module_template.rb:\d+ warning: `eval' should not be aliased.*\n/, '')
-    end
-  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 2.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