kbaum-cucumber 0.4.5.pre

data/spec/cucumber/parser/table_parser_spec.rb

@@ -0,0 +1,52 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'treetop'
+require 'cucumber/parser'
+
+module Cucumber
+  module Parser
+    describe 'Tables' do
+      before do
+        @parser = NaturalLanguage.get(StepMother.new, 'en').parser
+      end
+      
+      after do
+        NaturalLanguage.instance_variable_set(:@languages, nil)
+      end
+
+      def parse(text)
+        @parser.__send__(:prepare_to_parse, text)
+        @parser.root = :table
+        table = @parser._nt_table
+        table.raw
+      end
+
+      it "should parse a 1x2 table with newline" do
+        parse(" | 1 | 2 | \n").should == [%w{1 2}]
+      end
+
+      it "should parse a 1x2 table without newline" do
+        parse("| 1 | 2 |").should == [%w{1 2}]
+      end
+
+      it "should parse a 1x2 table without spaces" do
+        parse("|1|2|").should == [%w{1 2}]
+      end
+
+      it "should parse a 2x2 table" do
+        parse("| 1 | 2 |\n| 3 | 4 |\n").should == [%w{1 2}, %w{3 4}]
+      end
+
+      it "should parse a 2x2 table with several newlines" do
+        parse("| 1 | 2 |\n| 3 | 4 |\n\n\n").should == [%w{1 2}, %w{3 4}]
+      end
+
+      it "should parse a 2x2 table with empty cells" do
+        parse("| 1 |  |\n|| 4 |\n").should == [['1', ''], ['', '4']]
+      end
+
+      it "should not parse a 2x2 table that isn't closed" do
+        parse("| 1 |  |\n|| 4 ").should_not == [['1', ''], ['', '4']]
+      end
+    end
+  end
+end

data/spec/cucumber/rb_support/rb_step_definition_spec.rb

@@ -0,0 +1,132 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'cucumber/ast'
+require 'cucumber/step_mother'
+require 'cucumber/rb_support/rb_language'
+
+module Cucumber
+  module RbSupport
+    describe RbStepDefinition do
+      before do      
+        @step_mother = StepMother.new
+        @step_mother.load_natural_language('en')
+        @rb = @step_mother.load_programming_language('rb')
+        @dsl = Object.new 
+        @dsl.extend RbSupport::RbDsl
+        @step_mother.before(mock('scenario', :null_object => true))
+
+        $inside = nil
+      end
+      
+      it "should allow calling of other steps" do
+        @dsl.Given /Outside/ do
+          Given "Inside"
+        end
+        @dsl.Given /Inside/ do
+          $inside = true
+        end
+
+        @step_mother.step_match("Outside").invoke(nil)
+        $inside.should == true
+      end
+
+      it "should allow calling of other steps with inline arg" do
+        @dsl.Given /Outside/ do
+          Given "Inside", Ast::Table.new([['inside']])
+        end
+        @dsl.Given /Inside/ do |table|
+          $inside = table.raw[0][0]
+        end
+
+        @step_mother.step_match("Outside").invoke(nil)
+        $inside.should == 'inside'
+      end
+
+      it "should raise Undefined when inside step is not defined" do
+        @dsl.Given /Outside/ do
+          Given 'Inside'
+        end
+
+        lambda do
+          @step_mother.step_match('Outside').invoke(nil)
+        end.should raise_error(Undefined, 'Undefined step: "Inside"')
+      end
+
+      it "should allow forced pending" do
+        @dsl.Given /Outside/ do
+          pending("Do me!")
+        end
+
+        lambda do
+          @step_mother.step_match("Outside").invoke(nil)
+        end.should raise_error(Pending, "Do me!")
+      end
+
+      it "should raise ArityMismatchError when the number of capture groups differs from the number of step arguments" do
+        @dsl.Given /No group: \w+/ do |arg|
+        end
+
+        lambda do
+          @step_mother.step_match("No group: arg").invoke(nil)
+        end.should raise_error(ArityMismatchError)
+      end
+
+      it "should allow announce" do
+        v = mock('visitor')
+        v.should_receive(:announce).with('wasup')
+        @step_mother.visitor = v
+        @dsl.Given /Loud/ do
+          announce 'wasup'
+        end
+        
+        @step_mother.step_match("Loud").invoke(nil)
+      end
+      
+      it "should recognize $arg style captures" do
+        @dsl.Given "capture this: $arg" do |arg|
+          arg.should == 'this'
+        end
+
+       @step_mother.step_match('capture this: this').invoke(nil)
+      end
+      
+    
+      def unindented(s)
+        s.split("\n")[1..-2].join("\n").indent(-10)
+      end
+    
+      it "should recognise quotes in name and make according regexp" do
+        @rb.snippet_text('Given', 'A "first" arg', nil).should == unindented(%{
+          Given /^A "([^\\"]*)" arg$/ do |arg1|
+            pending # express the regexp above with the code you wish you had
+          end
+        })
+      end
+
+      it "should recognise several quoted words in name and make according regexp and args" do
+        @rb.snippet_text('Given', 'A "first" and "second" arg', nil).should == unindented(%{
+          Given /^A "([^\\"]*)" and "([^\\"]*)" arg$/ do |arg1, arg2|
+            pending # express the regexp above with the code you wish you had
+          end
+        })
+      end
+      
+      it "should not use quote group when there are no quotes" do
+        @rb.snippet_text('Given', 'A first arg', nil).should == unindented(%{
+          Given /^A first arg$/ do
+            pending # express the regexp above with the code you wish you had
+          end
+        })
+      end
+
+      it "should be helpful with tables" do
+        @rb.snippet_text('Given', 'A "first" arg', Cucumber::Ast::Table).should == unindented(%{
+          Given /^A "([^\\"]*)" arg$/ do |arg1, table|
+            # table is a Cucumber::Ast::Table
+            pending # express the regexp above with the code you wish you had
+          end
+        })
+      end
+    end
+  end
+end

data/spec/cucumber/rb_support/regexp_argument_matcher_spec.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'cucumber/rb_support/regexp_argument_matcher'
+
+module Cucumber
+  module RbSupport
+    describe RegexpArgumentMatcher do
+      it "should create 2 arguments" do
+        arguments = RegexpArgumentMatcher.arguments_from(/I (\w+) (\w+)/, "I like fish")
+        arguments.map{|argument| [argument.val, argument.pos]}.should == [["like", 2], ["fish", 7]]
+      end
+
+      it "should create 2 arguments when first group is optional" do
+        arguments = RegexpArgumentMatcher.arguments_from(/should( not)? be flashed '([^']*?)'$/, "I should be flashed 'Login failed.'")
+        arguments.map{|argument| [argument.val, argument.pos]}.should == [[nil, nil], ["Login failed.", 21]]
+      end
+    end
+  end
+end

data/spec/cucumber/sell_cucumbers.feature

@@ -0,0 +1,19 @@
+Feature: Sell cucumbers
+  As a cucumber farmer
+  I want to sell cucumbers
+  So that I buy meat
+
+  Scenario: Sell a dozen
+    Given there are 5 cucumbers
+    When I sell 12 cucumbers
+    Then I should owe 7 cucumbers
+
+  Scenario: Sell twenty
+    Given there are 5 cucumbers
+    When I sell 20 cucumbers
+    Then I should owe 15 cucumbers
+
+  Scenario: Sell fifty
+    Given there are 5 cucumbers
+    When I sell 50 cucumbers
+    Then I should owe 45 cucumbers

data/spec/cucumber/step_match_spec.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'cucumber/rb_support/rb_step_definition'
+require 'cucumber/rb_support/rb_language'
+
+module Cucumber
+  describe StepMatch do
+    before do
+      @rb_language = RbSupport::RbLanguage.new(nil)
+    end
+
+    def stepdef(regexp)
+      RbSupport::RbStepDefinition.new(@rb_language, regexp, lambda{})
+    end
+
+    def step_match(regexp, name)
+      stepdef = stepdef(regexp)
+      StepMatch.new(stepdef, name, nil, stepdef.arguments_from(name))
+    end
+
+    it "should format one groups when we use Unicode" do
+      m = step_match(/I (\w+) ok/, "I æøåÆØÅæøåÆØÅæøåÆØÅæøåÆØÅ ok")
+      m.format_args("<span>%s</span>").should == "I <span>æøåÆØÅæøåÆØÅæøåÆØÅæøåÆØÅ</span> ok"
+    end
+
+    it "should format several groups when we use Unicode" do
+      m = step_match(/I (\w+) (\w+) (\w+) this (\w+)/, "I ate æøåÆØÅæøåÆØÅæøåÆØÅæøåÆØÅ egg this morning")
+      m.format_args("<span>%s</span>").should == "I <span>ate</span> <span>æøåÆØÅæøåÆØÅæøåÆØÅæøåÆØÅ</span> <span>egg</span> this <span>morning</span>"
+    end
+
+    it "should format groups with format string" do
+      m = step_match(/I (\w+) (\d+) (\w+) this (\w+)/, "I ate 1 egg this morning")
+      m.format_args("<span>%s</span>").should == "I <span>ate</span> <span>1</span> <span>egg</span> this <span>morning</span>"
+    end
+
+    it "should format groups with format string when there are dupes" do
+      m = step_match(/I (\w+) (\d+) (\w+) this (\w+)/, "I bob 1 bo this bobs")
+      m.format_args("<span>%s</span>").should == "I <span>bob</span> <span>1</span> <span>bo</span> this <span>bobs</span>"
+    end
+
+    it "should format groups with block" do
+      m = step_match(/I (\w+) (\d+) (\w+) this (\w+)/, "I ate 1 egg this morning")
+      m.format_args(&lambda{|m| "<span>#{m}</span>"}).should == "I <span>ate</span> <span>1</span> <span>egg</span> this <span>morning</span>"
+    end
+
+    it "should format groups with proc object" do
+      m = step_match(/I (\w+) (\d+) (\w+) this (\w+)/, "I ate 1 egg this morning")
+      m.format_args(lambda{|m| "<span>#{m}</span>"}).should == "I <span>ate</span> <span>1</span> <span>egg</span> this <span>morning</span>"
+    end
+
+    it "should format groups even when first group is optional and not matched" do
+      m = step_match(/should( not)? be flashed '([^']*?)'$/, "I should be flashed 'Login failed.'")
+      m.format_args("<span>%s</span>").should == "I should be flashed '<span>Login failed.</span>'"
+    end
+  end
+end

data/spec/cucumber/step_mother_spec.rb

@@ -0,0 +1,270 @@
+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
+
+    it "should format step names" do
+      @dsl.Given(/it (.*) in (.*)/) do |what, month|
+      end
+      @dsl.Given(/nope something else/) do |what, month|
+      end
+      
+      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|}
+
+      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:30:in `/Three (.*) mice/'
+spec/cucumber/step_mother_spec.rb:31: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|}
+      
+      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:47:in `/Three (.*) mice/'
+spec/cucumber/step_mother_spec.rb:48: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|}
+      
+      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|}
+      
+      @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|}
+      
+      @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$/) {}
+      
+      @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
+
+    # 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|}
+    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:108: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(mock('scenario', :null_object => true))
+      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:140:in `World'
+spec/cucumber/step_mother_spec.rb:142: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'){}
+            
+      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
+    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')
+    end
+
+    describe "without capture groups" do
+      it "complains when registering with a with no transform block" do
+        lambda do
+          @dsl.Transform('^abc$')
+        end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
+      end
+      
+      it "complains when registering with a zero-arg transform block" do
+        lambda do
+          @dsl.Transform('^abc$') {42}
+        end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
+      end
+
+      it "complains when registering with a splat-arg transform block" do
+        lambda do
+          @dsl.Transform('^abc$') {|*splat| 42 }
+        end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
+      end
+
+      it "complains when transforming with an arity mismatch" do
+        lambda do
+          @dsl.Transform('^abc$') {|one, two| 42 }
+          @rb.execute_transforms(['abc'])
+        end.should raise_error(Cucumber::ArityMismatchError)
+      end
+
+      it "allows registering a regexp pattern that yields the step_arg matched" do
+        @dsl.Transform(/^ab*c$/) {|arg| 42}
+        @rb.execute_transforms(['ab']).should == ['ab']
+        @rb.execute_transforms(['ac']).should == [42]
+        @rb.execute_transforms(['abc']).should == [42]
+        @rb.execute_transforms(['abbc']).should == [42]
+      end
+    end
+
+    describe "with capture groups" do
+      it "complains when registering with a with no transform block" do
+        lambda do
+          @dsl.Transform('^a(.)c$')
+        end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
+      end
+      
+      it "complains when registering with a zero-arg transform block" do
+        lambda do
+          @dsl.Transform('^a(.)c$') { 42 }
+        end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
+      end
+
+      it "complains when registering with a splat-arg transform block" do
+        lambda do
+          @dsl.Transform('^a(.)c$') {|*splat| 42 }
+        end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
+      end
+
+      it "complains when transforming with an arity mismatch" do
+        lambda do
+          @dsl.Transform('^a(.)c$') {|one, two| 42 }
+          @rb.execute_transforms(['abc'])
+        end.should raise_error(Cucumber::ArityMismatchError)
+      end
+      
+      it "allows registering a regexp pattern that yields capture groups" do
+        @dsl.Transform(/^shape: (.+), color: (.+)$/) do |shape, color|
+          {shape.to_sym => color.to_sym}
+        end
+        @rb.execute_transforms(['shape: circle, color: blue']).should == [{:circle => :blue}]
+        @rb.execute_transforms(['shape: square, color: red']).should == [{:square => :red}]
+        @rb.execute_transforms(['not shape: square, not color: red']).should == ['not shape: square, not color: red']
+      end
+    end
+    
+    it "allows registering a string pattern" do
+      @dsl.Transform('^ab*c$') {|arg| 42}
+      @rb.execute_transforms(['ab']).should == ['ab']
+      @rb.execute_transforms(['ac']).should == [42]
+      @rb.execute_transforms(['abc']).should == [42]
+      @rb.execute_transforms(['abbc']).should == [42]
+    end
+
+    it "gives match priority to transforms defined last" do
+      @dsl.Transform(/^transform_me$/) {|arg| :foo }
+      @dsl.Transform(/^transform_me$/) {|arg| :bar }
+      @dsl.Transform(/^transform_me$/) {|arg| :baz }
+      @rb.execute_transforms(['transform_me']).should == [:baz]
+    end
+    
+    it "allows registering a transform which returns nil" do
+      @dsl.Transform('^ac$') {|arg| nil}
+      @rb.execute_transforms(['ab']).should == ['ab']
+      @rb.execute_transforms(['ac']).should == [nil]
+    end
+  end
+
+end