aslakhellesoy-cucumber 0.1.16.4 → 0.1.16.5

data/spec/cucumber/formatters/pretty_formatter_spec.rb

@@ -1,410 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Cucumber
-  module Formatters
-    describe PrettyFormatter do
-
-      def mock_step(stubs={})
-        stub('step', {
-          :keyword => 'Given',
-          :format => 'formatted yes',
-          :name => 'example',
-          :error => nil,
-          :padding_length => 2,
-          :file => 'test',
-          :line => 1,
-          :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',
-          :row? => false,
-          :pending? => false,
-          :file => 'file', 
-          :line => 1,
-          :padding_length => 2,
-          :outline? => false,
-          :table_header => nil}.merge(stubs))
-      end
-      
-      def mock_scenario_outline(stubs={})
-        mock_scenario({:outline? => true}.merge(stubs))
-      end
-
-      def mock_feature(stubs={})
-        stub("feature", stubs)
-      end
-
-      def mock_error(stubs={})
-        stub('error', {
-          :message => 'failed',
-          :backtrace => 'example backtrace'}.merge(stubs))
-      end
-
-      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
-        io = StringIO.new
-        formatter = PrettyFormatter.new io, StepMother.new
-        step = stub('step',
-          :error => nil, :row? => false, :keyword => 'Given', :format => 'formatted yes'
-        )
-        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 scenario pending")
-        end
-
-        it "should display as pending in the dump (with two scenarios)" do
-          @formatter.scenario_executing(@scenario)
-          @formatter.scenario_executing(@scenario)
-          @formatter.dump
-          @io.string.should include("2 scenarios pending")
-        end
-      end
-      
-      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
-      
-      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
-          
-          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 #{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 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)
-
-          @io.string.should include("Given test  # features/example.feature:5")
-        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, :pending? => false))
-
-          @io.string.should include("Scenario: title  # features/example.feature:2")
-        end
-
-        it "should display file for feature" do
-          @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, :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
-
-      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
-
-      it "should display the total number of scenarios executed (for 0 scenarios)" do
-        io = StringIO.new
-        formatter = PrettyFormatter.new io, mock('step_mother')
-                
-        formatter.dump
-        
-        io.string.should include("0 scenarios")
-      end
-          
-      it "should display the total number of scenarios executed (for 1 scenario)" do
-        io = StringIO.new
-        formatter = PrettyFormatter.new io, mock('step_mother')
-                
-        formatter.scenario_executing(mock_scenario)
-        formatter.scenario_executed(mock_scenario)
-
-        formatter.dump
-        
-        io.string.should include("1 scenario")
-      end
-          
-      it "should display the total number of scenarios executed (for 2 scenarios)" do
-        io = StringIO.new
-        formatter = PrettyFormatter.new io, mock('step_mother')
-                
-        formatter.scenario_executing(mock_scenario)
-        formatter.scenario_executed(mock_scenario)
-
-        formatter.scenario_executing(mock_scenario)
-        formatter.scenario_executed(mock_scenario)
-
-        formatter.dump
-        
-        io.string.should include("2 scenarios")
-      end
-          
-      describe "colour" do
-
-        before(:each) do
-          ::Term::ANSIColor.coloring = true
-          @io = StringIO.new
-          @formatter = PrettyFormatter.new @io, mock('step_mother')
-        end
-        
-        it "should show the scenario outline keyword and title as pending blue" do
-          @formatter.scenario_executing(mock_scenario(:outline? => true, :name => 'blue'))
-
-          @io.string.should =~ /\e\[36m\s*Scenario Outline: blue\e\[0m/
-        end
-        
-        it "should show passing steps as green" do
-          @formatter.scenario_executing(mock_scenario)
-          @formatter.step_passed(mock_step, nil, nil)
-          @formatter.dump
-
-          @io.string.should =~ /\e\[32m1 step passed\e/
-        end
-        
-        it "should show pending steps as yellow" do
-          @formatter.scenario_executing(mock_scenario)
-          @formatter.step_pending(mock_step, nil, nil)
-          @formatter.dump
-
-          @io.string.should =~ /\e\[33m1 step pending\e/
-        end
-        
-        it "should show failed steps as red" do
-          @formatter.scenario_executing(mock_scenario)
-          @formatter.step_failed(mock_step(:error => mock_error(:cucumber_backtrace => [])), nil, nil)
-          @formatter.dump
-
-          @io.string.should =~ /\e\[31m1 step failed\e/
-        end
-        
-        it "should show skipped steps as cyan" do
-          @formatter.scenario_executing(mock_scenario)
-          @formatter.step_skipped(mock_step, nil, nil)
-          @formatter.dump
-
-          @io.string.should =~ /\e\[36m1 step skipped\e/
-        end
-
-      end
-    end
-  end
-end

data/spec/cucumber/formatters/progress_formatter_spec.rb

@@ -1,81 +0,0 @@
-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
-        step = stub('step',
-          :error => nil
-        )
-        formatter.step_passed(step,nil,nil)
-        io.string.should =~ /^\.$/
-      end
-
-      it "should print F when failed" do
-        io = StringIO.new
-        formatter = ProgressFormatter.new io
-        step = stub('step',
-          :error => StandardError.new
-        )
-        formatter.step_failed(step,nil,nil)
-        io.string.should =~ /^\F$/
-      end
-
-      it "should print P when pending" do
-        io = StringIO.new
-        formatter = ProgressFormatter.new io
-        step = stub('step',
-          :error => Pending.new,
-          :scenario => mock('scenario')
-        )
-        formatter.step_pending(step,nil,nil)
-        io.string.should =~ /^\P$/
-      end
-
-      it "should print _ when skipped" do
-        io = StringIO.new
-        formatter = ProgressFormatter.new io
-        formatter.step_skipped(nil,nil,nil)
-        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
-          @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/model/table_spec.rb

@@ -1,32 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Cucumber
-  module Model
-    describe Table do
-      before do
-        @raw = [
-          %w{name gender},
-          %w{aslak male},
-          %w{patty female},
-          ]
-      end
-
-      it "should convert into hash-array" do
-        ha = Table.new(@raw).hashes
-        ha.should == [
-          {'name' => 'aslak', 'gender' => 'male'},
-          {'name' => 'patty', 'gender' => 'female'}
-        ]
-      end
-      
-      it "should return the rows of the table" do
-        ar = Table.new(@raw).rows
-        ar.should == [
-          ["aslak", "male"],
-          ["patty", "female"]
-        ]
-      end
-      
-    end
-  end
-end

data/spec/cucumber/step_mother_spec.rb

@@ -1,74 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-module Cucumber
-  describe StepMother do
-    it "should report file and line numbers for both duplicate step definitions" do
-      m = StepMother.new
-      
-      m.register_step_proc /Three (.*) mice/ do |disability|
-      end
-
-      begin
-        m.register_step_proc /Three (.*) mice/ do |disability|
-        end
-        violated("Should raise error")
-      rescue => e
-        e.message.should =~ %r{Duplicate step definitions:.+step_mother_spec\.rb:8:in `/Three \(\.\*\) mice/'.+step_mother_spec\.rb\:12:in `/Three \(\.\*\) mice/'}m
-
-      end
-    end
-
-    it "should report file and line numbers for multiple step definitions" do
-      m = StepMother.new
-      
-      m.register_step_proc /Three (.*) mice/ do |disability|
-      end
-
-      m.register_step_proc /Three blind (.*)/ do |animal|
-      end
-
-      begin
-        m.regexp_args_proc('Three blind mice')
-        violated("Should raise error")
-      rescue => e
-        e.message.should =~ %r{Multiple step definitions match "Three blind mice":
-
-.+step_mother_spec\.rb:24:in `/Three \(\.\*\) mice/'
-.+step_mother_spec\.rb:27:in `/Three blind \(\.\*\)/'
-
-}m
-      end
-    end
-    
-    it "should mark step as pending when it doesn't match any procs" do
-      pending "think some more about what to expect here" do
-        m = StepMother.new
-        step = mock('step')
-        step.should_receive(:pending!)
-        raise "FIXME"
-        m.execute(step)
-      end
-    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
-    
-    it "should explain to the programmer that step definitions always need a proc" do
-      m = StepMother.new
-      lambda do
-        m.register_step_proc(/no milk today/)
-      end.should raise_error(MissingProc, "Step definitions must always have a proc")
-    end
-
-  end
-end