cucumber-wire 0.0.1

data/features/step_definitions/aruba_steps.rb

@@ -0,0 +1 @@
+require "aruba/cucumber"

data/features/step_definitions/wire_steps.rb

@@ -0,0 +1,58 @@
+Given /^there is a wire server (running |)on port (\d+) which understands the following protocol:$/ do |running, port, table|
+  protocol = table.hashes.map do |table_hash|
+    table_hash['response'] = table_hash['response'].gsub(/\n/, '\n')
+    table_hash
+  end
+
+  @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
+
+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
+    @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
+
+  def stop_wire_server
+    return unless @wire_pid
+    Process.kill('KILL', @wire_pid)
+    Process.wait(@wire_pid)
+  rescue Errno::ESRCH
+    # No such process - wire server has already been stopped by the After hook
+  end
+end
+
+Before do
+  extend(WireHelper)
+end
+
+After do
+  stop_wire_server
+end

data/features/step_matches_message.feature

@@ -0,0 +1,79 @@
+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/support/fake_wire_server.rb

@@ -0,0 +1,80 @@
+require 'multi_json'
+require 'socket'
+
+class FakeWireServer
+  def initialize(port, protocol_table)
+    @port, @protocol_table = port, protocol_table
+    @delays = {}
+  end
+
+  def run(io)
+    @server = TCPServer.open(@port)
+    loop { handle_connections(io) }
+  end
+
+  def delay_response(message, delay)
+    @delays[message] = delay
+  end
+
+  private
+
+  def handle_connections(io)
+    Thread.start(@server.accept) { |socket| open_session_on socket, io }
+  end
+
+  def open_session_on(socket, io)
+    begin
+      on_message = lambda { |message| io.puts message }
+      SocketSession.new(socket, @protocol_table, @delays, on_message).start
+    rescue Exception => e
+      raise e
+    ensure
+      socket.close
+    end
+  end
+
+  class SocketSession
+    def initialize(socket, protocol, delays, on_message)
+      @socket = socket
+      @protocol = protocol
+      @delays = delays
+      @on_message = on_message
+    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)
+        @on_message.call(MultiJson.load(protocol_entry['request'])[0])
+        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|
+        MultiJson.load(entry['request']) == MultiJson.load(data)
+      end
+    end
+
+    def send_response(response)
+      @socket.puts response + "\n"
+    end
+
+    def delay(data)
+      message = MultiJson.load(data.strip)[0]
+      @delays[message.to_sym] || 0
+    end
+  end
+end

data/features/table_diffing.feature

@@ -0,0 +1,124 @@
+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
+
+  Background:
+    Given a file named "features/wired.feature" with:
+      """
+      Feature: Hello
+        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: Invoke a step definition tries to diff the table and fails
+    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":[]}]]                                                                  |
+      | ["begin_scenario"]                                   | ["success"]                                                                                          |
+      | ["invoke",{"id":"1","args":[]}]                      | ["diff",[[["a","b"],["c","d"]],[["x","y"],["z","z"]]]]                                               |
+      | ["diff_failed"]                                      | ["fail",{"message":"Not same", "exception":"DifferentException", "backtrace":["a.cs:12","b.cs:34"]}] |
+      | ["end_scenario"]                                     | ["success"]                                                                                          |
+    When I run `cucumber -f progress --backtrace -q`
+    Then the stderr should not contain anything
+    And it should fail with exactly:
+      """
+      F
+
+      (::) failed steps (::)
+
+      Not same (DifferentException from localhost:54321)
+      a.cs:12
+      b.cs:34
+      features/wired.feature:3:in `Given we're all wired'
+
+      Failing Scenarios:
+      cucumber features/wired.feature:2
+
+      1 scenario (1 failed)
+      1 step (1 failed)
+
+      """
+
+  Scenario: Invoke a step definition tries to diff the table and passes
+    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":[]}]]    |
+      | ["begin_scenario"]                                   | ["success"]                            |
+      | ["invoke",{"id":"1","args":[]}]                      | ["diff",[[["a"],["b"]],[["a"],["b"]]]] |
+      | ["diff_ok"]                                          | ["success"]                            |
+      | ["end_scenario"]                                     | ["success"]                            |
+    When I run `cucumber -f progress -q`
+    Then it should pass with exactly:
+      """
+      .
+
+      1 scenario (1 passed)
+      1 step (1 passed)
+
+      """
+
+  @spawn
+  Scenario: Invoke a step definition which successfully diffs a table but then fails
+    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":[]}]]                           |
+      | ["begin_scenario"]                                   | ["success"]                                                   |
+      | ["invoke",{"id":"1","args":[]}]                      | ["diff",[[["a"],["b"]],[["a"],["b"]]]]                        |
+      | ["diff_ok"]                                          | ["fail",{"message":"I wanted things to be different for us"}] |
+      | ["end_scenario"]                                     | ["success"]                                                   |
+    When I run `cucumber -f progress -q`
+    Then it should fail with exactly:
+      """
+      F
+
+      (::) failed steps (::)
+
+      I wanted things to be different for us (Cucumber::Wire::Exception)
+      features/wired.feature:3:in `Given we're all wired'
+
+      Failing Scenarios:
+      cucumber features/wired.feature:2
+
+      1 scenario (1 failed)
+      1 step (1 failed)
+
+      """
+
+  @spawn
+  Scenario: Invoke a step definition which asks for an immediate diff that fails
+    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":[]}]] |
+      | ["begin_scenario"]                                   | ["success"]                         |
+      | ["invoke",{"id":"1","args":[]}]                      | ["diff!",[[["a"]],[["b"]]]]         |
+      | ["end_scenario"]                                     | ["success"]                         |
+    When I run `cucumber -f progress -q`
+    And it should fail with exactly:
+      """
+      F
+
+      (::) failed steps (::)
+
+      Tables were not identical:
+
+        | (-) a | (+) b |
+       (Cucumber::MultilineArgument::DataTable::Different)
+      features/wired.feature:3:in `Given we're all wired'
+
+      Failing Scenarios:
+      cucumber features/wired.feature:2
+
+      1 scenario (1 failed)
+      1 step (1 failed)
+
+      """

data/features/tags.feature

@@ -0,0 +1,86 @@
+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
+
+  Background:
+    Given a file named "features/step_definitions/some_remote_place.wire" with:
+      """
+      host: localhost
+      port: 54321
+
+      """
+
+  Scenario: Run a scenario
+    Given a file named "features/wired.feature" with:
+      """
+        @foo @bar
+        Feature: Wired
+
+          @baz
+          Scenario: Everybody's Wired
+            Given we're all wired
+
+      """
+    And 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":[]}]] |
+      | ["begin_scenario", {"tags":["bar","baz","foo"]}]     | ["success"]                         |
+      | ["invoke",{"id":"1","args":[]}]                      | ["success"]                         |
+      | ["end_scenario", {"tags":["bar","baz","foo"]}]       | ["success"]                         |
+    When I run `cucumber -f pretty -q`
+    Then the stderr should not contain anything
+    And it should pass with:
+      """
+      @foo @bar
+      Feature: Wired
+
+        @baz
+        Scenario: Everybody's Wired
+          Given we're all wired
+
+      1 scenario (1 passed)
+      1 step (1 passed)
+
+      """
+
+  Scenario: Run a scenario outline example
+  Given a file named "features/wired.feature" with:
+    """
+      @foo @bar
+      Feature: Wired
+
+        @baz
+        Scenario Outline: Everybody's Wired
+          Given we're all <something>
+
+        Examples:
+          | something |
+          | wired     |
+
+    """
+  And 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":[]}]] |
+    | ["begin_scenario", {"tags":["bar","baz","foo"]}]     | ["success"]                         |
+    | ["invoke",{"id":"1","args":[]}]                      | ["success"]                         |
+    | ["end_scenario", {"tags":["bar","baz","foo"]}]       | ["success"]                         |
+  When I run `cucumber -f pretty -q`
+  Then the stderr should not contain anything
+  And it should pass with exactly:
+    """
+    @foo @bar
+    Feature: Wired
+
+      @baz
+      Scenario Outline: Everybody's Wired
+        Given we're all <something>
+
+        Examples: 
+          | something |
+          | wired     |
+
+    1 scenario (1 passed)
+    1 step (1 passed)
+
+    """

data/features/timeouts.feature

@@ -0,0 +1,63 @@
+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.
+
+  Background:
+    Given a file named "features/wired.feature" with:
+      """
+      Feature: Telegraphy
+        Scenario: Wired
+          Given we're all wired
+
+      """
+
+  Scenario: Try to talk to a server that's not there
+    Given a file named "features/step_definitions/some_remote_place.wire" with:
+      """
+      host: localhost
+      port: 54321
+
+      """
+    When I run `cucumber -f progress`
+    Then the stderr should contain:
+      """
+      Unable to contact the wire server at localhost:54321
+      """
+
+  @spawn
+  Scenario: Invoke a step definition that takes longer than its timeout
+    Given a file named "features/step_definitions/some_remote_place.wire" with:
+      """
+      host: localhost
+      port: 54321
+      timeout:
+        invoke: 0.1
+
+      """
+    And there is a wire server on port 54321 which understands the following protocol:
+      | request                                              | response                                                     |
+      | ["step_matches",{"name_to_match":"we're all wired"}] | ["success",[{"id":"1", "args":[{"val":"wired", "pos":10}]}]] |
+      | ["begin_scenario"]                                   | ["success"]                                                  |
+      | ["invoke",{"id":"1","args":["wired"]}]               | ["success"]                                                  |
+      | ["end_scenario"]                                     | ["success"]                                                  |
+    And the wire server takes 0.2 seconds to respond to the invoke message
+    When I run `cucumber -f pretty -q`
+    Then the stderr should not contain anything
+    And it should fail with exactly:
+      """
+      Feature: Telegraphy
+
+        Scenario: Wired
+          Given we're all wired
+            Timed out calling wire server with message 'invoke' (Timeout::Error)
+            features/wired.feature:3:in `Given we're all wired'
+
+      Failing Scenarios:
+      cucumber features/wired.feature:2
+
+      1 scenario (1 failed)
+      1 step (1 failed)
+
+      """