cucumber 0.1.12 → 0.1.13

data/spec/cucumber/formatters/ansicolor_spec.rb

@@ -6,24 +6,24 @@ module Cucumber
     describe ANSIColor do
       include ANSIColor
       
-      before do
+      after do
         ::Term::ANSIColor.coloring = true
       end
       
-      after do
-        ::Term::ANSIColor.coloring = false
+      it "should wrap passed_param with bold green and reset to green" do
+        passed_param("foo").should == "\e[32m\e[1mfoo\e[0m\e[0m\e[32m"
       end
-      
-      it "should wrap string in bold green for #passed with string arg" do
-        passed("foo").should == "\e[0m\e[1m\e[32mfoo\e[0m\e[0m"
+
+      it "should wrap passed in green" do
+        passed("foo").should == "\e[32mfoo\e[0m"
       end
 
-      it "should return bold green without wrapping for #passed without arg" do
-        passed.should == "\e[0m\e[1m\e[32m"
+      it "should not reset passed if there are no arguments" do
+        passed.should == "\e[32m"
       end
 
-      it "should return grey for #comment" do
-        comment("foo").should == "\e[0m\e[90mfoo\e[0m"
+      it "should wrap comments in grey" do
+        comment("foo").should == "\e[90mfoo\e[0m"
       end
       
       it "should not generate ansi codes when colors are disabled" do

data/spec/cucumber/formatters/html_formatter_spec.rb

@@ -33,6 +33,18 @@ module Cucumber
   
     describe HtmlFormatter do
       SIMPLE_DIR = File.dirname(__FILE__) + '/../../../examples/simple'
+
+      def mock_row_step(stubs = {})
+        mock('row step', {:id => 1, :outline? => true, :regexp_args_proc => [nil, nil, nil], :visible_args => []}.merge(stubs))
+      end
+      
+      def mock_step(stubs = {})
+        mock('step', {:id => 1, :keyword => 'Given', :format => '', :regexp_args_proc => [nil, nil, nil]}.merge(stubs))
+      end
+      
+      def mock_scenario_outline(stubs = {})
+        mock('scenario outline', {:table_header => nil, :accept => nil}.merge(stubs))
+      end
       
       before do
         p = Cucumber::TreetopParser::FeatureParser.new
@@ -68,6 +80,24 @@ module Cucumber
           @io.string.should include(column_header)
         end
       end
+
+      it "should only show arguments in a row step outline that are visible" do
+        @formatter.visit_row_step(mock_row_step(:outline? => true, :regexp_args_proc => [nil, ['mouse', 'monkey'], nil], :visible_args => ['mouse']))
+        
+        @io.string.should_not =~ /monkey/
+      end
+
+      it "should escape placeholders in step outline" do
+        CGI.should_receive(:escapeHTML).with("I'm a <placeholder>")
+                
+        @formatter.visit_step_outline(mock_step(:format => "I'm a <placeholder>"))
+      end
+      
+      it "should show Scenario Outline keyword for scenario outline" do
+        @formatter.visit_scenario_outline(mock_scenario_outline(:name => "outline", :accept => nil))
+        
+        @io.string.should =~ /Scenario Outline/
+      end
       
     end
   end

data/spec/cucumber/formatters/pretty_formatter_spec.rb

@@ -13,9 +13,16 @@ module Cucumber
           :padding_length => 2,
           :file => 'test',
           :line => 1,
-          :row? => false}.merge(stubs))
+          :row? => false,
+          :forced_to_pending? => false,
+          :regexp_args_proc => [nil, nil, mock_proc],
+          :outline? => false}.merge(stubs))
       end
 
+      def mock_step_outline(stubs={})
+        mock_step({:outline? => true}.merge(stubs))
+      end
+   
       def mock_scenario(stubs={})
         stub('scenario', {
           :name => 'test',
@@ -23,7 +30,12 @@ module Cucumber
           :pending? => false,
           :file => 'file', 
           :line => 1,
-          :padding_length => 2}.merge(stubs))
+          :padding_length => 2,
+          :outline? => false}.merge(stubs))
+      end
+      
+      def mock_scenario_outline(stubs={})
+        mock_scenario({:outline? => true}.merge(stubs))
       end
 
       def mock_feature(stubs={})
@@ -36,8 +48,16 @@ module Cucumber
           :backtrace => 'example backtrace'}.merge(stubs))
       end
 
-      def mock_proc
-        stub(Proc, :to_comment_line => '# steps/example_steps.rb:11')
+      def mock_proc(stubs={})
+        stub(Proc, {:to_comment_line => '# steps/example_steps.rb:11'}.merge(stubs))
+      end
+
+      before do
+        ::Term::ANSIColor.coloring = false
+      end
+
+      after do
+        ::Term::ANSIColor.coloring = true
       end
 
       it "should print step file and line when passed" do
@@ -81,6 +101,27 @@ module Cucumber
         io.string.should =~ /\n\n  Scenario: spacey/
       end
       
+      it "should distinguish a scenario outline from a scenario when displaying keywords" do
+        io = StringIO.new
+        formatter = PrettyFormatter.new(io,  mock('step_mother'))
+        
+        formatter.scenario_executing(mock_scenario_outline(:name => 'outliner'))
+
+        io.string.should =~ /Scenario Outline: outliner/
+      end
+      
+      %w{passed pending failed skipped}.each do |result|
+        it "should only show visible placeholder values in #{result} step " do
+          io = StringIO.new
+          formatter = PrettyFormatter.new(io,  mock('step_mother'))
+          formatter.instance_variable_set('@table_column_widths', [0])
+
+          formatter.send("step_#{result}".to_sym, mock_step_outline(:row? => true, :visible_args => ['monkey'], :padding_length => 2), nil, ['mouse'])
+
+          io.string.should =~ /monkey/
+         end
+       end
+      
       {'should' => true, 'should not' => false}.each do |should_or_should_not, show_snippet|
         describe "snippets option #{show_snippet}" do
           
@@ -136,6 +177,12 @@ module Cucumber
           end
         end
 
+        it "should display feature file and line for step outline" do
+          @formatter.step_traced(mock_step_outline(:file => "features/example.feature", :line => 11, :padding_length => 2), nil, nil)
+
+          @io.string.should include("Given formatted yes  # features/example.feature:11")
+        end
+
         it "should display feature file and line for pending step" do
           @formatter.step_pending(mock_step(:name => 'test', :file => 'features/example.feature', :line => 5, :padding_length => 2), nil, nil)
 
@@ -199,6 +246,94 @@ module Cucumber
         }.should_not raise_error(TypeError)
       end
 
+      describe "pending messages" do
+
+        before(:each) do
+          @io = StringIO.new
+          @formatter = PrettyFormatter.new @io, mock('step_mother')
+        end
+
+        it "should show pending message for step" do
+          @formatter.step_pending(mock_step(:keyword => 'Given', :forced_to_pending? => true, :error => ForcedPending.new("please implement me")), /yatta/, nil)
+
+          @formatter.dump
+
+          @io.string.should include("Given /yatta/ (please implement me)")
+        end
+        
+        it "should show pending step's file and line" do
+          @formatter.step_pending(mock_step(:forced_to_pending? => true, :error => ForcedPending.new("please implement me"), 
+                                            :regexp_args_proc => [nil, nil, mock_proc(:to_comment_line => "steps/example_steps.rb:11")]), nil, nil)
+
+          @formatter.dump
+        
+          @io.string.should include("steps/example_steps.rb:11")
+        end
+        
+        it "should not show duplicates" do
+          @formatter.step_pending(mock_step(:keyword => 'Given', :forced_to_pending? => true, :error => ForcedPending.new("please implement me")), /yatta/, [])
+          @formatter.step_pending(mock_step(:forced_to_pending? => true, :error => ForcedPending.new("please implement me"), :row? => true), /yatta/, [])
+
+          @formatter.dump
+
+          @io.string.scan(/please implement me/).length.should_not == 2
+        end
+        
+        it "should ignore messages from steps that where not forced to pending" do
+          @formatter.step_pending(mock_step(:keyword => 'Given', :forced_to_pending? => false, :error => Pending.new("do not show me")), nil, [])
+          
+          @formatter.dump
+          
+          @io.string.should_not include("do not show me")
+        end
+        
+      end
+
+      describe "no pending messages" do
+        
+        it "should not show any pending message information" do
+          io = StringIO.new
+          formatter = PrettyFormatter.new io, mock('step_mother')
+
+          formatter.dump
+        
+          io.string.should_not include("Pending Notes:\n")
+        end
+
+      end
+      
+      it "should show number of pending steps that have no step definition" do
+        io = StringIO.new
+        formatter = PrettyFormatter.new io, mock('step_mother')
+        
+        formatter.step_pending(mock_step(:error => ForcedPending.new, :forced_to_pending? => true), nil, [])
+        formatter.step_pending(mock_step(:error => Pending.new, :forced_to_pending? => false), nil, [])
+        
+        formatter.dump
+        
+        io.string.should include("1 with no step definition")
+      end
+
+      describe "colour" do
+
+        before(:all) do
+          Term::ANSIColor.coloring = true
+        end
+
+        after(:all) do
+          Term::ANSIColor.coloring = false
+        end
+
+        it "should show the scenario outline keyword and title as pending blue" do
+          ::Term::ANSIColor.coloring = true
+          io = StringIO.new
+          formatter = PrettyFormatter.new io, mock('step_mother')
+          formatter.scenario_executing(mock_scenario(:outline? => true, :name => 'blue'))
+
+          io.string.should =~ /\e\[36m\s*Scenario Outline: blue\e\[0m/
+        end
+
+      end
     end
   end
 end

data/spec/cucumber/formatters/progress_formatter_spec.rb

@@ -3,6 +3,14 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 module Cucumber
   module Formatters
     describe ProgressFormatter do
+      before do
+        ::Term::ANSIColor.coloring = false
+      end
+
+      after do
+        ::Term::ANSIColor.coloring = true
+      end
+      
       it "should print . when passed" do
         io = StringIO.new
         formatter = ProgressFormatter.new io
@@ -41,6 +49,14 @@ module Cucumber
         io.string.should =~ /^_$/
       end
 
+      it "should print nothing when traced" do
+        io = StringIO.new
+        formatter = ProgressFormatter.new io
+        formatter.step_traced(nil, nil, nil)
+        
+        io.string.should =~ /^$/
+      end
+
       describe "scenario without any steps" do
         before :each do
           @io         = StringIO.new

data/spec/cucumber/tree/feature_spec.rb

@@ -4,6 +4,16 @@ module Cucumber
   module Tree
     describe Feature do
       
+      def mock_scenario(stubs = {})
+        mock("scenario", {:update_table_column_widths => nil,
+                          :outline? => false,
+                          :table_header= => nil}.merge(stubs))
+      end
+      
+      def mock_scenario_outline(stubs = {})
+        mock_scenario({:outline? => true, :row? => false, :table_header= => nil}.merge(stubs))
+      end
+      
       it "should have padding_length 2 when alone" do
         feature = Feature.new('header')
         feature.padding_length.should == 2
@@ -14,30 +24,99 @@ module Cucumber
         it "should create a new scenario for a feature" do
           feature = Feature.new('header')
 
-          Scenario.should_receive(:new).with(feature, 'test scenario', "19")
+          Scenario.should_receive(:new).with(feature, 'test scenario', "29")
 
           feature.Scenario('test scenario') {}
         end
       
       end
       
+      describe "creating a Scenario Outline" do
+
+        it "should create a new scenario outline for feature" do
+          feature = Feature.new('header')
+          
+          ScenarioOutline.should_receive(:new).with(feature, 'test', '41')
+          
+          feature.ScenarioOutline('test') {}
+        end
+
+      end
+      
       describe "creating a Table" do
+
+        before(:each) do
+          @feature = Feature.new('header')
+        end
+
+        describe "previous scenario is a scenario outline" do
+
+          it "should create a row scenario outline for feature" do
+            mock_scenario_outline = mock_scenario_outline(:outline? => true)
+            Scenario.stub!(:new).and_return(mock_scenario_outline)
+            @feature.add_scenario('scenario', 5)    
+
+            RowScenarioOutline.should_receive(:new).with(@feature, mock_scenario_outline, ['1', '2'], anything)
+
+            @feature.Table do |t| 
+              t | "input_1" | "input_2" | t 
+              t | 1 | 2 | t
+            end
+          end
+
+        end
+        
+        describe "previous scenario was a regular scenario" do
+          
+          it "should create a row scenario for feature" do
+            mock_scenario = mock_scenario(:outline? => false)
+            Scenario.stub!(:new).and_return(mock_scenario)
+            @feature.add_scenario('scenario', 5)    
+
+            RowScenario.should_receive(:new).with(@feature, mock_scenario, ['1', '2'], anything)
+
+            @feature.Table do |t| 
+              t | "input_1" | "input_2" | t 
+              t | 1 | 2 | t
+            end
+          end
+          
+        end
     
         it "should set the table header of the template scenario" do
-          feature = Feature.new('header')
-          mock_scenario = mock("scenario", :update_table_column_widths => nil)
+          mock_scenario = mock("scenario", :update_table_column_widths => nil, :outline? => false)
           Scenario.stub!(:new).and_return(mock_scenario)
-          feature.add_scenario('scenario', 5)    
+          @feature.add_scenario('scenario', 5)    
 
           mock_scenario.should_receive(:table_header=).with(["input_1", "input_2"])
 
-          feature.Table do |t| 
+          @feature.Table do |t| 
             t | "input_1" | "input_2" | t 
             t | 1 | 2 | t
           end
         end
       
       end
+      
+      it "should create a new row scenario outline" do
+        feature = Feature.new('header')
+         
+        RowScenarioOutline.should_receive(:new)
+           
+        feature.add_row_scenario_outline(mock_scenario_outline, [], 1)
+      end
+      
+      it "should visit scenario outline" do
+        feature = Feature.new('header')
+        ScenarioOutline.stub!(:new).and_return(mock_scenario_outline(:outline? => true, :row? => false))
+        feature.add_scenario_outline(nil, nil)
+        mock_visitor = mock('visitor', :visit_header => nil)
+
+        mock_visitor.should_receive(:visit_scenario_outline)
+        
+        feature.accept(mock_visitor)
+      end
+            
     end
   end
 end

data/spec/cucumber/tree/row_scenario_outline_spec.rb

@@ -0,0 +1,73 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Cucumber
+  module Tree
+    describe RowScenarioOutline do
+
+      def mock_feature
+         mock_feature = mock("feature")
+      end
+
+      def mock_scenario(stubs ={})
+        mock("scenario", {:update_table_column_widths => nil}.merge(stubs))
+      end
+
+      def mock_step(stubs = {})
+        mock("step", {:arity => 0}.merge(stubs))
+      end
+
+      it "should indicate scenario is a scenario outline" do
+        outline = RowScenarioOutline.new(mock_feature, mock_scenario, [], 1)
+      
+        outline.should be_a_outline
+      end
+  
+      describe "steps" do
+
+        it "should create a new step with placeholders in template scenario steps replaced with values from scenario row" do
+          mock_step = mock_step(:keyword => 'Given', :name => '<animal> burning bright')
+          mock_scenario = mock_scenario(:table_header => ["animal"], :steps => [mock_step] )
+          outline = RowScenarioOutline.new(mock_feature, mock_scenario, ["tiger"], 1)
+
+          RowStepOutline.should_receive(:new).with(outline, mock_step, 'tiger burning bright', ["tiger"], 1)
+
+          outline.steps
+        end
+      
+        it "should leave the scenario template's name unchanged when replacing placeholders" do
+          mock_step = mock_step(:keyword => 'Given', :name => '<animal> burning bright', :extra_args => [])
+          mock_scenario = mock_scenario(:table_header => ["animal"], :steps => [mock_step] )
+          outline = RowScenarioOutline.new(mock_feature, mock_scenario, ["tiger"], 1)
+
+          outline.steps
+          
+          mock_step.name.should == '<animal> burning bright'
+        end
+
+        it "should leave the step name untouched if it has no placeholders" do
+          mock_step = mock_step(:keyword => 'Given', :name => 'beauty too rich for earth too dear')
+          mock_scenario = mock_scenario(:table_header => ["animal"], :steps => [mock_step] )     
+          outline = RowScenarioOutline.new(mock_feature, mock_scenario, ["tiger"], 1)
+
+          RowStepOutline.should_receive(:new).with(outline, mock_step, 'beauty too rich for earth too dear', [], 1)
+
+          outline.steps
+        end
+            
+        it "should ensure that created steps do not contain values already used in previous steps" do
+          mock_step_1 = mock_step(:keyword => 'Given', :name => '<animal> eating')
+          mock_step_2 = mock_step(:keyword => 'Given', :name => 'eating <animal>')
+          mock_scenario = mock_scenario(:table_header => ["animal"], :steps => [mock_step_1, mock_step_2] )       
+          outline = RowScenarioOutline.new(mock_feature, mock_scenario, ["tiger"], 1)
+                                                                                              
+          RowStepOutline.should_receive(:new).with(anything, anything, anything, ['tiger'], anything)
+          RowStepOutline.should_receive(:new).with(anything, anything, anything, [], anything)
+
+          outline.steps
+        end
+            
+      end
+      
+    end
+  end
+end