mobiusloop 0.1.2

data/features/docs/writing_support_code/hook_order.feature

@@ -0,0 +1,61 @@
+  @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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,95 @@
+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

@@ -0,0 +1,98 @@
+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/lib/step_definitions/aruba_steps.rb

@@ -0,0 +1,26 @@
+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

data/features/lib/step_definitions/cucumber_steps.rb

@@ -0,0 +1,78 @@
+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 "([^\"]*)" 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 "([^\"]*)" 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
+
+Then /^the stderr should contain a warning message$/ do
+  expect(all_stderr).to include("[warning]")
+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)

data/features/lib/step_definitions/iso-8859-1_steps.rb

@@ -0,0 +1,12 @@
+# encoding: iso-8859-1
+# Ideally we would use Norwegian keywords here, but that won't work unless this file is UTF-8 encoded.
+# Alternatively it would be possible to use Norwegian keywords and encode the file as UTF-8.
+#
+# In both cases, stepdef arguments will be sent in as UTF-8, regardless of what encoding is used.
+Given /^jeg drikker en "([^"]*)"$/ do |drink|
+  expect(drink).to eq '�l'.encode('UTF-8')
+end
+
+When /^skal de andre si "([^"]*)"$/ do |greeting|
+  expect(greeting).to eq 'sk�l'.encode('UTF-8')
+end

data/features/lib/step_definitions/json_steps.rb

@@ -0,0 +1,7 @@
+Then /^it should (pass|fail) with JSON:$/ do |pass_fail, json|
+  actual = normalise_json(MultiJson.load(all_stdout))
+  expected = MultiJson.load(json)
+
+  expect(actual).to eq expected
+  assert_success(pass_fail == 'pass')
+end

data/features/lib/step_definitions/junit_steps.rb

@@ -0,0 +1,13 @@
+Then(/^the junit output file "(.*?)" should contain:$/) do |actual_file, text|
+  actual = IO.read(current_dir + '/' + actual_file)
+  actual = replace_junit_time(actual)
+  expect(actual).to eq text
+end
+
+module JUnitHelper
+  def replace_junit_time(s)
+    s.gsub(/\d+\.\d\d+/m, '0.05')
+  end
+end
+
+World(JUnitHelper)