kosmas58-cucumber 0.1.16.6 → 0.1.99.21

data/spec/cucumber/formatters/progress_formatter_spec.rb

@@ -1,81 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Cucumber
-  module Formatters
-    describe ProgressFormatter do
-      before do
-        ::Term::ANSIColor.coloring = false
-      end
-
-      after do
-        ::Term::ANSIColor.coloring = true
-      end
-      
-      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
-
-      it "should print nothing when traced" do
-        io = StringIO.new
-        formatter = ProgressFormatter.new io
-        formatter.step_traced(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,32 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Cucumber
-  module Model
-    describe Table do
-      before do
-        @raw = [
-          %w{name gender},
-          %w{aslak male},
-          %w{patty female},
-          ]
-      end
-
-      it "should convert into hash-array" do
-        ha = Table.new(@raw).hashes
-        ha.should == [
-          {'name' => 'aslak', 'gender' => 'male'},
-          {'name' => 'patty', 'gender' => 'female'}
-        ]
-      end
-      
-      it "should return the rows of the table" do
-        ar = Table.new(@raw).rows
-        ar.should == [
-          ["aslak", "male"],
-          ["patty", "female"]
-        ]
-      end
-      
-    end
-  end
-end

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