aslakhellesoy-cucumber 0.1.12 → 0.1.13

data/spec/cucumber/cli_spec.rb

@@ -17,12 +17,12 @@ module Cucumber
     end
     
     before(:each) do
-      Kernel.stub!(:exit)
+      Kernel.stub!(:exit).and_return(nil)
     end
     
-    def given_cucumber_yml_defined_as(hash)
+    def given_cucumber_yml_defined_as(hash_or_string)
       File.stub!(:exist?).and_return(true)
-      cucumber_yml = hash.to_yaml
+      cucumber_yml = hash_or_string.is_a?(Hash) ? hash_or_string.to_yaml : hash_or_string
       IO.stub!(:read).with('cucumber.yml').and_return(cucumber_yml)
     end
     
@@ -73,6 +73,18 @@ Defined profiles in cucumber.yml:
       error.string.should == "Profiles must be defined as a String.  The 'foo' profile was [1, 2, 3] (Array).\n"
     end
     
+    it "should provide a helpful error message when a specified profile exists but is nil or blank" do
+      [nil, '   '].each do |bad_input|
+        cli = CLI.new(StringIO.new, error = StringIO.new)
+
+        given_cucumber_yml_defined_as({'foo' => bad_input})
+
+        cli.parse_options!(%w{--profile foo})
+
+        error.string.should match(/The 'foo' profile in cucumber.yml was blank.  Please define the command line arguments for the 'foo' profile in cucumber.yml./)
+      end
+    end
+
     it "should provide a helpful error message when no YAML file exists and a profile is specified" do
       cli = CLI.new(StringIO.new, error = StringIO.new)
       
@@ -80,7 +92,32 @@ Defined profiles in cucumber.yml:
     
       cli.parse_options!(%w{--profile i_do_not_exist})
         
-      error.string.should match(/cucumber.yml was not found.  Please define your 'i_do_not_exist' and other profiles in cucumber.yml./)
+      error.string.should match(/cucumber.yml was not found.  Please refer to cucumber's documentaion on defining profiles in cucumber.yml./)
+    end
+
+    it "should provide a helpful error message when cucumber.yml is blank or malformed" do
+        expected_error_message = /cucumber.yml was found, but was blank or malformed. Please refer to cucumber's documentaion on correct profile usage./
+          
+      ['', 'sfsadfs', "--- \n- an\n- array\n", "---dddfd"].each do |bad_input|
+        cli = CLI.new(StringIO.new, error = StringIO.new)
+      
+        given_cucumber_yml_defined_as(bad_input)
+        cli.parse_options!([])
+        
+        error.string.should match(expected_error_message)
+      end
+    end
+    
+    it "should procide a helpful error message when the YAML can not be parsed" do
+        expected_error_message = /cucumber.yml was found, but could not be parsed. Please refer to cucumber's documentaion on correct profile usage./
+      cli = CLI.new(StringIO.new, error = StringIO.new)
+      
+      given_cucumber_yml_defined_as("input that causes an exception in YAML loading")
+      YAML.should_receive(:load).and_raise Exception
+      
+      cli.parse_options!([])
+      
+      error.string.should match(expected_error_message)
     end
 
     it "should accept --no-source option" do
@@ -112,6 +149,21 @@ Defined profiles in cucumber.yml:
       cli.options[:verbose].should be_true
     end
 
+    it "should require files in support paths first" do
+      File.stub!(:directory?).and_return(true)
+      Dir.stub!(:[]).and_return(["/features/step_definitions/foo.rb","/features/support/env.rb"])
+      
+      cli = CLI.new(StringIO.new)
+      cli.parse_options!(%w{--require /features})
+
+      cli.should_receive(:require).twice.with(/treetop_parser/).ordered
+      cli.should_receive(:require).with("/features/support/env.rb").ordered
+      cli.should_receive(:require).with("/features/step_definitions/foo.rb").ordered
+      cli.should_receive(:require).with("spec/expectations/differs/default").ordered
+
+      cli.execute!(stub('step mother'), mock_executor, mock_features)
+    end
+
     describe "verbose mode" do
       
       before(:each) do
@@ -384,6 +436,36 @@ Defined profiles in cucumber.yml:
       cli.execute!(stub('step mother'), mock_executor, stub('features'))
     end
 
+    describe "--backtrace" do
+      before do
+        Exception.cucumber_full_backtrace = false
+      end
+      
+      it "should show full backtrace when --backtrace is present" do
+        cli = CLI.new
+        cli.parse_options!(['--backtrace'])
+        begin
+          "x".should == "y"
+        rescue => e
+          e.cucumber_backtrace[0].should_not == "#{__FILE__}:#{__LINE__ - 2}"
+        end
+      end
+
+      it "should strip gems when --backtrace is absent" do
+        cli = CLI.new
+        cli.parse_options!(['--'])
+        begin
+          "x".should == "y"
+        rescue => e
+          e.cucumber_backtrace[0].should == "#{__FILE__}:#{__LINE__ - 2}"
+        end
+      end
+
+      after do
+        Exception.cucumber_full_backtrace = false
+      end
+    end
+
     describe "example.feature:line file arguments" do
 
       it "should extract line numbers" do
@@ -413,8 +495,7 @@ Defined profiles in cucumber.yml:
       
         cli.options[:lines_for_features].should == {'example.feature' => [11, 12]}
       end
-    
-  end
+    end
 
     it "should search for all features in the specified directory" do
       cli = CLI.new

data/spec/cucumber/executor_spec.rb

@@ -10,10 +10,24 @@ module Cucumber
         :name => 'test', 
         :accept => nil, 
         :steps => [],
-        :pending? => true
+        :pending? => true,
+        :outline? => false,
       }.merge(stubs))
     end
     
+    def parse_features(feature_file)
+      parser = TreetopParser::FeatureParser.new
+      feature = parser.parse_feature(feature_file)
+    end
+
+    before do
+      ::Term::ANSIColor.coloring = false
+    end
+
+    after do
+      ::Term::ANSIColor.coloring = true
+    end
+
     before do # TODO: Way more setup and duplication of lib code. Use lib code!
       @io = StringIO.new
       @step_mother = StepMother.new
@@ -21,9 +35,8 @@ module Cucumber
       @formatters = Broadcaster.new [Formatters::ProgressFormatter.new(@io)]
       @executor.formatters = @formatters
       @feature_file = File.dirname(__FILE__) + '/sell_cucumbers.feature'
-      @parser = TreetopParser::FeatureParser.new
-      @features = Tree::Features.new
-      @feature = @parser.parse_feature(@feature_file)
+      @features = features = Tree::Features.new
+      @feature = parse_features(@feature_file)
       @features << @feature
     end
     
@@ -46,7 +59,7 @@ module Cucumber
 
 1)
 dang
-#{__FILE__}:43:in `Then /I should owe (\\d*) cucumbers/'
+#{__FILE__}:56:in `Then /I should owe (\\d*) cucumbers/'
 #{@feature_file}:9:in `Then I should owe 7 cucumbers'
 })
     end
@@ -75,6 +88,13 @@ dang
         world.doit.should == "dunit"
         world.beatit.should == "beatenit"
       end
+      
+      it "should add support for calling 'pending' from world" do
+        world = @executor.create_world
+      
+        world.should respond_to(:pending)
+      end
+      
     end
 
     describe "visiting feature" do
@@ -162,6 +182,54 @@ dang
       end
       
     end
+    
+    describe "visiting step outline" do
+        
+      it "should trace step" do
+        mock_formatter = mock('formatter')
+        @executor.formatters = mock_formatter
+        mock_step_outline = mock('step outline', :regexp_args_proc => [])
+ 
+        mock_formatter.should_receive(:step_traced)
+        
+        @executor.visit_step_outline(mock_step_outline)
+      end
+      
+    end
+    
+    describe "visit forced pending step" do
+
+      before(:each) do
+        @executor.formatters = mock('formatter', :null_object => true)          
+      end
+
+      it "should store the pending exception with the step" do
+        mock_step = mock("mock step", :regexp_args_proc => nil)
+        pending_exception = ForcedPending.new("implement me")
+        mock_step.stub!(:execute_in).and_raise(pending_exception)
+
+        mock_step.should_receive(:'error=').with(pending_exception)
+        
+        @executor.visit_step(mock_step)
+      end
+      
+      describe "after failed/pending step" do
+        
+        it "should store the pending exception with the step" do
+          mock_step_1 = mock("mock step", :null_object => true)
+          mock_step_2 = mock("mock step", :regexp_args_proc => nil)
+          pending_exception = ForcedPending.new("implement me")
+          mock_step_1.stub!(:execute_in).and_raise(StandardError)
+          mock_step_2.stub!(:execute_in).and_raise(pending_exception)
+
+          mock_step_2.should_receive(:'error=').with(pending_exception)
+
+          @executor.visit_step(mock_step_1)
+          @executor.visit_step(mock_step_2)
+        end
+        
+      end
+    end
               
     describe "visiting row scenarios" do
       
@@ -175,40 +243,44 @@ dang
         }.merge(stubs))
       end
 
-      describe "without having first run the matching regular scenario" do
-      
+      %w{regular_scenario scenario_outline}.each do |regular_or_outline|
+
         before(:each) do
-          @regular_scenario = Tree::Scenario.new(nil, 'test', 1)
+          @scenario = mock("#{regular_or_outline} scenario", :name => 'test', :at_line? => true, :pending? => false, :accept => nil)
+
           @executor.lines_for_features = Hash.new([5])
-          @executor.visit_regular_scenario(@regular_scenario)
+          @executor.send("visit_#{regular_or_outline}".to_sym, @scenario)
         end
+
+        describe "without having first run the matching #{regular_or_outline}" do
         
-        it "should run the regular scenario before the row scenario" do
-          @regular_scenario.should_receive(:accept)
-          row_scenario = mock_row_scenario(:name => 'test', :at_line? => true)
-          row_scenario.should_receive(:accept)
-          @executor.visit_row_scenario(row_scenario)
-        end
+            it "should run the #{regular_or_outline} before the row scenario" do
+              @scenario.should_receive(:accept)
+              row_scenario = mock_row_scenario(:name => 'test', :at_line? => true)
+              row_scenario.should_receive(:accept)
 
-        it "should run the row scenario after running the regular scenario" do
-          row_scenario = mock_row_scenario(:at_line? => true)
-          row_scenario.should_receive(:accept)
-          @executor.visit_row_scenario(row_scenario)
-        end
-      
-      end
+              @executor.visit_row_scenario(row_scenario)
+            end
+
+            it "should run the row scenario after running the #{regular_or_outline}" do
+              row_scenario = mock_row_scenario(:at_line? => true)
+              row_scenario.should_receive(:accept)
+              @scenario.stub!(:accept)
 
-      describe "having run matching regular scenario" do
+              @executor.visit_row_scenario(row_scenario)
+            end
       
-        it "should not run the regular scenario if it has already run" do
-          scenario = Tree::Scenario.new(nil, 'test', 1)
-          @executor.visit_regular_scenario(scenario)
+        end
 
-          scenario.should_not_receive(:accept)
+        describe "having run matching #{regular_or_outline}" do
+      
+          it "should not run the regular scenario if it has already run" do
+            @scenario.should_not_receive(:accept)
 
-          @executor.visit_row_scenario(mock_row_scenario(:name => 'test', :at_line? => true, :accept => nil))
-        end
+            @executor.visit_row_scenario(mock_row_scenario(:name => 'test', :at_line? => true, :accept => nil))
+          end
       
+        end
       end
     end
     
@@ -293,6 +365,6 @@ dang
         @executor.visit_features(@features)
       end
     end
-        
+
   end
 end

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