mobiusloop 0.1.2

data/features/docs/api/listen_for_events.feature

@@ -0,0 +1,58 @@
+Feature: Listen for events
+
+  Scenario: Step Matched Event
+    Given a file named "features/test.feature" with:
+      """
+      Feature:
+        Scenario:
+          Given matching
+      """
+    And a file named "features/step_definitions/steps.rb" with:
+      """
+      Given(/matching/) do
+      end
+      """
+    And a file named "features/support/my_listener.rb" with:
+      """
+      AfterConfiguration do |config|
+        io = config.out_stream
+        config.on_event Cucumber::Events::StepMatch do |event|
+          io.puts "Success!"
+          io.puts "Event type:      #{event.class}"
+          io.puts "Step name:       #{event.test_step.name}"
+          io.puts "Source location: #{event.step_match.location}"
+        end
+      end
+      """
+    When I run `cucumber`
+    Then it should pass with:
+      """
+      Success!
+      Event type:      Cucumber::Events::StepMatch
+      Step name:       matching
+      Source location: features/step_definitions/steps.rb:1
+      """
+
+  Scenario: After Test Step event
+    Given a file named "features/test.feature" with:
+      """
+      Feature:
+        Scenario:
+          Given passing
+      """
+    And the standard step definitions
+    And a file named "features/support/my_listener.rb" with:
+      """
+      AfterConfiguration do |config|
+        io = config.out_stream
+        config.on_event Cucumber::Events::AfterTestStep do |event|
+          io.puts "YO"
+        end
+      end
+      """
+    When I run `cucumber`
+    Then it should pass with:
+      """
+      YO
+      """
+

data/features/docs/api/run_cli_main_with_existing_runtime.feature

@@ -0,0 +1,26 @@
+@spawn
+Feature: Run Cli::Main with existing Runtime
+
+  This is the API that Spork uses. It creates an existing runtime.
+  When the process forks, Spork them passes the runtime to Cli::Main to
+  run it.
+
+    Scenario: Run a single feature
+      Given the standard step definitions
+      Given a file named "features/success.feature" with:
+        """
+        Feature:
+          Scenario:
+            Given this step passes
+        """
+      When I run the following Ruby code:
+        """
+        require 'cucumber'
+        runtime = Cucumber::Runtime.new
+        Cucumber::Cli::Main.new([]).execute!(runtime)
+        """
+      Then it should pass
+      And the output should contain:
+        """
+        Given this step passes
+        """

data/features/docs/cli/backtraces.feature

@@ -0,0 +1,36 @@
+Feature: Backtraces
+
+  In order to discover errors quickly
+  As a cuker
+  I want to see backtraces for failures
+
+  Background:
+    Given a file named "features/failing_hard.feature" with:
+      """
+      Feature: Sample
+        Scenario: Example
+          Given failing
+      """
+
+  @jruby
+  Scenario: Backtraces enabled
+    Given a file named "features/step_definitions/steps.rb" with:
+      """
+      require 'java'
+      java_import 'java.util.Collections'
+
+      Given /^failing$/ do
+        Collections.empty_list.add 1
+      end
+      """
+    When I run `cucumber features/failing_hard.feature`
+    Then it should fail with:
+      """
+      Feature: Sample
+
+        Scenario: Example # features/failing_hard.feature:2
+          Given failing   # features/step_definitions/steps.rb:4
+             (Java::JavaLang::UnsupportedOperationException)
+            java.util.AbstractList.add(java/util/AbstractList.java:
+      """
+

data/features/docs/cli/dry_run.feature

@@ -0,0 +1,70 @@
+Feature: Dry Run
+
+  Dry run gives you a way to quickly scan your features without actually running them.
+
+  - Invokes formatters without executing the steps.
+  - This also omits the loading of your support/env.rb file if it exists.
+
+  Scenario: With a failing step
+    Given a file named "features/test.feature" with:
+      """
+      Feature: test
+        Scenario:
+          Given this step fails
+      """
+    And the standard step definitions
+    When I run `cucumber --dry-run`
+    Then it should pass with exactly:
+      """
+      Feature: test
+
+        Scenario:               # features/test.feature:2
+          Given this step fails # features/step_definitions/steps.rb:4
+
+      1 scenario (1 skipped)
+      1 step (1 skipped)
+
+      """
+
+  Scenario: In strict mode
+    Given a file named "features/test.feature" with:
+      """
+      Feature: test
+        Scenario:
+          Given this step fails
+      """
+    And the standard step definitions
+    When I run `cucumber --dry-run --strict`
+    Then it should pass with exactly:
+      """
+      Feature: test
+
+        Scenario:               # features/test.feature:2
+          Given this step fails # features/step_definitions/steps.rb:4
+
+      1 scenario (1 skipped)
+      1 step (1 skipped)
+
+      """
+
+  Scenario: In strict mode with an undefined step
+    Given a file named "features/test.feature" with:
+      """
+      Feature: test
+        Scenario:
+          Given this step is undefined
+      """
+    When I run `cucumber --dry-run --strict`
+    Then it should fail with:
+      """
+      Feature: test
+
+        Scenario:                      # features/test.feature:2
+          Given this step is undefined # features/test.feature:3
+            Undefined step: "this step is undefined" (Cucumber::Undefined)
+            features/test.feature:3:in `Given this step is undefined'
+
+      1 scenario (1 undefined)
+      1 step (1 undefined)
+
+      """

data/features/docs/cli/exclude_files.feature

@@ -0,0 +1,18 @@
+Feature: Excluding ruby and feature files from runs
+
+  Developers are able to easily exclude files from cucumber runs
+  This is a nice feature to have in conjunction with profiles, so you can exclude
+  certain environment files from certain runs.
+
+  Scenario: exclude ruby files
+    Given an empty file named "features/support/dont_require_me.rb"
+    And an empty file named "features/step_definitions/fooz.rb"
+    And an empty file named "features/step_definitions/foof.rb"
+    And an empty file named "features/step_definitions/foot.rb"
+    And an empty file named "features/support/require_me.rb"
+    When I run `cucumber features -q --verbose --exclude features/support/dont --exclude foo[zf]`
+    Then "features/support/require_me.rb" should be required
+    And "features/step_definitions/foot.rb" should be required
+    And "features/support/dont_require_me.rb" should not be required
+    And "features/step_definitions/foof.rb" should not be required
+    And "features/step_definitions/fooz.rb" should not be required

data/features/docs/cli/execute_with_tag_filter.feature

@@ -0,0 +1,117 @@
+Feature: Tag logic
+  In order to conveniently run subsets of features
+  As a Cuker
+  I want to select features using logical AND/OR of tags
+
+  Background:
+    Given a file named "features/test.feature" with:
+      """
+      @feature
+      Feature: Sample
+
+        @one @three
+        Scenario: Example
+          Given passing
+
+        @one
+        Scenario: Another Example
+          Given passing
+
+        @three
+        Scenario: Yet another Example
+          Given passing
+
+        @ignore
+        Scenario: And yet another Example
+      """
+
+  Scenario: ANDing tags
+    When I run `cucumber -q -t @one -t @three features/test.feature`
+    Then it should pass with:
+      """
+      @feature
+      Feature: Sample
+
+        @one @three
+        Scenario: Example
+          Given passing
+
+      1 scenario (1 undefined)
+      1 step (1 undefined)
+
+      """
+
+  Scenario: ORing tags
+    When I run `cucumber -q -t @one,@three features/test.feature`
+    Then it should pass with:
+      """
+      @feature
+      Feature: Sample
+
+        @one @three
+        Scenario: Example
+          Given passing
+
+        @one
+        Scenario: Another Example
+          Given passing
+
+        @three
+        Scenario: Yet another Example
+          Given passing
+
+      3 scenarios (3 undefined)
+      3 steps (3 undefined)
+
+      """
+
+  Scenario: Negative tags
+    When I run `cucumber -q -t ~@three features/test.feature`
+    Then it should pass with:
+      """
+      @feature
+      Feature: Sample
+
+        @one
+        Scenario: Another Example
+          Given passing
+
+        @ignore
+        Scenario: And yet another Example
+
+      2 scenarios (1 undefined, 1 passed)
+      1 step (1 undefined)
+      """
+
+  Scenario: Run with limited tag count, blowing it on scenario
+     When I run `cucumber -q --no-source --tags @one:1 features/test.feature`
+     Then it fails before running features with:
+       """
+       @one occurred 2 times, but the limit was set to 1
+         features/test.feature:5
+         features/test.feature:9
+       """
+
+  Scenario: Run with limited tag count, blowing it via feature inheritance
+     When I run `cucumber -q --no-source --tags @feature:1 features/test.feature`
+     Then it fails before running features with:
+       """
+       @feature occurred 4 times, but the limit was set to 1
+         features/test.feature:5
+         features/test.feature:9
+         features/test.feature:13
+         features/test.feature:17
+       """
+
+  Scenario: Run with limited tag count using negative tag, blowing it via a tag that is not run
+     When I run `cucumber -q --no-source --tags ~@one:1 features/test.feature`
+     Then it fails before running features with:
+       """
+       @one occurred 2 times, but the limit was set to 1
+       """
+
+  Scenario: Limiting with tags which do not exist in the features
+    Originally added to check [Lighthouse bug #464](https://rspec.lighthouseapp.com/projects/16211/tickets/464).
+
+    When I run `cucumber -q -t @i_dont_exist features/test.feature`
+    Then it should pass

data/features/docs/cli/fail_fast.feature

@@ -0,0 +1,46 @@
+@spawn
+Feature: Fail fast
+
+  The --fail-fast flag causes Cucumber to exit immediately after the first 
+  scenario fails.
+
+  Scenario: When a scenario fails
+    Given a file named "features/bad.feature" with:
+      """
+      Feature: Bad
+        Scenario: Failing
+          Given this step fails
+      """
+    And a file named "features/good.feature" with:
+    """
+    Feature: Good
+      Scenario: Passing
+        Given this step passes
+    """
+    And the standard step definitions
+    When I run `cucumber --fail-fast`
+    Then it should fail
+    And the output should contain:
+    """
+    1 scenario (1 failed)
+    """
+
+  Scenario: When all the scenarios pass
+    Given a file named "features/first.feature" with:
+      """
+      Feature: first feature
+        Scenario: foo first
+          Given this step passes
+        Scenario: bar first
+          Given this step passes
+      """
+    And a file named "features/second.feature" with:
+      """
+      Feature: second
+        Scenario: foo second
+          Given this step passes
+        Scenario: bar second
+          Given this step passes
+      """
+    When I run `cucumber --fail-fast`
+    Then it should pass

data/features/docs/cli/finding_steps.feature

@@ -0,0 +1,28 @@
+Feature: Loading the steps users expect
+  As a User
+  In order to run features in subdirectories without having to pass extra options
+  I want cucumber to load all step files
+
+  Scenario:
+    Given a file named "features/nesting/test.feature" with:
+      """
+      Feature: Feature in Subdirectory
+        Scenario: A step not in the subdirectory
+          Given not found in subdirectory
+      """
+    And a file named "features/step_definitions/steps_no_in_subdirectory.rb" with:
+      """
+      Given(/^not found in subdirectory$/) { }
+      """
+    When I run `cucumber -q features/nesting/test.feature`
+    Then it should pass with:
+      """
+      Feature: Feature in Subdirectory
+
+        Scenario: A step not in the subdirectory
+          Given not found in subdirectory
+
+      1 scenario (1 passed)
+      1 step (1 passed)
+      """
+

data/features/docs/cli/randomize.feature

@@ -0,0 +1,140 @@
+Feature: Randomize
+
+  Use the `--order random` switch to run scenarios in random order.
+
+  This is especially helpful for detecting situations where you have state
+  leaking between scenarios, which can cause flickering or fragile tests.
+
+  If you do find a random run that exposes dependencies between your tests,
+  you can reproduce that run by using the seed that's printed at the end of
+  the test run.
+
+  For a given seed, the order of scenarios is constant, i.e. if step A runs
+  before step B, it will always run before step B even if other steps are
+  skipped.
+
+  Background:
+    Given a file named "features/bad_practice_part_1.feature" with:
+      """
+      Feature: Bad practice, part 1
+        
+        Scenario: Set state
+          Given I set some state
+      
+        Scenario: Depend on state from a preceding scenario
+          When I depend on the state
+      """
+    And a file named "features/bad_practice_part_2.feature" with:
+      """
+      Feature: Bad practice, part 2
+
+        Scenario: Depend on state from a preceding feature
+          When I depend on the state
+      """
+    And a file named "features/unrelated.feature" with:
+      """
+      Feature: Unrelated
+
+        @skipme
+        Scenario: Do something unrelated
+          When I do something
+      """
+    And a file named "features/step_definitions/steps.rb" with:
+      """
+      Given(/^I set some state$/) do
+        $global_state = "set"
+      end
+
+      Given(/^I depend on the state$/) do
+        raise "I expect the state to be set!" unless $global_state == "set"
+      end
+
+      Given(/^I do something$/) do
+      end
+      """
+
+  Scenario: Run scenarios in order
+    When I run `cucumber`
+    Then it should pass
+
+  @spawn
+  Scenario: Run scenarios randomized
+    When I run `cucumber --order random:41544 -q`
+    Then it should fail
+    And the stdout should contain exactly:
+      """
+      Feature: Bad practice, part 1
+
+        Scenario: Depend on state from a preceding scenario
+          When I depend on the state
+            I expect the state to be set! (RuntimeError)
+            ./features/step_definitions/steps.rb:6:in `/^I depend on the state$/'
+            features/bad_practice_part_1.feature:7:in `When I depend on the state'
+
+      Feature: Unrelated
+
+        @skipme
+        Scenario: Do something unrelated
+          When I do something
+
+      Feature: Bad practice, part 2
+
+        Scenario: Depend on state from a preceding feature
+          When I depend on the state
+            I expect the state to be set! (RuntimeError)
+            ./features/step_definitions/steps.rb:6:in `/^I depend on the state$/'
+            features/bad_practice_part_2.feature:4:in `When I depend on the state'
+
+      Feature: Bad practice, part 1
+
+        Scenario: Set state
+          Given I set some state
+      
+      Failing Scenarios:
+      cucumber features/bad_practice_part_1.feature:6
+      cucumber features/bad_practice_part_2.feature:3
+
+      4 scenarios (2 failed, 2 passed)
+      4 steps (2 failed, 2 passed)
+
+      Randomized with seed 41544
+
+      """
+
+  @spawn
+  Scenario: Run scenarios randomized with some skipped
+    When I run `cucumber --tags ~@skipme --order random:41544 -q`
+    Then it should fail
+    And the stdout should contain exactly:
+      """
+      Feature: Bad practice, part 1
+
+        Scenario: Depend on state from a preceding scenario
+          When I depend on the state
+            I expect the state to be set! (RuntimeError)
+            ./features/step_definitions/steps.rb:6:in `/^I depend on the state$/'
+            features/bad_practice_part_1.feature:7:in `When I depend on the state'
+
+      Feature: Bad practice, part 2
+
+        Scenario: Depend on state from a preceding feature
+          When I depend on the state
+            I expect the state to be set! (RuntimeError)
+            ./features/step_definitions/steps.rb:6:in `/^I depend on the state$/'
+            features/bad_practice_part_2.feature:4:in `When I depend on the state'
+
+      Feature: Bad practice, part 1
+
+        Scenario: Set state
+          Given I set some state
+
+      Failing Scenarios:
+      cucumber features/bad_practice_part_1.feature:6
+      cucumber features/bad_practice_part_2.feature:3
+
+      3 scenarios (2 failed, 1 passed)
+      3 steps (2 failed, 1 passed)
+
+      Randomized with seed 41544
+
+      """