elight-cucumber 0.1.9

data/spec/cucumber/formatters/html_formatter_spec.rb

@@ -0,0 +1,74 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'stringio'
+require 'cucumber/tree/top_down_visitor'
+
+module Cucumber
+  module Formatters
+    class MiniExecutor < Cucumber::Tree::TopDownVisitor
+      def initialize(f)
+        @f = f
+      end
+      
+      def visit_step(step)
+        if step.regexp == //
+          # Just make sure there are some params so we can get <span>s
+          proc = lambda do |_|
+            case(step.id % 3)
+            when 0
+              raise Pending
+            when 1
+              raise "This one failed"
+            end
+          end
+          proc.extend(CoreExt::CallIn)
+          proc.name = "WHATEVER"
+          step.attach(/(\w+).*/, proc, ['xxx'])
+          o = Object.new
+          step.execute_in(o) rescue nil
+        else
+          @f.step_executed(step)
+        end
+      end
+    end
+  
+    describe HtmlFormatter do
+      SIMPLE_DIR = File.dirname(__FILE__) + '/../../../examples/simple'
+      
+      before do
+        p = Cucumber::TreetopParser::FeatureParser.new
+        @features = Tree::Features.new
+      	Dir["#{SIMPLE_DIR}/*.feature"].each do |f|
+          @features << p.parse_feature(f)
+        end
+        @io = StringIO.new
+        step_mother = mock('step mother')
+        @formatter = HtmlFormatter.new(@io, step_mother)
+        @me = MiniExecutor.new(@formatter)
+      end
+      
+      xit "should render HTML" do
+        @me.visit_features(@features) # set regexp+proc+args and execute
+        @formatter.visit_features(@features)
+        @me.visit_features(@features) # output result of execution
+        @formatter.dump
+        expected_html = File.dirname(__FILE__) + '/features.html'
+        #File.open(expected_html, 'w') {|io| io.write(@io.string)}
+        @io.string.should eql(IO.read(expected_html))
+      end
+      
+      it "should render FIT table headers" do
+        scenario = mock('scenario', :name => 'test', :accept => nil)
+        row_scenario = mock('row scenario', :name => 'test', :accept => nil)
+        scenario.stub!(:table_header).and_return(['test', 'fit', 'headers'])
+                
+        @formatter.visit_regular_scenario(scenario)
+        @formatter.visit_row_scenario(row_scenario)
+        
+        ['test', 'fit' ,'headers'].each do |column_header|
+          @io.string.should include(column_header)
+        end
+      end
+      
+    end
+  end
+end

data/spec/cucumber/formatters/pretty_formatter_spec.rb

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

data/spec/cucumber/formatters/profile_formatter_spec.rb

@@ -0,0 +1,193 @@
+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)
+        step_definition_put = 1
+
+        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,45 @@
+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
+    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