cucumber 2.0.0.beta.3 → 2.0.0

data/features/docs/wire_protocol.feature

@@ -1,337 +0,0 @@
-@wire
-Feature: Wire Protocol
-  In order to be allow Cucumber to touch my app in intimate places
-  As a developer on platform which doesn't support Ruby
-  I want a low-level protocol which Cucumber can use to run steps within my app
-
-  #
-  # Cucumber's wire protocol is an implementation of Cucumber's internal
-  # 'programming language' abstraction, and 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.
-  #
-  # Cucumber sends the following request messages out over the wire:
-  #
-  #   * step_matches   : this is used to find out whether the wire server has a
-  #                      definition for a given step
-  #   * invoke         : this is used to 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        : which expects different arguments (sometimes none at
-  #                      all) depending on the request.
-  #   * fail           : causes a Cucumber::WireSupport::WireException to be
-  #                      raised.
-  #
-  # Some messages support more responses - see below for details.
-  #
-  # 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.
-  #
-  # These messages are described in detail below, with examples.
-  #
-
-  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
-
-      """
-
-
-  #
-  # # Request: 'step_matches'
-  #
-  # 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.
-
-  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)
-
-      """
-
-  # 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.
-  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)
-
-      """
-
-  # Optionally, the StepMatch can also contain a source reference, and a native
-  # regexp string which will be used by some formatters.
-  Scenario: Step matches returns details about the remote step definition
-    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
-
-
-  #
-  # # Request: 'invoke'
-  #
-  # 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[1] reply one of the following:
-  #   * success
-  #   * fail
-  #   * pending : optionally takes a message argument
-  #
-  # [1] This isn't the whole story: see also wire_protocol_table_diffing.feature
-  #
-
-  # ## Pending Steps
-  #
-  @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:
-      """
-      Feature: High strung
-
-        Scenario: Wired
-          Given we're all wired
-            I'll do it later (Cucumber::Pending)
-            features/wired.feature:3:in `Given we're all wired'
-
-      1 scenario (1 pending)
-      1 step (1 pending)
-
-      """
-
-  # ## Passing Steps
-  #
-  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)
-
-      """
-
-  # ## Failing Steps
-  #
-  # When 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
-  #
-  @spawn
-  Scenario: Invoke a step definition which 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":[]}]                      | ["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 `Given we're all wired'
-
-      Failing Scenarios:
-      cucumber features/wired.feature:2 # Scenario: Wired
-
-      1 scenario (1 failed)
-      1 step (1 failed)
-
-      """
-
-  # ## Step Arguments
-  #
-  # Imagine we have a step definition like:
-  #
-  #     Given /we're all (.*)/ do | what_we_are |
-  #     end
-  #
-  # When this step definition matches the step name in our feature, the word
-  # 'wired' will be captured as an argument.
-  #
-  # Cucumber expects this StepArgument 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)
-  #
-  Scenario: Invoke a step definition which takes string arguments (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":[{"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)
-
-      """
-
-  # ## Multiline Table Arguments
-  #
-  # When the step has a multiline table argument, it will be passed with the
-  # invoke message as a string - a serialized JSON array of array of strings.
-  # In the following scenario our step definition takes two arguments - one
-  # captures the "we're" and the other takes the table.
-  Scenario: Invoke a step definition which takes table arguments (and passes)
-    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)
-
-      """
-
-
-  #
-  # # Request: 'snippets'
-  #
-  @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
-
-      """
-
-  #
-  # # Bad Response
-  #
-  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 stdout should contain:
-      """
-      undefined method `handle_yikes'
-      """

data/gem_tasks/yard/default/layout/html/footer.erb

@@ -1,5 +0,0 @@
-<div id="footer">
-  Generated on <%= Time.now.strftime("%c") %> by 
-  <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
-  <%= YARD::VERSION %> (ruby-<%= RUBY_VERSION %>).
-</div>

data/gem_tasks/yard/default/layout/html/index.erb

@@ -1 +0,0 @@
-<%= yieldall %>

data/gem_tasks/yard/default/layout/html/layout.erb

@@ -1,25 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-  <head>
-    <%= erb(:headers) %>
-  </head>
-  <body>
-    <script type="text/javascript" charset="utf-8">
-      if (window.top.frames.main) document.body.className = 'frames';
-    </script>
-    
-    <div id="header">
-      <%= erb(:logo) %>
-      <%= erb(:breadcrumb) %>
-      <%= erb(:search) %>
-      <div class="clear"></div>
-    </div>
-    
-    <iframe id="search_frame"></iframe>
-    
-    <div id="content"><%= yieldall %></div>
-    
-    <%= erb(:footer) %>
-  </body>
-</html>

data/gem_tasks/yard/default/layout/html/logo.erb

@@ -1 +0,0 @@
-<h3><img src="<%= url_for('images/bubble_32x32.png') %>"></img> Cucumber <%= Cucumber::VERSION %></h3>

data/gem_tasks/yard/default/layout/html/setup.rb

@@ -1,4 +0,0 @@
-def init
-  super
-  options[:serializer].serialize('/images/bubble_32x32.png', IO.read(File.dirname(__FILE__) + '/bubble_32x32.png'))
-end

data/gem_tasks/yard.rake

@@ -1,43 +0,0 @@
-require 'yard'
-require 'yard/rake/yardoc_task'
-require File.expand_path(File.dirname(__FILE__) + '/../lib/cucumber/platform')
-
-DOC_DIR      = File.expand_path(File.dirname(__FILE__) + '/../doc')
-SITE_DIR     = File.expand_path(File.dirname(__FILE__) + '/../../cucumber.github.com')
-API_DIR      = File.join(SITE_DIR, 'api', 'cucumber', 'ruby', 'yardoc')
-TEMPLATE_DIR = File.expand_path(File.join(File.dirname(__FILE__), 'yard'))
-YARD::Templates::Engine.register_template_path(TEMPLATE_DIR)
-
-namespace :api do
-  YARD::Rake::YardocTask.new(:yard) do |yard|
-    yard.options = ["--out", DOC_DIR]
-  end
-
-  task :sync_with_git do
-    unless File.directory?(SITE_DIR)
-      raise "You need to git clone git@github.com:cucumber/cucumber.github.com.git #{SITE_DIR}"
-    end
-    Dir.chdir(SITE_DIR) do
-      sh 'git pull -u'
-    end
-  end
-
-  task :copy_to_website do
-    rm_rf API_DIR
-    cp_r DOC_DIR, API_DIR
-  end
-
-  task :release do
-    Dir.chdir(SITE_DIR) do
-      sh 'git add .'
-      sh '''git commit -m "Update API docs for Cucumber-Ruby v#{Cucumber::VERSION}"'''
-      sh 'git push'
-    end
-  end
-
-  desc "Generate YARD docs for Cucumber's API"
-  task :doc => [:yard, :sync_with_git, :copy_to_website, :release]
-  
-  desc "Build cucumber gem and doc locally"
-  task :build => [:yard, :sync_with_git, :copy_to_website]
-end

data/lib/cucumber/mappings.rb

@@ -1,238 +0,0 @@
-require 'cucumber/runtime'
-require 'cucumber'
-require 'cucumber/multiline_argument'
-
-module Cucumber
-  class Mappings
-
-    def self.for(runtime)
-      if runtime.dry_run?
-        Mappings::DryRun.new(runtime)
-      else
-        Mappings.new(runtime)
-      end
-    end
-
-    def initialize(runtime = nil)
-      @runtime = runtime
-    end
-
-    def test_step(step, mapper)
-      map_step(step, mapper)
-      map_after_step_hooks(mapper)
-    end
-
-    def test_case(test_case, mapper)
-      map_test_case(test_case, mapper)
-      map_test_case_hooks(mapper)
-    end
-
-    def runtime
-      return @runtime if @runtime
-      result = Cucumber::Runtime.new
-      result.support_code.load_files!(support_files)
-      @runtime = result
-    end
-
-    private
-
-    attr_reader :scenario
-    private :scenario
-
-    def ruby
-      @ruby ||= runtime.load_programming_language('rb')
-    end
-
-    def support_files
-      Dir['features/**/*.rb']
-    end
-
-    def map_step(step, mapper)
-      step.describe_source_to MapStep.new(runtime, mapper)
-    end
-
-    def map_after_step_hooks(mapper)
-      ruby.hooks_for(:after_step, scenario).each do |hook|
-        mapper.after do
-          hook.invoke 'AfterStep', scenario
-        end
-      end
-    end
-
-    def map_test_case(test_case, mapper)
-      @scenario = Source.new(test_case).build_scenario
-      mapper.before do
-        runtime.begin_scenario(scenario)
-      end
-    end
-
-    def map_test_case_hooks(mapper)
-      ruby.hooks_for(:before, scenario).each do |hook|
-        mapper.before do |result|
-          hook.invoke('Before', scenario.with_result(result))
-        end
-      end
-      ruby.hooks_for(:after, scenario).each do |hook|
-        mapper.after do |result|
-          hook.invoke('After', scenario.with_result(result))
-        end
-      end
-      ruby.hooks_for(:around, scenario).each do |hook|
-        mapper.around do |run_scenario|
-          hook.invoke('Around', scenario, &run_scenario)
-        end
-      end
-    end
-
-    # adapts our test_case to look like the Cucumber Runtime's old Scenario
-    class TestCase
-      def initialize(test_case, feature, result = Core::Test::Result::Unknown.new)
-        @test_case = test_case
-        @feature = feature
-        @result = result
-      end
-
-      def accept_hook?(hook)
-        hook.tag_expressions.all? { |expression| @test_case.match_tags?(expression) }
-      end
-
-      def failed?
-        @result.failed?
-      end
-
-      def language
-        @test_case.language
-      end
-
-      def feature
-        @feature
-      end
-
-      def name
-        @test_case.name
-      end
-
-      def title
-        warn("deprecated: call #name instead")
-        name
-      end
-
-      def source_tags
-        #warn('deprecated: call #tags instead')
-        tags
-      end
-
-      def source_tag_names
-        tags.map &:name
-      end
-
-      def tags
-        @test_case.tags
-      end
-
-      def outline?
-        false
-      end
-
-      def with_result(result)
-        self.class.new(@test_case, @feature, result)
-      end
-    end
-
-    class Scenario < TestCase
-    end
-
-    class ScenarioOutlineExample < TestCase
-      def outline?
-        true
-      end
-
-      def scenario_outline
-        self
-      end
-    end
-
-    class Source
-      def initialize(test_case)
-        @test_case = test_case
-        test_case.describe_source_to(self)
-      end
-
-      def feature(feature)
-        @feature = feature
-      end
-
-      def scenario(scenario)
-        @factory = Scenario
-      end
-
-      def scenario_outline(scenario)
-        @factory = ScenarioOutlineExample
-      end
-
-      def examples_table(examples_table)
-      end
-
-      def examples_table_row(row)
-      end
-
-      def build_scenario
-        @factory.new(@test_case, Feature.new(@feature.legacy_conflated_name_and_description))
-      end
-    end
-
-    class DryRun < Mappings
-
-      private
-
-      def map_test_case(*)
-        # NOOP - we don't want to create World etc for dry run
-      end
-
-      def map_step(step, mapper)
-        step.describe_source_to MapStep::DryRun.new(runtime, mapper)
-      end
-
-      def map_after_step_hooks(mapper)
-        # NOOP - we don't need after step hooks for dry run
-      end
-
-      def map_test_case_hooks(mapper)
-        # NOOP - we don't need hooks for dry run
-      end
-    end
-
-    Feature = Struct.new(:name)
-
-    class MapStep
-      include Cucumber.initializer(:runtime, :mapper)
-
-      def step(node)
-        step_match = runtime.step_match(node.name)
-        map_step(node, step_match)
-      rescue Cucumber::Undefined
-      end
-
-      def feature(*);end
-      def scenario(*);end
-      def background(*);end
-      def scenario_outline(*);end
-      def examples_table(*);end
-      def examples_table_row(*);end
-
-      private
-      def map_step(node, step_match)
-        multiline_arg = MultilineArgument.from_core(node.multiline_arg)
-        mapper.map { step_match.invoke(multiline_arg) }
-      end
-
-      class DryRun < MapStep
-        private
-        def map_step(node, step_match)
-          mapper.map { raise Core::Test::Result::Skipped, "dry run" }
-        end
-      end
-    end
-
-  end
-end