dwaite-cucumber 0.3.101

data/spec/cucumber/step_mother_spec.rb

@@ -0,0 +1,282 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require 'cucumber'
+require 'cucumber/rb_support/rb_language'
+
+module Cucumber
+  describe StepMother do
+    before do
+      @dsl = Object.new
+      @dsl.extend(RbSupport::RbDsl)
+
+      @step_mother = StepMother.new
+      @step_mother.load_natural_language('en')
+      @rb = @step_mother.load_programming_language('rb')
+
+      @visitor = mock('Visitor')
+    end
+
+    def register
+      @step_mother.register_step_definitions(@rb.step_definitions)
+    end
+
+    it "should format step names" do
+      @dsl.Given(/it (.*) in (.*)/) do |what, month|
+      end
+      @dsl.Given(/nope something else/) do |what, month|
+      end
+      register
+      
+      format = @step_mother.step_match("it snows in april").format_args("[%s]")
+      format.should == "it [snows] in [april]"
+    end
+
+    it "should raise Ambiguous error with guess hint when multiple step definitions match" do
+      @dsl.Given(/Three (.*) mice/) {|disability|}
+      @dsl.Given(/Three blind (.*)/) {|animal|}
+      register
+
+      lambda do
+        @step_mother.step_match("Three blind mice")
+      end.should raise_error(Ambiguous, %{Ambiguous match of "Three blind mice":
+
+spec/cucumber/step_mother_spec.rb:35:in `/Three (.*) mice/'
+spec/cucumber/step_mother_spec.rb:36:in `/Three blind (.*)/'
+
+You can run again with --guess to make Cucumber be more smart about it
+})
+    end
+
+    it "should not show --guess hint when --guess is used" do
+      @step_mother.options = {:guess => true}
+
+      @dsl.Given(/Three (.*) mice/) {|disability|}
+      @dsl.Given(/Three cute (.*)/) {|animal|}
+      register
+
+      lambda do
+        @step_mother.step_match("Three cute mice")
+      end.should raise_error(Ambiguous, %{Ambiguous match of "Three cute mice":
+
+spec/cucumber/step_mother_spec.rb:53:in `/Three (.*) mice/'
+spec/cucumber/step_mother_spec.rb:54:in `/Three cute (.*)/'
+
+})
+    end
+
+    it "should not raise Ambiguous error when multiple step definitions match, but --guess is enabled" do
+      @step_mother.options = {:guess => true}
+      @dsl.Given(/Three (.*) mice/) {|disability|}
+      @dsl.Given(/Three (.*)/) {|animal|}
+      register
+
+      lambda do
+        @step_mother.step_match("Three blind mice")
+      end.should_not raise_error
+    end
+    
+    it "should pick right step definition when --guess is enabled and equal number of capture groups" do
+      @step_mother.options = {:guess => true}
+      right = @dsl.Given(/Three (.*) mice/) {|disability|}
+      wrong = @dsl.Given(/Three (.*)/) {|animal|}
+      register
+
+      @step_mother.step_match("Three blind mice").step_definition.should == right
+    end
+    
+    it "should pick right step definition when --guess is enabled and unequal number of capture groups" do
+      @step_mother.options = {:guess => true}
+      right = @dsl.Given(/Three (.*) mice ran (.*)/) {|disability|}
+      wrong = @dsl.Given(/Three (.*)/) {|animal|}
+      register
+
+      @step_mother.step_match("Three blind mice ran far").step_definition.should == right
+    end
+
+    it "should pick most specific step definition when --guess is enabled and unequal number of capture groups" do
+      @step_mother.options = {:guess => true}
+      general       = @dsl.Given(/Three (.*) mice ran (.*)/) {|disability|}
+      specific      = @dsl.Given(/Three blind mice ran far/) {}
+      more_specific = @dsl.Given(/^Three blind mice ran far$/) {}
+      register
+
+      @step_mother.step_match("Three blind mice ran far").step_definition.should == more_specific
+    end
+    
+    it "should raise Undefined error when no step definitions match" do
+      lambda do
+        @step_mother.step_match("Three blind mice")
+      end.should raise_error(Undefined)
+    end
+
+    it "should raise Redundant error when same regexp is registered twice" do
+      @dsl.Given(/Three (.*) mice/) {|disability|}
+      lambda do
+        @dsl.Given(/Three (.*) mice/) {|disability|}
+        register
+      end.should raise_error(Redundant)
+    end
+
+    # http://railsforum.com/viewtopic.php?pid=93881
+    it "should not raise Redundant unless it's really redundant" do
+      @dsl.Given(/^(.*) (.*) user named '(.*)'$/) {|a,b,c|}
+      @dsl.Given(/^there is no (.*) user named '(.*)'$/) {|a,b|}
+      register
+    end
+
+    it "should raise an error if the world is nil" do
+      @dsl.World do
+      end
+
+      begin
+        @step_mother.before_and_after(nil) {}
+        raise "Should fail"
+      rescue RbSupport::NilWorld => e
+        e.message.should == "World procs should never return nil"
+        e.backtrace.should == ["spec/cucumber/step_mother_spec.rb:128:in `World'"]
+      end
+    end
+
+    module ModuleOne
+    end
+
+    module ModuleTwo
+    end
+
+    class ClassOne
+    end
+
+    it "should implicitly extend world with modules" do
+      @dsl.World(ModuleOne, ModuleTwo)
+      @step_mother.before(nil)
+      class << @rb.current_world
+        included_modules.index(ModuleOne).should_not == nil
+        included_modules.index(ModuleTwo).should_not == nil
+      end
+      @rb.current_world.class.should == Object
+    end
+
+    it "should raise error when we try to register more than one World proc" do
+      @dsl.World { Hash.new }
+      lambda do
+        @dsl.World { Array.new }
+      end.should raise_error(RbSupport::MultipleWorld, %{You can only pass a proc to #World once, but it's happening
+in 2 places:
+
+spec/cucumber/step_mother_spec.rb:160:in `World'
+spec/cucumber/step_mother_spec.rb:162:in `World'
+
+Use Ruby modules instead to extend your worlds. See the Cucumber::RbSupport::RbDsl#World RDoc
+or http://wiki.github.com/aslakhellesoy/cucumber/a-whole-new-world.
+
+})
+    end
+
+    it "should find before hooks" do
+      fish = @dsl.Before('@fish'){}
+      meat = @dsl.Before('@meat'){}
+      register
+      
+      scenario = mock('Scenario')
+      scenario.should_receive(:accept_hook?).with(fish).and_return(true)
+      scenario.should_receive(:accept_hook?).with(meat).and_return(false)
+      
+      @rb.hooks_for(:before, scenario).should == [fish]
+    end
+  end
+
+  describe StepMother, "step argument transformations" do
+    after(:each) do
+      # generally transforms are global, but state should be 
+      # cleared when testing them here at the unit level
+      class StepMother; @@transforms = [] end
+    end
+
+    describe "without capture groups" do
+      it "complains when registering with a with no transform block" do
+        lambda do
+          StepMother.register_transform('^abc$')
+        end.should raise_error(Cucumber::ArityMismatchError)
+      end
+      
+      it "complains when registering with a zero-arg transform block" do
+        lambda do
+          StepMother.register_transform('^abc$') {42}
+        end.should raise_error(Cucumber::ArityMismatchError)
+      end
+
+      it "complains when registering with a splat-arg transform block" do
+        lambda do
+          StepMother.register_transform('^abc$') {|*splat| 42 }
+        end.should raise_error(Cucumber::ArityMismatchError)
+      end
+
+      it "complains when transforming with an arity mismatch" do
+        lambda do
+          StepMother.register_transform('^abc$') {|one, two| 42 }
+          StepMother.transform_arguments(['abc'])
+        end.should raise_error(Cucumber::ArityMismatchError)
+      end
+
+      it "allows registering a regexp pattern that yields the step_arg matched" do
+        StepMother.register_transform(/^ab*c$/) {|arg| 42}
+        StepMother.transform_arguments(['ab']).should == ['ab']
+        StepMother.transform_arguments(['ac']).should == [42]
+        StepMother.transform_arguments(['abc']).should == [42]
+        StepMother.transform_arguments(['abbc']).should == [42]
+      end
+    end
+
+    describe "with capture groups" do
+      it "complains when registering with a with no transform block" do
+        lambda do
+          StepMother.register_transform('^a(.)c$')
+        end.should raise_error(Cucumber::ArityMismatchError)
+      end
+      
+      it "complains when registering with a zero-arg transform block" do
+        lambda do
+          StepMother.register_transform('^a(.)c$') { 42 }
+        end.should raise_error(Cucumber::ArityMismatchError)
+      end
+
+      it "complains when registering with a splat-arg transform block" do
+        lambda do
+          StepMother.register_transform('^a(.)c$') {|*splat| 42 }
+        end.should raise_error(Cucumber::ArityMismatchError)
+      end
+
+      it "complains when transforming with an arity mismatch" do
+        lambda do
+          StepMother.register_transform('^a(.)c$') {|one, two| 42 }
+          StepMother.transform_arguments(['abc'])
+        end.should raise_error(Cucumber::ArityMismatchError)
+      end
+      
+      it "allows registering a regexp pattern that yields capture groups" do
+        StepMother.register_transform(/^shape: (.+), color: (.+)$/) do |shape, color|
+          {shape.to_sym => color.to_sym}
+        end
+        StepMother.transform_arguments(['shape: circle, color: blue']).should == [{:circle => :blue}]
+        StepMother.transform_arguments(['shape: square, color: red']).should == [{:square => :red}]      
+        StepMother.transform_arguments(['not shape: square, not color: red']).should == ['not shape: square, not color: red']
+      end
+    end
+    
+    it "allows registering a string pattern" do
+      StepMother.register_transform('^ab*c$') {|arg| 42}
+      StepMother.transform_arguments(['ab']).should == ['ab']
+      StepMother.transform_arguments(['ac']).should == [42]
+      StepMother.transform_arguments(['abc']).should == [42]
+      StepMother.transform_arguments(['abbc']).should == [42]
+    end
+
+    it "gives match priority to transforms defined last" do
+      StepMother.register_transform(/^transform_me$/) {|arg| :foo }
+      StepMother.register_transform(/^transform_me$/) {|arg| :bar }
+      StepMother.register_transform(/^transform_me$/) {|arg| :baz }
+      StepMother.transform_arguments(['transform_me']).should == [:baz]
+    end
+  end
+
+end

data/spec/cucumber/treetop_parser/empty_feature.feature

@@ -0,0 +1,4 @@
+Feature: No scenarios yet
+  In order to ...
+  As a ...
+  I want to ...

data/spec/cucumber/treetop_parser/empty_scenario.feature

@@ -0,0 +1,9 @@
+Feature: Empty scenarios should work
+
+  Scenario: Complete scenario
+    Given a valid API key
+
+  Scenario: Will write at somepoint
+
+  Scenario: Another Complete scenario
+    Given an invalid API key

data/spec/cucumber/treetop_parser/empty_scenario_outline.feature

@@ -0,0 +1,3 @@
+Feature: Empty scenarios outlines should work
+
+  Scenario Outline: Implement me please

data/spec/cucumber/treetop_parser/fit_scenario.feature

@@ -0,0 +1,8 @@
+Some title  
+
+  Scenario: second  
+    Given 'bind me please'
+  
+  More Examples:
+  |c|
+  |I can have spaces|

data/spec/cucumber/treetop_parser/given_scenario.feature

@@ -0,0 +1,9 @@
+Some title  
+
+  Scenario: first     
+    Given a
+    Given b
+   
+  Scenario: second  
+    GivenScenario: first
+    Given c

data/spec/cucumber/treetop_parser/invalid_scenario_outlines.feature

@@ -0,0 +1,7 @@
+Feature: Invalid Scenario Outlines
+
+Scenario Outline: I must have steps if I have a examples table
+  Examples:
+  | Name    |
+  | Izanaki |
+  | Izanami |

data/spec/cucumber/treetop_parser/multiline_steps.feature

@@ -0,0 +1,17 @@
+Feature: Multiline steps should work
+
+  Scenario: Reading a table
+    Given the following table
+      | where | why     |
+      | Oslo  | born    |
+      | London| working |
+    Then I should be working in London
+    And I should be born in Oslo
+    And I should be able to expect
+      """
+      A string
+        that "indents"
+      and spans
+      several lines
+      
+      """

data/spec/cucumber/treetop_parser/multiple_tables.feature

@@ -0,0 +1,27 @@
+Feature: Addition
+  In order to avoid silly mistakes
+  As a math idiot
+  I want to be told the sum of two numbers
+
+  Scenario: Add two numbers
+    Given I have entered 50 into the calculator
+    And I have entered 70 into the calculator
+    When I press add
+    Then the result should be 120 on the screen
+
+  More Examples:
+    | input_1 | input_2 | button | output |
+    | 20      | 30      | add    | 50     |
+    | 2       | 5       | add    | 7      |
+    | 0       | 40      | add    | 40     |
+
+  Scenario: Add three numbers
+    Given I have entered 25 into the calculator
+    And I have entered 12 into the calculator
+    And I have entered 13 into the calculator
+    When I press add
+    Then the result should be 50 on the screen
+
+  More Examples:
+    | input_1 | input_2 | input_3 | button | output |
+    | 1       | 2       | 3       | add    | 6      |

data/spec/cucumber/treetop_parser/scenario_outline.feature

@@ -0,0 +1,16 @@
+Feature: Valid Outlines
+
+Scenario Outline: Joe fails to login
+  Given I login as Joe without the '<Privilege>' privilege
+  When I <Request Method> /admin/<Path>
+  Then I should see the text "Sorry Joe, you're not allowed to see <Path>"
+  
+  Examples:
+  | Privilege | Request Method | Path       |
+  | user      | GET            | reports    |
+  | user      | GET            | managers   |
+
+Scenario Outline: Look at me ma no examples!
+  Given I login as Joe without the '<Privilege>' privilege
+  When I <Request Method> /admin/<Path>
+  Then I should see the text "Sorry Joe, you're not allowed to see <Path>"

data/spec/cucumber/treetop_parser/spaces.feature

@@ -0,0 +1,12 @@
+
+
+    Feature:  Some title  
+
+  Scenario: first     
+  
+    Given a  
+   
+  Scenario: second  
+   
+    Given b
+    

data/spec/cucumber/treetop_parser/test_dos.feature

@@ -0,0 +1,25 @@
+Feature: Search
+  In order to learn cucumber
+  As an engineer
+  I want to run some simple tests
+
+  Scenario: 1) Reverse a String
+    Given a string "abc"
+    When the string is reversed
+    Then the string should be "cba"
+    
+  More Examples:
+    |input |output|
+    |a     |a     |
+    |ab    |ba    |    
+
+  Scenario: 2) Upcase a String
+    Given a string "abc"
+    When the string is upcased
+    Then the string should be "ABC"
+
+  Scenario: 3) Combining 2 Methods
+    Given a string "abc"
+    When the string is upcased
+    And the string is reversed
+    Then the string should be "CBA"

data/spec/cucumber/treetop_parser/with_comments.feature

@@ -0,0 +1,23 @@
+# Header title
+# Two lines
+Feature: Some header  
+
+  Background:
+  # comment
+  Given whatever
+
+  # Scenario header
+  # on two lines
+  Scenario: Some scenario
+    Given one
+#    When two
+    Then three
+    
+  Scenario Outline: Some outline
+    Given <one>
+    Then <two>
+  
+  # Examples group comment  
+  Examples:
+  | one | two |
+  | a   | b   |

data/spec/cucumber/treetop_parser/with_tags.feature

@@ -0,0 +1,18 @@
+# Uhm hai
+# nai
+@nice @hallo
+Feature: With tags
+
+  @one @two
+  Scenario: Complete scenario
+    Given a valid API key
+
+  @three
+  Scenario: Will write at somepoint
+
+  @four @$$
+  Scenario: Another Complete scenario
+    Given an invalid API key
+
+  @six
+  Scenario Outline: Jalla

data/spec/cucumber/world/pending_spec.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'cucumber/rb_support/rb_language'
+
+module Cucumber
+    describe 'Pending' do
+
+      before(:each) do
+        l = RbSupport::RbLanguage.new(StepMother.new)
+        l.begin_rb_scenario
+        @world = l.current_world
+      end
+
+      it 'should raise a Pending if no block is supplied' do
+        lambda {
+          @world.pending "TODO"
+        }.should raise_error(Pending, /TODO/)
+      end
+
+      it 'should raise a Pending if a supplied block fails as expected' do
+        lambda {
+          @world.pending "TODO" do
+            raise "oops"
+          end
+        }.should raise_error(Pending, /TODO/)
+      end
+
+      it 'should raise a Pending if a supplied block fails as expected with a mock' do
+        lambda {
+          @world.pending "TODO" do
+            m = mock('thing')
+            m.should_receive(:foo)
+            m.rspec_verify
+          end
+        }.should raise_error(Pending, /TODO/)
+      end
+
+      it 'should raise a Pending if a supplied block starts working' do
+        lambda {
+          @world.pending "TODO" do
+            # success!
+          end
+        }.should raise_error(Pending, /TODO/)
+      end
+
+    end
+end

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--format
+profile
+--diff

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+gem 'rspec'
+require 'spec'
+require 'spec/autorun'
+
+ENV['CUCUMBER_COLORS']=nil
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'cucumber'
+$:.unshift(File.dirname(__FILE__))
+
+Spec::Runner.configure do |config|
+  config.before(:each) do
+    ::Term::ANSIColor.coloring = true
+    Cucumber::Parser::NaturalLanguage.instance_variable_set(:@languages, nil)
+  end
+end
+
+alias running lambda