mobiusloop 0.1.2

data/features/docs/writing_support_code/after_hooks.feature

@@ -0,0 +1,102 @@
+Feature: After Hooks
+
+  After hooks can be used to clean up any state you've altered during your
+  scenario, or to check the status of the scenario and act accordingly.
+
+  You can ask a scenario whether it has failed, for example.
+
+  Mind you, even if it hasn't failed yet, you can still make the scenario
+  fail if your After hook throws an error.
+
+  Background:
+    Given the standard step definitions
+
+  Scenario Outline: Retrieve the status of a scenario as a symbol
+    Given a file named "features/support/debug_hook.rb" with:
+      """
+      After do |scenario|
+        puts scenario.status.inspect
+      end
+      """
+    And a file named "features/result.feature" with:
+      """
+      Feature:
+        Scenario:
+          Given this step <result>
+      """
+    When I run `cucumber -f progress`
+    Then the output should contain "<status symbol>"
+
+    Examples:
+      | result     | status symbol |
+      | passes     | :passed       |
+      | fails      | :failed       |
+      | is pending | :pending      |
+
+  Scenario: Check the failed status of a scenario in a hook
+    Given a file named "features/support/debug_hook.rb" with:
+      """
+      After do |scenario|
+        if scenario.failed?
+          puts "eek"
+        end
+      end
+      """
+    And a file named "features/fail.feature" with:
+      """
+      Feature:
+        Scenario:
+          Given this step fails
+      """
+    When I run `cucumber -f progress`
+    Then the output should contain:
+      """
+      eek
+      """
+
+  Scenario: Make a scenario fail from an After hook
+    Given a file named "features/support/bad_hook.rb" with:
+      """
+      After do
+        fail 'yikes'
+      end
+      """
+    And a file named "features/pass.feature" with:
+      """
+      Feature:
+        Scenario:
+          Given this step passes
+      """
+    When I run `cucumber -f pretty`
+    Then it should fail with:
+      """
+        Scenario:                # features/pass.feature:2
+          Given this step passes # features/step_definitions/steps.rb:1
+            yikes (RuntimeError)
+            ./features/support/bad_hook.rb:2:in `After'
+      """
+
+  Scenario: After hooks are executed in reverse order of definition
+    Given a file named "features/support/hooks.rb" with:
+      """
+      After do
+        puts "First"
+      end
+
+      After do
+        puts "Second"
+      end
+      """
+    And a file named "features/pass.feature" with:
+      """
+      Feature:
+        Scenario:
+          Given this step passes
+      """
+    When I run `cucumber -f progress`
+    Then the output should contain:
+      """
+      Second
+
+      First
+      """

data/features/docs/writing_support_code/after_step_hooks.feature

@@ -0,0 +1,53 @@
+Feature: AfterStep Hooks
+  AfterStep hooks can be used to further inspect the Step object of the step
+  that has just run, or to simply check the step's result.
+
+  Background:
+    Given the standard step definitions
+    And a file named "features/sample.feature" with:
+      """
+      Feature: Sample
+
+        Scenario: Success
+          Given this step passes
+      """
+
+  Scenario: Access Test Step object in AfterStep Block
+    Given a file named "features/support/env.rb" with:
+      """
+      AfterStep do |result, test_step|
+        expect(test_step).to be_a(Cucumber::Core::Test::Step)
+      end
+      """
+    When I run `cucumber features`
+    Then it should pass with:
+      """
+      Feature: Sample
+
+        Scenario: Success        # features/sample.feature:3
+          Given this step passes # features/step_definitions/steps.rb:1
+
+      1 scenario (1 passed)
+      1 step (1 passed)
+
+      """
+
+  Scenario: An AfterStep with one named argument receives only the result
+    Given a file named "features/support/env.rb" with:
+      """
+      AfterStep do |result|
+        expect(result).to be_a(Cucumber::Core::Test::Result::Passed)
+      end
+      """
+    When I run `cucumber features`
+    Then it should pass with:
+      """
+      Feature: Sample
+
+        Scenario: Success        # features/sample.feature:3
+          Given this step passes # features/step_definitions/steps.rb:1
+
+      1 scenario (1 passed)
+      1 step (1 passed)
+
+      """

data/features/docs/writing_support_code/around_hooks.feature

@@ -0,0 +1,260 @@
+@spawn
+Feature: Around hooks
+
+  In order to support transactional scenarios for database libraries
+  that provide only a block syntax for transactions, Cucumber should
+  permit definition of Around hooks.
+
+  Scenario: A single Around hook
+    Given a file named "features/step_definitions/steps.rb" with:
+      """
+      Then /^the hook is called$/ do
+        expect($hook_called).to be true
+      end
+      """
+    And a file named "features/support/hooks.rb" with:
+      """
+      Around do |scenario, block|
+        $hook_called = true
+        block.call
+      end
+      """
+    And a file named "features/f.feature" with:
+      """
+      Feature: Around hooks
+        Scenario: using hook
+          Then the hook is called
+      """
+    When I run `cucumber features/f.feature`
+    Then it should pass with:
+      """
+      Feature: Around hooks
+
+        Scenario: using hook      # features/f.feature:2
+          Then the hook is called # features/step_definitions/steps.rb:1
+
+      1 scenario (1 passed)
+      1 step (1 passed)
+
+      """
+
+  Scenario: Multiple Around hooks
+    Given a file named "features/step_definitions/steps.rb" with:
+      """
+      Then /^the hooks are called in the correct order$/ do
+        expect($hooks_called).to eq ['A', 'B', 'C']
+      end
+      """
+    And a file named "features/support/hooks.rb" with:
+      """
+      Around do |scenario, block|
+        $hooks_called ||= []
+        $hooks_called << 'A'
+        block.call
+      end
+
+      Around do |scenario, block|
+        $hooks_called ||= []
+        $hooks_called << 'B'
+        block.call
+      end
+
+      Around do |scenario, block|
+        $hooks_called ||= []
+        $hooks_called << 'C'
+        block.call
+      end
+      """
+    And a file named "features/f.feature" with:
+      """
+      Feature: Around hooks
+        Scenario: using multiple hooks
+          Then the hooks are called in the correct order
+      """
+    When I run `cucumber features/f.feature`
+    Then it should pass with:
+      """
+      Feature: Around hooks
+
+        Scenario: using multiple hooks                   # features/f.feature:2
+          Then the hooks are called in the correct order # features/step_definitions/steps.rb:1
+
+      1 scenario (1 passed)
+      1 step (1 passed)
+
+      """
+
+  Scenario: Mixing Around, Before, and After hooks
+    Given a file named "features/step_definitions/steps.rb" with:
+      """
+      Then /^the Around hook is called around Before and After hooks$/ do
+        expect($hooks_called).to eq ['Around', 'Before']
+      end
+      """
+    And a file named "features/support/hooks.rb" with:
+      """
+      Around do |scenario, block|
+        $hooks_called ||= []
+        $hooks_called << 'Around'
+        block.call
+        $hooks_called << 'Around'
+        $hooks_called.should == ['Around', 'Before', 'After', 'Around'] #TODO: Find out why this fails using the new rspec expect syntax.
+      end
+
+      Before do |scenario|
+        $hooks_called ||= []
+        $hooks_called << 'Before'
+      end
+
+      After do |scenario|
+        $hooks_called ||= []
+        $hooks_called << 'After'
+        expect($hooks_called).to eq ['Around', 'Before', 'After']
+      end
+      """
+    And a file named "features/f.feature" with:
+      """
+      Feature: Around hooks
+        Scenario: Mixing Around, Before, and After hooks
+          Then the Around hook is called around Before and After hooks
+      """
+    When I run `cucumber features/f.feature`
+    Then it should pass with:
+      """
+      Feature: Around hooks
+
+        Scenario: Mixing Around, Before, and After hooks               # features/f.feature:2
+          Then the Around hook is called around Before and After hooks # features/step_definitions/steps.rb:1
+
+      1 scenario (1 passed)
+      1 step (1 passed)
+
+      """
+
+  Scenario: Around hooks with tags
+    Given a file named "features/step_definitions/steps.rb" with:
+      """
+      Then /^the Around hooks with matching tags are called$/ do
+        expect($hooks_called).to eq ['one', 'one or two']
+      end
+      """
+    And a file named "features/support/hooks.rb" with:
+      """
+      Around('@one') do |scenario, block|
+        $hooks_called ||= []
+        $hooks_called << 'one'
+        block.call
+      end
+
+      Around('@one,@two') do |scenario, block|
+        $hooks_called ||= []
+        $hooks_called << 'one or two'
+        block.call
+      end
+
+      Around('@one', '@two') do |scenario, block|
+        $hooks_called ||= []
+        $hooks_called << 'one and two'
+        block.call
+      end
+
+      Around('@two') do |scenario, block|
+        $hooks_called ||= []
+        $hooks_called << 'two'
+        block.call
+      end
+      """
+    And a file named "features/f.feature" with:
+      """
+      Feature: Around hooks
+        @one
+        Scenario: Around hooks with tags
+          Then the Around hooks with matching tags are called
+      """
+    When I run `cucumber -q -t @one features/f.feature`
+    Then it should pass with:
+      """
+      Feature: Around hooks
+
+        @one
+        Scenario: Around hooks with tags
+          Then the Around hooks with matching tags are called
+
+      1 scenario (1 passed)
+      1 step (1 passed)
+
+      """
+
+  Scenario: Around hooks with scenario outlines
+    Given a file named "features/step_definitions/steps.rb" with:
+      """
+      Then /^the hook is called$/ do
+        expect($hook_called).to be true
+      end
+      """
+    And a file named "features/support/hooks.rb" with:
+      """
+      Around do |scenario, block|
+        $hook_called = true
+        block.call
+      end
+      """
+    And a file named "features/f.feature" with:
+      """
+      Feature: Around hooks with scenario outlines
+        Scenario Outline: using hook
+          Then the hook is called
+
+          Examples:
+            | Number |
+            | one    |
+            | two    |
+      """
+    When I run `cucumber features/f.feature`
+    Then it should pass with:
+      """
+      Feature: Around hooks with scenario outlines
+
+        Scenario Outline: using hook # features/f.feature:2
+          Then the hook is called    # features/f.feature:3
+
+          Examples: 
+            | Number |
+            | one    |
+            | two    |
+
+      2 scenarios (2 passed)
+      2 steps (2 passed)
+
+      """
+
+  Scenario: Around Hooks and the Custom World
+    Given a file named "features/step_definitions/steps.rb" with:
+      """
+      Then /^the world should be available in the hook$/ do
+        $previous_world = self
+        expect($hook_world).to eq(self)
+      end
+
+      Then /^what$/ do
+        expect($hook_world).not_to eq($previous_world)
+      end
+      """
+    And a file named "features/support/hooks.rb" with:
+      """
+      Around do |scenario, block|
+        $hook_world = self
+        block.call
+      end
+      """
+    And a file named "features/f.feature" with:
+      """
+      Feature: Around hooks
+        Scenario: using hook
+          Then the world should be available in the hook
+
+        Scenario: using the same hook
+          Then what
+      """
+    When I run `cucumber features/f.feature`
+    Then it should pass

data/features/docs/writing_support_code/before_hook.feature

@@ -0,0 +1,65 @@
+Feature: Before Hook
+
+  Scenario: Examine names of scenario and feature
+    Given a file named "features/foo.feature" with:
+      """
+      Feature: Feature name
+
+        Scenario: Scenario name
+          Given a step
+      """
+    And a file named "features/support/hook.rb" with:
+      """
+      names = []
+      Before do |scenario|
+        expect(scenario).to_not respond_to(:scenario_outline)
+        names << scenario.feature.name.split("\n").first
+        names << scenario.name.split("\n").first
+        if(names.size == 2)
+          raise "NAMES:\n" + names.join("\n") + "\n"
+        end
+      end
+      """
+    When I run `cucumber`
+    Then the output should contain:
+      """
+        NAMES:
+        Feature name
+        Scenario name
+
+      """
+
+  Scenario: Examine names of scenario outline and feature
+    Given a file named "features/foo.feature" with:
+      """
+      Feature: Feature name
+
+        Scenario Outline: Scenario Outline name
+          Given a <placeholder>
+
+          Examples: Examples Table name
+            | <placeholder> |
+            | step          |
+      """
+    And a file named "features/support/hook.rb" with:
+      """
+      names = []
+      Before do |scenario|
+        names << scenario.scenario_outline.feature.name.split("\n").first
+        names << scenario.scenario_outline.name.split("\n").first
+        names << scenario.name.split("\n").first
+        if(names.size == 3)
+          raise "NAMES:\n" + names.join("\n") + "\n"
+        end
+      end
+      """
+    When I run `cucumber`
+    Then the output should contain:
+      """
+            NAMES:
+            Feature name
+            Scenario Outline name, Examples Table name (#1)
+            Scenario Outline name, Examples Table name (#1)
+
+      """
+