cucumber-wire 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 75471bc4f5662b423d400b2cd105d7cdcce04ded55cf82773e72885647d03f00
-  data.tar.gz: 032db46bd8e08ee87a2744f083ac99ac50e745960709d93c354e21951ef3fb9e
+  metadata.gz: 462ca912391ac19f173a610a18056c7c2dd3ddc42d6ab7b11aeaef6986d60201
+  data.tar.gz: ba3040346ba690ce5471b5af2e97b9a5e383001933684c79c553e9603f9fdd98
 SHA512:
-  metadata.gz: 94b13b0ee96d03f9d9c42671411209579807477c2945f9c5602f9a96f25f17647af1e7b89df2732af54370721b40230b642a21ec34f2b30e89753d1836942a34
-  data.tar.gz: 16dd72d0f9c9c2db7da35b600d5ef981fc00e29efb1fc07fa54ff2b3cb940a0aa34b311a86675b65560d49dc059c5179983ae4d1676da595ec1f445189a5e14f
+  metadata.gz: 620e604bec618f31fbb554079297f4c55f956e8bccad13deaa760c2ddbc902e8fb0371336584a3d8c122c4ccdf1298860a763865f1a1c319035bdc27d8805a0c
+  data.tar.gz: 6e3ff7030d0770fe50d3010db7a21e55811dc78c369de8725175680666738d642b93fba2354f9dd076233fa6f26ed1d1eb44d6ea46156124be696074ff7f9cd5

data/CHANGELOG.md

@@ -10,15 +10,12 @@ Please visit [cucumber/CONTRIBUTING.md](https://github.com/cucumber/cucumber/blo
 
 ----
 
-## [In Git](https://github.com/cucumber/cucumber-ruby-wire/compare/v1.0.0...master)
-
-### Removed
-
-### Added
+## [1.1.0](https://github.com/cucumber/cucumber-ruby-wire/compare/v1.0.0...v1.1.0)
 
 ### Changed
 
-### Fixed
+* Update to cucumber-expressions 8.0.2
+* Update to cucumber 4.0.0
 
 ## [1.0.0](https://github.com/cucumber/cucumber-ruby-wire/compare/v0.0.1...v1.0.0)
 

data/lib/cucumber/wire/add_hooks_filter.rb

@@ -9,8 +9,8 @@ module Cucumber
       end
 
       def before_hook(test_case)
-        # TODO: is this dependency on Cucumber::Hooks OK? Feels a bit internal..
-        # TODO: how do we express the location of the hook? Should we create one hook per connection so we can use the host:port of the connection?
+        # TODO: is this dependency on Cucumber::Hooks OK? Feels a bit internal..
+        # TODO: how do we express the location of the hook? Should we create one hook per connection so we can use the host:port of the connection?
         Cucumber::Hooks.before_hook(Core::Test::Location.new('TODO:wire')) do
           connections.begin_scenario(test_case)
         end

data/lib/cucumber/wire/connections.rb

@@ -26,7 +26,7 @@ module Cucumber
       def find_match(test_step)
         matches = step_matches(test_step.name)
         return unless matches.any?
-        # TODO: handle ambiguous matches (push to cucumber?)
+        # TODO: handle ambiguous matches (push to cucumber?)
         matches.first
       end
 

data/lib/cucumber/wire/protocol/requests.rb

@@ -69,7 +69,7 @@ module Cucumber
           end
 
           def handle_diff!(tables)
-            # TODO: figure out if / how we could get a location for a table from the wire (or make a null location)
+            # TODO: figure out if / how we could get a location for a table from the wire (or make a null location)
             location = Core::Test::Location.new(__FILE__, __LINE__)
             table1 = table(tables[0], location)
             table2 = table(tables[1], location)

data/lib/cucumber/wire/version

@@ -1 +1 @@
-1.0.0
+1.1.0

metadata

@@ -1,141 +1,145 @@
 --- !ruby/object:Gem::Specification
 name: cucumber-wire
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Matt Wynne
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-29 00:00:00.000000000 Z
+date: 2019-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cucumber-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '5.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: cucumber-expressions
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '8.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.0.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '8.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.0.2
 - !ruby/object:Gem::Dependency
   name: cucumber
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4.0'
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
+        version: '3.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.5
+        version: 3.1.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.5
+        version: 3.1.2
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.2
+        version: 12.3.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.2
+        version: 12.3.3
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.8.0
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '3.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.8.0
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '3.8'
 - !ruby/object:Gem::Dependency
   name: aruba
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.14'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.11
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.14'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.11
 description: Wire protocol for Cucumber
 email: cukes@googlegroups.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".rspec"
-- ".travis.yml"
 - CHANGELOG.md
 - CONTRIBUTING.md
-- Gemfile
 - LICENSE
 - README.md
-- Rakefile
-- cucumber-wire.gemspec
-- features/docstring.feature
-- features/erb_configuration.feature
-- features/handle_unexpected_response.feature
-- features/invoke_message.feature
-- features/readme.md
-- features/snippets_message.feature
-- features/step_definitions/aruba_steps.rb
-- features/step_definitions/wire_steps.rb
-- features/step_matches_message.feature
-- features/support/fake_wire_server.rb
-- features/table_diffing.feature
-- features/tags.feature
-- features/timeouts.feature
 - lib/cucumber/wire.rb
 - lib/cucumber/wire/add_hooks_filter.rb
 - lib/cucumber/wire/configuration.rb
@@ -169,21 +173,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.2'
+      version: '2.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.4
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
-summary: cucumber-wire-1.0.0
+summary: cucumber-wire-1.1.0
 test_files:
+- spec/cucumber/wire/data_packet_spec.rb
 - spec/cucumber/wire/configuration_spec.rb
-- spec/cucumber/wire/connection_spec.rb
 - spec/cucumber/wire/connections_spec.rb
-- spec/cucumber/wire/data_packet_spec.rb
 - spec/cucumber/wire/exception_spec.rb
+- spec/cucumber/wire/connection_spec.rb

data/.rspec

@@ -1 +0,0 @@
---color

data/.travis.yml

@@ -1,22 +0,0 @@
-rvm:
-  - ruby-head
-  - 2.4.0
-  - 2.3.3
-  - 2.2
-
-matrix:
-  allow_failures:
-    - rvm: ruby-head
-  fast_finish: true
-
-# whitelist
-branches:
-  only:
-    - master
-
-notifications:
-  email:
-    - cukes-devs@googlegroups.com
-  webhooks:
-    urls: # gitter
-      - https://webhooks.gitter.im/e/dc010332f9d40fcc21c4

data/Gemfile

@@ -1,20 +0,0 @@
-gemspec
-
-source "https://rubygems.org"
-unless ENV['CUCUMBER_USE_RELEASED_GEMS']
-  # cucumber gem
-  cucumber_path = File.expand_path("../../cucumber-ruby", __FILE__)
-  if File.exist?(cucumber_path) && !ENV['CUCUMBER_USE_GIT']
-    gem "cucumber", path: cucumber_path
-  else
-    gem "cucumber", :git => "git://github.com/cucumber/cucumber-ruby.git"
-  end
-
-  # cucumber-core gem
-  core_path = File.expand_path("../../cucumber-ruby-core", __FILE__)
-  if File.exist?(core_path) && !ENV['CUCUMBER_USE_GIT_CORE']
-    gem "cucumber-core", path: core_path
-  else
-    gem 'cucumber-core', :git => "git://github.com/cucumber/cucumber-ruby-core.git"
-  end
-end

data/Rakefile

@@ -1,13 +0,0 @@
-require 'rubygems'
-require 'bundler'
-Bundler::GemHelper.install_tasks
-
-task default: [:unit_tests, :acceptance_tests]
-
-task :unit_tests do
-  sh "bundle exec rspec"
-end
-
-task :acceptance_tests do
-  sh "bundle exec cucumber"
-end

data/cucumber-wire.gemspec

@@ -1,31 +0,0 @@
-# -*- encoding: utf-8 -*-
-$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
-
-Gem::Specification.new do |s|
-  s.name        = 'cucumber-wire'
-  s.version     = File.read(File.dirname(__FILE__) + "/lib/cucumber/wire/version")
-  s.authors     = ["Matt Wynne"]
-  s.description = "Wire protocol for Cucumber"
-  s.summary     = "cucumber-wire-#{s.version}"
-  s.email       = 'cukes@googlegroups.com'
-  s.homepage    = "http://cucumber.io"
-  s.platform    = Gem::Platform::RUBY
-  s.license     = "MIT"
-  s.required_ruby_version = ">= 2.2"
-
-  s.add_dependency 'cucumber-core', '~> 4.0'
-  s.add_dependency 'cucumber-expressions', '~> 6.0'
-
-  s.add_development_dependency 'cucumber', '~> 4.0'
-
-  s.add_development_dependency 'bundler',   '>= 1.3.5'
-  s.add_development_dependency 'rake',      '>= 0.9.2'
-  s.add_development_dependency 'rspec',     '~> 3'
-  s.add_development_dependency 'aruba',     '~> 0'
-
-  s.rubygems_version = ">= 1.6.1"
-  s.files            = `git ls-files`.split("\n").reject {|path| path =~ /\.gitignore$/ }
-  s.test_files       = `git ls-files -- spec/*`.split("\n")
-  s.rdoc_options     = ["--charset=UTF-8"]
-  s.require_path     = "lib"
-end

data/features/docstring.feature

@@ -1,39 +0,0 @@
-Feature: Wire protocol docstrings
-
-  In order to use docstrings as arguments to step definitions, we send them as
-  an additional argument after the arguments extracted by the wire server.
-
-  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:
-      """
-      Feature: High strung
-        Scenario: Wired
-          Given we're all wired
-            \"\"\"
-            to want more
-            \"\"\"
-      """
-    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"]                                   | ["success"]                         |
-      | ["invoke",{"id":"1","args":["to want more"]}]        | ["success"]                         |
-      | ["end_scenario"]                                     | ["success"]                         |
-    When I run `cucumber -f progress`
-    Then the stderr should not contain anything
-    And it should pass with:
-      """
-      .
-
-      1 scenario (1 passed)
-      1 step (1 passed)
-
-      """

data/features/erb_configuration.feature

@@ -1,54 +0,0 @@
-Feature: ERB configuration
-
-  As a developer on server with multiple users
-  I want to be able to configure which port my wire server runs on
-  So that I can avoid port conflicts
-
-  Background:
-    Given a file named "features/wired.feature" with:
-      """
-      Feature: High strung
-        Scenario: Wired
-          Given we're all wired
-
-      """
-
-  Scenario: ERB is used in the wire file which references an environment variable that is not set
-      Given a file named "features/step_definitions/server.wire" with:
-        """
-        host: localhost
-        port: <%= ENV['PORT'] || 12345 %>
-        """
-      And there is a wire server running on port 12345 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`
-      Then it should pass with:
-        """
-        U
-
-        1 scenario (1 undefined)
-        1 step (1 undefined)
-
-        """
-
-
-  Scenario: ERB is used in the wire file which references an environment variable
-      Given I have environment variable PORT set to "16816"
-      And a file named "features/step_definitions/server.wire" with:
-        """
-        host: localhost
-        port: <%= ENV['PORT'] || 12345 %>
-        """
-      And there is a wire server running on port 16816 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`
-      Then it should pass with:
-        """
-        U
-
-        1 scenario (1 undefined)
-        1 step (1 undefined)
-
-        """

data/features/handle_unexpected_response.feature

@@ -1,29 +0,0 @@
-Feature: Handle unexpected response
-
-  When the server sends us back a message we don't understand, this is how Cucumber will behave.
-
-  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: Unexpected response
-    Given there is a wire server running on port 54321 which understands the following protocol:
-      | request                                              | response                            |
-      | ["begin_scenario"]                                   | ["yikes"]                           |
-      | ["step_matches",{"name_to_match":"we're all wired"}] | ["success",[{"id":"1", "args":[]}]] |
-    When I run `cucumber -f pretty`
-    Then the output should contain:
-      """
-      undefined method `handle_yikes'
-      """

data/features/invoke_message.feature

@@ -1,210 +0,0 @@
-Feature: Invoke message
-
-  Assuming a StepMatch was returned for a given step name, when it's time to
-  invoke that step definition, Cucumber will send an invoke message.
-
-  The invoke message contains the ID of the step definition, as returned by
-  the wire server in response to the the step_matches call, along with the
-  arguments that were parsed from the step name during the same step_matches
-  call.
-
-  The wire server will normally reply one of the following:
-
-  * `success`
-  * `fail`
-  * `pending` - optionally takes a message argument
-
-  This isn't quite the whole story: see also table_diffing.feature
-
-  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: Invoke a step definition which is pending
-    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":[]}]                      | ["pending", "I'll do it later"]     |
-      | ["end_scenario"]                                     | ["success"]                         |
-    When I run `cucumber -f pretty -q`
-    And it should pass with exactly:
-      """
-      Feature: High strung
-
-        Scenario: Wired
-          Given we're all wired
-
-      1 scenario (1 pending)
-      1 step (1 pending)
-
-      """
-
-  Scenario: Invoke a step definition which 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":[]}]                      | ["success"]                         |
-      | ["end_scenario"]                                     | ["success"]                         |
-    When I run `cucumber -f progress`
-    And it should pass with:
-      """
-      .
-
-      1 scenario (1 passed)
-      1 step (1 passed)
-
-      """
-
-  @spawn
-  Scenario: Invoke a step definition which fails
-
-    If an invoked step definition fails, it can return details of the exception
-    in the reply to invoke. This causes a Cucumber::WireSupport::WireException to be
-    raised.
-
-    Valid arguments are:
-
-    - `message` (mandatory)
-    - `exception`
-    - `backtrace`
-
-    See the specs for Cucumber::WireSupport::WireException for more details
-
-    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":[]}]                      | ["fail",{"message":"The wires are down", "exception":"Some.Foreign.ExceptionType"}] |
-      | ["end_scenario"]                                     | ["success"]                                                                         |
-    When I run `cucumber -f progress`
-    Then the stderr should not contain anything
-    And it should fail with:
-      """
-      F
-
-      (::) failed steps (::)
-
-      The wires are down (Some.Foreign.ExceptionType from localhost:54321)
-      features/wired.feature:3:in `we're all wired'
-
-      Failing Scenarios:
-      cucumber features/wired.feature:2 # Scenario: Wired
-
-      1 scenario (1 failed)
-      1 step (1 failed)
-
-      """
-
-  Scenario: Invoke a step definition which takes string arguments (and passes)
-
-    If the step definition at the end of the wire captures arguments, these are
-    communicated back to Cucumber in the `step_matches` message.
-
-    Cucumber expects these StepArguments to be returned in the StepMatch. The keys
-    have the following meanings:
-
-    - `val` - the value of the string captured for that argument from the step
-      name passed in step_matches
-    - `pos` - the position within the step name that the argument was matched
-      (used for formatter highlighting)
-
-    The argument values are then sent back by Cucumber in the `invoke` message.
-
-    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":[{"val":"wired", "pos":10}]}]] |
-      | ["begin_scenario"]                                   | ["success"]                                                  |
-      | ["invoke",{"id":"1","args":["wired"]}]               | ["success"]                                                  |
-      | ["end_scenario"]                                     | ["success"]                                                  |
-    When I run `cucumber -f progress`
-    Then the stderr should not contain anything
-    And it should pass with:
-      """
-      .
-
-      1 scenario (1 passed)
-      1 step (1 passed)
-
-      """
-
-  Scenario: Invoke a step definition which takes regular and table arguments (and passes)
-
-    If the step has a multiline table argument, it will be passed with the
-    invoke message as an array of array of strings.
-
-    In this scenario our step definition takes two arguments - one
-    captures the "we're" and the other takes the table.
-
-    Given a file named "features/wired_on_tables.feature" with:
-      """
-      Feature: High strung
-        Scenario: Wired and more
-          Given we're all:
-            | wired |
-            | high  |
-            | happy |
-      """
-    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:"}]                       | ["success",[{"id":"1", "args":[{"val":"we're", "pos":0}]}]] |
-      | ["begin_scenario"]                                                    | ["success"]                                                 |
-      | ["invoke",{"id":"1","args":["we're",[["wired"],["high"],["happy"]]]}] | ["success"]                                                 |
-      | ["end_scenario"]                                                      | ["success"]                                                 |
-    When I run `cucumber -f progress features/wired_on_tables.feature`
-    Then the stderr should not contain anything
-    And it should pass with:
-      """
-      .
-
-      1 scenario (1 passed)
-      1 step (1 passed)
-
-      """
-
-  Scenario: Invoke a scenario outline step
-    Given a file named "features/wired_in_an_outline.feature" with:
-      """
-      Feature:
-        Scenario Outline:
-          Given we're all <arg>
-
-          Examples:
-            | arg   |
-            | 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"]                                   | ["success"]                         |
-      | ["invoke",{"id":"1","args":[]}]                      | ["success"]                         |
-      | ["end_scenario"]                                     | ["success"]                         |
-    When I run `cucumber -f progress features/wired_in_an_outline.feature`
-    Then the stderr should not contain anything
-    And it should pass with:
-      """
-      .
-
-      1 scenario (1 passed)
-      1 step (1 passed)
-
-      """
-    And the wire server should have received the following messages:
-      | step_matches   |
-      | begin_scenario |
-      | invoke         |
-      | end_scenario   |

data/features/readme.md

@@ -1,26 +0,0 @@
-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 `Wire::DataPacket` 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::Wire::DataPacket` 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::Wire::Exception to be raised.
-
-Some messages support more responses - see individual scenarios for details.

data/features/snippets_message.feature

@@ -1,47 +0,0 @@
-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:
-      """
-      foo()
-        bar;
-      baz
-
-      """

data/features/step_definitions/aruba_steps.rb

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

data/features/step_definitions/wire_steps.rb

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

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

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

@@ -1,124 +0,0 @@
-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 `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 `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 `we're all wired'
-
-      Failing Scenarios:
-      cucumber features/wired.feature:2
-
-      1 scenario (1 failed)
-      1 step (1 failed)
-
-      """

data/features/tags.feature

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

@@ -1,63 +0,0 @@
-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 `we're all wired'
-
-      Failing Scenarios:
-      cucumber features/wired.feature:2
-
-      1 scenario (1 failed)
-      1 step (1 failed)
-
-      """