cucumber 0.1.7 → 0.1.8

data/lib/cucumber/version.rb

@@ -2,7 +2,7 @@ module Cucumber #:nodoc:
   class VERSION #:nodoc:
     MAJOR = 0
     MINOR = 1
-    TINY  = 7
+    TINY  = 8
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/{generators → rails_generators}/cucumber/templates/common_webrat.rb

@@ -13,7 +13,7 @@ When /^I fill in "(.*)" with "(.*)"$/ do |field, value|
   fills_in(field, :with => value) 
 end
 
-When /^I select "(.*)" from "(.*)"$/ do |field, value|
+When /^I select "(.*)" from "(.*)"$/ do |value, field|
   selects(value, :from => field) 
 end
 
@@ -33,15 +33,6 @@ When /^I attach the file at "(.*)" to "(.*)" $/ do |path, field|
   attaches_file(field, path)
 end
 
-When /^I go to (.*)$/ do |page|
-  visits case page
-  when "the home page"
-    "/"
-  else
-    raise "Can't find mapping from \"#{page}\" to a path"
-  end
-end
-
 Then /^I should see "(.*)"$/ do |text|
   response.body.should =~ /#{text}/m
 end

data/{generators → rails_generators}/feature/templates/feature.erb

@@ -22,6 +22,7 @@ Feature: Manage <%= plural_name %>
     When I delete the first <%= singular_name %>
     Then there should be 3 <%= plural_name %> left
     
+  More Examples:
     | initial | after |
     | 100     | 99    |
     | 1       | 0     |

data/spec/cucumber/cli_spec.rb

@@ -15,7 +15,8 @@ module Cucumber
         :require => ['from/yml'], 
         :dry_run => false, 
         :lang => 'en',
-        :source => true
+        :source => true,
+        :out => STDOUT
       }
     end
 
@@ -31,16 +32,23 @@ module Cucumber
         :require => ['from/yml'], 
         :dry_run => false, 
         :lang => 'en',
-        :source => true
+        :source => true,
+        :out => STDOUT
       }
     end
     
-    it "should accept source option" do
+    it "should accept --no-source option" do
       cli = CLI.new
       cli.parse_options!(%w{--no-source})
       
       cli.options[:source].should be_false
     end
+
+    it "should accept --out option" do
+      cli = CLI.new
+      File.should_receive(:open).with('jalla.txt', 'w')
+      cli.parse_options!(%w{--out jalla.txt})
+    end
         
   end
 end

data/spec/cucumber/core_ext/proc_spec.rb

@@ -34,6 +34,12 @@ module Cucumber
           proc.call_in(Object.new, 1)
         }.should raise_error(Cucumber::ArityMismatchError, "expected 2 block argument(s), got 1")
       end
+      
+      it "should remove extraneous path info for file" do
+        proc = lambda {|a,b|}
+        proc.extend CallIn
+        proc.file_colon_line.should == "spec/cucumber/core_ext/proc_spec.rb:39"
+      end
     end
   end
 end

data/spec/cucumber/formatters/html_formatter_spec.rb

@@ -41,7 +41,8 @@ module Cucumber
           @features << p.parse_feature(f)
         end
         @io = StringIO.new
-        @formatter = HtmlFormatter.new(@io)
+        step_mother = mock('step mother')
+        @formatter = HtmlFormatter.new(@io, step_mother)
         @me = MiniExecutor.new(@formatter)
       end
       
@@ -54,6 +55,20 @@ module Cucumber
         #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

@@ -12,6 +12,16 @@ module Cucumber
           :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', {
@@ -35,47 +45,66 @@ module Cucumber
       
       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
-            io = StringIO.new
-
-            step_mother = mock('step_mother')
-            formatter = PrettyFormatter.new io, step_mother, :source => true
-            formatter.send("step_#{result}".to_sym, mock_step(:regexp_args_proc => [nil, nil, mock_proc], :error => StandardError.new, :padding_length => 2), nil, nil)
+            @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")
+            @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 align step comments" do
-          io = StringIO.new
+        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)
-
-          step_mother = mock('step_mother')
-          formatter = PrettyFormatter.new io, step_mother, :source => true
           
-          formatter.step_passed(step_1, nil, nil)
-          formatter.step_passed(step_4, nil, nil)
-          formatter.step_passed(step_9, nil, nil)
+          @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")
+          @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 NOT display step source for pending step" do
-          io = StringIO.new
-          step_mother = mock('step_mother')
+                
+        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 = PrettyFormatter.new io, step_mother, :source => true
-          formatter.step_pending(mock_step(:regexp_args_proc => [nil, nil, mock_proc]), nil, nil)
+          @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_not include("steps/example_steps.rb:11")
+          @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

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/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