cucumber 1.2.1 → 1.2.2

data/spec/cucumber/formatter/interceptor_spec.rb

@@ -68,6 +68,16 @@ module Cucumber::Formatter
         $stdout.should_not be interceptor
       end
 
+      it 'should noop if $stdout or $stderr has been overwritten' do
+        $stdout = StringIO.new
+        pipe = Interceptor::Pipe.unwrap! :stdout
+        pipe.should == $stdout
+
+        $stderr = StringIO.new
+        pipe = Interceptor::Pipe.unwrap! :stderr
+        pipe.should == $stderr
+      end
+
       it 'should disable the pipe bypass' do
         buffer = '(::)'
         Interceptor::Pipe.unwrap! :stdout

data/spec/cucumber/formatter/progress_spec.rb

@@ -11,7 +11,7 @@ module Cucumber
         progress = Cucumber::Formatter::Progress.new(mock("step mother"), @out, {})
         @visitor = Cucumber::Ast::TreeWalker.new(nil, [progress])
       end
- 
+
       describe "visiting a table cell value without a status" do
         it "should take the status from the last run step" do
           @visitor.visit_step_result('', '', nil, :failed, nil, 10, nil, nil)

data/spec/cucumber/formatter/spec_helper.rb

@@ -3,12 +3,12 @@ module Cucumber
 
     module SpecHelperDsl
       attr_reader :feature_content, :step_defs, :feature_filename
-    
+
       def define_feature(string, feature_file = 'spec.feature')
         @feature_content = string
         @feature_filename = feature_file
       end
-    
+
       def define_steps(&block)
         @step_defs = block
       end
@@ -20,11 +20,11 @@ module Cucumber
         features = load_features(self.class.feature_content || raise("No feature content defined!"))
         run(features)
       end
-      
+
       def step_mother
         @step_mother ||= Runtime.new
       end
-      
+
       def load_features(content)
         feature_file = FeatureFile.new(self.class.feature_filename, content)
         features = Ast::Features.new
@@ -33,20 +33,20 @@ module Cucumber
         features.add_feature(feature) if feature
         features
       end
-    
+
       def run(features)
         configuration = Cucumber::Configuration.default
         tree_walker = Cucumber::Ast::TreeWalker.new(step_mother, [@formatter], configuration)
         tree_walker.visit_features(features)
       end
-    
+
       def define_steps
         return unless step_defs = self.class.step_defs
         rb = step_mother.load_programming_language('rb')
         dsl = Object.new
         dsl.extend RbSupport::RbDsl
         dsl.instance_exec &step_defs
-      end 
+      end
     end
   end
 end

data/spec/cucumber/rake/forked_spec.rb

@@ -24,9 +24,22 @@ module Cucumber
         end
 
         it "uses bundle exec to find cucumber and libraries" do
+          bundle_cmd = Gem.default_exec_format % 'bundle'
+
+          subject.cmd.should == [Cucumber::RUBY_BINARY,
+                                 '-S',
+                                 bundle_cmd,
+                                 'exec',
+                                 'cucumber',
+                                 '--cuke-option'] + feature_files
+        end
+
+        it "obeys program suffix for bundler" do
+          Gem::ConfigMap.stub(:[]).with(:ruby_install_name).and_return('XrubyY')
+
           subject.cmd.should == [Cucumber::RUBY_BINARY,
                                  '-S',
-                                 'bundle',
+                                 'XbundleY',
                                  'exec',
                                  'cucumber',
                                  '--cuke-option'] + feature_files
@@ -59,4 +72,4 @@ module Cucumber
     end
 
   end
-end
+end

data/spec/cucumber/rake/rcov_spec.rb

@@ -61,11 +61,11 @@ module Cucumber
                                  '--',
                                  '--cuke-option'] + feature_files
         end
-        
+
       end
 
 
     end
 
   end
-end
+end

data/spec/cucumber/rb_support/rb_language_spec.rb

@@ -10,7 +10,7 @@ module Cucumber
       let(:support_code) do
         Cucumber::Runtime::SupportCode.new(user_interface, {})
       end
-      let(:dsl) do 
+      let(:dsl) do
         rb
         Object.new.extend(RbSupport::RbDsl)
       end
@@ -18,12 +18,20 @@ module Cucumber
       def unindented(s)
         s.split("\n")[1..-2].join("\n").indent(-10)
       end
-      
+
       describe "snippets" do
-    
+
+        it "should wrap snippet patterns in parentheses" do
+          rb.snippet_text('Given', 'A "string" with 4 spaces', nil).should == unindented(%{
+          Given(/^A "(.*?)" with (\\d+) spaces$/) do |arg1, arg2|
+            pending # express the regexp above with the code you wish you had
+          end
+          })
+        end
+
         it "should recognise numbers in name and make according regexp" do
           rb.snippet_text('Given', 'Cloud 9 yeah', nil).should == unindented(%{
-          Given /^Cloud (\\d+) yeah$/ do |arg1|
+          Given(/^Cloud (\\d+) yeah$/) do |arg1|
             pending # express the regexp above with the code you wish you had
           end
           })
@@ -31,7 +39,7 @@ module Cucumber
 
         it "should recognise a mix of ints, strings and why not a table too" do
           rb.snippet_text('Given', 'I have 9 "awesome" cukes in 37 "boxes"', Cucumber::Ast::Table).should == unindented(%{
-          Given /^I have (\\d+) "(.*?)" cukes in (\\d+) "(.*?)"$/ do |arg1, arg2, arg3, arg4, table|
+          Given(/^I have (\\d+) "(.*?)" cukes in (\\d+) "(.*?)"$/) do |arg1, arg2, arg3, arg4, table|
             # table is a Cucumber::Ast::Table
             pending # express the regexp above with the code you wish you had
           end
@@ -40,7 +48,7 @@ module Cucumber
 
         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|
+          Given(/^A "(.*?)" arg$/) do |arg1|
             pending # express the regexp above with the code you wish you had
           end
           })
@@ -48,15 +56,15 @@ module Cucumber
 
         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|
+          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
+          Given(/^A first arg$/) do
             pending # express the regexp above with the code you wish you had
           end
           })
@@ -64,38 +72,38 @@ module Cucumber
 
         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|
+          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
-    
+
       describe "#load_code_file" do
         after do
           FileUtils.rm_rf('tmp.rb')
         end
-        
+
         def a_file_called(name)
           File.open('tmp.rb', 'w') do |f|
             f.puts yield
           end
         end
-        
+
         it "re-loads the file when called multiple times" do
           a_file_called('tmp.rb') do
             "$foo = 1"
           end
-          
+
           rb.load_code_file('tmp.rb')
           $foo.should == 1
-          
+
           a_file_called('tmp.rb') do
             "$foo = 2"
           end
-          
+
           rb.load_code_file('tmp.rb')
           $foo.should == 2
         end
@@ -189,6 +197,15 @@ or http://wiki.github.com/cucumber/cucumber/a-whole-new-world.
             rb.execute_transforms(['abc']).should == [42]
             rb.execute_transforms(['abbc']).should == [42]
           end
+
+          it "transforms times" do
+            require 'time'
+            dsl.Transform(/^(\d\d-\d\d-\d\d\d\d)$/) do |arg|
+              Time.parse(arg)
+            end
+            rb.execute_transforms(['10-0E-1971']).should == ['10-0E-1971']
+            rb.execute_transforms(['10-03-1971']).should == [Time.parse('10-03-1971')]
+          end
         end
 
         describe "with capture groups" do

data/spec/cucumber/rb_support/rb_step_definition_spec.rb

@@ -7,19 +7,22 @@ module Cucumber
   module RbSupport
     describe RbStepDefinition do
       let(:user_interface) { double('user interface') }
-      let(:support_code) { Cucumber::Runtime::SupportCode.new(user_interface) }
-      let(:rb)      { support_code.load_programming_language('rb')}
-      let(:dsl) do 
+      let(:support_code)   { Cucumber::Runtime::SupportCode.new(user_interface) }
+      let(:rb)             { support_code.load_programming_language('rb') }
+      let(:dsl) do
         rb
         Object.new.extend(Cucumber::RbSupport::RbDsl)
       end
-      
-      before do      
-        rb.before(mock('scenario').as_null_object)
 
+      before do
+        rb.before(mock('scenario').as_null_object)
         $inside = nil
       end
-      
+
+      def run_step(text)
+        support_code.step_match(text).invoke(nil)
+      end
+
       it "should allow calling of other steps" do
         dsl.Given /Outside/ do
           step "Inside"
@@ -28,7 +31,7 @@ module Cucumber
           $inside = true
         end
 
-        support_code.step_match("Outside").invoke(nil)
+        run_step "Outside"
         $inside.should == true
       end
 
@@ -40,24 +43,35 @@ module Cucumber
           $inside = table.raw[0][0]
         end
 
-        support_code.step_match("Outside").invoke(nil)
+        run_step "Outside"
         $inside.should == 'inside'
       end
 
-      it "should call a method on the world when specified with a symbol" do
-        rb.current_world.should_receive(:with_symbol)
-        dsl.Given /With symbol/, :with_symbol
+      context "mapping to world methods" do
+        it "should call a method on the world when specified with a symbol" do
+          rb.current_world.should_receive(:with_symbol)
+          dsl.Given /With symbol/, :with_symbol
 
-        support_code.step_match("With symbol").invoke(nil)
-      end
+          run_step "With symbol"
+        end
 
-      it "should call a method on a specified object" do
-        target = double('target')
-        target.should_receive(:with_symbol)
-        rb.current_world.stub!(:target).and_return(target)
-        dsl.Given /With symbol on block/, :with_symbol, :on => lambda { target }
+        it "should call a method on a specified object" do
+          target = double('target')
+          rb.current_world.stub(:target => target)
+          dsl.Given /With symbol on block/, :with_symbol, :on => lambda { target }
 
-        support_code.step_match("With symbol on block").invoke(nil)
+          target.should_receive(:with_symbol)
+          run_step "With symbol on block"
+        end
+
+        it "should call a method on a specified world attribute" do
+          target = double('target')
+          rb.current_world.stub(:target => target)
+          dsl.Given /With symbol on symbol/, :with_symbol, :on => :target
+
+          target.should_receive(:with_symbol)
+          run_step "With symbol on symbol"
+        end
       end
 
       it "should raise Undefined when inside step is not defined" do
@@ -65,9 +79,8 @@ module Cucumber
           step 'Inside'
         end
 
-        lambda do
-          support_code.step_match('Outside').invoke(nil)
-        end.should raise_error(Cucumber::Undefined, 'Undefined step: "Inside"')
+        lambda { run_step "Outside" }.
+          should raise_error(Cucumber::Undefined, 'Undefined step: "Inside"')
       end
 
       it "should allow forced pending" do
@@ -75,18 +88,16 @@ module Cucumber
           pending("Do me!")
         end
 
-        lambda do
-          support_code.step_match("Outside").invoke(nil)
-        end.should raise_error(Cucumber::Pending, "Do me!")
+        lambda { run_step "Outside" }.
+          should raise_error(Cucumber::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
-          support_code.step_match("No group: arg").invoke(nil)
-        end.should raise_error(Cucumber::ArityMismatchError)
+        lambda { run_step "No group: arg" }.
+          should raise_error(Cucumber::ArityMismatchError)
       end
 
       it "should allow puts" do
@@ -94,16 +105,15 @@ module Cucumber
         dsl.Given /Loud/ do
           puts 'wasup'
         end
-        
-        support_code.step_match("Loud").invoke(nil)
+        run_step "Loud"
       end
-      
+
       it "should recognize $arg style captures" do
+        arg_value = "wow!"
         dsl.Given "capture this: $arg" do |arg|
-          arg.should == 'this'
+          arg.should == arg_value
         end
-
-       support_code.step_match('capture this: this').invoke(nil)
+        run_step "capture this: wow!"
       end
 
       it "should have a JSON representation of the signature" do

data/spec/cucumber/rb_support/rb_transform_spec.rb

@@ -11,15 +11,15 @@ module Cucumber
         it "converts captures groups to non-capture groups" do
           transform(/(a|b)bc/).to_s.should == "(?:a|b)bc"
         end
-        
+
         it "leaves non capture groups alone" do
           transform(/(?:a|b)bc/).to_s.should == "(?:a|b)bc"
         end
-        
+
         it "strips away anchors" do
           transform(/^xyz$/).to_s.should == "xyz"
         end
       end
     end
   end
-end
+end

data/spec/cucumber/runtime/for_programming_languages_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+module Cucumber
+  describe Runtime::ForProgrammingLanguages do
+
+    let(:user_interface)  { double('user interface') }
+    subject               { Runtime::SupportCode.new(user_interface,{}) }
+    let(:runtime_facade)  { Runtime::ForProgrammingLanguages.new(subject, user_interface) }
+
+    it 'should produce Ast::DocString by #doc_string with default content-type' do
+      str = runtime_facade.doc_string('DOC')
+      str.should be_kind_of(Ast::DocString)
+      str.content_type.should eq('')
+    end
+
+    it 'should produce Ast::DocString by #doc_string with ruby content-type' do
+      str = runtime_facade.doc_string('DOC','ruby')
+      str.should be_kind_of(Ast::DocString)
+      str.content_type.should eq('ruby')
+    end
+
+    it 'should produce Ast::Table by #table' do
+      runtime_facade.table(%{
+      | account | description | amount |
+      | INT-100 | Taxi        | 114    |
+      | CUC-101 | Peeler      | 22     |
+      }).should be_kind_of(Ast::Table)
+    end
+
+  end
+end

data/spec/cucumber/runtime/results_spec.rb

@@ -24,16 +24,16 @@ module Cucumber
           subject.scenario_visited(failed_scenario)
           subject.should be_failure
         end
-        
+
         it 'should return true if a step failed' do
           subject.step_visited(failed_step)
           subject.should be_failure
         end
-        
+
         it 'should return false if there are no scenarios' do
           subject.should_not be_failure
         end
-        
+
         it 'should return false if all scenarios passed' do
           subject.scenario_visited(passed_scenario)
           subject.scenario_visited(passed_scenario)
@@ -49,7 +49,7 @@ module Cucumber
             subject.step_visited(pending_step)
             subject.should be_failure
           end
-          
+
           it 'should return true if a step is undefined' do
             subject.step_visited(undefined_step)
             subject.should be_failure
@@ -70,7 +70,7 @@ module Cucumber
         it 'should return false if there are no scenarios' do
           subject.should_not be_failure
         end
-        
+
         it 'should return false if all scenarios fail' do
           subject.scenario_visited(failed_scenario)
           subject.should_not be_failure