cucumber 0.1.8 → 0.1.9

data/spec/cucumber/formatters/ansicolor_spec.rb

@@ -6,6 +6,14 @@ module Cucumber
     describe ANSIColor do
       include ANSIColor
       
+      before do
+        ::Term::ANSIColor.coloring = true
+      end
+      
+      after do
+        ::Term::ANSIColor.coloring = false
+      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"
       end
@@ -19,7 +27,7 @@ module Cucumber
       end
       
       it "should not generate ansi codes when colors are disabled" do
-        ENV['CUCUMBER_COLORS_DISABLED'] = '1'
+        ::Term::ANSIColor.coloring = false
         passed("foo").should == "foo"
       end
     end

data/spec/cucumber/formatters/autotest_formatter_spec.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Cucumber::Formatters
+  describe AutotestFormatter do
+    before(:each) do
+      @io        = StringIO.new
+      @formatter = AutotestFormatter.new @io
+      @scenario  = mock('scenario', :name => "Doing tricky things")
+      @step      = mock('step', :scenario => @scenario)
+    end
+
+    %w{failed skipped pending}.each do |didnt_pass|
+      it "should print a scenario's name when it has a #{didnt_pass} step" do
+        @formatter.send("step_#{didnt_pass}".to_sym, @step, mock('regexp'), mock('args'))
+        @io.string.should == "Doing tricky things\n"
+      end
+    end
+
+    it "should not print the same scenario's name twice" do
+      another_step = mock('another step', :scenario => @scenario)
+      @formatter.send("step_failed".to_sym, @step,         mock('regexp'), mock('args'))
+      @formatter.send("step_skipped".to_sym, another_step, mock('regexp'), mock('args'))
+      @io.string.should == "Doing tricky things\n"
+    end
+  end
+end

data/spec/cucumber/formatters/pretty_formatter_spec.rb

@@ -3,36 +3,43 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 module Cucumber
   module Formatters
     describe PrettyFormatter do
-      
+
       def mock_step(stubs={})
         stub('step', {
-          :keyword => 'Given', 
+          :keyword => 'Given',
           :format => 'formatted yes',
           :name => 'example',
           :error => nil,
+          :padding_length => 2,
+          :file => 'test',
+          :line => 1,
           :row? => false}.merge(stubs))
       end
-      
+
       def mock_scenario(stubs={})
         stub('scenario', {
           :name => 'test',
-          :row? => false }.merge(stubs))
+          :row? => false,
+          :pending? => false,
+          :file => 'file', 
+          :line => 1,
+          :padding_length => 2}.merge(stubs))
       end
 
       def mock_feature(stubs={})
         stub("feature", stubs)
       end
-    
+
       def mock_error(stubs={})
         stub('error', {
-          :message => 'failed', 
+          :message => 'failed',
           :backtrace => 'example backtrace'}.merge(stubs))
       end
-      
+
       def mock_proc
         stub(Proc, :to_comment_line => '# steps/example_steps.rb:11')
       end
-            
+
       it "should print step file and line when passed" do
         io = StringIO.new
         formatter = PrettyFormatter.new io, StepMother.new
@@ -42,70 +49,156 @@ module Cucumber
         formatter.step_passed(step, nil, nil)
         io.string.should == "    Given formatted yes\n"
       end
+
+      describe "scenario without any steps" do
+        before :each do
+          @io         = StringIO.new
+          @formatter  = PrettyFormatter.new(@io, StepMother.new)
+          @scenario   = mock_scenario(:name => "title", :pending? => true)
+        end
+
+        it "should display as pending when executing" do
+          @formatter.should_receive(:pending).with("  Scenario: title")
+          @formatter.scenario_executing(@scenario)
+        end
+
+        it "should display as pending in the dump" do
+          @formatter.scenario_executing(@scenario)
+          @formatter.dump
+          @io.string.should include("1 scenarios pending")
+        end
+      end
       
-      describe "show source option true" do
+      it "should put a line between last row scenario and new scenario" do
+        io = StringIO.new
+        formatter = PrettyFormatter.new io, mock('step_mother'), :source => true
+        scenario = mock_scenario(:row? => true)
+  
+        formatter.scenario_executing(scenario)
+        formatter.scenario_executed(scenario)
+        formatter.scenario_executing(mock_scenario(:name => 'spacey', :row? => false))
+     
+        io.string.should =~ /\n\n  Scenario: spacey/
+      end
+      
+      {'should' => true, 'should not' => false}.each do |should_or_should_not, show_snippet|
+        describe "snippets option #{show_snippet}" do
+          
+          it "#{should_or_should_not} show snippet for pending step" do
+            @io = StringIO.new
+            step_mother = mock('step_mother', :has_step_definition? => false)
+            @formatter = PrettyFormatter.new @io, step_mother, :snippets => show_snippet
+                    
+            @formatter.step_pending(mock_step(:actual_keyword => 'Given', :name => 'pending step snippet'), nil, nil)
+            @formatter.dump
+
+            @io.string.send(should_or_should_not.gsub(' ','_').to_sym, include("Given /^pending step snippet$/ do"))
+          end
+        
+        end
+      end                  
+      
+      it  "should escape snippets which have special regular expression characters" do
+        @io = StringIO.new
+        step_mother = mock('step_mother', :has_step_definition? => false)
+        @formatter = PrettyFormatter.new @io, step_mother, :snippets => true
+
+        @formatter.step_pending(mock_step(:actual_keyword => 'Given', :name => "$1 millon /'s"), nil, nil)
+        @formatter.dump
+
+        @io.string.should include("Given /^\\$1 millon \\/'s$/ do")
+      end
+          
+      it "should not show the snippet for a step which already has a step definition" do
+        @io = StringIO.new
+        step_mother = mock('step_mother', :has_step_definition? => true)
+        @formatter = PrettyFormatter.new @io, step_mother, :snippets => true
+
+        @formatter.step_pending(mock_step(:actual_keyword => 'Given', :name => 'pending step snippet'), nil, nil)
+        @formatter.dump
+
+        @io.string.should_not include("Given /^pending step snippet$/ do")
+      end
       
+      describe "show source option true" do
+
         before(:each) do
           @io = StringIO.new
           step_mother = mock('step_mother')
           @formatter = PrettyFormatter.new @io, step_mother, :source => true
         end
-      
+
         %w{passed failed skipped}.each do |result|
-          it "should display step source for passed step" do
+          it "should display step source for #{result} step" do
             @formatter.send("step_#{result}".to_sym, mock_step(:regexp_args_proc => [nil, nil, mock_proc], :error => StandardError.new, :padding_length => 2), nil, nil)
-          
+
             @io.string.should include("Given formatted yes  # steps/example_steps.rb:11")
           end
         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)
-          
+
           @io.string.should include("Given test  # features/example.feature:5")
-        end        
-        
+        end
+
         it "should display file and line for scenario" do
-          @formatter.scenario_executing(mock_scenario(:name => "title", :file => 'features/example.feature', :line => 2 , :padding_length => 2))
-          
+          @formatter.scenario_executing(mock_scenario(:name => "title", :file => 'features/example.feature', :line => 2 , :padding_length => 2, :pending? => false))
+
           @io.string.should include("Scenario: title  # features/example.feature:2")
         end
-               
+
         it "should display file for feature" do
-          @formatter.visit_feature(mock_feature(:file => 'features/example.feature', :padding_length => 2))
+          @formatter.feature_executing(mock_feature(:file => 'features/example.feature', :padding_length => 2))
           @formatter.header_executing("Feature: test\n In order to ...\n As a ...\n I want to ...\n")
-          
+
           @io.string.should include("Feature: test  # features/example.feature\n")
           @io.string.should include("In order to ...\n")
           @io.string.should include("As a ...\n")
           @io.string.should include("I want to ...\n")
         end
-                
+
         it "should align step comments" do
           step_1 = mock_step(:regexp_args_proc => [nil, nil, mock_proc], :format => "1", :padding_length => 10)
           step_4 = mock_step(:regexp_args_proc => [nil, nil, mock_proc], :format => "4444", :padding_length => 7)
           step_9 = mock_step(:regexp_args_proc => [nil, nil, mock_proc], :format => "999999999", :padding_length => 2)
-          
+
           @formatter.step_passed(step_1, nil, nil)
           @formatter.step_passed(step_4, nil, nil)
           @formatter.step_passed(step_9, nil, nil)
-          
+
           @io.string.should include("Given 1          # steps/example_steps.rb:11")
           @io.string.should include("Given 4444       # steps/example_steps.rb:11")
           @io.string.should include("Given 999999999  # steps/example_steps.rb:11")
         end
-                
+
         it "should align step comments with respect to their scenario's comment" do
           step = mock_step(:regexp_args_proc => [nil, nil, mock_proc], :error => StandardError.new, :padding_length => 6)
 
-          @formatter.scenario_executing(mock_scenario(:name => "very long title", :file => 'features/example.feature', :line => 5, :steps => [step], :padding_length => 2))
+          @formatter.scenario_executing(mock_scenario(:name => "very long title", :file => 'features/example.feature', :line => 5, :steps => [step], :padding_length => 2, :pending? => false))
           @formatter.step_passed(step, nil, nil)
-          
+
           @io.string.should include("Scenario: very long title  # features/example.feature:5")
           @io.string.should include("  Given formatted yes      # steps/example_steps.rb:11")
         end
 
       end
+
+      it "should reset the column count correctly" do
+        io = StringIO.new
+        formatter = PrettyFormatter.new io, mock('step_mother'), :source => true
+
+        large_scenario = mock_scenario(:row? => false, :table_column_widths => [3,3,5,4,4], :table_header => %w(one two three four five))
+        formatter.scenario_executing(large_scenario)
+        formatter.scenario_executed(large_scenario)
+
+        small_scenario = mock_scenario(:row? => false, :table_column_widths => [3,3], :table_header => %w(one two))
+        formatter.scenario_executing(small_scenario)
+        lambda {
+          formatter.scenario_executed(small_scenario)
+        }.should_not raise_error(TypeError)
+      end
+
     end
   end
 end

data/spec/cucumber/formatters/profile_formatter_spec.rb

@@ -177,8 +177,7 @@ module Cucumber
 
       it "should print the top 5 step invocations for step definition" do
         formatter.instance_variable_set("@step_time", Time.now)
-        step_definition_put = 1
-
+   
         10.times do |test_number|
           formatter.step_passed(mock_step(:format => 'please invocate me', :actual_keyword => 'Given'), nil, nil)
         end

data/spec/cucumber/formatters/progress_formatter_spec.rb

@@ -27,7 +27,8 @@ module Cucumber
         io = StringIO.new
         formatter = ProgressFormatter.new io
         step = stub('step',
-          :error => Pending.new
+          :error => Pending.new,
+          :scenario => mock('scenario')
         )
         formatter.step_pending(step,nil,nil)
         io.string.should =~ /^\P$/
@@ -39,6 +40,26 @@ module Cucumber
         formatter.step_skipped(nil,nil,nil)
         io.string.should =~ /^_$/
       end
+
+      describe "scenario without any steps" do
+        before :each do
+          @io         = StringIO.new
+          @formatter  = ProgressFormatter.new(@io)
+          @feature    = stub("feature", :header => "Feature Header")
+          @scenario   = stub("scenario", :feature => @feature, :name => "Scenario Title", :row? => false, :pending? => true)
+        end
+
+        it "should print a P when executing" do
+          @formatter.should_receive(:pending).with("P")
+          @formatter.scenario_executing(@scenario)
+        end
+
+        it "should display as pending in the dump" do
+          @formatter.scenario_executing(@scenario)
+          @formatter.dump
+          @io.string.should include("Feature Header (Scenario Title)")
+        end
+      end
     end
   end
 end

data/spec/cucumber/sell_cucumbers.feature

@@ -7,3 +7,13 @@ Feature: Sell cucumbers
     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_mother_spec.rb

@@ -49,5 +49,26 @@ module Cucumber
         m.execute(step)
       end
     end
+
+    it "should mark a step as pending if it does not have a proc" do
+      m = StepMother.new
+      m.register_step_proc /I have no body/
+      regexp, args, proc = m.regexp_args_proc "I have no body"
+      proc.should == StepMother::PENDING
+    end
+
+    it "should report that a step has a definition if the step is registered" do
+      m = StepMother.new
+      m.register_step_proc /I am a real step definition/ do end
+
+      m.has_step_definition?('I am a real step definition').should be_true
+    end
+
+    it "should report that a step does not have a definition if it has not been registered" do
+      m = StepMother.new
+    
+      m.has_step_definition?('I am a step without a definition').should be_false
+    end
+
   end
 end

data/spec/cucumber/tree/row_scenario_spec.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Cucumber
+  module Tree
+    describe RowScenario do
+      
+      describe "pending?" do
+        before :each do
+          @scenario = Scenario.new(nil, '', 1)
+          @row_scenario = RowScenario.new(mock('feature'), @scenario, [], 1)
+        end
+        
+        it "should return true if the template scenario has no steps" do
+          @row_scenario.should be_pending
+        end
+        
+        it "should return false if the template scenario has no steps" do
+          @scenario.create_step('Given', 'a long step', 1)
+          @row_scenario.should_not be_pending
+        end
+        
+      end
+    end
+  end
+end

data/spec/cucumber/tree/scenario_spec.rb

@@ -2,36 +2,75 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 
 module Cucumber
   module Tree
-    describe Scenario do      
+    describe Scenario do
       xit "should reuse steps in GivenScenario" do
         given_scenario = GivenScenario.new(scenario_2, "First", 99)
-      
+
         scenario_2.create_step(given_scenario)
         scenario_2.create_step(step_a)
         scenario_2.steps.should == [step_1, step_2, step_a]
       end
-      
+
       it "should have padding_length 2 when alone" do
         scenario = Scenario.new(nil, 'test', 1)
         scenario.padding_length.should == 2
       end
-      
+
       it "should include indent when padding to step" do
         scenario = Scenario.new(nil, '', 1)
         scenario.create_step('Given', 'a long step', 1)
 
-        #Scenario: ***********
+        #Scenario: *********
         #  Given a long step
-        scenario.padding_length.should == 9 + 2 #Allow for indent
+        scenario.padding_length.should == 9 + Scenario::INDENT
       end
-  
+
       it "should ignore step padding if scenario is longer than all steps" do
         scenario = Scenario.new(nil, 'Very long scenario and then some', 1)
         scenario.create_step('Given', 'test', 1)
+
+        scenario.padding_length.should == 2
+      end
+
+      describe "utf-8 strings" do
+        describe "when calculating padding" do
+
+          it "should take into consideration utf-8 scenario names" do
+            scenario = Scenario.new(nil, 'こんばんは', 1)
+            scenario.create_step('Given', 'a long step', 1)
+        
+            #Scenario: こんばんは****
+            #  Given a long step
+            scenario.padding_length.should == 4 + Scenario::INDENT
+          end
+      
+          it "should take into consideration a utf-8 keyword for 'scenario'" do
+            Cucumber.language.stub!(:[]).with('scenario').and_return("シナリオ")
+            scenario = Scenario.new(nil, '', 1)
+            scenario.create_step('Given', 'step', 1)
         
-        scenario.padding_length.should == 2                                                                                                                                     
+            #シナリオ: ******
+            #  Given step
+            scenario.padding_length.should == 6 + Scenario::INDENT
+          end
+        
+        end
       end
       
+      describe "pending?" do
+        before :each do
+          @scenario = Scenario.new(nil, '', 1)
+        end
+        
+        it "should return true if there aren't any steps" do
+          @scenario.should be_pending
+        end
+        
+        it "should return false if there are steps" do
+          @scenario.create_step('Given', 'a long step', 1)
+          @scenario.should_not be_pending
+        end
+      end
     end
   end
 end