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

data/features/docs/exception_in_around_hook.feature

@@ -1,78 +0,0 @@
-Feature: Exceptions in Around Hooks
-
-  Around hooks are awkward beasts to handle internally.
-
-  Right now, if there's an error in your Around hook before you call `block.call`,
-  we won't even print the steps for the scenario.
-
-  This is because that `block.call` invokes all the logic that would tell Cucumber's
-  UI about the steps in your scenario. If we never reach that code, we'll never be
-  told about them.
-
-  There's another scenario to consider, where the exception occurs after the steps
-  have been run. How would we want to report in that case?
-
-  Scenario: Exception before the test case is run
-    Given the standard step definitions
-    And a file named "features/support/env.rb" with:
-      """
-      Around do |scenario, block|
-        fail "this should be reported"
-        block.call
-      end
-      """
-    And a file named "features/test.feature" with:
-      """
-      Feature:
-        Scenario:
-          Given this step passes
-      """
-    When I run `cucumber -q`
-    Then it should fail with exactly:
-      """
-      Feature: 
-
-        Scenario: 
-        this should be reported (RuntimeError)
-        ./features/support/env.rb:2:in `Around'
-      
-      Failing Scenarios:
-      cucumber features/test.feature:2
-      
-      1 scenario (1 failed)
-      0 steps
-      
-      """
-
-  Scenario: Exception after the test case is run
-    Given the standard step definitions
-    And a file named "features/support/env.rb" with:
-      """
-      Around do |scenario, block|
-        block.call
-        fail "this should be reported"
-      end
-      """
-    And a file named "features/test.feature" with:
-      """
-      Feature:
-        Scenario:
-          Given this step passes
-      """
-    When I run `cucumber -q`
-    Then it should fail with exactly:
-      """
-      Feature: 
-
-        Scenario: 
-          Given this step passes
-            this should be reported (RuntimeError)
-            ./features/support/env.rb:3:in `Around'
-      
-      Failing Scenarios:
-      cucumber features/test.feature:2
-      
-      1 scenario (1 failed)
-      1 step (1 passed)
-
-      """

data/features/docs/exception_in_before_hook.feature

@@ -1,96 +0,0 @@
-Feature: Exception in Before Block
-  In order to know with confidence that my before blocks have run OK
-  As a developer
-  I want exceptions raised in Before blocks to be handled gracefully and reported by the formatters
-
-  Background:
-    Given the standard step definitions
-    And a file named "features/support/env.rb" with:
-      """
-      class SomeSetupException < Exception; end
-      class BadStepException < Exception; end
-      Before do
-        raise SomeSetupException.new("I cannot even start this scenario")
-      end
-      """
-
-  @spawn
-  Scenario: Handle Exception in standard scenario step and carry on
-    Given a file named "features/naughty_step_in_scenario.feature" with:
-      """
-      Feature: Sample
-
-        Scenario: Run a good step
-          Given this step passes
-      """
-    When I run `cucumber features`
-    Then it should fail with:
-      """
-      Feature: Sample
-
-        Scenario: Run a good step # features/naughty_step_in_scenario.feature:3
-        I cannot even start this scenario (SomeSetupException)
-        ./features/support/env.rb:4:in `Before'
-          Given this step passes  # features/step_definitions/steps.rb:1
-
-      Failing Scenarios:
-      cucumber features/naughty_step_in_scenario.feature:3 # Scenario: Run a good step
-
-      1 scenario (1 failed)
-      1 step (1 skipped)
-
-      """
-
-  Scenario: Handle Exception in Before hook for Scenario with Background
-    Given a file named "features/naughty_step_in_before.feature" with:
-      """
-      Feature: Sample
-
-        Background:
-          Given this step passes
-
-        Scenario: Run a good step
-          Given this step passes
-      """
-    When I run `cucumber features`
-    Then it should fail with exactly:
-      """
-      Feature: Sample
-      
-        Background:              # features/naughty_step_in_before.feature:3
-        I cannot even start this scenario (SomeSetupException)
-        ./features/support/env.rb:4:in `Before'
-          Given this step passes # features/step_definitions/steps.rb:1
-      
-        Scenario: Run a good step # features/naughty_step_in_before.feature:6
-          Given this step passes  # features/step_definitions/steps.rb:1
-
-      Failing Scenarios:
-      cucumber features/naughty_step_in_before.feature:6 # Scenario: Run a good step
-
-      1 scenario (1 failed)
-      2 steps (2 skipped)
-      0m0.012s
-
-      """
-
-  Scenario: Handle Exception using the progress format
-    Given a file named "features/naughty_step_in_scenario.feature" with:
-      """
-      Feature: Sample
-
-        Scenario: Run a good step
-          Given this step passes
-      """
-    When I run `cucumber features --format progress`
-    Then it should fail with:
-      """
-      F-
-
-      Failing Scenarios:
-      cucumber features/naughty_step_in_scenario.feature:3 # Scenario: Run a good step
-
-      1 scenario (1 failed)
-      1 step (1 skipped)
-
-      """

data/features/docs/extending_cucumber/custom_filter.feature

@@ -1,29 +0,0 @@
-Feature: Custom filter
-
-  Scenario: Add a custom filter via AfterConfiguration hook
-    Given a file named "features/test.feature" with:
-      """
-      Feature:
-        Scenario:
-          Given my special step
-      """
-    And a file named "features/support/my_filter.rb" with:
-      """
-      require 'cucumber/core/filter'
-
-      MakeAnythingPass = Cucumber::Core::Filter.new do
-        def test_case(test_case)
-          activated_steps = test_case.test_steps.map do |test_step|
-            test_step.with_action { }
-          end
-          test_case.with_steps(activated_steps).describe_to receiver
-        end
-      end
-
-      AfterConfiguration do |config|
-        config.filters << MakeAnythingPass.new
-      end
-      """
-    When I run `cucumber --strict`
-    Then it should pass
-

data/features/docs/extending_cucumber/custom_formatter.feature

@@ -1,102 +0,0 @@
-Feature: Custom Formatter
-
-  Background:
-    Given a file named "features/f.feature" with:
-      """
-      Feature: I'll use my own
-        Scenario: Just print me
-          Given this step passes
-      """
-    And the standard step definitions
-
-  Scenario: Subscribe to result events
-
-    This is the recommended way to format output.
-
-    Given a file named "features/support/custom_formatter.rb" with:
-      """
-      module MyCustom
-        class Formatter
-          def initialize(config)
-            @io = config.out_stream
-            config.on_event :test_case_starting do |event|
-              print_test_case_name(event.test_case)
-            end
-          end
-
-          def print_test_case_name(test_case)
-            feature = test_case.source.first
-            scenario = test_case.source.last
-            @io.puts feature.short_name.upcase
-            @io.puts "  #{scenario.name.upcase}"
-          end
-        end
-      end
-      """
-    When I run `cucumber features/f.feature --format MyCustom::Formatter`
-    Then it should pass with exactly:
-      """
-      I'LL USE MY OWN
-        JUST PRINT ME
-
-      """
-
-  Scenario: Use the legacy API
-    This is deprecated and should no longer be used.
-
-    Given a file named "features/support/custom_legacy_formatter.rb" with:
-      """
-      module MyCustom
-        class LegacyFormatter
-          def initialize(runtime, io, options)
-            @io = io
-          end
-
-          def before_feature(feature)
-            @io.puts feature.short_name.upcase
-          end
-
-          def scenario_name(keyword, name, file_colon_line, source_indent)
-            @io.puts "  #{name.upcase}"
-          end
-        end
-      end
-      """
-    When I run `cucumber features/f.feature --format MyCustom::LegacyFormatter`
-    Then it should pass with exactly:
-      """
-      I'LL USE MY OWN
-        JUST PRINT ME
-
-      """
-
-  Scenario: Use both old and new
-    You can both APIs at once, for now
-
-    Given a file named "features/support/custom_mixed_formatter.rb" with:
-      """
-      module MyCustom
-        class MixedFormatter
-
-          def initialize(runtime, io, options)
-            @io = io
-          end
-
-          def before_test_case(test_case)
-            feature = test_case.source.first
-            @io.puts feature.short_name.upcase
-          end
-
-          def scenario_name(keyword, name, file_colon_line, source_indent)
-            @io.puts "  #{name.upcase}"
-          end
-        end
-      end
-      """
-    When I run `cucumber features/f.feature --format MyCustom::MixedFormatter`
-    Then it should pass with exactly:
-      """
-      I'LL USE MY OWN
-        JUST PRINT ME
-
-      """

data/features/docs/formatters/api_methods.feature

@@ -1,37 +0,0 @@
-Feature: Formatter API methods
-
-  Some utility methods are provided to make it easier to write your own formatters.
-
-  Here are some examples.
-
-  Scenario: A formatter that uses `Cucumber::Formatter::Io#ensure_file`
-
-    The ensure_file method is a little helper function that some formatters use,
-    normally when given a CLI argument with `--out` to check that the file passed
-    by the user actually exists.
-
-    The second argument is the name of the formatter, used to print a useful
-    error message if the file can't be created for some reason.
-
-    Given a file named "features/f.feature" with:
-      """
-      Feature: Test
-        Scenario: Test
-      """
-    And a directory named "my/special"
-    And a file named "features/support/custom_formatter.rb" with:
-      """
-      require 'cucumber/formatter/io'
-      module Cucumber
-        module Formatter
-          class Test
-            include Io
-            def initialize(runtime, path_or_io, options)
-              ensure_file("my/special/output.file", "custom formatter")
-            end
-          end
-        end
-      end
-      """
-    When I run `cucumber features/f.feature --format Cucumber::Formatter::Test`
-    Then it should pass

data/features/docs/formatters/debug_formatter.feature

@@ -1,47 +0,0 @@
-Feature: Debug formatter
-
-  In order to help you easily visualise the listener API, you can use
-  the `debug` formatter that prints the calls to the listener as a
-  feature is run.
-
-  Background:
-    Given the standard step definitions
-
-  Scenario: title
-    Given a file named "features/test.feature" with:
-      """
-      Feature:
-        Scenario:
-          Given this step passes
-      """
-    When I run `cucumber -f debug`
-    Then the stderr should not contain anything
-    Then it should pass with:
-      """
-      before_test_case
-      before_features
-      before_feature
-      before_tags
-      after_tags
-      feature_name
-      before_test_step
-      after_test_step
-      before_test_step
-      before_feature_element
-      before_tags
-      after_tags
-      scenario_name
-      before_steps
-      before_step
-      before_step_result
-      step_name
-      after_step_result
-      after_step
-      after_test_step
-      after_steps
-      after_feature_element
-      after_test_case
-      after_feature
-      after_features
-      done
-      """

data/features/docs/formatters/formatter_step_file_colon_line.feature

@@ -1,44 +0,0 @@
-Feature: Formatter API: Step file path and line number (Issue #179)
-  To all reporter to understand location of current executing step let's fetch this information
-  from step/step_invocation and pass to reporters
-
-  Scenario: my own formatter
-    Given a file named "features/f.feature" with:
-      """
-      Feature: I'll use my own
-        because I'm worth it
-        Scenario: just print step current line and feature file name
-          Given step at line 4
-          Given step at line 5
-      """
-    And a file named "features/step_definitions/steps.rb" with:
-      """
-      Given(/^step at line (.*)$/) {|line| }
-      """
-    And a file named "features/support/jb/formatter.rb" with:
-      """
-      module Jb
-        class Formatter
-          def initialize(runtime, io, options)
-            @io = io
-          end
-
-          def before_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background, file_colon_line)
-            @io.puts "step result event: #{file_colon_line}"
-          end
-
-          def step_name(keyword, step_match, status, source_indent, background, file_colon_line)
-            @io.puts "step name event: #{file_colon_line}"
-          end
-        end
-      end
-      """
-    When I run `cucumber features/f.feature --format Jb::Formatter`
-    Then it should pass with exactly:
-      """
-      step result event: features/f.feature:4
-      step name event: features/f.feature:4
-      step result event: features/f.feature:5
-      step name event: features/f.feature:5
-
-      """

data/features/docs/formatters/html_formatter.feature

@@ -1,91 +0,0 @@
-Feature: HTML output formatter
-
-  Background:
-    Given the standard step definitions
-    And a file named "features/scenario_outline_with_undefined_steps.feature" with:
-      """
-      Feature:
-
-        Scenario Outline:
-          Given this step is undefined
-
-        Examples:
-          |foo|
-          |bar|
-      """
-    And a file named "features/scenario_outline_with_pending_step.feature" with:
-      """
-      Feature: Outline
-
-        Scenario Outline: Will it blend?
-          Given this step is pending
-          And other step
-          When I do something with <example>
-          Then I should see something
-          Examples:
-            | example |
-            | one     |
-            | two     |
-            | three   |
-      """
-    And a file named "features/failing_background_step.feature" with:
-      """
-      Feature: Feature with failing background step
-
-        Background:
-          Given this step fails
-
-        Scenario:
-          When I do something
-          Then I should see something
-      """
-
-  Scenario: an scenario outline, one undefined step, one random example, expand flag on
-    When I run `cucumber features/scenario_outline_with_undefined_steps.feature --format html --expand `
-    Then it should pass
-
-  Scenario Outline: an scenario outline, one pending step
-    When I run `cucumber <file> --format html <flag>`
-    Then it should pass
-    And the output should contain:
-    """
-    makeYellow('scenario_1')
-    """
-    And the output should not contain:
-    """
-    makeRed('scenario_1')
-    """
-
-    Examples:
-      | file                                                   | flag     |
-      | features/scenario_outline_with_pending_step.feature    | --expand |
-      | features/scenario_outline_with_pending_step.feature    |          |
-
-    Examples:
-      | file                                                   | flag     |
-      | features/scenario_outline_with_undefined_steps.feature | --expand |
-      | features/scenario_outline_with_undefined_steps.feature |          |
-
-  Scenario: when using a profile the html shouldn't include 'Using the default profile...'
-    And a file named "cucumber.yml" with:
-    """
-      default: -r features
-    """
-    When I run `cucumber features/scenario_outline_with_undefined_steps.feature --profile default --format html`
-    Then it should pass
-    And the output should not contain:
-    """
-    Using the default profile...
-    """
-
-  Scenario: a feature with a failing background step
-    When I run `cucumber features/failing_background_step.feature --format html`
-    Then the output should not contain:
-    """
-    makeRed('scenario_0')
-    """
-    And the output should contain:
-    """
-    makeRed('background_0')
-    """
-