cucumber 0.8.5 → 0.8.6

data/features/rake_task.feature

@@ -1,152 +0,0 @@
-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

@@ -1,34 +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/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

@@ -1,45 +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/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

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

data/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/features/snippets_when_using_star_keyword.feature

@@ -1,36 +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
-
-  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/extra_steps.rb

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

data/features/step_definitions/simplest_steps.rb

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

data/features/step_definitions/wire_steps.rb

@@ -1,32 +0,0 @@
-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.simplest

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

@@ -1,77 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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)
-
-      """