square-cucumber 0.3.12.2

data/features/junit_formatter.feature

@@ -0,0 +1,71 @@
+Feature: JUnit output formatter
+  In order for developers to create test reports with ant
+  Cucumber should be able to output JUnit xml files
+  
+  Background:
+    Given I am in junit
+    And the tmp directory is empty
+  
+  @mri186 @diffxml
+  Scenario: one feature, one passing scenario, one failing scenario
+    When I run cucumber --format junit --out tmp/ features/one_passing_one_failing.feature
+    Then it should fail with
+      """
+
+      """
+    And "examples/junit/tmp/TEST-one_passing_one_failing.xml" should contain XML
+      """
+      <?xml version="1.0" encoding="UTF-8"?>
+      <testsuite errors="0" tests="2" name="One passing scenario, one failing scenario" failures="1">
+      <testcase name="Given a passing scenario" classname="One passing scenario, one failing scenario.Passing">
+      </testcase>
+      <testcase name="Given a failing scenario" classname="One passing scenario, one failing scenario.Failing">
+        <failure message="Given a failing scenario">
+       (RuntimeError)
+      ./features/step_definitions/steps.rb:6:in `/a failing scenario/'
+      features/one_passing_one_failing.feature:7:in `Given a failing scenario'  </failure>
+      </testcase>
+      </testsuite>
+      
+      """
+  
+  @mri186 @diffxml
+  Scenario: pending step
+    When I run cucumber --format junit --out tmp/ features/pending.feature
+    Then it should pass with
+      """
+      
+      """
+    And "examples/junit/tmp/TEST-pending.xml" should contain XML
+      """
+      <?xml version="1.0" encoding="UTF-8"?>
+      <testsuite errors="0" tests="1" name="Pending step" failures="1">
+      <testcase name="Given a pending step" classname="Pending step.Pending">
+        <failure message="Given a pending step">
+      TODO (Cucumber::Pending)
+      ./features/step_definitions/steps.rb:10:in `/a pending step/'
+      features/pending.feature:4:in `Given a pending step'  </failure>
+      </testcase>
+      </testsuite>
+      
+      """
+    
+  Scenario: run all features
+    When I run cucumber --format junit --out tmp/ features
+    Then it should fail with
+      """
+      
+      """
+    And "examples/junit/tmp/TEST-one_passing_one_failing.xml" should exist
+    And "examples/junit/tmp/TEST-pending.xml" should exist
+  
+  Scenario: show correct error message if no --out is passed
+    When I run cucumber --format junit features
+	  Then STDERR should not match 
+		  """
+can't convert .* into String \(TypeError\)
+		  """
+    And STDERR should match
+		  """
+You \*must\* specify \-\-out DIR for the junit formatter
+	    """

data/features/language_from_header.feature

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

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

@@ -0,0 +1,150 @@
+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(:features) do |t|
+        t.profile = "foo"
+      end
+      """
+    When I run rake features
+    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 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(:features) do |t|
+        t.profile = "bar"
+        t.cucumber_opts = %w{--quiet --no-color}
+      end
+      """
+    When I run rake features
+    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 with a defined profile and feature list
+    Given a file named "features/the_one_i_want_to_run.feature" with:
+      """
+      Feature: Desired
+
+        Scenario: Something
+          Given this is missing
+      """
+    Given the following profile is defined:
+      """
+      baz: ['--quiet', '--no-color']
+      """
+    And a file named "Rakefile" with:
+      """
+      $LOAD_PATH.unshift(CUCUMBER_LIB)
+      require 'cucumber/rake/task'
+
+      Cucumber::Rake::Task.new(:features) do |t|
+        t.profile = "baz"
+        t.feature_list = ['features/the_one_i_want_to_run.feature']
+      end
+      """
+    When I run rake features
+    Then it should pass
+    And the output should contain
+      """
+      Feature: Desired
+
+        Scenario: Something
+          Given this is missing
+
+      1 scenario (1 undefined)
+      1 step (1 undefined)
+      """
+
+  Scenario: deprecation warnings
+    Given a file named "Rakefile" with:
+      """
+      $LOAD_PATH.unshift(CUCUMBER_LIB)
+      require 'cucumber/rake/task'
+
+      Cucumber::Rake::Task.new(:features) do |t|
+        t.feature_list = ['features/missing_step_definitions.feature']
+      end
+      """
+    When I run rake features
+    Then it should pass
+    And STDERR should match
+      """
+      Cucumber::Rake::Task#feature_list is deprecated and will be removed in 0.4.0.  Please use profiles for complex settings: http://wiki.github.com/aslakhellesoy/cucumber/using-rake#profiles
+      """
+
+  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(:features) do |t|
+        t.profile = "no_bomb"
+        t.cucumber_opts = %w{--quiet --no-color}
+      end
+      """
+
+    When I run rake features
+    Then it should pass
+    And the output should not contain
+      """
+        * features/support/dont_require_me.rb
+      """

data/features/report_called_undefined_steps.feature

@@ -0,0 +1,35 @@
+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
+
+  @mri186
+  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:20: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:20: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
+      end
+
+
+      """
+

data/features/snippet.feature

@@ -0,0 +1,22 @@
+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
+      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
+      end
+      """

data/features/step_definitions/cucumber_steps.rb

@@ -0,0 +1,130 @@
+require 'tempfile'
+
+Given /^I am in (.*)$/ do |example_dir_relative_path|
+  @current_dir = examples_dir(example_dir_relative_path)
+end
+
+Given /^a standard Cucumber project directory structure$/ do
+  @current_dir = working_dir
+  in_current_dir do
+    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 not running (?:.*) in the background$/ do
+  # no-op
+end
+
+
+When /^I run cucumber (.*)$/ do |cucumber_opts|
+  run "#{Cucumber::RUBY_BINARY} #{Cucumber::BINARY} --no-color #{cucumber_opts}"
+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|
+  last_stdout.should == 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 /^"(.*)" should contain XML$/ do |file, xml|
+  t = Tempfile.new('cucumber-junit')
+  t.write(xml)
+  t.flush
+  t.close
+  cmd = "diffxml #{t.path} #{file}"
+  diff = `#{cmd}`
+  if diff =~ /<delta>/m
+    raise diff + "\nXML WAS:\n" + IO.read(file)
+  end
+end
+
+Then /^"(.*)" should contain$/ do |file, text|
+  strip_duration(IO.read(file)).should == text
+end
+
+Then /^"(.*)" should match$/ do |file, text|
+  IO.read(file).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! Remember to update duration afterwards.
+  # 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 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
+