cucumber 2.0.0.rc.4 → 4.0.0.rc.2

data/features/docs/writing_support_code/before_hook.feature

@@ -1,61 +0,0 @@
-Feature: Before Hook
-
-  Scenario: Examine names of scenario and feature
-    Given a file named "features/foo.feature" with:
-      """
-      Feature: Feature name
-
-        Scenario: Scenario name
-          Given a step
-      """
-    And a file named "features/support/hook.rb" with:
-      """
-      names = []
-      Before do |scenario|
-        expect(scenario).to_not respond_to(:scenario_outline)
-        names << scenario.feature.name.split("\n").first
-        names << scenario.name.split("\n").first
-        if(names.size == 2)
-          raise "NAMES:\n" + names.join("\n") + "\n"
-        end
-      end
-      """
-    When I run `cucumber`
-    Then the output should contain:
-      """
-        NAMES:
-        Feature name
-        Scenario: Scenario name
-      """
-
-  Scenario: Examine names of scenario outline and feature
-    Given a file named "features/foo.feature" with:
-      """
-      Feature: Feature name
-
-        Scenario Outline: Scenario Outline name
-          Given a <placeholder>
-
-          Examples: Examples Table name
-            | <placeholder> |
-            | step          |
-      """
-    And a file named "features/support/hook.rb" with:
-      """
-      names = []
-      Before do |scenario|
-        names << scenario.scenario_outline.feature.name.split("\n").first
-        names << scenario.scenario_outline.name.split("\n").first
-        if(names.size == 2)
-          raise "NAMES:\n" + names.join("\n") + "\n"
-        end
-      end
-      """
-    When I run `cucumber`
-    Then the output should contain:
-      """
-            NAMES:
-            Feature name
-            Scenario Outline: Scenario Outline name
-      """
-

data/features/docs/writing_support_code/hook_order.feature

@@ -1,61 +0,0 @@
-  @spawn
-  Feature: Hooks execute in defined order
-
-  Background:
-    Given a file named "features/step_definitions/steps.rb" with:
-      """
-      Given /^background step$/ do; $EventOrder.push(:background_step) end
-      Given /^scenario step$/ do; $EventOrder.push(:scenario_step) end
-      """
-    And a file named "features/support/hooks.rb" with:
-      """
-      $EventOrder = []
-      Around('@around') do |scenario,block|
-        $EventOrder.push :around_begin
-        block.call
-        $EventOrder.push :around_end
-      end
-      Before('@before') do
-        $EventOrder.push :before
-      end
-      After('@after') do |scenario|
-        $EventOrder.push :after
-      end
-      at_exit {
-        puts "Event order: #{$EventOrder.join(' ')}"
-      }
-      """
-    And a file named "features/around_hook_covers_background.feature" with:
-      """
-      @around
-      Feature: Around hooks cover background steps
-        Background:
-          Given background step
-        Scenario:
-          Given scenario step
-      """
-    And a file named "features/all_hook_order.feature" with:
-      """
-      @around
-      @before
-      @after
-      Feature: All hooks execute in expected order
-        Background:
-          Given background step
-        Scenario:
-          Given scenario step
-      """
-
-  Scenario: Around hooks cover background steps
-    When I run `cucumber -o /dev/null features/around_hook_covers_background.feature`
-    Then the output should contain:
-      """
-      Event order: around_begin background_step scenario_step around_end
-      """
-
-  Scenario: All hooks execute in expected order
-    When I run `cucumber -o /dev/null features/all_hook_order.feature`
-    Then the output should contain:
-      """
-      Event order: around_begin before background_step scenario_step after around_end
-      """

data/features/docs/writing_support_code/load_path.feature

@@ -1,17 +0,0 @@
-Feature: Set up a default load path
-
-  When you're developing a gem, it's convenient if your project's `lib` directory
-  is already in the load path. Cucumber does this for you.
-
-  Scenario: ./lib is included in the $LOAD_PATH
-    Given a file named "features/support/env.rb" with:
-      """
-      require 'something'
-      """
-    And a file named "lib/something.rb" with:
-      """
-      class Something
-      end
-      """
-    When I run `cucumber`
-    Then it should pass

data/features/docs/writing_support_code/state.feature

@@ -1,32 +0,0 @@
-Feature: State
-
-  You can pass state between step by setting instance variables,
-  but those instance variables will be gone when the next scenario runs.
-
-  Scenario: Set an ivar in one scenario, use it in the next step
-    Given a file named "features/test.feature" with:
-      """
-      Feature:
-        Scenario:
-          Given I have set @flag = true
-          Then @flag should be true
-
-        Scenario:
-          Then @flag should be nil
-      """
-    And a file named "features/step_definitions/steps.rb" with:
-      """
-      Given /set @flag/ do
-        @flag = true
-      end
-      Then /flag should be true/ do
-        expect(@flag).to be_truthy
-      end
-      Then /flag should be nil/ do
-        expect(@flag).to be_nil
-      end
-      """
-    When I run `cucumber`
-    Then it should pass
-
-

data/features/docs/writing_support_code/tagged_hooks.feature

@@ -1,57 +0,0 @@
-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
-      """
-
-  @spawn
-  Scenario: Invoke tagged hook
-    When I run `cucumber features/f.feature:2`
-    Then it should fail with:
-      """
-      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)
-
-      """
-
-    Scenario: Omit tagged hook
-      When I run `cucumber features/f.feature:6`
-      Then it should pass with:
-        """
-        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)
-
-        """
-
-

data/features/lib/step_definitions/aruba_steps.rb

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

@@ -1,50 +0,0 @@
-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/lib/step_definitions/iso-8859-1_steps.rb

@@ -1,12 +0,0 @@
-# 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|
-  expect(drink).to eq '�l'.encode('UTF-8')
-end
-
-When /^skal de andre si "([^"]*)"$/ do |greeting|
-  expect(greeting).to eq 'sk�l'.encode('UTF-8')
-end

data/features/lib/step_definitions/json_steps.rb

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

@@ -1,13 +0,0 @@
-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,8 +0,0 @@
-# encoding: utf-8
-
-Then(/^cucumber lists all the supported languages$/) do
-  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

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

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

data/features/lib/step_definitions/wire_steps.rb

@@ -1,41 +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
-
-module WireHelper
-  def start_wire_server
-    @wire_pid = fork { @server.run }
-    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

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

@@ -1,77 +0,0 @@
-require 'multi_json'
-require 'socket'
-
-class FakeWireServer
-  def initialize(port, protocol_table)
-    @port, @protocol_table = port, protocol_table
-    @delays = {}
-  end
-
-  def run
-    @server = TCPServer.open(@port)
-    loop { handle_connections }
-  end
-
-  def delay_response(message, delay)
-    @delays[message] = delay
-  end
-
-  private
-
-  def handle_connections
-    Thread.start(@server.accept) { |socket| open_session_on socket }
-  end
-
-  def open_session_on(socket)
-    begin
-      SocketSession.new(socket, @protocol_table, @delays).start
-    rescue Exception => e
-      raise e
-    ensure
-      socket.close
-    end
-  end
-
-  class SocketSession
-    def initialize(socket, protocol, delays)
-      @socket = socket
-      @protocol = protocol
-      @delays = delays
-    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)
-        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