cucumber 2.0.0.rc.4 → 2.0.0.rc.5

data/features/docs/wire_protocol/readme.md

@@ -0,0 +1,26 @@
+Cucumber's wire protocol allows step definitions to be
+implemented and invoked on any platform.
+
+Communication is over a TCP socket, which Cucumber connects to when it finds
+a definition file with the .wire extension in the step_definitions folder
+(or other load path). Note that these files are rendered with ERB when loaded.
+
+A WirePacket flowing in either direction is formatted as a JSON-encoded
+string, with a newline character signaling the end of a packet. See the
+specs for Cucumber::WireSupport::WirePacket for more details.
+
+Cucumber sends the following request messages out over the wire:
+
+* `step_matches` - Find out whether the wire server has a definition for a step
+* `invoke` - Ask for a step definition to be invoked
+* `begin_scenario` - signals that cucumber is about to execute a scenario
+* `end_scenario` - signals that cucumber has finished executing a scenario
+* `snippet_text` - requests a snippet for an undefined step
+
+Every message supports two standard responses:
+
+* `success` - expects different arguments (sometimes none at all) depending
+  on the request that was sent.
+* `fail` - causes a Cucumber::WireSupport::WireException to be raised.
+
+Some messages support more responses - see individual scenarios for details.

data/features/docs/wire_protocol/snippets_message.feature

@@ -0,0 +1,51 @@
+@wire
+Feature: Snippets message
+
+  If a step doesn't match, Cucumber will ask the wire server to return a snippet of code for a
+  step definition.
+
+  Background:
+    Given a file named "features/wired.feature" with:
+      """
+      Feature: High strung
+        Scenario: Wired
+          Given we're all wired
+
+      """
+    And a file named "features/step_definitions/some_remote_place.wire" with:
+      """
+      host: localhost
+      port: 54321
+
+      """
+
+  @spawn
+  Scenario: Wire server returns snippets for a step that didn't match
+    Given there is a wire server running on port 54321 which understands the following protocol:
+      | request                                                                                          | response                         |
+      | ["step_matches",{"name_to_match":"we're all wired"}]                                             | ["success",[]]                   |
+      | ["snippet_text",{"step_keyword":"Given","multiline_arg_class":"","step_name":"we're all wired"}] | ["success","foo()\n  bar;\nbaz"] |
+      | ["begin_scenario"]                                                                               | ["success"]                      |
+      | ["end_scenario"]                                                                                 | ["success"]                      |
+    When I run `cucumber -f pretty`
+    Then the stderr should not contain anything
+    And it should pass with:
+      """
+      Feature: High strung
+
+        Scenario: Wired         # features/wired.feature:2
+          Given we're all wired # features/wired.feature:3
+
+      1 scenario (1 undefined)
+      1 step (1 undefined)
+      """
+    And the output should contain:
+      """
+
+      You can implement step definitions for undefined steps with these snippets:
+
+      foo()
+        bar;
+      baz
+
+      """

data/features/docs/wire_protocol/step_matches_message.feature

@@ -0,0 +1,81 @@
+@wire
+Feature: Step matches message
+
+  When the features have been parsed, Cucumber will send a `step_matches`
+  message to ask the wire server if it can match a step name. This happens for
+  each of the steps in each of the features.
+
+  The wire server replies with an array of StepMatch objects.
+
+  When each StepMatch is returned, it contains the following data:
+
+  * `id` - identifier for the step definition to be used later when if it
+  needs to be invoked. The identifier can be any string value and
+  is simply used for the wire server's own reference.
+  * `args` - any argument values as captured by the wire end's own regular
+  expression (or other argument matching) process.
+
+  Background:
+    Given a file named "features/wired.feature" with:
+      """
+      Feature: High strung
+        Scenario: Wired
+          Given we're all wired
+
+      """
+    And a file named "features/step_definitions/some_remote_place.wire" with:
+      """
+      host: localhost
+      port: 54321
+
+      """
+
+  Scenario: Dry run finds no step match
+    Given there is a wire server running on port 54321 which understands the following protocol:
+      | request                                              | response       |
+      | ["step_matches",{"name_to_match":"we're all wired"}] | ["success",[]] |
+    When I run `cucumber --dry-run --no-snippets -f progress`
+    And it should pass with:
+      """
+      U
+
+      1 scenario (1 undefined)
+      1 step (1 undefined)
+
+      """
+
+  Scenario: Dry run finds a step match
+    Given there is a wire server running on port 54321 which understands the following protocol:
+      | request                                              | response                            |
+      | ["step_matches",{"name_to_match":"we're all wired"}] | ["success",[{"id":"1", "args":[]}]] |
+    When I run `cucumber --dry-run -f progress`
+    And it should pass with:
+      """
+      -
+
+      1 scenario (1 skipped)
+      1 step (1 skipped)
+
+      """
+
+  Scenario: Step matches returns details about the remote step definition
+
+    Optionally, the StepMatch can also contain a source reference, and a native
+    regexp string which will be used by some formatters.
+
+    Given there is a wire server running on port 54321 which understands the following protocol:
+      | request                                              | response                                                                           |
+      | ["step_matches",{"name_to_match":"we're all wired"}] | ["success",[{"id":"1", "args":[], "source":"MyApp.MyClass:123", "regexp":"we.*"}]] |
+    When I run `cucumber -f stepdefs --dry-run`
+    Then it should pass with:
+      """
+      -
+
+      we.*   # MyApp.MyClass:123
+
+      1 scenario (1 skipped)
+      1 step (1 skipped)
+
+      """
+    And the stderr should not contain anything
+

data/features/docs/{wire_protocol_table_diffing.feature → wire_protocol/table_diffing.feature}

@@ -1,5 +1,6 @@
 @wire
 Feature: Wire protocol table diffing
+
   In order to use the amazing functionality in the Cucumber table object
   As a wire server
   I want to be able to ask for a table diff during a step definition invocation

data/features/docs/{wire_protocol_tags.feature → wire_protocol/tags.feature}

@@ -1,5 +1,6 @@
 @wire
 Feature: Wire protocol tags
+
   In order to use Before and After hooks in a wire server, we send tags with the 
   scenario in the begin_scenario and end_scenario messages
 

data/features/docs/{wire_protocol_timeouts.feature → wire_protocol/timeouts.feature}

@@ -1,5 +1,6 @@
 @wire
 Feature: Wire protocol timeouts
+
   We don't want Cucumber to hang forever on a wire server that's not even there,
   but equally we need to give the user the flexibility to allow step definitions
   to take a while to execute, if that's what they need.

data/features/docs/work_in_progress.feature

@@ -148,7 +148,7 @@ Feature: Cucumber --work-in-progress switch
       The --wip switch was used, so I didn't expect anything to pass. These scenarios passed:
       (::) passed scenarios (::)
 
-      features/passing_outline.feature:7:in `Scenario Outline: Passing, Examples (row 1)'
+      features/passing_outline.feature:7:in `Scenario Outline: Passing, Examples (#1)'
 
 
       """

data/features/docs/writing_support_code/around_hooks.feature

@@ -227,3 +227,34 @@ Feature: Around hooks
       2 steps (2 passed)
 
       """
+
+  Scenario: Around Hooks and the Custom World
+    Given a file named "features/step_definitions/steps.rb" with:
+      """
+      Then /^the world should be available in the hook$/ do
+        $previous_world = self
+        expect($hook_world).to eq(self)
+      end
+
+      Then /^what$/ do
+        expect($hook_world).not_to eq($previous_world)
+      end
+      """
+    And a file named "features/support/hooks.rb" with:
+      """
+      Around do |scenario, block|
+        $hook_world = self
+        block.call
+      end
+      """
+    And a file named "features/f.feature" with:
+      """
+      Feature: Around hooks
+        Scenario: using hook
+          Then the world should be available in the hook
+
+        Scenario: using the same hook
+          Then what
+      """
+    When I run `cucumber features/f.feature`
+    Then it should pass

data/features/docs/writing_support_code/before_hook.feature

@@ -25,7 +25,8 @@ Feature: Before Hook
       """
         NAMES:
         Feature name
-        Scenario: Scenario name
+        Scenario name
+
       """
 
   Scenario: Examine names of scenario outline and feature
@@ -46,7 +47,8 @@ Feature: Before Hook
       Before do |scenario|
         names << scenario.scenario_outline.feature.name.split("\n").first
         names << scenario.scenario_outline.name.split("\n").first
-        if(names.size == 2)
+        names << scenario.name.split("\n").first
+        if(names.size == 3)
           raise "NAMES:\n" + names.join("\n") + "\n"
         end
       end
@@ -56,6 +58,8 @@ Feature: Before Hook
       """
             NAMES:
             Feature name
-            Scenario Outline: Scenario Outline name
+            Scenario Outline name, Examples Table name (#1)
+            Scenario Outline name, Examples Table name (#1)
+
       """
 

data/features/docs/writing_support_code/tagged_hooks.feature

@@ -4,7 +4,7 @@ Feature: Tagged hooks
     Given the standard step definitions
     And a file named "features/support/hooks.rb" with:
       """
-      Before('~@no-boom') do
+      Before('~@no-boom') do 
         raise 'boom'
       end
       """
@@ -17,12 +17,23 @@ Feature: Tagged hooks
         @no-boom
         Scenario: omitting hook
           Given this step passes
+
+        Scenario Outline: omitting hook on specified examples
+          Given this step passes
+
+          Examples:
+          | Value       |
+          | Irrelevant  |
+
+          @no-boom
+          Examples:
+          | Value           |
+          | Also Irrelevant |
       """
 
-  @spawn
-  Scenario: Invoke tagged hook
+  Scenario: omit tagged hook
     When I run `cucumber features/f.feature:2`
-    Then it should fail with:
+    Then it should fail with exactly:
       """
       Feature: With and without hooks
       
@@ -36,12 +47,13 @@ Feature: Tagged hooks
       
       1 scenario (1 failed)
       1 step (1 skipped)
+      0m0.012s
 
       """
 
-    Scenario: Omit tagged hook
+    Scenario: omit tagged hook
       When I run `cucumber features/f.feature:6`
-      Then it should pass with:
+      Then it should pass with exactly:
         """
         Feature: With and without hooks
 
@@ -51,7 +63,33 @@ Feature: Tagged hooks
 
         1 scenario (1 passed)
         1 step (1 passed)
+        0m0.012s
 
         """
+    Scenario: Omit example hook
+      When I run `cucumber features/f.feature:12`
+      Then it should fail with exactly:
+        """
+        Feature: With and without hooks
+
+          Scenario Outline: omitting hook on specified examples # features/f.feature:9
+            Given this step passes                              # features/f.feature:10
+
+            Examples: 
+              | Value      |
+              boom (RuntimeError)
+              ./features/support/hooks.rb:2:in `Before'
+              | Irrelevant |
 
+        Failing Scenarios:
+        cucumber features/f.feature:14 # Scenario Outline: omitting hook on specified examples, Examples (#1)
+
+        1 scenario (1 failed)
+        1 step (1 skipped)
+        0m0.012s
+
+      """
+    Scenario: 
+      When I run `cucumber features/f.feature:17`
+      Then it should pass
 

data/features/lib/step_definitions/wire_steps.rb

@@ -17,9 +17,26 @@ Given /^I have environment variable (\w+) set to "([^"]*)"$/ do |variable, value
   set_env(variable, value)
 end
 
+Then(/^the wire server should have received the following messages:$/) do |expected_messages|
+  expect(messages_received).to eq expected_messages.raw.flatten
+end
+
 module WireHelper
+  attr_reader :messages_received
+
   def start_wire_server
-    @wire_pid = fork { @server.run }
+    @messages_received = []
+    reader, writer = IO.pipe
+    @wire_pid = fork { 
+      reader.close
+      @server.run(writer)
+    }
+    writer.close
+    Thread.new do
+      while message = reader.gets
+        @messages_received << message.strip
+      end
+    end
     at_exit { stop_wire_server }
   end
 

data/features/lib/support/fake_wire_server.rb

@@ -7,9 +7,9 @@ class FakeWireServer
     @delays = {}
   end
 
-  def run
+  def run(io)
     @server = TCPServer.open(@port)
-    loop { handle_connections }
+    loop { handle_connections(io) }
   end
 
   def delay_response(message, delay)
@@ -18,13 +18,14 @@ class FakeWireServer
 
   private
 
-  def handle_connections
-    Thread.start(@server.accept) { |socket| open_session_on socket }
+  def handle_connections(io)
+    Thread.start(@server.accept) { |socket| open_session_on socket, io }
   end
 
-  def open_session_on(socket)
+  def open_session_on(socket, io)
     begin
-      SocketSession.new(socket, @protocol_table, @delays).start
+      on_message = lambda { |message| io.puts message }
+      SocketSession.new(socket, @protocol_table, @delays, on_message).start
     rescue Exception => e
       raise e
     ensure
@@ -33,10 +34,11 @@ class FakeWireServer
   end
 
   class SocketSession
-    def initialize(socket, protocol, delays)
+    def initialize(socket, protocol, delays, on_message)
       @socket = socket
       @protocol = protocol
       @delays = delays
+      @on_message = on_message
     end
 
     def start
@@ -50,6 +52,7 @@ class FakeWireServer
     def handle(data)
       if protocol_entry = response_to(data.strip)
         sleep delay(data)
+        @on_message.call(MultiJson.load(protocol_entry['request'])[0])
         send_response(protocol_entry['response'])
       else
         serialized_exception = { :message => "Not understood: #{data}", :backtrace => [] }

data/lib/cucumber.rb

@@ -1,7 +1,5 @@
-$:.unshift(File.dirname(__FILE__)) unless
-  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
-
 require 'yaml'
+require 'cucumber/encoding'
 require 'cucumber/platform'
 require 'cucumber/runtime'
 require 'cucumber/cli/main'

data/lib/cucumber/cli/options.rb

@@ -1,6 +1,7 @@
 require 'cucumber/cli/profile_loader'
 require 'cucumber/formatter/ansicolor'
 require 'cucumber/rb_support/rb_language'
+require 'cucumber/project_initializer'
 
 module Cucumber
   module Cli
@@ -126,6 +127,12 @@ module Cucumber
             *FORMAT_HELP) do |v|
             @options[:formats] << [v, @out_stream]
           end
+          opts.on('--init',
+            'Initializes folder structure and generates conventional files for',
+            'a Cucumber project.') do |v|
+            ProjectInitializer.new.run
+            Kernel.exit(0)
+          end
           opts.on("-o", "--out [FILE|DIR]",
             "Write output to a file/directory instead of STDOUT. This option",
             "applies to the previously specified --format, or the",