aslakhellesoy-cucumber 0.1.5 → 0.1.9

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 mark a step as pending if it does not have a proc" do
+      m = StepMother.new
+      m.register_step_proc /I have no body/
+      regexp, args, proc = m.regexp_args_proc "I have no body"
+      proc.should == StepMother::PENDING
+    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
+
+  end
+end

data/spec/cucumber/tree/feature_spec.rb

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

data/spec/cucumber/tree/row_scenario_spec.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Cucumber
+  module Tree
+    describe RowScenario do
+      
+      describe "pending?" do
+        before :each do
+          @scenario = Scenario.new(nil, '', 1)
+          @row_scenario = RowScenario.new(mock('feature'), @scenario, [], 1)
+        end
+        
+        it "should return true if the template scenario has no steps" do
+          @row_scenario.should be_pending
+        end
+        
+        it "should return false if the template scenario has no steps" do
+          @scenario.create_step('Given', 'a long step', 1)
+          @row_scenario.should_not be_pending
+        end
+        
+      end
+    end
+  end
+end