casecumber 1.0.2.1 → 1.2.1.cb2

data/spec/cucumber/cli/configuration_spec.rb

@@ -321,12 +321,12 @@ END_OF_MESSAGE
     end
 
     it "should accept --color option" do
-      Term::ANSIColor.should_receive(:coloring=).with(true)
+      Cucumber::Term::ANSIColor.should_receive(:coloring=).with(true)
       config.parse!(['--color'])
     end
 
     it "should accept --no-color option" do
-      Term::ANSIColor.should_receive(:coloring=).with(false)
+      Cucumber::Term::ANSIColor.should_receive(:coloring=).with(false)
       config = Configuration.new(StringIO.new)
       config.parse!(['--no-color'])
     end
@@ -404,14 +404,20 @@ END_OF_MESSAGE
     end
     
     describe "#tag_expression" do
+      include RSpec::WorkInProgress
+
       it "returns an empty expression when no tags are specified" do
-        config.parse!([])
-        config.tag_expression.should be_empty
+        pending_under :java, 'the java class Gherkin::TagExpression has no isEmpty method' do
+          config.parse!([])
+          config.tag_expression.should be_empty
+        end
       end
 
       it "returns an expression when tags are specified" do
-        config.parse!(['--tags','@foo'])
-        config.tag_expression.should_not be_empty
+        pending_under :java, 'the java class Gherkin::TagExpression has no isEmpty method' do
+          config.parse!(['--tags','@foo'])
+          config.tag_expression.should_not be_empty
+        end
       end
     end
     

data/spec/cucumber/cli/main_spec.rb

@@ -47,7 +47,7 @@ module Cucumber
 
         before(:each) do
           b = Cucumber::Parser::GherkinBuilder.new
-          @empty_feature = b.feature(Gherkin::Formatter::Model::Feature.new([], [], "Feature", "Foo", "", 99))
+          @empty_feature = b.feature(Gherkin::Formatter::Model::Feature.new([], [], "Feature", "Foo", "", 99, ""))
         end
 
         it "should show feature files parsed" do
@@ -95,7 +95,7 @@ module Cucumber
 
       context "--drb" do
         before(:each) do
-          @configuration = mock('Configuration', :drb? => true).as_null_object
+          @configuration = mock('Configuration', :drb? => true, :dotcucumber => false).as_null_object
           Configuration.stub!(:new).and_return(@configuration)
 
           @args = ['features']

data/spec/cucumber/cli/options_spec.rb

@@ -55,14 +55,20 @@ module Cli
 
       context '--i18n' do
         context "with LANG specified as 'help'" do
+          include RSpec::WorkInProgress
+
           it "lists all known langues" do
-            when_parsing '--i18n help' do
-              Kernel.should_receive(:exit)
+            pending_under :java, "require gherkin >= b5e96f13" do
+              when_parsing '--i18n help' do
+                Kernel.should_receive(:exit)
+              end
             end
           end
 
           it "exits the program" do
-            when_parsing('--i18n help') { Kernel.should_receive(:exit) }
+            pending_under :java, "require gherkin >= b5e96f13" do
+              when_parsing('--i18n help') { Kernel.should_receive(:exit) }
+            end
           end
         end
       end

data/spec/cucumber/constantize_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+module Cucumber
+  describe Constantize do
+    include Constantize
+
+    it "loads html formatter" do
+      clazz = constantize('Cucumber::Formatter::Html')
+      clazz.name.should == 'Cucumber::Formatter::Html'
+    end
+
+    it "fails to load a made up class" do
+      expect { constantize('My::MadeUp::ClassName') }.to raise_error(LoadError)
+    end
+  end
+end

data/spec/cucumber/formatter/ansicolor_spec.rb

@@ -23,7 +23,7 @@ module Cucumber
       end
       
       it "should not generate ansi codes when colors are disabled" do
-        ::Term::ANSIColor.coloring = false
+        ::Cucumber::Term::ANSIColor.coloring = false
         passed("foo").should == "foo"
       end
     end

data/spec/cucumber/formatter/html_spec.rb

@@ -193,7 +193,7 @@ module Cucumber
       
         describe "with a step that fails in the scenario" do
           define_steps do
-            Given(/boo/) { raise 'eek' }
+            Given(/boo/) { raise StandardError, 'eek'.freeze }
           end
         
           define_feature(<<-FEATURE)
@@ -202,8 +202,9 @@ module Cucumber
             Scenario: Monkey gets a fright
               Given boo
             FEATURE
-      
-          it { @doc.should have_css_node('.feature .scenario .step.failed', /eek/) }
+
+          it { @doc.should have_css_node('.feature .scenario .step.failed .message', /eek/) }
+          it { @doc.should have_css_node('.feature .scenario .step.failed .message', /StandardError/) }
         end
       
         describe "with a step that fails in the backgound" do

data/spec/cucumber/formatter/interceptor_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+require 'cucumber/formatter/interceptor'
+
+module Cucumber::Formatter
+  describe Interceptor::Pipe do
+    let(:pipe) do
+      pipe = double('original pipe')
+      pipe.stub(:instance_of?).and_return(true)
+      pipe
+    end
+
+    describe '#wrap!' do
+      it 'should raise an ArgumentError if its not passed :stderr/:stdout' do
+        expect {
+          Interceptor::Pipe.wrap(:nonsense)
+        }.to raise_error(ArgumentError)
+
+      end
+
+      context 'when passed :stderr' do
+        before :each do
+          @stderr = $stdout
+        end
+
+        it 'should wrap $stderr' do
+          wrapped = Interceptor::Pipe.wrap(:stderr)
+          $stderr.should be_instance_of Interceptor::Pipe
+          $stderr.should be wrapped
+        end
+
+        after :each do
+          $stderr = @stderr
+        end
+      end
+
+      context 'when passed :stdout' do
+        before :each do
+          @stdout = $stdout
+        end
+
+        it 'should wrap $stdout' do
+          wrapped = Interceptor::Pipe.wrap(:stdout)
+          $stdout.should be_instance_of Interceptor::Pipe
+          $stdout.should be wrapped
+        end
+
+        after :each do
+          $stdout = @stdout
+        end
+      end
+    end
+
+    describe '#unwrap!' do
+      before :each do
+        @stdout = $stdout
+        @wrapped = Interceptor::Pipe.wrap(:stdout)
+      end
+
+      it 'should raise an ArgumentError if it wasn\'t passed :stderr/:stdout' do
+        expect {
+          Interceptor::Pipe.unwrap!(:nonsense)
+        }.to raise_error(ArgumentError)
+      end
+
+      it 'should reset $stdout when #unwrap! is called' do
+        interceptor = Interceptor::Pipe.unwrap! :stdout
+        interceptor.should be_instance_of Interceptor::Pipe
+        $stdout.should_not be interceptor
+      end
+
+      it 'should disable the pipe bypass' do
+        buffer = '(::)'
+        Interceptor::Pipe.unwrap! :stdout
+
+        @wrapped.should_receive(:write).with(buffer)
+        @wrapped.buffer.should_not_receive(:<<)
+        @wrapped.write(buffer)
+      end
+
+      after :each do
+        $stdout = @stdout
+      end
+    end
+
+    describe '#write' do
+      let(:buffer) { 'Some stupid buffer' }
+      let(:pi) { Interceptor::Pipe.new(pipe) }
+
+      it 'should write arguments to the original pipe' do
+        pipe.should_receive(:write).with(buffer).and_return(buffer.size)
+        pi.write(buffer).should == buffer.size
+      end
+
+      it 'should add the buffer to its stored output' do
+        pipe.stub(:write)
+        pi.write(buffer)
+        pi.buffer.should_not be_empty
+        pi.buffer.first.should == buffer
+      end
+    end
+
+    describe '#method_missing' do
+      let(:pi) { Interceptor::Pipe.new(pipe) }
+
+      it 'should pass #tty? to the original pipe' do
+        pipe.should_receive(:tty?).and_return(true)
+        pi.tty?.should be true
+      end
+    end
+  end
+end

data/spec/cucumber/formatter/junit_spec.rb

@@ -8,28 +8,28 @@ module Cucumber::Formatter
   describe Junit do
     extend SpecHelperDsl
     include SpecHelper
-    
+
     class TestDoubleJunitFormatter < Junit
       attr_reader :written_files
-      
+
       def write_file(feature_filename, data)
         @written_files ||= {}
         @written_files[feature_filename] = data
       end
     end
-    
+
     before(:each) do
       File.stub!(:directory?).and_return(true)
       @formatter = TestDoubleJunitFormatter.new(step_mother, '', {})
     end
-    
+
     describe "a feature with no name" do
       define_feature <<-FEATURE
         Feature:
           Scenario: Passing
             Given a passing scenario
       FEATURE
-      
+
       it "should raise an exception" do
         lambda { run_defined_feature }.should raise_error(Junit::UnNamedFeatureError)
       end
@@ -40,7 +40,7 @@ module Cucumber::Formatter
         run_defined_feature
         @doc = Nokogiri.XML(@formatter.written_files.values.first)
       end
-      
+
       describe "with a single scenario" do
         define_feature <<-FEATURE
           Feature: One passing scenario, one failing scenario
@@ -48,8 +48,24 @@ module Cucumber::Formatter
             Scenario: Passing
               Given a passing scenario
         FEATURE
-        
+
         it { @doc.to_s.should =~ /One passing scenario, one failing scenario/ }
+
+        it 'should have a root system-out node' do
+          @doc.xpath('//testsuite/system-out').size.should == 1
+        end
+
+        it 'should have a root system-err node' do
+          @doc.xpath('//testsuite/system-err').size.should == 1
+        end
+
+        it 'should have a system-out node under <testcase/>' do
+          @doc.xpath('//testcase/system-out').size.should == 1
+        end
+
+        it 'should have a system-err node under <testcase/>' do
+          @doc.xpath('//testcase/system-err').size.should == 1
+        end
       end
 
       describe "with a scenario in a subdirectory" do
@@ -64,12 +80,12 @@ module Cucumber::Formatter
           @formatter.written_files.keys.first.should == File.join('', 'TEST-features-some-path-spec.xml')
         end
       end
-      
+
       describe "with a scenario outline table" do
         define_steps do
           Given(/.*/) {  }
         end
-        
+
         define_feature <<-FEATURE
           Feature: Eat things when hungry
 
@@ -78,7 +94,7 @@ module Cucumber::Formatter
               And stuff:
                 | foo |
                 | bar |
-            
+
             Examples: Good
               | Things   |
               | Cucumber |
@@ -87,7 +103,7 @@ module Cucumber::Formatter
               | Things   |
               | Big Mac  |
         FEATURE
-        
+
         it { @doc.to_s.should =~ /Eat things when hungry/ }
         it { @doc.to_s.should =~ /Cucumber/ }
         it { @doc.to_s.should =~ /Whisky/ }
@@ -96,25 +112,25 @@ module Cucumber::Formatter
         it { @doc.to_s.should_not =~ /Good|Evil/ }
         it { @doc.to_s.should_not =~ /type="skipped"/}
       end
-  
+
       describe "with a regular data table scenario" do
         define_steps do
-          Given(/the following items on a shortlist/) { |table| }  
+          Given(/the following items on a shortlist/) { |table| }
           When(/I go.*/) {  }
-          Then(/I should have visited at least/) { |table| } 
+          Then(/I should have visited at least/) { |table| }
         end
-        
+
         define_feature <<-FEATURE
           Feature: Shortlist
 
-            Scenario: Procure items 
+            Scenario: Procure items
               Given the following items on a shortlist:
-                | item    |       
-                | milk    |       
+                | item    |
+                | milk    |
                 | cookies |
               When I get some..
               Then I'll eat 'em
-           
+
         FEATURE
         # these type of tables shouldn't crash (or generate test cases)
         it { @doc.to_s.should_not =~ /milk/ }
@@ -122,4 +138,4 @@ module Cucumber::Formatter
       end
     end
   end
-end
+end

data/spec/cucumber/formatter/progress_spec.rb

@@ -6,7 +6,7 @@ module Cucumber
     describe Progress do
 
       before(:each) do
-        Term::ANSIColor.coloring = false
+        Cucumber::Term::ANSIColor.coloring = false
         @out = StringIO.new
         progress = Cucumber::Formatter::Progress.new(mock("step mother"), @out, {})
         @visitor = Cucumber::Ast::TreeWalker.new(nil, [progress])
@@ -14,7 +14,7 @@ module Cucumber
  
       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)
+          @visitor.visit_step_result('', '', nil, :failed, nil, 10, nil, nil)
           outline_table = mock()
           outline_table.should_receive(:accept) do |visitor|
             visitor.visit_table_cell_value('value', nil)

data/spec/cucumber/rb_support/rb_language_spec.rb

@@ -31,7 +31,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 +40,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,7 +48,7 @@ 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
           })
@@ -64,7 +64,7 @@ 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
@@ -279,4 +279,4 @@ or http://wiki.github.com/cucumber/cucumber/a-whole-new-world.
 
     end
   end
-end
+end

data/spec/cucumber/rb_support/rb_step_definition_spec.rb

@@ -22,7 +22,7 @@ module Cucumber
       
       it "should allow calling of other steps" do
         dsl.Given /Outside/ do
-          Given "Inside"
+          step "Inside"
         end
         dsl.Given /Inside/ do
           $inside = true
@@ -34,7 +34,7 @@ module Cucumber
 
       it "should allow calling of other steps with inline arg" do
         dsl.Given /Outside/ do
-          Given "Inside", Cucumber::Ast::Table.new([['inside']])
+          step "Inside", Cucumber::Ast::Table.new([['inside']])
         end
         dsl.Given /Inside/ do |table|
           $inside = table.raw[0][0]
@@ -44,9 +44,25 @@ module Cucumber
         $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
+
+        support_code.step_match("With symbol").invoke(nil)
+      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 }
+
+        support_code.step_match("With symbol on block").invoke(nil)
+      end
+
       it "should raise Undefined when inside step is not defined" do
         dsl.Given /Outside/ do
-          Given 'Inside'
+          step 'Inside'
         end
 
         lambda do
@@ -91,7 +107,7 @@ module Cucumber
       end
 
       it "should have a JSON representation of the signature" do
-        RbStepDefinition.new(rb, /I CAN HAZ (\d+) CUKES/i, lambda{}).to_hash.should == {'source' => "I CAN HAZ (\\d+) CUKES", 'flags' => 'i'}
+        RbStepDefinition.new(rb, /I CAN HAZ (\d+) CUKES/i, lambda{}, {}).to_hash.should == {'source' => "I CAN HAZ (\\d+) CUKES", 'flags' => 'i'}
       end
     end
   end

data/spec/cucumber/rb_support/rb_transform_spec.rb

@@ -8,8 +8,12 @@ module Cucumber
         RbTransform.new(nil, regexp, lambda { |a| })
       end
       describe "#to_s" do
-        it "removes the capture group parentheses" do
-          transform(/(a)bc/).to_s.should == "abc"
+        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

data/spec/cucumber/rb_support/regexp_argument_matcher_spec.rb

@@ -4,14 +4,18 @@ require 'cucumber/rb_support/regexp_argument_matcher'
 module Cucumber
   module RbSupport
     describe RegexpArgumentMatcher do
+      include RSpec::WorkInProgress
+
       it "should create 2 arguments" do
         arguments = RegexpArgumentMatcher.arguments_from(/I (\w+) (\w+)/, "I like fish")
-        arguments.map{|argument| [argument.val, argument.byte_offset]}.should == [["like", 2], ["fish", 7]]
+        arguments.map{|argument| [argument.val, argument.offset]}.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.byte_offset]}.should == [[nil, nil], ["Login failed.", 21]]
+        pending_under :java, "requires cucumber/gherkin >= ac42f51" do
+          arguments = RegexpArgumentMatcher.arguments_from(/should( not)? be flashed '([^']*?)'$/, "I should be flashed 'Login failed.'")
+          arguments.map{|argument| [argument.val, argument.offset]}.should == [[nil, nil], ["Login failed.", 21]]
+        end
       end
     end
   end

data/spec/cucumber/runtime/results_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+module Cucumber
+  describe Runtime::Results do
+
+    let(:configuration) {double 'Configuration', :strict? => false}
+    let(:passed_scenario) {double 'Scenario', :status => :passed}
+    let(:failed_scenario) {double 'Scenario', :status => :failed}
+    let(:passed_step) {double 'Step', :status => :passed}
+    let(:failed_step) {double 'Step', :status => :failed}
+    let(:pending_step) {double 'Step', :status => :pending}
+    let(:undefined_step) {double 'Step', :status => :undefined}
+
+    subject {described_class.new(configuration)}
+
+    describe '#failure?' do
+      context 'feature is not work in progress' do
+        before do
+          configuration.stub(:wip? => false)
+        end
+
+        it 'should return true if a scenario failed' do
+          subject.scenario_visited(passed_scenario)
+          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)
+          subject.should_not be_failure
+        end
+
+        context 'configuration is strict' do
+          before do
+            configuration.stub(:strict? => true)
+          end
+
+          it 'should return true if a step is pending' do
+            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
+          end
+        end
+      end
+
+      context 'feature is work in progress' do
+        before do
+          configuration.stub(:wip? => true)
+        end
+
+        it 'should return true if a scenario passed' do
+          subject.scenario_visited(passed_scenario)
+          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 fail' do
+          subject.scenario_visited(failed_scenario)
+          subject.should_not be_failure
+        end
+      end
+    end
+  end
+end

data/spec/cucumber/step_match_spec.rb

@@ -5,6 +5,8 @@ require 'cucumber/rb_support/rb_language'
 
 module Cucumber
   describe StepMatch do
+    include RSpec::WorkInProgress
+    
     WORD = Cucumber::RUBY_1_9 ? '[[:word:]]' : '\w'
 
     before do
@@ -12,7 +14,7 @@ module Cucumber
     end
 
     def stepdef(regexp)
-      RbSupport::RbStepDefinition.new(@rb_language, regexp, lambda{})
+      RbSupport::RbStepDefinition.new(@rb_language, regexp, lambda{}, {})
     end
 
     def step_match(regexp, name)
@@ -57,8 +59,10 @@ module Cucumber
     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>'"
+      pending_under :java, "requires cucumber/gherkin >= ac42f51" 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
 
     it "should format embedded groups" do
@@ -66,4 +70,4 @@ module Cucumber
       m.format_args("<span>%s</span>").should == "running<span> 5 times</span> <span>10</span> meters"
     end
   end
-end
+end

data/spec/spec_helper.rb

@@ -17,6 +17,20 @@ $KCODE='u' unless Cucumber::RUBY_1_9
 
 RSpec.configure do |c|
   c.before do
-    ::Term::ANSIColor.coloring = true
+    ::Cucumber::Term::ANSIColor.coloring = true
   end
 end
+
+module RSpec
+  module WorkInProgress
+    def pending_under platforms, reason, &block
+      if [platforms].flatten.map(&:to_s).include? RUBY_PLATFORM
+        pending "pending under #{platforms.inspect} because: #{reason}", &block 
+      else
+        yield
+      end
+    end
+  end
+end
+
+