cucumber 0.8.6 → 0.8.7

data/features/step_definitions/extra_steps.rb

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

data/features/step_definitions/simplest_steps.rb

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

data/features/step_definitions/wire_steps.rb

@@ -0,0 +1,32 @@
+Given /^there is a wire server (running |)on port (\d+) which understands the following protocol:$/ do |running, port, table|
+  protocol = table.hashes
+  @server = FakeWireServer.new(port.to_i, protocol)
+  start_wire_server if running.strip == "running"
+end
+
+Given /^the wire server takes (.*) seconds to respond to the invoke message$/ do |timeout|
+  @server.delay_response(:invoke, timeout.to_f)
+  start_wire_server
+end
+
+module WireHelper
+  def start_wire_server
+    @wire_pid = fork do
+      @server.run
+    end
+  end
+  
+  def stop_wire_server
+    return unless @wire_pid
+    Process.kill('KILL', @wire_pid)
+    Process.wait
+  end
+end
+
+Before('@wire') do
+  extend(WireHelper)
+end
+
+After('@wire') do
+  stop_wire_server
+end

data/features/support/env.rb

@@ -1,26 +1,148 @@
-ENV['FORCE_COLOR'] = 'true'
-require 'aruba/api'
-require 'aruba/cucumber'
+require 'rubygems'
+require 'tempfile'
+begin
+  require 'rspec/expectations'
+rescue LoadError
+  require 'spec/expectations'
+end
+require 'fileutils'
+require 'forwardable'
+require 'cucumber/formatter/unicode'
+
+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
+
+  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
 
-# Monkey patch aruba to filter out some stuff
-module Aruba::Api
-  alias __all_stdout all_stdout
-  
-  def all_stdout
-    unrandom(__all_stdout)
+  def replace_junit_duration(s, replacement)
+    s.gsub(/\d+\.\d\d+/m, replacement)
   end
 
-  def unrandom(out)
-    out = out.gsub(/#{Dir.pwd}\/tmp\/aruba/, '.') # Remove absolute paths
-    out = out.gsub(/^\d+m\d+\.\d+s$/, '0m0.012s') # Make duration predictable
-    out = out.gsub(/Coverage report generated for Cucumber Features to #{Dir.pwd}\/coverage.*\n$/, '') # Remove SimpleCov message
+  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
-  # Make sure bin/cucumber runs with SimpleCov enabled
-  # set_env('SIMPLECOV', 'true')
-  
-  # Set a longer timeout for aruba
-  @aruba_timeout_seconds = 5
+  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

data/features/support/env.rb.simplest

@@ -0,0 +1,7 @@
+require 'rubygems'
+
+class SomeException < Exception; end
+
+Before do
+  raise SomeException.new("I cannot even start this scenario")
+end

data/features/support/fake_wire_server.rb

@@ -0,0 +1,77 @@
+require 'socket'
+require 'json'
+
+class FakeWireServer
+  def initialize(port, protocol_table)
+    @port, @protocol_table = port, protocol_table
+    @delays = {}
+  end
+
+  def run
+    @server = TCPServer.open(@port)
+    loop { handle_connections }
+  end
+  
+  def delay_response(message, delay)
+    @delays[message] = delay
+  end
+
+  private
+
+  def handle_connections
+    Thread.start(@server.accept) { |socket| open_session_on socket }
+  end
+
+  def open_session_on(socket)
+    begin
+      SocketSession.new(socket, @protocol_table, @delays).start
+    rescue Exception => e
+      raise e
+    ensure
+      socket.close
+    end
+  end
+  
+  class SocketSession
+    def initialize(socket, protocol, delays)
+      @socket = socket
+      @protocol = protocol
+      @delays = delays
+    end
+
+    def start
+      while message = @socket.gets
+        handle(message)
+      end
+    end
+
+    private
+    
+    def handle(data)
+      if protocol_entry = response_to(data.strip)
+        sleep delay(data)
+        send_response(protocol_entry['response'])
+      else
+        serialized_exception = { :message => "Not understood: #{data}", :backtrace => [] }
+        send_response(['fail', serialized_exception ].to_json)
+      end
+    rescue => e
+      send_response(['fail', { :message => e.message, :backtrace => e.backtrace, :exception => e.class } ].to_json)
+    end
+
+    def response_to(data)
+      @protocol.detect do |entry| 
+        JSON.parse(entry['request']) == JSON.parse(data)
+      end
+    end
+
+    def send_response(response)
+      @socket.puts response + "\n"
+    end
+    
+    def delay(data)
+      message = JSON.parse(data.strip)[0]
+      @delays[message.to_sym] || 0
+    end
+  end
+end

data/features/table_diffing.feature

@@ -0,0 +1,45 @@
+Feature: Table diffing
+  In order to more easily compare data in tables
+  step definition writers should be able to diff
+  a table with expected data and see the diff inline
+  
+  Scenario: Extra row
+    Given a standard Cucumber project directory structure
+    And a file named "features/tables.feature" with:
+      """
+      Feature: Tables
+        Scenario: Extra row
+          Then the table should be:
+            | x | y |
+            | a | b |
+      """
+    And a file named "features/step_definitions/table_steps.rb" with:
+      """
+      Then /the table should be:/ do |expected| x=1
+        expected.diff!(table(%{
+          | x | y | 
+          | a | c |
+        }))
+      end
+      """
+    When I run cucumber -i features/tables.feature
+    Then it should fail with
+      """
+      Feature: Tables
+      
+        Scenario: Extra row         # features/tables.feature:2
+          Then the table should be: # features/step_definitions/table_steps.rb:1
+            | x | y |
+            | a | b |
+            | a | c |
+            Tables were not identical (Cucumber::Ast::Table::Different)
+            ./features/step_definitions/table_steps.rb:2:in `/the table should be:/'
+            features/tables.feature:3:in `Then the table should be:'
+      
+      Failing Scenarios:
+      cucumber features/tables.feature:2 # Scenario: Extra row
+
+      1 scenario (1 failed)
+      1 step (1 failed)
+
+      """

data/features/table_mapping.feature

@@ -0,0 +1,34 @@
+Feature: Table mapping
+  Scenario: Mapping table shouldn't change output
+    Given a standard Cucumber project directory structure
+    And a file named "features/f.feature" with:
+      """
+      Feature: F
+        Scenario: S
+          Given a table:
+            | who   |
+            | aslak |
+      """
+    And a file named "features/step_definitions/steps.rb" with:
+      """
+      Given(/a table:/) { |table| table.map_headers!(/who/i => 'Who')
+        table.map_column!('Who') { |who| "Cuke" }
+        table.hashes[0]['Who'] = "Joe"
+        table.hashes.should == [{"Who"=>"Joe"}]
+      }
+      """
+    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
+          Given a table: # features/step_definitions/steps.rb:1
+            | who   |
+            | aslak |
+
+      1 scenario (1 passed)
+      1 step (1 passed)
+      
+      """

data/features/tag_logic.feature

@@ -0,0 +1,258 @@
+Feature: Tag logic
+  In order to conveniently run subsets of features
+  As a Cuker
+  I want to select features using logical AND/OR of tags
+
+  Background:
+    Given a standard Cucumber project directory structure
+    And a file named "features/tagulicious.feature" with:
+      """
+      Feature: Sample
+
+        @one @three
+        Scenario: Example
+          Given passing
+
+        @one
+        Scenario: Another Example
+          Given passing
+
+        @three
+        Scenario: Yet another Example
+          Given passing
+
+        @ignore
+        Scenario: And yet another Example
+      """
+
+  Scenario: ANDing tags
+    When I run cucumber -q -t @one -t @three features/tagulicious.feature
+    Then it should pass
+    And the output should contain
+      """
+      Feature: Sample
+
+        @one @three
+        Scenario: Example
+          Given passing
+
+      1 scenario (1 undefined)
+      1 step (1 undefined)
+
+      """
+
+  Scenario: ORing tags
+    When I run cucumber -q -t @one,@three features/tagulicious.feature
+    Then it should pass
+    And the output should contain
+      """
+      Feature: Sample
+
+        @one @three
+        Scenario: Example
+          Given passing
+
+        @one
+        Scenario: Another Example
+          Given passing
+
+        @three
+        Scenario: Yet another Example
+          Given passing
+
+      3 scenarios (3 undefined)
+      3 steps (3 undefined)
+
+      """
+
+  Scenario: Before hooks ORing
+    Given a file named "features/support/hooks.rb" with:
+      """
+      Before('@one,@three') do
+        raise 'boom'
+      end
+      """
+    When I run cucumber -q features/tagulicious.feature
+    Then it should fail with
+      """
+      Feature: Sample
+
+        @one @three
+        Scenario: Example
+       boom (RuntimeError)
+       ./features/support/hooks.rb:2:in `Before'
+          Given passing
+
+        @one
+        Scenario: Another Example
+       boom (RuntimeError)
+       ./features/support/hooks.rb:2:in `Before'
+          Given passing
+
+        @three
+        Scenario: Yet another Example
+       boom (RuntimeError)
+       ./features/support/hooks.rb:2:in `Before'
+          Given passing
+
+        @ignore
+        Scenario: And yet another Example
+
+      Failing Scenarios:
+      cucumber features/tagulicious.feature:4 # Scenario: Example
+      cucumber features/tagulicious.feature:8 # Scenario: Another Example
+      cucumber features/tagulicious.feature:12 # Scenario: Yet another Example
+
+      4 scenarios (3 failed, 1 passed)
+      3 steps (3 undefined)
+
+      """
+
+  Scenario: Before hooks ANDing
+    Given a file named "features/support/hooks.rb" with:
+      """
+      Before('@one','@three') do
+        raise 'boom'
+      end
+      """
+    When I run cucumber -q features/tagulicious.feature
+    Then it should fail with
+      """
+      Feature: Sample
+
+        @one @three
+        Scenario: Example
+       boom (RuntimeError)
+       ./features/support/hooks.rb:2:in `Before'
+          Given passing
+
+        @one
+        Scenario: Another Example
+          Given passing
+
+        @three
+        Scenario: Yet another Example
+          Given passing
+
+        @ignore
+        Scenario: And yet another Example
+
+      Failing Scenarios:
+      cucumber features/tagulicious.feature:4 # Scenario: Example
+
+      4 scenarios (1 failed, 2 undefined, 1 passed)
+      3 steps (3 undefined)
+
+      """
+
+  Scenario: Before hooks ANDing with a bad hook matching nothing
+    Given a file named "features/support/hooks.rb" with:
+      """
+      Before('@one','@notused') do
+        raise 'boom'
+      end
+      """
+    When I run cucumber -q features/tagulicious.feature
+    Then it should pass with
+      """
+      Feature: Sample
+
+        @one @three
+        Scenario: Example
+          Given passing
+
+        @one
+        Scenario: Another Example
+          Given passing
+
+        @three
+        Scenario: Yet another Example
+          Given passing
+
+        @ignore
+        Scenario: And yet another Example
+
+      4 scenarios (3 undefined, 1 passed)
+      3 steps (3 undefined)
+
+      """
+
+  Scenario: After hooks ORing
+    Given a file named "features/support/hooks.rb" with:
+      """
+      After('@one,@three') do
+        raise 'boom'
+      end
+      """
+    When I run cucumber -q features/tagulicious.feature
+    Then it should fail with
+      """
+      Feature: Sample
+
+        @one @three
+        Scenario: Example
+          Given passing
+            boom (RuntimeError)
+            ./features/support/hooks.rb:2:in `After'
+
+        @one
+        Scenario: Another Example
+          Given passing
+            boom (RuntimeError)
+            ./features/support/hooks.rb:2:in `After'
+
+        @three
+        Scenario: Yet another Example
+          Given passing
+            boom (RuntimeError)
+            ./features/support/hooks.rb:2:in `After'
+
+        @ignore
+        Scenario: And yet another Example
+
+      Failing Scenarios:
+      cucumber features/tagulicious.feature:4 # Scenario: Example
+      cucumber features/tagulicious.feature:8 # Scenario: Another Example
+      cucumber features/tagulicious.feature:12 # Scenario: Yet another Example
+
+      4 scenarios (3 failed, 1 passed)
+      3 steps (3 undefined)
+
+      """
+
+  Scenario: After hooks ANDing
+    Given a file named "features/support/hooks.rb" with:
+      """
+      After('@one','@three') do
+        raise 'boom'
+      end
+      """
+    When I run cucumber -q features/tagulicious.feature
+    Then it should fail with
+      """
+      Feature: Sample
+
+        @one @three
+        Scenario: Example
+          Given passing
+            boom (RuntimeError)
+            ./features/support/hooks.rb:2:in `After'
+
+        @one
+        Scenario: Another Example
+          Given passing
+
+        @three
+        Scenario: Yet another Example
+          Given passing
+
+        @ignore
+        Scenario: And yet another Example
+
+      Failing Scenarios:
+      cucumber features/tagulicious.feature:4 # Scenario: Example
+
+      4 scenarios (1 failed, 2 undefined, 1 passed)
+      3 steps (3 undefined)
+
+      """