aslakhellesoy-cucumber 0.1.16.4 → 0.1.16.5

data/spec/cucumber/tree/feature_spec.rb

@@ -1,122 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Cucumber
-  module Tree
-    describe Feature do
-      
-      def mock_scenario(stubs = {})
-        mock("scenario", {:update_table_column_widths => nil,
-                          :outline? => false,
-                          :table_header= => nil}.merge(stubs))
-      end
-      
-      def mock_scenario_outline(stubs = {})
-        mock_scenario({:outline? => true, :row? => false, :table_header= => nil}.merge(stubs))
-      end
-      
-      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', "29")
-
-          feature.Scenario('test scenario') {}
-        end
-      
-      end
-      
-      describe "creating a Scenario Outline" do
-
-        it "should create a new scenario outline for feature" do
-          feature = Feature.new('header')
-          
-          ScenarioOutline.should_receive(:new).with(feature, 'test', '41')
-          
-          feature.ScenarioOutline('test') {}
-        end
-
-      end
-      
-      describe "creating a Table" do
-
-        before(:each) do
-          @feature = Feature.new('header')
-        end
-
-        describe "previous scenario is a scenario outline" do
-
-          it "should create a row scenario outline for feature" do
-            mock_scenario_outline = mock_scenario_outline(:outline? => true)
-            Scenario.stub!(:new).and_return(mock_scenario_outline)
-            @feature.add_scenario('scenario', 5)    
-
-            RowScenarioOutline.should_receive(:new).with(@feature, mock_scenario_outline, ['1', '2'], anything)
-
-            @feature.Table do |t| 
-              t | "input_1" | "input_2" | t 
-              t | 1 | 2 | t
-            end
-          end
-
-        end
-        
-        describe "previous scenario was a regular scenario" do
-          
-          it "should create a row scenario for feature" do
-            mock_scenario = mock_scenario(:outline? => false)
-            Scenario.stub!(:new).and_return(mock_scenario)
-            @feature.add_scenario('scenario', 5)    
-
-            RowScenario.should_receive(:new).with(@feature, mock_scenario, ['1', '2'], anything)
-
-            @feature.Table do |t| 
-              t | "input_1" | "input_2" | t 
-              t | 1 | 2 | t
-            end
-          end
-          
-        end
-    
-        it "should set the table header of the template scenario" do
-          mock_scenario = mock("scenario", :update_table_column_widths => nil, :outline? => false)
-          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
-      
-      it "should create a new row scenario outline" do
-        feature = Feature.new('header')
-         
-        RowScenarioOutline.should_receive(:new)
-           
-        feature.add_row_scenario_outline(mock_scenario_outline, [], 1)
-      end
-      
-      it "should visit scenario outline" do
-        feature = Feature.new('header')
-        ScenarioOutline.stub!(:new).and_return(mock_scenario_outline(:outline? => true, :row? => false))
-        feature.add_scenario_outline(nil, nil)
-        mock_visitor = mock('visitor', :visit_header => nil)
-
-        mock_visitor.should_receive(:visit_scenario_outline)
-        
-        feature.accept(mock_visitor)
-      end
-            
-    end
-  end
-end

data/spec/cucumber/tree/row_scenario_outline_spec.rb

@@ -1,73 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Cucumber
-  module Tree
-    describe RowScenarioOutline do
-
-      def mock_feature
-         mock_feature = mock("feature")
-      end
-
-      def mock_scenario(stubs ={})
-        mock("scenario", {:update_table_column_widths => nil}.merge(stubs))
-      end
-
-      def mock_step(stubs = {})
-        mock("step", {:arity => 0}.merge(stubs))
-      end
-
-      it "should indicate scenario is a scenario outline" do
-        outline = RowScenarioOutline.new(mock_feature, mock_scenario, [], 1)
-      
-        outline.should be_a_outline
-      end
-  
-      describe "steps" do
-
-        it "should create a new step with placeholders in template scenario steps replaced with values from scenario row" do
-          mock_step = mock_step(:keyword => 'Given', :name => '<animal> burning bright')
-          mock_scenario = mock_scenario(:table_header => ["animal"], :steps => [mock_step] )
-          outline = RowScenarioOutline.new(mock_feature, mock_scenario, ["tiger"], 1)
-
-          RowStepOutline.should_receive(:new).with(outline, mock_step, 'tiger burning bright', ["tiger"], 1)
-
-          outline.steps
-        end
-      
-        it "should leave the scenario template's name unchanged when replacing placeholders" do
-          mock_step = mock_step(:keyword => 'Given', :name => '<animal> burning bright', :extra_args => [])
-          mock_scenario = mock_scenario(:table_header => ["animal"], :steps => [mock_step] )
-          outline = RowScenarioOutline.new(mock_feature, mock_scenario, ["tiger"], 1)
-
-          outline.steps
-          
-          mock_step.name.should == '<animal> burning bright'
-        end
-
-        it "should leave the step name untouched if it has no placeholders" do
-          mock_step = mock_step(:keyword => 'Given', :name => 'beauty too rich for earth too dear')
-          mock_scenario = mock_scenario(:table_header => ["animal"], :steps => [mock_step] )     
-          outline = RowScenarioOutline.new(mock_feature, mock_scenario, ["tiger"], 1)
-
-          RowStepOutline.should_receive(:new).with(outline, mock_step, 'beauty too rich for earth too dear', [], 1)
-
-          outline.steps
-        end
-            
-        it "should ensure that created steps do not contain values already used in previous steps" do
-          mock_step_1 = mock_step(:keyword => 'Given', :name => '<animal> eating')
-          mock_step_2 = mock_step(:keyword => 'Given', :name => 'eating <animal>')
-          mock_scenario = mock_scenario(:table_header => ["animal"], :steps => [mock_step_1, mock_step_2] )       
-          outline = RowScenarioOutline.new(mock_feature, mock_scenario, ["tiger"], 1)
-                                                                                              
-          RowStepOutline.should_receive(:new).with(anything, anything, anything, ['tiger'], anything)
-          RowStepOutline.should_receive(:new).with(anything, anything, anything, [], anything)
-
-          outline.steps
-        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/row_step_outline_spec.rb

@@ -1,38 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Cucumber
-  module Tree
-    describe RowStepOutline do
-      
-      def mock_step(stubs = {})
-        mock("step", {:extra_args => []}.merge(stubs))
-      end
-      
-      
-      it "should be a outline" do
-        outline_row = RowStepOutline.new(mock("scenario"), mock_step, 'outline', [], 1)
-        
-        outline_row.should be_a_outline
-      end
-
-      it "should be a row step" do
-        outline_row = RowStepOutline.new(mock("scenario"), mock_step, 'outline', [], 1)
-        
-        outline_row.should be_a_row
-      end
-
-      it "should have visible args" do
-        outline_row = RowStepOutline.new(mock("scenario"), mock_step, 'outline', ["tiger", "night"], 1)
-
-        outline_row.visible_args.should == ["tiger", "night"]
-      end
-      
-      it "should have extra args" do
-        outline_row = RowStepOutline.new(mock("scenario"), mock_step(:extra_args => ["extra", "arrrgs"]), 'outline', [], 1)
-
-        outline_row.extra_args.should == ["extra", "arrrgs"]
-      end
-      
-    end
-  end
-end

data/spec/cucumber/tree/scenario_outline_spec.rb

@@ -1,50 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Cucumber
-  module Tree
-    describe ScenarioOutline do
-
-      def mock_feature
-         mock_feature = mock("feature")
-      end
-
-      def mock_scenario(stubs ={})
-        mock("scenario", {:update_table_column_widths => nil}.merge(stubs))
-      end
-
-      it "should indicate its a scenario outline" do
-        scenario_outline = ScenarioOutline.new(mock_feature, '', 1)
-        
-        scenario_outline.should be_a_outline 
-      end
-      
-      it "should create a step outline when adding new steps" do
-        scenario_outline = ScenarioOutline.new(mock_feature, '', 1)
-        
-        StepOutline.should_receive(:new)
-        
-        scenario_outline.create_step('Given', '', 2)
-      end
-      
-      it "should visit step outlines" do
-        outline = ScenarioOutline.new(mock_feature, '', 1)
-        outline.create_step('Given', '', 1)
-        mock_visitor = mock('visitor')        
-        
-        mock_visitor.should_receive(:visit_step_outline)
-        
-        outline.accept(mock_visitor)
-      end
-
-      it "should include indent when padding to step" do
-        scenario = ScenarioOutline.new(mock_feature, '', 1)
-        scenario.create_step('Given', 'a longish step', 1)
-
-        #Scenario Outline: ****
-        #  Given a longish step
-        scenario.padding_length.should == 4 + Scenario::INDENT
-      end
-      
-    end
-  end
-end

data/spec/cucumber/tree/scenario_spec.rb

@@ -1,134 +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
-      
-      describe "at_line?" do
-        
-        describe "when there is a next scenario" do
-        
-          before :each do
-            feature = Feature.new(nil)
-            @scenario = feature.add_scenario('', 5)
-            feature.add_scenario('', 10)
-          end
-        
-          it "should return false if the line is lesser than the scenario's line" do
-            @scenario.should_not be_at_line(4)
-          end
-        
-          it "should return true if the line is equal to the scenario's line" do
-            @scenario.should be_at_line(5)
-          end
-        
-          it "should return false if the line is equal to the next scenario's line" do
-            @scenario.should_not be_at_line(10)
-          end
-        
-          it "should return false if the line is greater than the next scenario's line" do
-            @scenario.should_not be_at_line(11)
-          end
-        
-          it "should return true if the line is lesser then the next scenario's line" do
-            @scenario.should be_at_line(9)
-          end
-          
-        end
-        
-        describe "when there is no next scenario" do
-          
-          before :each do
-            feature = Feature.new(nil)
-            feature.stub!(:lines => 20)
-            @scenario = feature.add_scenario('', 12)
-          end
-          
-          it "should return false if the line is lesser than the scenario's line" do
-            @scenario.should_not be_at_line(11)
-          end
-          
-          it "should return true if the line is within the scenario's line and the lines of the feature" do
-            @scenario.should be_at_line(12)
-            @scenario.should be_at_line(20)
-          end
-          
-          it "should return false if the line is greater than the lines of the feature" do
-            @scenario.should_not be_at_line(21)
-          end
-          
-        end
-        
-      end
-      
-    end
-  end
-end

data/spec/cucumber/tree/step_outline_spec.rb

@@ -1,17 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Cucumber
-  module Tree
-    describe StepOutline do
-
-      it "should be a outline" do
-        step_outline = StepOutline.new(mock("scenario"), 'Given', 'outline', 1)
-
-        step_outline.should be_a_outline
-      end
-      
-    end
-  end
-end
-
-

data/spec/cucumber/tree/step_spec.rb

@@ -1,59 +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
-
-      it "should indicate if a forced pending exception occured" do
-        scenario = Scenario.new(nil, '9', 1)
-        step = scenario.create_step('Given', '666666', 98)
-        
-        step.instance_variable_set("@error", ForcedPending.new)
-        
-        step.should be_forced_to_pending
-      end
-      
-    end
-  end
-end
-

data/spec/cucumber/treetop_parser/feature_parser_spec.rb

@@ -1,120 +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 empty scenario outlines" do
-        p = FeatureParser.new
-        f = p.parse_feature(File.dirname(__FILE__) + '/empty_scenario_outline.feature')
-        
-        f.scenarios[0].should have(0).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(4).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
-      
-      it "should parse scenario outlines" do
-        p = FeatureParser.new
-        f = p.parse_feature(File.dirname(__FILE__) + '/scenario_outline.feature')
-
-        f.should have(4).scenarios
-      end
-      
-      it "should not allow a scenario outline with an example table but no steps" do
-        p = FeatureParser.new
-        lambda{
-          p.parse_feature(File.dirname(__FILE__) + '/invalid_scenario_outlines.feature')
-        }.should raise_error(Feature::SyntaxError)
-      end
-      
-    end
-  end
-end