kbaum-cucumber 0.4.5.pre

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,63 @@
+require 'socket'
+require 'json'
+
+class FakeWireServer
+  def initialize(port, protocol_table)
+    @port, @protocol_table = port, protocol_table
+  end
+
+  def run
+    @server = TCPServer.open(@port)
+    loop { handle_connections }
+  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).start
+    rescue Exception => e
+      raise e
+    ensure
+      socket.close
+    end
+  end
+  
+  class SocketSession
+    def initialize(socket, protocol)
+      @socket = socket
+      @protocol = protocol
+    end
+
+    def start
+      while message = @socket.gets
+        handle(message)
+      end
+    end
+
+    private
+    
+    def handle(data)
+      if protocol_entry = response_to(data.strip)
+        send_response(protocol_entry['response'])
+      else
+        serialized_exception = { :message => "Not understood: #{data}", :backtrace => [] }
+        send_response(['fail', serialized_exception ].to_json)
+      end
+    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
+  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|
+        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,35 @@
+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:/ do |table|
+        table.map_headers!(/who/i => 'Who')
+        table.map_column!('Who') { |who| "Cuke" }
+        table.hashes[0]['Who'] = "Joe"
+        table.hashes.should == [{"Who"=>"Joe"}]
+      end
+      """
+    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,@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 -t @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)
+
+      """

data/features/transform.feature

@@ -0,0 +1,245 @@
+Feature: transform
+  In order to maintain modularity within step definitions
+  As a step definition editor
+  I want to register a regex to capture and tranform step definition arguments.
+
+  Background:         
+    Given a standard Cucumber project directory structure
+    And a file named "features/step_definitions/steps.rb" with:
+      """
+      Then /^I should transform ('\d+' to an Integer)$/ do |integer|
+        integer.should be_kind_of(Integer)
+      end
+
+      Then /^I should transform ('\w+' to a Symbol)$/ do |symbol|
+        symbol.should be_kind_of(Symbol)
+      end
+
+      Then /^I should transform ('\d+' to a Float)$/ do |float|
+        float.should be_kind_of(Float)
+      end
+
+      Then /^I should transform ('\w+' to an Array)$/ do |array|
+        array.should be_kind_of(Array)
+      end
+
+      Then /^I should transform ('\w+' to Nil)$/ do |string|
+        string.should be_nil
+      end
+
+      Then /^I should not transform ('\d+') to an Integer$/ do |string|
+        string.should be_kind_of(String)
+      end
+
+      Then /^I should transform ((?:nothing|'\d+') to an optional Integer)$/ do |integer|
+        integer.should be_nil
+      end
+      """
+    And a file named "features/support/env.rb" with:
+      """
+      Transform /^'\d+' to an Integer$/ do |step_arg|
+        /'(\d+)' to an Integer/.match(step_arg).captures[0].to_i
+      end
+
+      Transform /^(?:nothing|'(\d+)') to an optional Integer$/ do |str|
+        str ? str.to_i : nil
+      end
+
+      Transform /^'(\d+)' to a Float$/ do |integer_string|
+        Transform("'#{integer_string}' to an Integer").to_f
+      end
+
+      Transform(/^('\w+') to Nil$/) {|str| nil }
+
+      Transform(/^('\w+') to a Symbol$/) {|str| str.to_sym }
+
+      module MyHelpers
+        def fetch_array
+          @array
+        end
+      end
+
+      World(MyHelpers)
+
+      Before do
+        @array = []
+      end
+
+      Transform(/^('\w+') to an Array$/) {|str| fetch_array }
+      """
+      
+  Scenario: run a specific scenario with a registered transform
+    Given a file named "features/transform_sample.feature" with:
+      """
+      Feature: Step argument transformations
+
+        Scenario: transform with matches
+          Then I should transform '10' to an Integer
+
+        Scenario: transform with matches that capture
+          Then I should transform 'abc' to a Symbol
+
+        Scenario: transform with matches that reuse transforms
+          Then I should transform '10' to a Float
+
+        Scenario: transform with matches that use current world
+          Then I should transform 'abc' to an Array
+
+        Scenario: transform with matches that return nil
+          Then I should transform 'nil' to Nil
+
+        Scenario: transform without matches
+          Then I should not transform '10' to an Integer
+
+        Scenario: transform with optional arguments not given
+          Then I should transform nothing to an optional Integer
+      """
+    When I run cucumber --backtrace -s features
+    Then it should pass with
+      """
+      Feature: Step argument transformations
+    
+        Scenario: transform with matches
+          Then I should transform '10' to an Integer
+
+        Scenario: transform with matches that capture
+          Then I should transform 'abc' to a Symbol
+
+        Scenario: transform with matches that reuse transforms
+          Then I should transform '10' to a Float
+
+        Scenario: transform with matches that use current world
+          Then I should transform 'abc' to an Array
+
+        Scenario: transform with matches that return nil
+          Then I should transform 'nil' to Nil
+
+        Scenario: transform without matches
+          Then I should not transform '10' to an Integer
+
+        Scenario: transform with optional arguments not given
+          Then I should transform nothing to an optional Integer
+
+      7 scenarios (7 passed)
+      7 steps (7 passed)
+    
+      """
+
+  Scenario: run a table scenario with an unrelated registered transform
+    Given a file named "features/transform_sample.feature" with:
+      """
+      Feature: Step argument transformations
+
+        Scenario: A table
+          Then I should check the following table:
+            | letter | letter_plus_a |
+            |      r |            ra |
+            |      m |            ma |
+            |      p |            pa |
+      """
+    And a file named "features/support/table.rb" with:
+      """
+      Transform /^table:number,number_plus_a$/ do |table|
+        :not_what_you_were_expecting
+      end
+
+      Then "I should check the following table:" do |table|
+        table.hashes.each do |hash|
+          hash['letter_plus_a'].should == (hash['letter'] + 'a')
+        end
+      end
+      """
+    When I run cucumber -s features
+    Then it should pass with
+      """
+      Feature: Step argument transformations
+
+        Scenario: A table
+          Then I should check the following table:
+            | letter | letter_plus_a |
+            | r      | ra            |
+            | m      | ma            |
+            | p      | pa            |
+
+      1 scenario (1 passed)
+      1 step (1 passed)
+
+      """
+
+  Scenario: run a table scenario with an related registered transform not using table
+    Given a file named "features/transform_sample.feature" with:
+      """
+      Feature: Step argument transformations
+
+        Scenario: A table
+          Then I should check the following table:
+            | letter | letter_plus_a |
+            |      r |            ra |
+            |      m |            ma |
+            |      p |            pa |
+      """
+    And a file named "features/support/table.rb" with:
+      """
+      Transform /^table:letter,letter_plus_a$/ do |table|
+        1
+      end
+
+      Then "I should check the following table:" do |columns|
+        columns.should == 1
+      end
+      """
+    When I run cucumber -s features
+    Then it should pass with
+      """
+      Feature: Step argument transformations
+
+        Scenario: A table
+          Then I should check the following table:
+            | letter | letter_plus_a |
+            | r      | ra            |
+            | m      | ma            |
+            | p      | pa            |
+
+      1 scenario (1 passed)
+      1 step (1 passed)
+
+      """
+
+  Scenario: run a table scenario with an related registered transform using table
+    Given a file named "features/transform_sample.feature" with:
+      """
+      Feature: Step argument transformations
+
+        Scenario: A table
+          Then I should check the following table:
+            | letter | letter_plus_a |
+            |      r |            ra |
+            |      m |            ma |
+            |      p |            pa |
+      """
+    And a file named "features/support/table.rb" with:
+      """
+      Transform /^table:letter,letter_plus_a$/ do |table|
+        table.rows.map { |row| row.join(',') }
+      end
+
+      Then "I should check the following table:" do |rows_in_table|
+        rows_in_table.should == ['r,ra','m,ma','p,pa']
+      end
+      """
+    When I run cucumber -b -s features
+    Then it should pass with
+      """
+      Feature: Step argument transformations
+
+        Scenario: A table
+          Then I should check the following table:
+            | letter | letter_plus_a |
+            | r      | ra            |
+            | m      | ma            |
+            | p      | pa            |
+
+      1 scenario (1 passed)
+      1 step (1 passed)
+
+      """