cucumber 3.0.0.pre.1 → 4.0.0.rc.4

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,95 +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
-
-        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/transforms.feature

@@ -1,98 +0,0 @@
-Feature: Transforms
-
-  Transforms 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 Transforms.
-    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 a Person aged 15 with blonde hair
-      """
-    And a file named "features/support/person.rb" with:
-      """
-      class Person
-        attr_accessor :age
-      
-        def to_s
-          "I am #{age} years old"
-        end
-      end
-      """
-
-  Scenario: Basic Transform
-    This is the most basic way to use a transform. Notice that the regular
-    expression is pretty much duplicated between the step defintion and the 
-    transform itself.
-
-    And a file named "features/step_definitions/steps.rb" with:
-      """
-      Transform(/a Person aged (\d+)/) do |age|
-        person = Person.new
-        person.age = age.to_i
-        person
-      end
-      
-      Given /^(a Person aged \d+) with blonde hair$/ do |person|
-        expect(person.age).to eq 15
-      end
-      """
-    When I run `cucumber features/foo.feature`
-    Then it should pass
-
-  Scenario: Re-use Transform's Regular Expression
-    If you keep a reference to the transform, you can use it in your
-    regular expressions to avoid repeating the regular expression.
-
-    And a file named "features/step_definitions/steps.rb" with:
-      """
-      A_PERSON = Transform(/a Person aged (\d+)/) do |age|
-        person = Person.new
-        person.age = age.to_i
-        person
-      end
-
-      Given /^(#{A_PERSON}) with blonde hair$/ do |person|
-        expect(person.age).to eq 15
-      end
-      """
-    When I run `cucumber features/foo.feature`
-    Then it should pass
-
-  Scenario: Use Transform from code
-    You can also call the `Transform` method from within a step definition to
-    dynamically run a tranform.
-
-    Note that this is rather useless at present, unless the transform itself has a side-effect, since the `Transform`
-    function still returns the regular expression pattern.
-
-    Given a file named "features/people.feature" with:
-      """
-      Feature:
-        Scenario:
-          Given people with these ages:
-            | name  | age |
-            | sue   | 25  |
-            | sally | 77  |
-      """
-    And a file named "features/step_definitions/steps.rb" with:
-      """
-      Transform(/a Person aged (\d+)/) do |age|
-        $person = Person.new
-        $person.age = age.to_i
-        $person
-      end
-
-      Given(/^people with these ages:$/) do |table|
-        table.rows.each do |name, age|
-          Transform("a Person aged #{age}")
-          expect($person.age).to eq age.to_i
-        end
-      end
-      """
-    When I run `cucumber features/people.feature`
-    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,27 +0,0 @@
-# frozen_string_literal: true
-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
-
-Then(/^the output includes the message "(.*)"$/) do |message|
-  expect(all_output).to include(message)
-end