cucumber 0.4.2 → 0.4.3

data/features/wire_protocol.feature

@@ -0,0 +1,177 @@
+@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).
+  #
+  # There are currently two messages which Cucumber sends over the wire:
+  #
+  #   * step_matches : this is used to find out whether the wire end has a definition for a given step
+  #   * invoke       : this is used to ask for a step definition to be invoked
+  #
+  # Message packets are formatted as JSON-encoded strings, with a newline character signalling the end of a
+  # packet. These messages are described below, with examples.
+  #
+
+  Background:
+    Given a standard Cucumber project directory structure
+    And a file named "features/wired.feature" with:
+      """
+        Scenario: Wired
+          Given we're all wired
+
+      """
+    And a file named "features/step_definitions/some_remote_place.wire" with:
+      """
+      host: localhost
+      port: 98989
+
+      """
+
+
+  #
+  # step_matches
+  #
+  # When the features have been parsed, Cucumber will send a step_matches message to ask the wire end
+  # if it can match a step name. This happens for each of the steps in each of the features.
+  # The wire end replies with a step_match array, containing the IDs of any step definitions that could
+  # be invoked for the given step name.
+
+  Scenario: Dry run finds no step match
+    Given there is a wire server running on port 98989 which understands the following protocol:
+      | request                                              | response            |
+      | ["step_matches",{"name_to_match":"we're all wired"}] | ["step_matches",[]] |
+    When I run cucumber --dry-run -f progress features
+    And it should pass with
+      """
+      U
+
+      1 scenario (1 undefined)
+      1 step (1 undefined)
+
+      """
+
+  # When a step match is returned, it contains an identifier for the step definition to be used
+  # later when referring to this step definition again if it needs to be invoked. The identifier
+  # can take any form (as long as it's within a string) and is simply used for the wire end's own
+  # reference.
+  # The step match also contains any argument values as parsed out 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 98989 which understands the following protocol:
+      | request                                              | response                                 |
+      | ["step_matches",{"name_to_match":"we're all wired"}] | ["step_matches",[{"id":"1", "args":[]}]] |
+    When I run cucumber --dry-run -f progress features
+    And it should pass with
+      """
+      -
+
+      1 scenario (1 skipped)
+      1 step (1 skipped)
+
+      """
+
+
+  #
+  # invoke
+  #
+  # Assuming a step_match was returned for a given step name, when it's time to invoke that
+  # step definition, Cucumber will send an invoke message.
+  # The message contains the ID of the step definition, as returned by the wire end from the
+  # step_matches call, along with the arguments that were parsed from the step name during the
+  # same step_matches call.
+  # The wire end will reply with either a step_failed or a success message.
+
+  Scenario: Invoke a step definition which passes
+    Given there is a wire server running on port 98989 which understands the following protocol:
+      | request                                              | response                                 |
+      | ["step_matches",{"name_to_match":"we're all wired"}] | ["step_matches",[{"id":"1", "args":[]}]] |
+      | ["begin_scenario",null]                              | ["success",null]                         |
+      | ["invoke",{"id":"1","args":[]}]                      | ["success",null]                         |
+      | ["end_scenario",null]                                | ["success",null]                         |
+    When I run cucumber -f progress --backtrace features
+    And it should pass with
+      """
+      .
+
+      1 scenario (1 passed)
+      1 step (1 passed)
+
+      """
+
+  # When a step definition fails, it can return details of the exception in the reply to invoke. These
+  # will then be passed by Cucumber to the formatters for display to the user.
+  #
+  Scenario: Invoke a step definition which fails
+    Given there is a wire server running on port 98989 which understands the following protocol:
+      | request                                              | response                                         |
+      | ["step_matches",{"name_to_match":"we're all wired"}] | ["step_matches",[{"id":"1", "args":[]}]]         |
+      | ["begin_scenario",null]                              | ["success",null]                                 |
+      | ["invoke",{"id":"1","args":[]}]                      | ["step_failed",{"message":"The wires are down"}] |
+      | ["end_scenario",null]                                | ["success",null]                                 |
+    When I run cucumber -f progress features
+    Then STDERR should be empty
+    And it should fail with
+      """
+      F
+
+      (::) failed steps (::)
+
+      The wires are down (Cucumber::WireSupport::WireException)
+      features/wired.feature:2:in `Given we're all wired'
+
+      Failing Scenarios:
+      cucumber features/wired.feature:1 # Scenario: Wired
+
+      1 scenario (1 failed)
+      1 step (1 failed)
+
+      """
+
+  # 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 parsed 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 arguments (and passes)
+    Given there is a wire server running on port 98989 which understands the following protocol:
+      | request                                              | response                                                          |
+      | ["step_matches",{"name_to_match":"we're all wired"}] | ["step_matches",[{"id":"1", "args":[{"val":"wired", "pos":10}]}]] |
+      | ["begin_scenario",null]                              | ["success",null]                                                  |
+      | ["invoke",{"id":"1","args":["wired"]}]               | ["success",null]                                                  |
+      | ["end_scenario",null]                                | ["success",null]                                                  |
+    When I run cucumber -f progress --backtrace features
+    Then STDERR should be empty
+    And it should pass with
+      """
+      .
+
+      1 scenario (1 passed)
+      1 step (1 passed)
+
+      """
+
+
+  Scenario: Unexpected response
+    Given there is a wire server running on port 98989 which understands the following protocol:
+      | request                                              | response   |
+      | ["begin_scenario",null]                              | ["yikes"]  |
+    When I run cucumber -f progress features
+    Then STDERR should match
+      """
+      undefined method `handle_yikes'
+      """

data/lib/cucumber/ast/examples.rb

@@ -20,6 +20,10 @@ module Cucumber
         @outline_table.cells_rows[1..-1].each(&proc)
       end
 
+      def failed?
+        @outline_table.cells_rows[1..-1].select{|row| row.failed?}.any?
+      end
+
       def to_sexp
         sexp = [:examples, @keyword, @name]
         comment = @comment.to_sexp

data/lib/cucumber/ast/feature_element.rb

@@ -49,7 +49,8 @@ module Cucumber
       end
 
       def accept_hook?(hook)
-        Tags.matches?(source_tag_names, hook.tag_names)
+        parsed_hook_tag_names = hook.tag_names.map {|tag_string| Cli::Options.parse_tag_arguments(tag_string)}
+        Tags.matches?(source_tag_names, parsed_hook_tag_names)
       end
 
       def source_tag_names

data/lib/cucumber/ast/scenario_outline.rb

@@ -80,6 +80,10 @@ module Cucumber
         )
       end
 
+      def failed?
+        @examples_array.select{|examples| examples.failed?}.any?
+      end
+
       def to_sexp
         sexp = [:scenario_outline, @keyword, @name]
         comment = @comment.to_sexp

data/lib/cucumber/ast/table.rb

@@ -39,7 +39,8 @@ module Cucumber
         "table"
       end
 
-      # Creates a new instance. +raw+ should be an Array of Array of String.
+      # Creates a new instance. +raw+ should be an Array of Array of String
+      # or an Array of Hash (similar to what #hashes returns).
       # You don't typically create your own Table objects - Cucumber will do
       # it internally and pass them to your Step Definitions.
       #
@@ -47,12 +48,18 @@ module Cucumber
         @cells_class = Cells
         @cell_class = Cell
 
+        raw = ensure_array_of_array(raw)
         # Verify that it's square
         transposed = raw.transpose
         create_cell_matrix(raw)
         @conversion_procs = conversion_procs
       end
 
+      # JSON representation
+      def to_json
+        raw.to_json
+      end
+
       # Creates a copy of this table, inheriting any column mappings.
       # registered with #map_headers!
       #
@@ -261,7 +268,7 @@ module Cucumber
       # objects in their cells, you may want to use #map_column! before calling
       # #diff!. You can use #map_column! on either of the tables.
       #
-      # An exception is raised if there are missing rows or columns, or
+      # A Different error is raised if there are missing rows or columns, or
       # surplus rows. An error is <em>not</em> raised for surplus columns.
       # Whether to raise or not raise can be changed by setting values in
       # +options+ to true or false:
@@ -524,20 +531,18 @@ module Cucumber
 
       def ensure_table(table_or_array) #:nodoc:
         return table_or_array if Table === table_or_array
-        table_or_array = hashes_to_array(table_or_array) if Hash === table_or_array[0]
-        table_or_array = enumerable_to_array(table_or_array) unless Array == table_or_array[0]
         Table.new(table_or_array)
       end
 
+      def ensure_array_of_array(array)
+        Hash === array[0] ? hashes_to_array(array) : array
+      end
+
       def hashes_to_array(hashes) #:nodoc:
         header = hashes[0].keys
         [header] + hashes.map{|hash| header.map{|key| hash[key]}}
       end
 
-      def enumerable_to_array(rows) #:nodoc:
-        rows.map{|row| row.map{|cell| cell}}
-      end
-
       def ensure_green! #:nodoc:
         each_cell{|cell| cell.status = :passed}
       end

data/lib/cucumber/ast/tags.rb

@@ -1,5 +1,8 @@
+require 'set'
+
 module Cucumber
   module Ast
+
     # Holds the names of tags parsed from a feature file:
     #
     #   @invoice @release_2
@@ -7,33 +10,74 @@ module Cucumber
     # This gets stored internally as <tt>["invoice", "release_2"]</tt>
     #
     class Tags #:nodoc:
+
+      class And #:nodoc:
+        def initialize(tag_names)
+          @negative_tags, @positive_tags = tag_names.partition{|tag_name| Tags.exclude_tag?(tag_name)}
+          @negative_tags = Tags.strip_negative_char(@negative_tags)
+        end
+
+        def matches?(tag_names)
+          included?(tag_names) && !excluded?(tag_names)
+        end
+
+        private
+
+        def excluded?(tag_names)
+          (@negative_tags & tag_names).any?
+        end
+
+        def included?(tag_names)
+          positive_tag_set = Set.new(@positive_tags)
+          tag_names_set = Set.new(tag_names)
+          positive_tag_set.subset?(tag_names_set)
+        end
+      end
+
+      class Or #:nodoc:
+        def initialize(tag_exp)
+          @exp = tag_exp
+        end
+
+        def matches?(tag_names)
+          @exp.inject(false){|matches, tag_exp| matches || tag_exp.matches?(tag_names)}
+        end
+      end
+
       class << self
         EXCLUDE_PATTERN = /^~/
 
         def matches?(source_tag_names, tag_names)
-          exclude_tag_names, include_tag_names = tag_names.partition{|tag_name| exclude_tag?(tag_name)}
-          exclude_tag_names.map!{|name| name[1..-1]}
-          check_at_sign_prefix(exclude_tag_names + include_tag_names)
-          !excluded?(source_tag_names, exclude_tag_names) && included?(source_tag_names, include_tag_names)
+          validate_tags(tag_names)
+          tag_names.empty? ? true : check_if_tags_match(source_tag_names, tag_names)
         end
 
         def exclude_tag?(tag_name)
           tag_name =~ EXCLUDE_PATTERN
         end
-        
+
+        def strip_negative_char(tag_names)
+          tag_names.map{|name| name[1..-1]}
+        end
+
         private
 
-        def check_at_sign_prefix(tag_names)
-          tag_names.each{|tag_name| raise "Tag names must start with an @ sign. The following tag name didn't: #{tag_name}" unless tag_name[0..0] == '@'}
+        def validate_tags(tag_name_list)
+          all_tag_names = tag_name_list.flatten
+          exclude_tag_names, include_tag_names = all_tag_names.partition{|tag_name| exclude_tag?(tag_name)}
+          exclude_tag_names = strip_negative_char(exclude_tag_names)
+          check_at_sign_prefix(exclude_tag_names + include_tag_names)
         end
 
-        def excluded?(source_tag_names, query_tag_names)
-          source_tag_names.any? && (source_tag_names & query_tag_names).any?
+        def check_if_tags_match(source_tag_names, tag_names)
+          tag_exp = Or.new(tag_names.map{|tag_name_list| And.new(tag_name_list) })
+          tag_exp.matches?(source_tag_names)
         end
-        
-        def included?(source_tag_names, query_tag_names)
-          query_tag_names.empty? || (source_tag_names & query_tag_names).any?
+
+        def check_at_sign_prefix(tag_names)
+          tag_names.each{|tag_name| raise "Tag names must start with an @ sign. The following tag name didn't: #{tag_name}" unless tag_name[0..0] == '@'}
         end
+
       end
 
       attr_reader :tag_names

data/lib/cucumber/ast/tree_walker.rb

@@ -146,6 +146,12 @@ module Cucumber
       def announce(announcement)
         broadcast(announcement)
       end
+
+      # Embed +file+ of +mime_type+ in the formatter. This method can be called from within StepDefinitions.
+      # For most formatters this is a no-op.
+      def embed(file, mime_type)
+        broadcast(file, mime_type)
+      end
       
       private
       

data/lib/cucumber/cli/main.rb

@@ -69,11 +69,13 @@ module Cucumber
 
       def exceeded_tag_limts?(features)
         exceeded = false
-        configuration.options[:tag_names].each do |tag_name, limit|
-          if !Ast::Tags.exclude_tag?(tag_name) && limit
-            tag_count = features.tag_count(tag_name)
-            if tag_count > limit.to_i
-              exceeded = true
+        configuration.options[:tag_names].each do |tag_list|
+          tag_list.each do |tag_name, limit|
+            if !Ast::Tags.exclude_tag?(tag_name) && limit
+              tag_count = features.tag_count(tag_name)
+              if tag_count > limit.to_i
+                exceeded = true
+              end
             end
           end
         end

data/lib/cucumber/cli/options.rb

@@ -6,14 +6,14 @@ module Cucumber
       BUILTIN_FORMATS = {
         'html'      => ['Cucumber::Formatter::Html',     'Generates a nice looking HTML report.'],
         'pretty'    => ['Cucumber::Formatter::Pretty',   'Prints the feature as is - in colours.'],
-        'pdf'       => ['Cucumber::Formatter::Pdf',      "Generates a PDF report. You need to have the\n" + 
-                                                         "#{' ' * 51}prawn gem installed. Will pick up logo from\n" + 
+        'pdf'       => ['Cucumber::Formatter::Pdf',      "Generates a PDF report. You need to have the\n" +
+                                                         "#{' ' * 51}prawn gem installed. Will pick up logo from\n" +
                                                          "#{' ' * 51}features/support/logo.png or\n" +
                                                          "#{' ' * 51}features/support/logo.jpg if present."],
         'progress'  => ['Cucumber::Formatter::Progress', 'Prints one character per scenario.'],
         'rerun'     => ['Cucumber::Formatter::Rerun',    'Prints failing files with line numbers.'],
         'usage'     => ['Cucumber::Formatter::Usage',    "Prints where step definitions are used.\n" +
-                                                         "#{' ' * 51}The slowest step definitions (with duration) are\n" + 
+                                                         "#{' ' * 51}The slowest step definitions (with duration) are\n" +
                                                          "#{' ' * 51}listed first. If --dry-run is used the duration\n" +
                                                          "#{' ' * 51}is not shown, and step definitions are sorted by\n" +
                                                          "#{' ' * 51}filename instead."],
@@ -48,6 +48,10 @@ module Cucumber
         new(out_stream, error_stream, options).parse!(args)
       end
 
+      def self.parse_tag_arguments(tags_string)
+        tags_string.split(',')
+      end
+
       def initialize(out_stream = STDOUT, error_stream = STDERR, options = {})
         @out_stream   = out_stream
         @error_stream = error_stream
@@ -141,13 +145,18 @@ module Cucumber
           opts.on("-t TAGS", "--tags TAGS",
             "Only execute the features or scenarios with the specified tags.",
             "TAGS must be comma-separated without spaces. Example: --tags @dev\n",
+            "You can select tags using logical AND or logical OR:",
+            "To execute anything that is tagged with both @dev AND @prod\n",
+            "Example: --tags @dev,@prod",
+            "To execute anything that is tagged with @dev OR @prod\n",
+            "Example: --tags @dev --tags @prod\n",
             "Negative tags: Prefix tags with ~ to exclude features or scenarios",
             "having that tag. Example: --tags ~@slow\n",
             "Limit WIP: Positive tags can be given a threshold to limit the",
             "number of occurrences. Example: --tags @qa:3 will fail if there",
             "are more than 3 occurrences of the @qa tag.") do |v|
             tag_names = parse_tags(v)
-            @options[:tag_names].merge!(tag_names)
+            @options[:tag_names] << tag_names
           end
           opts.on("-n NAME", "--name NAME",
             "Only execute the feature elements which match part of the given name.",
@@ -158,7 +167,7 @@ module Cucumber
           opts.on("-e", "--exclude PATTERN", "Don't run feature files or require ruby files matching PATTERN") do |v|
             @options[:excludes] << Regexp.new(v)
           end
-          opts.on(PROFILE_SHORT_FLAG, "#{PROFILE_LONG_FLAG} PROFILE", 
+          opts.on(PROFILE_SHORT_FLAG, "#{PROFILE_LONG_FLAG} PROFILE",
               "Pull commandline arguments from cucumber.yml which can be defined as",
               "strings or arrays.  When a 'default' profile is defined and no profile",
               "is specified it is always used. (Unless disabled, see -P below.)",
@@ -241,7 +250,7 @@ module Cucumber
             Kernel.exit(0)
           end
         end.parse!
- 
+
         if @quiet
           @options[:snippets] = @options[:source] = false
         else
@@ -283,10 +292,10 @@ module Cucumber
       end
 
       def parse_tags(tag_string)
-        tag_names = tag_string.split(",")
+        tag_names = Options.parse_tag_arguments(tag_string)
         parse_tag_limits(tag_names)
       end
- 
+
       def parse_tag_limits(tag_names)
         tag_names.inject({}) do |dict, tag|
           tag, limit = tag.split(':')
@@ -331,7 +340,7 @@ module Cucumber
         @options[:require] += other_options[:require]
         @options[:excludes] += other_options[:excludes]
         @options[:name_regexps] += other_options[:name_regexps]
-        @options[:tag_names].merge! other_options[:tag_names]
+        @options[:tag_names] += other_options[:tag_names]
         @options[:env_vars] = other_options[:env_vars].merge(@options[:env_vars])
         if @options[:paths].empty?
           @options[:paths] = other_options[:paths]
@@ -384,7 +393,7 @@ module Cucumber
           :dry_run      => false,
           :formats      => [],
           :excludes     => [],
-          :tag_names    => {},
+          :tag_names    => [],
           :name_regexps => [],
           :env_vars     => {},
           :diff_enabled => true