cucumber 3.0.0.pre.2 → 4.0.0.rc.5

data/features/docs/writing_support_code/hook_order.feature

@@ -1,63 +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
-      """
-
-  @todo-windows
-  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
-      """
-
-  @todo-windows
-  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/parameter_types.feature

@@ -1,75 +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+/,
-        type: Person,
-        transformer: lambda do |name|
-          Person.new(name)
-        end,
-        use_for_snippets: true,
-        prefer_for_regexp_match: false
-      )
-      """
-    When I run `cucumber features/foo.feature`
-    Then it should pass
-
-  Scenario: Parameter type defined with legacy Transform method
-    This is for backwards compatibility - works with regular expressions,
-    but not with Cucumber Expressions, because no name is specified for the
-    parameter type.
-
-    Given a file named "features/support/transforms.rb" with:
-      """
-      Transform(/[A-Z]\w+/) do |name|
-        Person.new(name)
-      end
-      """
-    When I run `cucumber features/foo.feature`
-    Then it should fail with:
-      """
-      Undefined parameter type {person}
-      """

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)