jeffrafter-cucumber 0.1.10

data/spec/cucumber/formatters/pretty_formatter_spec.rb

@@ -0,0 +1,204 @@
+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}.merge(stubs))
+      end
+
+      def mock_scenario(stubs={})
+        stub('scenario', {
+          :name => 'test',
+          :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',
+          :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
+        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 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
+      
+      {'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 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
+
+    end
+  end
+end

data/spec/cucumber/formatters/profile_formatter_spec.rb

@@ -0,0 +1,192 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Cucumber
+  module Formatters
+    describe ProfileFormatter do
+      attr_reader :io, :formatter
+
+      def mock_proc(stubs={})
+        stub(Proc, {:to_comment_line => '# steps/example_steps.rb:11'}.merge(stubs))
+      end
+
+      def mock_step(stubs={})
+        stub('step', {:keyword => 'Given',
+          :actual_keyword =>  'Given',
+          :format => 'test',
+          :row? => false,
+          :file => 'test.feature',
+          :line => 5,
+          :regexp_args_proc => [nil, nil, mock_proc]}.merge(stubs))
+      end
+
+      before(:each) do
+        @io = StringIO.new
+        step_mother = stub('step_mother')
+        @formatter = ProfileFormatter.new(io, step_mother)
+      end
+
+      it "should print a heading" do
+        formatter.visit_features(nil)
+
+        io.string.should eql("Profiling enabled.\n")
+      end
+
+      it "should record the current time when starting a new step" do
+        now = Time.now
+        Time.stub!(:now).and_return(now)
+        formatter.step_executing('should foo', nil, nil)
+
+        formatter.instance_variable_get("@step_time").should == now
+      end
+      
+      describe "grouping recorded passed steps" do
+
+        before(:each) do
+          now = Time.now
+          formatter.instance_variable_set("@step_time", now)
+          Time.stub!(:now).and_return(now, now)
+        end
+
+        it "should group by regular expressions and actual keyword" do
+          step_1 = mock_step(:actual_keyword => 'Given')
+          step_2 = mock_step(:actual_keyword => 'Given')
+
+          formatter.step_passed(step_1, /nihon/, nil)
+          formatter.step_passed(step_2, /ichiban/, nil)
+
+          step_times = formatter.instance_variable_get("@step_times")
+
+          step_times.has_key?('Given /nihon/').should be_true
+          step_times.has_key?('Given /ichiban/').should be_true
+        end
+
+        it "should use a previous step's keyword when recording row steps" do
+          step = mock_step(:actual_keyword => 'Given')
+          step_row = mock_step(:row? => true)
+
+          formatter.step_passed(step, /nihon/, [])
+          formatter.step_passed(step_row, /nihon/, [])
+
+          step_times = formatter.instance_variable_get("@step_times")
+          
+          step_times['Given /nihon/'].length.should == 2
+        end
+
+      end
+
+      it "should correctly record a passed step" do
+        formatter.step_executing(nil, nil, nil)
+        formatter.step_passed(mock_step(:format => 'she doth teach the torches to burn bright', :actual_keyword => 'Given'), nil, nil)
+        formatter.dump
+
+        io.string.should include('Given she doth teach the torches to burn bright')
+      end
+
+      it "should correctly record a passed step row" do
+        formatter.step_executing(nil, nil, nil)
+        formatter.step_passed(mock_step(:row? => true), /example/, ['fitty'])
+        formatter.dump
+
+        io.string.should include('fitty')
+      end
+
+      it "should calculate the mean step execution time" do
+        now = Time.now
+        Time.stub!(:now).and_return(now, now+5, now, now+1)
+
+        2.times do
+          formatter.step_executing(mock_step, nil, nil)
+          formatter.step_passed(mock_step, nil, nil)
+        end
+
+        formatter.dump
+
+        io.string.should include('3.0000000')
+      end
+
+      it "should display file and line comment for step invocation" do
+        step = mock_step(:format => 'test', :actual_keyword => 'Given', :file => 'test.feature', :line => 5)
+
+        formatter.step_executing(step, nil, nil)
+        formatter.step_passed(step, nil, nil)
+        formatter.dump
+
+        @io.string.should include("# test.feature:5")
+      end
+
+      it "should display file and line comment for step definition" do
+        step = mock_step(:format => 'test', :actual_keyword => 'Given',
+                         :regexp_args_proc => [/test/, nil, mock_proc(:to_comment_line => '# steps/example_steps.rb:11')])
+
+        formatter.step_executing(step, nil, nil)
+        formatter.step_passed(step, nil, nil)
+        formatter.dump
+
+        @io.string.should include("# steps/example_steps.rb:11")
+      end
+
+      it "should show the performance times of the step invocations for a step definition" do
+        now = Time.now
+        Time.stub!(:now).and_return(now, now+5, now, now+1)
+
+        step = mock_step(:format => 'step invocation', :actual_keyword => 'Given')
+
+        2.times do
+          formatter.step_executing(step, /example/, nil)
+          formatter.step_passed(step, /example/, nil)
+        end
+
+        formatter.dump
+
+        io.string.should include("3.0000000  Given /example/")
+        io.string.should include("5.0000000  Given step invocation")
+        io.string.should include("1.0000000  Given step invocation")
+      end
+      
+      it "should sort the step invocations in descending order" do
+        now = Time.now
+        Time.stub!(:now).and_return(now, now+1, now, now+5)
+        
+        step = mock_step(:format => 'step invocation', :actual_keyword => 'Given')
+        
+        2.times do
+          formatter.step_executing(step, /example 1/, nil)
+          formatter.step_passed(step, /example 1/, nil)
+        end
+        
+        formatter.dump
+        io_string_lines = io.string.split("\n")
+        
+        io_string_lines.at(-2).should include('5.0000000')
+        io_string_lines.at(-1).should include('1.0000000')
+      end
+
+      it "should print the top average 10 step results" do
+        formatter.instance_variable_set("@step_time", Time.now)
+
+        11.times do |test_number|
+          step_regexp = Regexp.new "unique_test_#{test_number}"
+          formatter.step_passed(mock_step(:format => 'test', :actual_keyword => 'Given',
+          :regexp_args_proc => [step_regexp, nil, mock_proc]), step_regexp, nil)
+        end
+
+        formatter.dump
+
+        io.string.scan(/unique_test_\d+/).length.should == 10
+      end
+
+      it "should print the top 5 step invocations for step definition" do
+        formatter.instance_variable_set("@step_time", Time.now)
+   
+        10.times do |test_number|
+          formatter.step_passed(mock_step(:format => 'please invocate me', :actual_keyword => 'Given'), nil, nil)
+        end
+
+        formatter.dump
+
+        io.string.scan(/please invocate me/).length.should == 5
+      end
+
+    end
+  end
+end

data/spec/cucumber/formatters/progress_formatter_spec.rb

@@ -0,0 +1,65 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Cucumber
+  module Formatters
+    describe ProgressFormatter do
+      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
+
+      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

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

data/spec/cucumber/rails/stubs/mini_rails.rb

@@ -0,0 +1,17 @@
+# Define some stubs to fake Rails...
+module ActiveRecord
+  class Base
+  end
+end
+
+module ActionController
+  class Base
+  end
+  class IntegrationTest
+    def self.use_transactional_fixtures=(x)
+    end
+  end
+end
+
+module Dispatcher
+end

data/spec/cucumber/rails/stubs/test_help.rb

@@ -0,0 +1 @@
+# This file is loaded by rails/world.rb

data/spec/cucumber/rails/world_spec.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+$:.unshift(File.dirname(__FILE__) + '/stubs')
+
+describe "Rails world" do
+
+  it "should run without Test::Unit.run defined" do
+    require "mini_rails"
+    require "cucumber/rails/world"
+  end
+
+end

data/spec/cucumber/sell_cucumbers.feature

@@ -0,0 +1,19 @@
+Feature: Sell cucumbers
+  As a cucumber farmer
+  I want to sell cucumbers
+  So that I buy meat
+
+  Scenario: Sell a dozen
+    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

@@ -0,0 +1,74 @@
+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

data/spec/cucumber/tree/feature_spec.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Cucumber
+  module Tree
+    describe Feature do
+      
+      it "should have padding_length 2 when alone" do
+        feature = Feature.new('header')
+        feature.padding_length.should == 2
+      end
+      
+      describe "creating a Scenario" do
+      
+        it "should create a new scenario for a feature" do
+          feature = Feature.new('header')
+
+          Scenario.should_receive(:new).with(feature, 'test scenario', "19")
+
+          feature.Scenario('test scenario') {}
+        end
+      
+      end
+      
+      describe "creating a Table" do
+    
+        it "should set the table header of the template scenario" do
+          feature = Feature.new('header')
+          mock_scenario = mock("scenario", :update_table_column_widths => nil)
+          Scenario.stub!(:new).and_return(mock_scenario)
+          feature.add_scenario('scenario', 5)    
+
+          mock_scenario.should_receive(:table_header=).with(["input_1", "input_2"])
+
+          feature.Table do |t| 
+            t | "input_1" | "input_2" | t 
+            t | 1 | 2 | t
+          end
+        end
+      
+      end
+    end
+  end
+end