cucumber 3.0.0 → 3.1.0

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/parameter_types.feature

@@ -1,53 +0,0 @@
-Feature: Parameter Types
-
-  Parameter Types allow you to convert primitive string arguments captured in step definitions
-  into more meaningful data types.
-
-  Background:
-    Let's just create a simple feature for testing out parameter types.
-    We also have a Person class that we need to be able to build.
-
-    Given a file named "features/foo.feature" with:
-      """
-      Feature:
-        Scenario:
-          Given Joe has gone home
-          When Sally contacts Joe
-      """
-    And a file named "features/step_definitions/steps.rb" with:
-      """
-      # It works with Regular Expressions
-      Given /([A-Z]\w+) has gone home/ do |person|
-        expect(person.name).to eq 'Joe'
-      end
-
-      # It works with Cucumber Expressions too
-      When "{person} contacts {person}" do |contacter, contactee|
-        expect(contacter.name).to eq 'Sally'
-        expect(contactee.name).to eq 'Joe'
-      end
-      """
-    And a file named "features/support/env.rb" with:
-      """
-      class Person
-        attr_reader :name
-
-        def initialize(name)
-          @name = name
-        end
-      end
-      """
-
-  Scenario: Parameter type defined with ParameterType method
-    This is the most basic way to use a parameter type.
-
-    Given a file named "features/support/parameter_types.rb" with:
-      """
-      ParameterType(
-        name: 'person',
-        regexp: /[A-Z]\w+/,
-        transformer: -> (name) { Person.new(name) }
-      )
-      """
-    When I run `cucumber features/foo.feature`
-    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,95 +0,0 @@
-Feature: Tagged hooks
-
-  Background:
-    Given the standard step definitions
-    And a file named "features/support/hooks.rb" with:
-      """
-      Before('not @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/docs/writing_support_code/world.feature

@@ -1,129 +0,0 @@
-Feature: World
-
-  In order to isolate each test scenario, the steps definitions belonging to the
-  same scenario will run in a isolated context, called 'world'. A world also
-  contains the helpers methods that will be used in the step definitions.
-
-  It is possible to add helpers methods to a world in three different ways:
-
-  1. Passing a module. In this case its methods will be added directly to the
-     world and be usable in the step definitions.
-
-  2. Passing a block, where the return value is the world object.
-
-  3. Passing a hash, where the keys are namespaces and the values are
-     modules. In this case, the methods of each module will be accessible using
-     the key as prefix.
-
-  Scenario: A world is extended using a module
-    Given a file named "features/support/helpers.rb" with:
-      """
-      module Helpers
-        def helper_method
-          42
-        end
-      end
-
-      World(Helpers)
-      """
-    And a file named "features/step_definitions/step.rb" with:
-      """
-      Then /^the helper method is called$/ do
-        expect(helper_method).to eql(42)
-      end
-      """
-    And a file named "features/f.feature" with:
-      """
-      Feature: Calling a method
-        Scenario: I call a method without namespaces
-          Then the helper method is called
-      """
-    When I run `cucumber features/f.feature`
-    Then it should pass
-
-  Scenario: A world is created using a block
-    Given a file named "features/support/helpers.rb" with:
-      """
-      class Helper
-        def helper_method
-          42
-        end
-      end
-
-      World do
-        Helper.new
-      end
-      """
-    And a file named "features/step_definitions/step.rb" with:
-      """
-      Then /^the helper method is called$/ do
-        expect(helper_method).to eql(42)
-      end
-      """
-    And a file named "features/f.feature" with:
-      """
-      Feature: Calling a method
-        Scenario: I call a method from a namespace
-          Then the helper method is called
-      """
-    When I run `cucumber features/f.feature`
-    Then it should pass
-
-  Scenario: A world is extended using a module with namespace
-    Given a file named "features/support/helpers.rb" with:
-      """
-      module Helpers
-        def helper_method
-          42
-        end
-      end
-
-      World(my_namespace: Helpers)
-      """
-    And a file named "features/step_definitions/step.rb" with:
-      """
-      Then /^the helper method is called$/ do
-        expect(my_namespace.helper_method).to eql(42)
-      end
-      """
-    And a file named "features/f.feature" with:
-      """
-      Feature: Calling a method
-        Scenario: I call a method from a namespace
-          Then the helper method is called
-      """
-    When I run `cucumber features/f.feature`
-    Then it should pass
-
-  Scenario: A world is extended using multiple modules with different namespaces
-    Given a file named "features/support/helpers.rb" with:
-      """
-      module ModuleOne
-        def forty_one
-          41
-        end
-      end
-
-      module ModuleTwo
-        def forty_two
-          42
-        end
-      end
-
-      World(module_one: ModuleOne, module_two: ModuleTwo)
-      """
-    And a file named "features/step_definitions/step.rb" with:
-      """
-      Then /^the helper method is called$/ do
-        expect(module_one.forty_one).to eql(41)
-        expect(module_two.forty_two).to eql(42)
-      end
-      """
-    And a file named "features/f.feature" with:
-      """
-      Feature: Calling a method
-        Scenario: I call a method from two namespaces
-          Then the helper method is called
-      """
-    When I run `cucumber features/f.feature`
-    Then it should pass

data/features/lib/step_definitions/aruba_steps.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-Then(/^it should (pass|fail)$/) do |result|
-  assert_success result == 'pass'
-end
-
-Then('{string} should not be required') do |file_name|
-  expect(all_output).not_to include("* #{file_name}")
-end
-
-Then('{string} 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
-
-Then('the output includes the message {string}') do |message|
-  expect(all_output).to include(message)
-end

data/features/lib/step_definitions/cli_steps.rb

@@ -1,4 +0,0 @@
-# frozen_string_literal: true
-Then('I should see the CLI help') do
-  expect(all_output).to include('Usage:')
-end

data/features/lib/step_definitions/cucumber_steps.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-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
-
-Given('a scenario {string} that passes') do |name|
-  write_file "features/#{name}.feature",
-  <<-FEATURE
-  Feature: #{name}
-    Scenario: #{name}
-      Given it passes
-  FEATURE
-
-  write_file "features/step_definitions/#{name}_steps.rb",
-  <<-STEPS
-  Given(/^it passes$/) { expect(true).to be true }
-  STEPS
-end
-
-Given('a scenario {string} that fails') do |name|
-  write_file "features/#{name}.feature",
-  <<-FEATURE
-  Feature: #{name}
-    Scenario: #{name}
-      Given it fails
-  FEATURE
-
-  write_file "features/step_definitions/#{name}_steps.rb",
-  <<-STEPS
-  Given(/^it fails$/) { expect(false).to be true }
-  STEPS
-end
-
-When(/^I run the feature with the (\w+) formatter$/) do |formatter|
-  expect(features.length).to eq 1
-  run_feature features.first, formatter
-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,16 +0,0 @@
-# encoding: iso-8859-1
-# frozen_string_literal: true
-# 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,8 +0,0 @@
-# frozen_string_literal: true
-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,14 +0,0 @@
-# frozen_string_literal: true
-Then('the junit output file {string} should contain:') do |actual_file, text|
-  actual = IO.read(current_dir + '/' + actual_file)
-  actual = replace_junit_time(actual)
-  expect(actual).to eq text
-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 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-Then('cucumber lists all the supported languages') do
-  sample_languages = %w(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,16 +0,0 @@
-# frozen_string_literal: true
-Given('the following profile(s) are/is defined:') do |profiles|
-  write_file 'cucumber.yml', profiles
-end
-
-Then('the {word} profile should be used') do |profile|
-  step 'the stdout should contain:', profile
-end
-
-Then('exactly these files should be loaded: {list}') do |files|
-  expect(all_stdout.scan(/^  \* (.*\.rb)$/).flatten).to eq files
-end
-
-Then('exactly these features should be run: {list}') do |files|
-  expect(all_stdout.scan(/^  \* (.*\.feature)$/).flatten).to eq files
-end

data/features/lib/step_definitions/retry_steps.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-Given('a scenario {string} that fails once, then passes') do |full_name|
-  name = snake_case(full_name)
-  write_file "features/#{name}.feature",
-  <<-FEATURE
-  Feature: #{full_name} feature
-    Scenario: #{full_name}
-      Given it fails once, then passes
-  FEATURE
-
-  write_file "features/step_definitions/#{name}_steps.rb",
-  <<-STEPS
-  Given(/^it fails once, then passes$/) do
-    $#{name} += 1
-    expect($#{name}).to be > 1
-  end
-  STEPS
-
-  write_file "features/support/#{name}_init.rb",
-  <<-INIT
-  $#{name} = 0
-  INIT
-end
-
-Given('a scenario {string} that fails twice, then passes') do |full_name|
-  name = snake_case(full_name)
-  write_file "features/#{name}.feature",
-  <<-FEATURE
-  Feature: #{full_name} feature
-    Scenario: #{full_name}
-      Given it fails twice, then passes
-  FEATURE
-
-  write_file "features/step_definitions/#{name}_steps.rb",
-  <<-STEPS
-  Given(/^it fails twice, then passes$/) do
-    $#{name} ||= 0
-    $#{name} += 1
-    expect($#{name}).to be > 2
-  end
-  STEPS
-
-  write_file "features/support/#{name}_init.rb",
-  <<-INIT
-  $#{name} = 0
-  INIT
-end
-
-module SnakeCase
-  def snake_case(name)
-    name.downcase.gsub(/\W/, '_')
-  end
-end
-
-World(SnakeCase)

data/features/lib/step_definitions/ruby_steps.rb

@@ -1,4 +0,0 @@
-# frozen_string_literal: true
-When('I run the following Ruby code:') do |code|
-  run_simple %{ruby -e "#{code}"}
-end

data/features/lib/support/env.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-require 'aruba/cucumber'
-require 'aruba/in_process'
-require 'aruba/spawn_process'
-require 'cucumber/cli/main'
-
-Before('@spawn') do
-  Aruba.process = Aruba::SpawnProcess
-end
-
-Before('not @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 ? 60 : 15
-end

data/features/lib/support/fake_wire_server.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-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
-      message = @socket.gets
-
-      while message
-        handle(message)
-        message = @socket.gets
-      end
-    end
-
-    private
-
-    def handle(data)
-      protocol_entry = response_to(data.strip)
-
-      if protocol_entry
-        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
-      response = [
-                    'fail',
-                    {
-                      :message => e.message,
-                      :backtrace => e.backtrace,
-                      :exception => e.class
-                    }
-                  ].to_json
-      send_response(response)
-    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