cucumber 0.8.6 → 0.8.7

data/features/rake_task.feature

@@ -0,0 +1,152 @@
+Feature: Rake task
+  In order to ease the development process
+  As a developer and CI server administrator
+  Cucumber features should be executable via Rake
+
+  Background:
+    Given a standard Cucumber project directory structure
+    And a file named "features/missing_step_definitions.feature" with:
+      """
+      Feature: Sample
+
+        Scenario: Wanted
+          Given I want to run this
+
+        Scenario: Unwanted
+          Given I don't want this ran
+      """
+
+
+  Scenario: rake task with a defined profile
+    Given the following profile is defined:
+      """
+      foo: --quiet --no-color features/missing_step_definitions.feature:3
+      """
+    And a file named "Rakefile" with:
+      """
+      $LOAD_PATH.unshift(CUCUMBER_LIB)
+      require 'cucumber/rake/task'
+
+      Cucumber::Rake::Task.new do |t|
+        t.profile = "foo"
+      end
+      """
+    When I run rake cucumber
+    Then it should pass
+    And the output should contain
+      """
+      Feature: Sample
+
+        Scenario: Wanted
+          Given I want to run this
+
+      1 scenario (1 undefined)
+      1 step (1 undefined)
+      """
+
+    Scenario: rake task without a profile
+      Given a file named "Rakefile" with:
+        """
+        $LOAD_PATH.unshift(CUCUMBER_LIB)
+        require 'cucumber/rake/task'
+
+        Cucumber::Rake::Task.new do |t|
+          t.cucumber_opts = %w{--quiet --no-color}
+        end
+        """
+      When I run rake cucumber
+      Then it should pass
+      And the output should contain
+        """
+        Feature: Sample
+
+          Scenario: Wanted
+            Given I want to run this
+
+          Scenario: Unwanted
+            Given I don't want this ran
+
+        2 scenarios (2 undefined)
+        2 steps (2 undefined)
+        """
+
+  Scenario: rake task with a defined profile and cucumber_opts
+    Given the following profile is defined:
+      """
+      bar: ['features/missing_step_definitions.feature:3']
+      """
+    And a file named "Rakefile" with:
+      """
+      $LOAD_PATH.unshift(CUCUMBER_LIB)
+      require 'cucumber/rake/task'
+
+      Cucumber::Rake::Task.new do |t|
+        t.profile = "bar"
+        t.cucumber_opts = %w{--quiet --no-color}
+      end
+      """
+    When I run rake cucumber
+    Then it should pass
+    And the output should contain
+      """
+      Feature: Sample
+
+        Scenario: Wanted
+          Given I want to run this
+
+      1 scenario (1 undefined)
+      1 step (1 undefined)
+      """
+
+  Scenario: respect requires
+    Given a file named "features/support/env.rb"
+    And a file named "features/support/dont_require_me.rb"
+    And the following profile is defined:
+      """
+      no_bomb: features/missing_step_definitions.feature:3 --require features/support/env.rb --verbose
+      """
+    And a file named "Rakefile" with:
+      """
+      $LOAD_PATH.unshift(CUCUMBER_LIB)
+      require 'cucumber/rake/task'
+
+      Cucumber::Rake::Task.new do |t|
+        t.profile = "no_bomb"
+        t.cucumber_opts = %w{--quiet --no-color}
+      end
+      """
+
+    When I run rake cucumber
+    Then it should pass
+    And the output should not contain
+      """
+        * features/support/dont_require_me.rb
+      """
+
+  Scenario: feature files with spaces
+    Given a file named "features/spaces are nasty.feature" with:
+       """
+       Feature: The futures green
+
+         Scenario: Orange
+           Given this is missing
+       """
+    And a file named "Rakefile" with:
+       """
+       $LOAD_PATH.unshift(CUCUMBER_LIB)
+       require 'cucumber/rake/task'
+
+       Cucumber::Rake::Task.new do |t|
+         t.cucumber_opts = %w{--quiet --no-color}
+       end
+       """
+    When I run rake cucumber
+    Then it should pass
+    And the output should contain
+       """
+       Feature: The futures green
+
+         Scenario: Orange
+           Given this is missing
+
+       """

data/features/report_called_undefined_steps.feature

@@ -0,0 +1,34 @@
+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/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/features/rerun_formatter.feature

@@ -0,0 +1,45 @@
+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/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
+    Then it should fail with
+      """
+      features/sample.feature:3:6:9
+
+      """

data/features/simplest.feature

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

data/features/snippet.feature

@@ -0,0 +1,23 @@
+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/features/snippets_when_using_star_keyword.feature

@@ -0,0 +1,36 @@
+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
+
+  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/features/step_definitions/cucumber_steps.rb

@@ -1,14 +1,160 @@
-When /^I run cucumber "(.+)"$/ do |cmd|
-  run_simple(unescape("cucumber #{cmd}"), false)
-end
+# encoding: utf-8
+require 'tempfile'
 
-Then /^it should (pass|fail) with JSON:$/ do |pass_fail, json|
-  JSON.parse(all_stdout).should == JSON.parse(json)
-  assert_success(pass_fail == 'pass')
+Given /^I am in (.*)$/ do |example_dir_relative_path|
+  @current_dir = fixtures_dir(example_dir_relative_path)
 end
 
-Given /^a directory without standard Cucumber project directory structure$/ do
+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} -r rubygems #{Cucumber::BINARY} --no-color #{cucumber_opts} CUCUMBER_OUTPUT_ENCODING=UTF-8"
+end
+
+When /^I run rake (.*)$/ do |rake_opts|
+  run "rake #{rake_opts} --trace"
+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|
+  combined_output.should =~ Regexp.compile(Regexp.escape(output))
+  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
+
+