cucumber 1.3.10 → 2.0.0

data/features/docs/writing_support_code/tagged_hooks.feature

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

data/features/lib/step_definitions/aruba_steps.rb

@@ -0,0 +1,22 @@
+Given('a Gemfile with:') do |content|
+  path = File.expand_path(current_dir + "/Gemfile")
+  write_file path, content
+  set_env "BUNDLE_GEMFILE", path
+end
+
+Then(/^it should (pass|fail)$/) do |result|
+  assert_success result == 'pass'
+end
+
+Then(/^"([^"]*)" should not be required$/) do |file_name|
+  expect(all_output).not_to include("* #{file_name}")
+end
+
+Then(/^"([^"]*)" should be required$/) do |file_name|
+  expect(all_output).to include("* #{file_name}")
+end
+
+Then /^it fails before running features with:$/ do |expected|
+  assert_matching_output("\\A#{expected}", all_output)
+  assert_success(false)
+end

data/features/lib/step_definitions/cucumber_steps.rb

@@ -0,0 +1,50 @@
+Given /^a directory without standard Cucumber project directory structure$/ do
+  in_current_dir do
+    FileUtils.rm_rf 'features' if File.directory?('features')
+  end
+end
+
+Given /^a scenario with a step that looks like this:$/ do |string|
+  create_feature do
+    create_scenario { string }
+  end
+end
+
+Given(/^a scenario with a step that looks like this in japanese:$/) do |string|
+  create_feature_ja do
+    create_scenario_ja { string }
+  end
+end
+
+Given(/^the standard step definitions$/) do
+  write_file 'features/step_definitions/steps.rb',
+
+  <<-STEPS
+  Given(/^this step passes$/)          { }
+  Given(/^this step raises an error$/) { raise 'error' }
+  Given(/^this step is pending$/)      { pending }
+  Given(/^this step fails$/)           { fail }
+  Given(/^this step is a table step$/) {|t| }
+  STEPS
+end
+
+Given /^a step definition that looks like this:$/ do |string|
+  create_step_definition { string }
+end
+
+When /^I run the feature with the (\w+) formatter$/ do |formatter|
+  expect(features.length).to eq 1
+  run_feature features.first, formatter
+end
+
+Then /^the stderr should contain a warning message$/ do
+  expect(all_stderr).to include("[warning]")
+end
+
+module CucumberHelper
+  def run_feature(filename = 'features/a_feature.feature', formatter = 'progress')
+    run_simple "#{Cucumber::BINARY} #{filename} --format #{formatter}", false
+  end
+end
+
+World(CucumberHelper)

data/features/{step_definitions → lib/step_definitions}/iso-8859-1_steps.rb

@@ -1,24 +1,12 @@
 # encoding: iso-8859-1
 # Ideally we would use Norwegian keywords here, but that won't work unless this file is UTF-8 encoded.
 # Alternatively it would be possible to use Norwegian keywords and encode the file as UTF-8.
-# 
+#
 # In both cases, stepdef arguments will be sent in as UTF-8, regardless of what encoding is used.
 Given /^jeg drikker en "([^"]*)"$/ do |drink|
-  drink.should == utf8('�l', 'iso-8859-1')
+  expect(drink).to eq '�l'.encode('UTF-8')
 end
 
 When /^skal de andre si "([^"]*)"$/ do |greeting|
-  greeting.should == utf8('sk�l', 'iso-8859-1')
+  expect(greeting).to eq 'sk�l'.encode('UTF-8')
 end
-
-module EncodingHelper
-  def utf8(string, encoding)
-    if string.respond_to?(:encode) # Ruby 1.9
-      string.encode('UTF-8')
-    else # Ruby 1.8
-      require 'iconv'
-      Iconv.new('UTF-8', encoding).iconv(string)
-    end
-  end
-end
-World(EncodingHelper)

data/features/lib/step_definitions/json_steps.rb

@@ -0,0 +1,7 @@
+Then /^it should (pass|fail) with JSON:$/ do |pass_fail, json|
+  actual = normalise_json(MultiJson.load(all_stdout))
+  expected = MultiJson.load(json)
+
+  expect(actual).to eq expected
+  assert_success(pass_fail == 'pass')
+end

data/features/lib/step_definitions/junit_steps.rb

@@ -0,0 +1,13 @@
+Then(/^the junit output file "(.*?)" should contain:$/) do |actual_file, text|
+  actual = IO.read(current_dir + '/' + actual_file)
+  actual = replace_junit_time(actual)
+  expect(actual).to eq text.to_s
+end
+
+module JUnitHelper
+  def replace_junit_time(s)
+    s.gsub(/\d+\.\d\d+/m, '0.05')
+  end
+end
+
+World(JUnitHelper)

data/features/lib/step_definitions/language_steps.rb

@@ -1,9 +1,8 @@
 # encoding: utf-8
 
 Then(/^cucumber lists all the supported languages$/) do
-  all_output.should include("Arabic")
-  all_output.should include("български")
-  all_output.should include("Pirate")
-  all_output.should include("English")
-  all_output.should include("日本語")
+  sample_languages = ["Arabic", "български", "Pirate", "English", "日本語"]
+  sample_languages.each do |language|
+    expect(all_output.force_encoding('utf-8')).to include(language)
+  end
 end

data/features/lib/step_definitions/profile_steps.rb

@@ -0,0 +1,15 @@
+Given /^the following profiles? (?:are|is) defined:$/ do |profiles|
+  write_file 'cucumber.yml', profiles
+end
+
+Then /^the (.*) profile should be used$/ do |profile|
+  step 'the stdout should contain:', profile
+end
+
+Then /^exactly these files should be loaded:\s*(.*)$/ do |files|
+  expect(all_stdout.scan(/^  \* (.*\.rb)$/).flatten).to eq files.split(/,\s+/)
+end
+
+Then /^exactly these features should be ran:\s*(.*)$/ do |files|
+  expect(all_stdout.scan(/^  \* (.*\.feature)$/).flatten).to eq files.split(/,\s+/)
+end

data/features/lib/step_definitions/ruby_steps.rb

@@ -0,0 +1,3 @@
+When(/^I run the following Ruby code:$/) do |code|
+  run_simple %{ruby -e "#{code}"}
+end

data/features/lib/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('@wire') do
+  extend(WireHelper)
+end
+
+After('@wire') do
+  stop_wire_server
+end

data/features/lib/support/env.rb

@@ -0,0 +1,21 @@
+require 'aruba/cucumber'
+require 'aruba/in_process'
+require 'aruba/spawn_process'
+require 'cucumber/cli/main'
+
+Before('@spawn') do
+  Aruba.process = Aruba::SpawnProcess
+end
+
+Before('~@spawn') do
+  Aruba::InProcess.main_class = Cucumber::Cli::Main
+  Aruba.process = Aruba::InProcess
+end
+
+Before do
+  # Make sure bin/cucumber runs with SimpleCov enabled
+  # set_env('SIMPLECOV', 'true')
+
+  # Set a longer timeout for aruba, and a really long one if running on JRuby
+  @aruba_timeout_seconds = Cucumber::JRUBY ? 35 : 15
+end

data/{legacy_features → features/lib}/support/fake_wire_server.rb

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

data/features/{support → lib/support}/feature_factory.rb

@@ -50,7 +50,7 @@ Feature: #{name}
   end
 
   def generate_step_definition_filename
-    "features/step_definitions/test_steps#{next_increment(:step_defs)}.rb"
+    "features/step_definitions/steps#{next_increment(:step_defs)}.rb"
   end
 
   def filename(name)

data/features/lib/support/normalise_output.rb

@@ -0,0 +1,33 @@
+# override aruba to filter out some stuff
+module NormaliseArubaOutput
+  def all_stdout
+    normalise_output(super)
+  end
+
+  def normalise_output(out)
+    out = out.gsub(/#{Dir.pwd}\/tmp\/aruba/, '.') # Remove absolute paths
+    out = out.gsub(/tmp\/aruba\//, '')            # Fix aruba path
+    out = out.gsub(/^.*cucumber_process\.rb.*$\n/, '')
+    out = out.gsub(/^\d+m\d+\.\d+s$/, '0m0.012s') # Make duration predictable
+    out = out.gsub(/Coverage report generated .+$\n/, '') # Remove SimpleCov message
+  end
+
+  def normalise_json(json)
+    #make sure duration was captured (should be >= 0)
+    #then set it to what is "expected" since duration is dynamic
+    json.each do |feature|
+      elements = feature.fetch('elements') { [] }
+      elements.each do |scenario|
+        scenario['steps'].each do |step|
+          if step['result']
+            expect(step['result']['duration']).to be >= 0
+            step['result']['duration'] = 1
+          end
+        end
+      end
+    end
+  end
+end
+
+World(NormaliseArubaOutput)
+

data/gem_tasks/cov.rake

@@ -0,0 +1,5 @@
+desc 'Run all tests and collect code coverage'
+task :cov do
+  ENV['SIMPLECOV'] = 'features'
+  Rake::Task['default'].invoke
+end

data/gem_tasks/cucumber.rake

@@ -7,12 +7,12 @@ class Cucumber::Rake::Task
       Cucumber::WINDOWS ? 'jruby_win' : 'jruby'
     elsif Cucumber::WINDOWS_MRI
       'windows_mri'
-    elsif Cucumber::RUBY_1_8_7
-      'ruby_1_8_7'
     elsif Cucumber::RUBY_1_9
       'ruby_1_9'
     elsif Cucumber::RUBY_2_0
       'ruby_2_0'
+    elsif Cucumber::RUBY_2_1
+      'ruby_2_1'
     end
   end
 end
@@ -22,9 +22,4 @@ Cucumber::Rake::Task.new(:features) do |t|
   t.set_profile_for_current_ruby
 end
 
-Cucumber::Rake::Task.new(:legacy_features) do |t|
-  t.fork = true
-  t.profile = :legacy
-end
-
-task :cucumber => [:features, :legacy_features]
+task :cucumber => :features

data/gem_tasks/rspec.rake

@@ -2,7 +2,5 @@ require 'rspec/core/rake_task'
 
 desc "Run RSpec"
 RSpec::Core::RakeTask.new do |t|
-  t.rcov = ENV['RCOV']
-  t.rcov_opts = %w{--exclude osx\/objc,gems\/,spec\/}
   t.verbose = true
 end

data/lib/cucumber/ast.rb

@@ -1,30 +1,13 @@
-require 'cucumber/ast/comment'
-require 'cucumber/ast/features'
-require 'cucumber/ast/feature'
-require 'cucumber/ast/background'
-require 'cucumber/ast/scenario'
-require 'cucumber/ast/scenario_outline'
-require 'cucumber/ast/step_invocation'
-require 'cucumber/ast/step_collection'
-require 'cucumber/ast/step'
-require 'cucumber/ast/table'
-require 'cucumber/ast/tags'
-require 'cucumber/ast/doc_string'
-require 'cucumber/ast/outline_table'
-require 'cucumber/ast/examples'
-require 'cucumber/ast/visitor'
-require 'cucumber/ast/tree_walker'
+require 'cucumber/multiline_argument'
 
 module Cucumber
-  # Classes in this module represent the Abstract Syntax Tree (AST)
-  # that gets built when feature files are parsed.
-  #
-  # AST classes don't expose any internal data directly. This is
-  # in order to encourage a less coupled design in the classes
-  # that operate on the AST. The only public method is #accept.
-  #
-  # The AST can be traversed with a visitor. See Cucumber::Format::Pretty
-  # for an example.
   module Ast
+    def self.const_missing(const_name)
+      if const_name == :Table
+        warn "`Cucumber::Ast::Table` has been deprecated. Use `Cucumber::MultilineArgument::DataTable` instead."
+        return Cucumber::MultilineArgument::DataTable
+      end
+      raise "`Cucumber::Ast` no longer exists. These classes have moved into the `Cucumber::Core::Ast` namespace, but may not have the same API."
+    end
   end
 end

data/lib/cucumber/cli/configuration.rb

@@ -25,10 +25,8 @@ module Cucumber
         @options.parse!(args)
         arrange_formats
         raise("You can't use both --strict and --wip") if strict? && wip?
-
+        # todo: remove
         @options[:tag_expression] = Gherkin::TagExpression.new(@options[:tag_expressions])
-        return @args.replace(@options.expanded_args_without_drb) if drb?
-
         set_environment_variables
       end
 
@@ -36,6 +34,14 @@ module Cucumber
         @options[:verbose]
       end
 
+      def randomize?
+        @options[:order] == 'random'
+      end
+
+      def seed
+        Integer(@options[:seed] || rand(0xFFFF))
+      end
+
       def strict?
         @options[:strict]
       end
@@ -48,14 +54,6 @@ module Cucumber
         @options[:guess]
       end
 
-      def drb?
-        @options[:drb]
-      end
-
-      def drb_port
-        @options[:drb_port].to_i if @options[:drb_port]
-      end
-
       def dry_run?
         @options[:dry_run]
       end
@@ -64,18 +62,10 @@ module Cucumber
         @options[:expand]
       end
 
-      def dotcucumber
-        @options[:dotcucumber]
-      end
-
       def snippet_type
         @options[:snippet_type] || :regexp
       end
 
-      def build_tree_walker(runtime)
-        Ast::TreeWalker.new(runtime, formatters(runtime), self)
-      end
-
       def formatter_class(format)
         if(builtin = Options::BUILTIN_FORMATS[format])
           constantize(builtin[0])
@@ -117,7 +107,7 @@ module Cucumber
             Dir["#{path}/**/*.feature"].sort
           elsif path[0..0] == '@' and # @listfile.txt
               File.file?(path[1..-1]) # listfile.txt is a file
-            IO.read(path[1..-1]).split
+            IO.read(path[1..-1]).split(/(.*?\.feature.*?) /).collect(&:strip).reject(&:empty?)
           else
             path
           end
@@ -140,10 +130,23 @@ module Cucumber
         logger
       end
 
+      # todo: remove
       def tag_expression
         Gherkin::TagExpression.new(@options[:tag_expressions])
       end
 
+      def tag_limits
+        tag_expression.limits.to_hash
+      end
+
+      def tag_expressions
+        @options[:tag_expressions]
+      end
+
+      def name_regexps
+        @options[:name_regexps]
+      end
+
       def filters
         @options.filters
       end
@@ -160,27 +163,14 @@ module Cucumber
       def paths
         @options[:paths]
       end
-    private
-      def with_default_features_path(paths)
-        return ['features'] if paths.empty?
-        paths
-      end
-
-
-      def formatters(runtime)
-        # TODO: We should remove the autoformat functionality. That
-        # can be done with the gherkin CLI.
-        if @options[:autoformat]
-          require 'cucumber/formatter/pretty'
-          return [Formatter::Pretty.new(runtime, out_stream, @options)]
-        end
 
+      def formatter_factories
         @options[:formats].map do |format_and_out|
           format = format_and_out[0]
           path_or_io = format_and_out[1]
           begin
-            formatter_class = formatter_class(format)
-            formatter_class.new(runtime, path_or_io, @options)
+            factory = formatter_class(format)
+            yield factory, path_or_io, @options
           rescue Exception => e
             e.message << "\nError creating formatter: #{format}"
             raise e
@@ -188,13 +178,19 @@ module Cucumber
         end
       end
 
+      private
+
+      def with_default_features_path(paths)
+        return ['features'] if paths.empty?
+        paths
+      end
+
       class LogFormatter < ::Logger::Formatter
         def call(severity, time, progname, msg)
           msg
         end
       end
 
-
       def set_environment_variables
         @options[:env_vars].each do |var, value|
           ENV[var] = value