cucumber 0.1.10 → 0.2.0

data/spec/cucumber/formatters/pretty_formatter_spec.rb

@@ -1,204 +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}.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/progress_formatter_spec.rb

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

@@ -1,20 +0,0 @@
-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/tree/feature_spec.rb

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

data/spec/cucumber/tree/row_scenario_spec.rb

@@ -1,55 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Cucumber
-  module Tree
-    describe RowScenario do
-      
-      def mock_scenario(stubs = {})
-        mock('scenario', {:update_table_column_widths => nil, :steps => []}.merge(stubs))
-      end
-            
-      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
-            
-      describe "generating row steps" do
-        
-         it "should cache unbound steps" do
-          row_scenario = RowScenario.new(mock('feature'), mock_scenario, [], 1)        
-          
-          row_scenario.steps.should equal(row_scenario.steps)
-        end
-        
-        it "should cache bound steps" do
-          mock_step = mock('step', :arity => 1)
-          row_scenario = RowScenario.new(mock('feature'), mock_scenario(:steps => [mock_step]), [], 1)        
-          
-          row_scenario.steps.should equal(row_scenario.steps)
-        end
-        
-        it "should regenerate row steps when scenario template steps have been matched" do
-          mock_step = mock('step', :arity => 0)
-          row_scenario = RowScenario.new(mock('feature'), mock_scenario(:steps => [mock_step]), [], 1)        
-          unbound_steps = row_scenario.steps
-          mock_step.stub!(:arity => 1)
-          
-          unbound_steps.should_not equal(row_scenario.steps)
-        end
-
-      end
-          
-    end
-  end
-end

data/spec/cucumber/tree/scenario_spec.rb

@@ -1,76 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Cucumber
-  module Tree
-    describe Scenario do
-      xit "should reuse steps in GivenScenario" do
-        given_scenario = GivenScenario.new(scenario_2, "First", 99)
-
-        scenario_2.create_step(given_scenario)
-        scenario_2.create_step(step_a)
-        scenario_2.steps.should == [step_1, step_2, step_a]
-      end
-
-      it "should have padding_length 2 when alone" do
-        scenario = Scenario.new(nil, 'test', 1)
-        scenario.padding_length.should == 2
-      end
-
-      it "should include indent when padding to step" do
-        scenario = Scenario.new(nil, '', 1)
-        scenario.create_step('Given', 'a long step', 1)
-
-        #Scenario: *********
-        #  Given a long step
-        scenario.padding_length.should == 9 + Scenario::INDENT
-      end
-
-      it "should ignore step padding if scenario is longer than all steps" do
-        scenario = Scenario.new(nil, 'Very long scenario and then some', 1)
-        scenario.create_step('Given', 'test', 1)
-
-        scenario.padding_length.should == 2
-      end
-
-      describe "utf-8 strings" do
-        describe "when calculating padding" do
-
-          it "should take into consideration utf-8 scenario names" do
-            scenario = Scenario.new(nil, 'こんばんは', 1)
-            scenario.create_step('Given', 'a long step', 1)
-        
-            #Scenario: こんばんは****
-            #  Given a long step
-            scenario.padding_length.should == 4 + Scenario::INDENT
-          end
-      
-          it "should take into consideration a utf-8 keyword for 'scenario'" do
-            Cucumber.language.stub!(:[]).with('scenario').and_return("シナリオ")
-            scenario = Scenario.new(nil, '', 1)
-            scenario.create_step('Given', 'step', 1)
-        
-            #シナリオ: ******
-            #  Given step
-            scenario.padding_length.should == 6 + Scenario::INDENT
-          end
-        
-        end
-      end
-      
-      describe "pending?" do
-        before :each do
-          @scenario = Scenario.new(nil, '', 1)
-        end
-        
-        it "should return true if there aren't any steps" do
-          @scenario.should be_pending
-        end
-        
-        it "should return false if there are steps" do
-          @scenario.create_step('Given', 'a long step', 1)
-          @scenario.should_not be_pending
-        end
-      end
-    end
-  end
-end

data/spec/cucumber/tree/step_spec.rb

@@ -1,50 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Cucumber
-  module Tree
-    describe Step do
-      it "should have padding_length 2 when alone" do
-        scenario = Scenario.new(nil, nil, 1)
-        step = scenario.create_step('Given', '666666', 98)
-        step.padding_length.should == 2
-      end
-
-      it "should have padding_length 5 when 3 shorter" do
-        scenario = Scenario.new(nil, nil, 1)
-        long = scenario.create_step('Given', '999999999', 80)
-        step = scenario.create_step('Given', '666666', 98)
-        step.padding_length.should == 5
-      end
-      
-      it "should remove indent from padding_length if padding to scenario" do
-        scenario = Scenario.new(nil, '9', 1)
-        step = scenario.create_step('Given', '9', 80)
-
-        #Scenario: 9  #
-        #  Given 9****
-        step.padding_length.should == 4
-      end
-
-      it "should default step arity to 0" do
-        scenario = Scenario.new(nil, '9', 1)
-        step = scenario.create_step('Given', '9', 80)
-        
-        step.arity.should == 0
-      end
-
-      describe "utf-8 strings" do
-
-        it "should have padding_length 6 when 4 shorter" do
-          scenario = Scenario.new(nil, nil, 1)
-          long = scenario.create_step('Given', '999999999', 2)
-          step = scenario.create_step('Given', "こんばんは", 3)
-        
-          step.padding_length.should == 6
-        end
-
-      end
-      
-    end
-  end
-end
-

data/spec/cucumber/treetop_parser/feature_parser_spec.rb

@@ -1,98 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Cucumber
-  module TreetopParser
-    describe FeatureParser do
-      it "should parse features with weird spaces" do
-        p = FeatureParser.new
-        f = p.parse_feature(File.dirname(__FILE__) + '/spaces.feature')
-        f.header.should == "Some title"
-        f.should have(2).scenarios
-
-        first = f.scenarios[0]
-        first.name.should == "first"
-        first.should have(1).steps
-        first.steps[0].name.should == "a"
-
-        second = f.scenarios[1]
-        second.name.should == "second"
-        second.should have(1).steps
-        second.steps[0].name.should == "b"
-      end
-      
-      it "should parse GivenScenario" do
-        p = FeatureParser.new
-        f = p.parse_feature(File.dirname(__FILE__) + '/given_scenario.feature')
-
-        f.header.should == "Some title"
-        f.should have(2).scenarios
-
-        first = f.scenarios[0]
-        first.should have(2).steps
-
-        second = f.scenarios[1]
-        second.should have(3).steps
-      end
-      
-      it "should allow spaces between FIT values" do
-        p = FeatureParser.new
-        Cucumber::Tree::RowScenario.should_receive(:new).with(anything, anything, ['I can have spaces'], anything)
-        
-        f = p.parse_feature(File.dirname(__FILE__) + '/fit_scenario.feature')
-      end
-      
-      it "should allow comments in feature files" do
-        p = FeatureParser.new
-        f = p.parse_feature(File.dirname(__FILE__) + '/with_comments.feature')
-        f.scenarios[0].should have(2).steps
-      end
-
-      it "should skip comments in feature header" do
-        p = FeatureParser.new
-        f = p.parse_feature(File.dirname(__FILE__) + '/with_comments.feature')
-        f.header.should == "Some header"
-      end
-
-      it "should skip comments in scenario header" do
-        p = FeatureParser.new
-        f = p.parse_feature(File.dirname(__FILE__) + '/with_comments.feature')
-        f.scenarios[0].name.should == "Some scenario"
-      end
-
-      it "should allow empty scenarios" do
-        p = FeatureParser.new
-        f = p.parse_feature(File.dirname(__FILE__) + '/empty_scenario.feature')
-        f.scenarios[0].should have(1).steps
-        f.scenarios[1].should have(0).steps
-        f.scenarios[2].should have(1).steps
-      end
-
-      it "should allow multiple tables" do
-        p = FeatureParser.new
-        f = p.parse_feature(File.dirname(__FILE__) + '/multiple_tables.feature')
-        f.should have(6).scenarios
-        f.scenarios[0].should have(5).steps
-      end
-
-      it "should allow empty features" do
-        p = FeatureParser.new
-        f = p.parse_feature(File.dirname(__FILE__) + '/empty_feature.feature')
-        f.should have(0).scenarios
-      end
-      
-      it "should parse features with dos line endings" do
-        p = FeatureParser.new
-        f = p.parse_feature(File.dirname(__FILE__) + '/test_dos.feature')
-        f.should have(5).scenarios
-      end
-
-      it "should parse multiline steps" do
-        p = FeatureParser.new
-        f = p.parse_feature(File.dirname(__FILE__) + '/multiline_steps.feature')
-        f.should have(1).scenarios
-        step = f.scenarios[0].steps[3]
-        step.extra_args[0].should == "A string\n  that \"indents\"\nand spans\nseveral lines\n"
-      end
-    end
-  end
-end