kbaum-cucumber 0.4.5.pre

data/spec/cucumber/ast/feature_spec.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'cucumber/ast/feature_factory'
+
+module Cucumber
+  module Ast
+    describe Feature do
+      include FeatureFactory
+
+      it "should convert to sexp" do
+        step_mother = StepMother.new
+        step_mother.load_natural_language('en')
+        step_mother.load_programming_language('rb')
+        dsl = Object.new 
+        dsl.extend RbSupport::RbDsl
+
+        feature = create_feature(dsl)
+        feature.to_sexp.should == 
+        [:feature,
+          "features/pretty_printing.feature",
+          "Pretty printing", 
+          [:comment, "# My feature comment\n"], 
+          [:tag, "one"], 
+          [:tag, "two"], 
+          [:background, 2, 'Background:',
+            [:step, 3, "Given", "a passing step"]],
+          [:scenario, 9, "Scenario:", 
+            "A Scenario", 
+            [:comment, "    # My scenario comment  \n# On two lines \n"], 
+            [:tag, "three"], 
+            [:tag, "four"],
+            [:step_invocation, 3, "Given", "a passing step"], # From the background
+            [:step_invocation, 10, "Given", "a passing step with an inline arg:",
+              [:table, 
+                [:row, -1,
+                  [:cell, "1"], [:cell, "22"], [:cell, "333"]], 
+                [:row, -1,
+                  [:cell, "4444"], [:cell, "55555"], [:cell, "666666"]]]], 
+            [:step_invocation, 11, "Given", "a happy step with an inline arg:", 
+              [:py_string, "\n I like\nCucumber sandwich\n"]], 
+            [:step_invocation, 12, "Given", "a failing step"]]]
+      end
+    end
+  end
+end

data/spec/cucumber/ast/outline_table_spec.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Cucumber::Ast
+  describe OutlineTable do
+    describe OutlineTable::ExampleRow do
+      describe "a header row" do
+        before(:each) do
+          @row = OutlineTable::ExampleRow.new(
+            mock('table', :index => 0), 
+            [mock('cell', :status= => nil)]
+          )
+        end
+        
+        it "should raise an error if you try to call #failed?" do
+          @row.accept_plain mock('visitor', :visit_table_cell => nil)
+          lambda{ @row.failed? }.should raise_error(NoMethodError, /cannot pass or fail/)
+        end
+      end
+    end
+  end
+end

data/spec/cucumber/ast/py_string_spec.rb

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'cucumber/ast/py_string'
+
+module Cucumber
+  module Ast
+    describe PyString do
+      it "should handle unindented" do
+        ps = PyString.new(10, 13, "4.1\n4.2\n", 0)
+        ps.to_s.should == "4.1\n4.2\n"
+      end
+
+      it "should handle indented" do
+        #                    """
+        ps = PyString.new(10, 13, "     4.1\n   4.2\n", 2)
+        ps.to_s.should == "   4.1\n 4.2\n"
+      end
+      
+      describe "replacing arguments" do
+
+        before(:each) do
+          @ps = PyString.new(10, 13, "<book>\n<qty>\n", 0)
+        end
+      
+        it "should return a new py_string with arguments replaced with values" do
+          py_string_with_replaced_arg = @ps.arguments_replaced({'<book>' => 'Life is elsewhere', '<qty>' => '5'})
+                
+          py_string_with_replaced_arg.to_s.should == "Life is elsewhere\n5\n"
+        end
+        
+        it "should not change the original py_string" do
+          py_string_with_replaced_arg = @ps.arguments_replaced({'<book>' => 'Life is elsewhere'})
+          
+          @ps.to_s.should_not include("Life is elsewhere")
+        end
+
+        it "should replaced nil with empty string" do
+          ps = PyString.new(10, 13, "'<book>'", 0)
+          py_string_with_replaced_arg = ps.arguments_replaced({'<book>' => nil}) 
+          
+          py_string_with_replaced_arg.to_s.should == "''"
+        end
+
+        it "should recognise when just a subset of a cell is delimited" do
+          @ps.should have_text('<qty>')
+        end
+
+      end
+      
+    end
+  end
+end

data/spec/cucumber/ast/scenario_outline_spec.rb

@@ -0,0 +1,73 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'cucumber/step_mother'
+require 'cucumber/ast'
+require 'cucumber/core_ext/string'
+require 'cucumber/rb_support/rb_language'
+
+module Cucumber
+  module Ast
+    describe ScenarioOutline do
+      before do
+        @step_mother = StepMother.new
+        @step_mother.load_programming_language('rb')
+        @step_mother.load_natural_language('en')
+        @dsl = Object.new
+        @dsl.extend(RbSupport::RbDsl)
+
+        @dsl.Given(/^there are (\d+) cucumbers$/) do |n|
+          @initial = n.to_i
+        end
+        @dsl.When(/^I eat (\d+) cucumbers$/) do |n|
+          @eaten = n.to_i
+        end
+        @dsl.Then(/^I should have (\d+) cucumbers$/) do |n|
+          (@initial - @eaten).should == n.to_i
+        end
+        @dsl.Then(/^I should have (\d+) cucumbers in my belly$/) do |n|
+          @eaten.should == n.to_i
+        end
+
+        @scenario_outline = ScenarioOutline.new(
+          background=nil,
+          Comment.new(""),
+          Tags.new(18, []),
+          19,
+          "Scenario:", "My outline",
+          [
+            Step.new(20, 'Given', 'there are <start> cucumbers'),
+            Step.new(21, 'When',  'I eat <eat> cucumbers'),
+            Step.new(22, 'Then',  'I should have <left> cucumbers'),
+            Step.new(23, 'And',   'I should have <eat> cucumbers in my belly')
+          ],
+          [
+            [
+              Comment.new("#Mmmm... cucumbers\n"),
+              24,
+              'Examples:',
+              'First table',
+              [
+                %w{start eat left},
+                %w{12 5 7},
+                %w{20 6 14}
+              ]
+            ]
+          ]
+
+        )
+      end
+
+      it "should replace all variables and call outline once for each table row" do
+        visitor = TreeWalker.new(@step_mother)
+        visitor.should_receive(:visit_table_row).exactly(3).times
+        visitor.visit_feature_element(@scenario_outline)
+      end
+
+      it "should pretty print" do
+        require 'cucumber/formatter/pretty'
+        formatter = Formatter::Pretty.new(@step_mother, STDOUT, {:comment => true, :tag_names => {}})
+        visitor = TreeWalker.new(@step_mother, [formatter])
+        visitor.visit_feature_element(@scenario_outline)
+      end
+    end
+  end
+end

data/spec/cucumber/ast/scenario_spec.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'cucumber/step_mother'
+require 'cucumber/ast'
+require 'cucumber/rb_support/rb_language'
+
+module Cucumber
+  module Ast
+    describe Scenario do
+      before do
+        @step_mother = StepMother.new
+        @step_mother.load_natural_language('en')
+        @step_mother.load_programming_language('rb')
+        @dsl = Object.new
+        @dsl.extend(RbSupport::RbDsl)
+
+        $x = $y = nil
+        @dsl.Given /y is (\d+)/ do |n|
+          $y = n.to_i
+        end
+        @visitor = TreeWalker.new(@step_mother)
+        @visitor.options = {}
+      end
+
+      it "should skip steps when previous is not passed" do
+        scenario = Scenario.new(
+          background=nil,
+          comment=Comment.new(""),
+          tags=Tags.new(98, []), 
+          line=99,
+          keyword="",
+          name="", 
+          steps=[
+            Step.new(7, "Given", "this is missing"),
+            Step.new(8, "Given", "y is 5")
+          ]
+        )
+        scenario.feature = mock('feature', :null_object => true)
+        @visitor.visit_feature_element(scenario)
+
+        $y.should == nil
+      end
+
+    end
+  end
+end

data/spec/cucumber/ast/step_collection_spec.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Cucumber
+  module Ast
+    describe StepCollection do
+      it "should convert And to Given in snippets" do
+        s1 = Step.new(1, 'Given', 'cukes')
+        s2 = Step.new(2, 'And', 'turnips')
+        s1.stub!(:language).and_return(Parser::NaturalLanguage.get(nil, 'en'))
+        s2.stub!(:language).and_return(Parser::NaturalLanguage.get(nil, 'en'))
+        c = StepCollection.new([s1, s2])
+        actual_keywords = c.step_invocations.map{|i| i.actual_keyword}
+        actual_keywords.should == %w{Given Given}
+      end
+    end
+  end
+end

data/spec/cucumber/ast/step_spec.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'cucumber/step_mother'
+require 'cucumber/ast'
+require 'cucumber/core_ext/string'
+
+module Cucumber
+  module Ast
+    describe Step do
+      it "should replace arguments in name" do
+        step = Step.new(1, 'Given', 'a <color> cucumber')
+
+        invocation_table = Table.new([
+          %w{color taste},
+          %w{green juicy}
+        ])
+        cells = invocation_table.cells_rows[1]
+        step_invocation = step.step_invocation_from_cells(cells)
+        
+        step_invocation.name.should == 'a green cucumber'
+      end
+
+      it "should use empty string for the replacement of arguments in name when replace value is nil" do
+        step = Step.new(1, 'Given', 'a <color>cucumber')
+
+        invocation_table = Table.new([
+          ['color'],
+          [nil]
+        ])
+        cells = invocation_table.cells_rows[1]
+        step_invocation = step.step_invocation_from_cells(cells)
+        
+        step_invocation.name.should == 'a cucumber'
+      end
+
+      it "should replace arguments in table arg" do
+        arg_table = Table.new([%w{taste_<taste> color_<color>}])
+
+        step = Step.new(1, 'Given', 'a <color> cucumber', arg_table)
+
+        invocation_table = Table.new([
+          %w{color taste},
+          %w{green juicy}
+        ])
+        cells = invocation_table.cells_rows[1]
+        step_invocation = step.step_invocation_from_cells(cells)
+        
+        step_invocation.instance_variable_get('@multiline_arg').raw.should == [%w{taste_juicy color_green}]
+      end
+
+      it "should replace arguments in py string arg" do
+        py_string = PyString.new(1, 2, 'taste_<taste> color_<color>', 0)
+
+        step = Step.new(1, 'Given', 'a <color> cucumber', py_string)
+
+        invocation_table = Table.new([
+          %w{color taste},
+          %w{green juicy}
+        ])
+        cells = invocation_table.cells_rows[1]
+        step_invocation = step.step_invocation_from_cells(cells)
+        
+        step_invocation.instance_variable_get('@multiline_arg').to_s.should == 'taste_juicy color_green'
+      end
+    end
+  end
+end

data/spec/cucumber/ast/table_spec.rb

@@ -0,0 +1,422 @@
+# encoding: utf-8
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'cucumber/ast/table'
+
+module Cucumber
+  module Ast
+    describe Table do
+      before do
+        @table = Table.new([
+          %w{one four seven},
+          %w{4444 55555 666666}
+        ])
+        def @table.cells_rows; super; end
+        def @table.columns; super; end
+      end
+
+      it "should have rows" do
+        @table.cells_rows[0].map{|cell| cell.value}.should == %w{one four seven}
+      end
+
+      it "should have columns" do
+        @table.columns[1].map{|cell| cell.value}.should == %w{four 55555}
+      end
+
+      it "should have headers" do
+        @table.headers.should == %w{one four seven}
+      end
+
+      it "should have same cell objects in rows and columns" do
+        # 666666
+        @table.cells_rows[1].__send__(:[], 2).should equal(@table.columns[2].__send__(:[], 1))
+      end
+
+      it "should know about max width of a row" do
+        @table.columns[1].__send__(:width).should == 5
+      end
+
+      it "should be convertible to an array of hashes" do
+        @table.hashes.should == [
+          {'one' => '4444', 'four' => '55555', 'seven' => '666666'}
+        ]
+      end
+
+      it "should accept symbols as keys for the hashes" do
+        @table.hashes.first[:one].should == '4444'
+      end
+
+      it "should allow map'ing columns" do
+        @table.map_column!('one') { |v| v.to_i }
+        @table.hashes.first['one'].should == 4444
+      end
+
+      it "should pass silently if a mapped column does not exist in non-strict mode" do
+        lambda {
+          @table.map_column!('two', false) { |v| v.to_i }
+        }.should_not raise_error
+      end
+
+      it "should fail if a mapped column does not exist in strict mode" do
+        lambda {
+          @table.map_column!('two', true) { |v| v.to_i }
+        }.should raise_error('The column named "two" does not exist')
+      end
+
+      describe "#match" do
+        before(:each) do
+          @table = Table.new([
+            %w{one four seven},
+            %w{4444 55555 666666}
+          ])
+        end
+          
+        it "returns nil if headers do not match" do
+          @table.match('does,not,match').should be_nil
+        end
+        it "requires a table: prefix on match" do
+          @table.match('table:one,four,seven').should_not be_nil
+        end
+        it "does not match if no table: prefix on match" do
+          @table.match('one,four,seven').should be_nil
+        end
+      end
+      describe "#transpose" do
+        before(:each) do
+          @table = Table.new([
+            %w{one 1111},
+            %w{two 22222}
+          ])
+        end
+                
+        it "should be convertible in to an array where each row is a hash" do 
+          @table.transpose.hashes[0].should == {'one' => '1111', 'two' => '22222'}
+        end
+      end
+      
+      describe "#rows_hash" do
+                
+        it "should return a hash of the rows" do
+          table = Table.new([
+            %w{one 1111},
+            %w{two 22222}
+          ])
+          table.rows_hash.should == {'one' => '1111', 'two' => '22222'}
+        end
+
+        it "should fail if the table doesn't have two columns" do
+          faulty_table = Table.new([
+            %w{one 1111 abc},
+            %w{two 22222 def}
+          ])
+          lambda {
+            faulty_table.rows_hash
+          }.should raise_error('The table must have exactly 2 columns')
+        end
+      end
+
+      describe '#map_headers' do
+        it "renames the columns to the specified values in the provided hash" do
+          table2 = @table.map_headers('one' => :three)
+          table2.hashes.first[:three].should == '4444'
+        end
+
+        it "allows renaming columns using regexp" do
+          table2 = @table.map_headers(/one|uno/ => :three)
+          table2.hashes.first[:three].should == '4444'
+        end
+
+        it "copies column mappings" do
+          @table.map_column!('one') { |v| v.to_i }
+          table2 = @table.map_headers('one' => 'three')
+          table2.hashes.first['three'].should == 4444
+        end
+
+        it "takes a block and operates on all the headers with it" do
+          table = Table.new([
+          ['HELLO', 'WORLD'],
+          %w{4444 55555}
+          ])
+
+          table.map_headers! do |header|
+            header.downcase
+          end
+
+          table.hashes.first.keys.should =~ %w[hello world]
+        end
+
+        it "treats the mappings in the provided hash as overrides when used with a block" do
+          table = Table.new([
+          ['HELLO', 'WORLD'],
+          %w{4444 55555}
+          ])
+
+          table.map_headers!('WORLD' => 'foo') do |header|
+            header.downcase
+          end
+
+          table.hashes.first.keys.should =~ %w[hello foo]
+        end
+
+      end
+
+      describe "replacing arguments" do
+
+        before(:each) do
+          @table = Table.new([
+            %w{qty book},
+            %w{<qty> <book>}
+          ])
+        end
+
+        it "should return a new table with arguments replaced with values" do
+          table_with_replaced_args = @table.arguments_replaced({'<book>' => 'Unbearable lightness of being', '<qty>' => '5'})
+
+          table_with_replaced_args.hashes[0]['book'].should == 'Unbearable lightness of being'
+          table_with_replaced_args.hashes[0]['qty'].should == '5'
+        end
+
+        it "should recognise when entire cell is delimited" do
+          @table.should have_text('<book>')
+        end
+
+        it "should recognise when just a subset of a cell is delimited" do
+          table = Table.new([
+            %w{qty book},
+            [nil, "This is <who>'s book"]
+          ])
+          table.should have_text('<who>')
+        end
+
+        it "should replace nil values with nil" do
+          table_with_replaced_args = @table.arguments_replaced({'<book>' => nil})
+
+          table_with_replaced_args.hashes[0]['book'].should == nil
+        end
+
+        it "should preserve values which don't match a placeholder when replacing with nil" do
+          table = Table.new([
+                              %w{book},
+                              %w{cat}
+                            ])
+          table_with_replaced_args = table.arguments_replaced({'<book>' => nil})
+          
+          table_with_replaced_args.hashes[0]['book'].should == 'cat'
+        end
+
+        it "should not change the original table" do
+          @table.arguments_replaced({'<book>' => 'Unbearable lightness of being'})
+
+          @table.hashes[0]['book'].should_not == 'Unbearable lightness of being'
+        end
+
+        it "should not raise an error when there are nil values in the table" do
+          table = Table.new([
+                              ['book', 'qty'],
+                              ['<book>', nil],
+                            ])
+          lambda{ 
+            table.arguments_replaced({'<book>' => nil, '<qty>' => '5'})
+          }.should_not raise_error
+        end
+
+      end
+      
+      describe "diff!" do
+        it "should detect a complex diff" do
+          t1 = table(%{
+            | 1         | 22          | 333         | 4444         |
+            | 55555     | 666666      | 7777777     | 88888888     |
+            | 999999999 | 0000000000  | 01010101010 | 121212121212 |
+            | 4000      | ABC         | DEF         | 50000        |
+          })
+          
+          t2 = table(%{
+            | a     | 4444     | 1         | 
+            | bb    | 88888888 | 55555     | 
+            | ccc   | xxxxxxxx | 999999999 | 
+            | dddd  | 4000     | 300       |
+            | e     | 50000    | 4000      |
+          })
+          lambda{t1.diff!(t2)}.should raise_error
+          t1.to_s(:indent => 12, :color => false).should == %{
+            |     1         | (-) 22         | (-) 333         |     4444         | (+) a    |
+            |     55555     | (-) 666666     | (-) 7777777     |     88888888     | (+) bb   |
+            | (-) 999999999 | (-) 0000000000 | (-) 01010101010 | (-) 121212121212 | (+)      |
+            | (+) 999999999 | (+)            | (+)             | (+) xxxxxxxx     | (+) ccc  |
+            | (+) 300       | (+)            | (+)             | (+) 4000         | (+) dddd |
+            |     4000      | (-) ABC        | (-) DEF         |     50000        | (+) e    |
+          }
+        end
+
+        it "should not change table when diffed with identical" do
+          t = table(%{
+            |a|b|c|
+            |d|e|f|
+            |g|h|i|
+          })
+          t.diff!(t.dup)
+          t.to_s(:indent => 12, :color => false).should == %{
+            |     a |     b |     c |
+            |     d |     e |     f |
+            |     g |     h |     i |
+          }
+        end
+
+        it "should inspect missing and surplus cells" do
+          t1 = Table.new([
+            ['name',  'male', 'lastname', 'swedish'],
+            ['aslak', 'true', 'hellesøy', 'false']
+          ])
+          t2 = Table.new([
+            ['name',  'male', 'lastname', 'swedish'],
+            ['aslak', true,   'hellesøy', false]
+          ])
+          lambda{t1.diff!(t2)}.should raise_error
+          t1.to_s(:indent => 12, :color => false).should == %{
+            |     name  |     male       |     lastname |     swedish     |
+            | (-) aslak | (-) (i) "true" | (-) hellesøy | (-) (i) "false" |
+            | (+) aslak | (+) (i) true   | (+) hellesøy | (+) (i) false   |
+          }
+        end
+
+        it "should allow column mapping of target before diffing" do
+          t1 = Table.new([
+            ['name',  'male'],
+            ['aslak', 'true']
+          ])
+          t1.map_column!('male') { |m| m == 'true' }
+          t2 = Table.new([
+            ['name',  'male'],
+            ['aslak', true]
+          ])
+          t1.diff!(t2)
+          t1.to_s(:indent => 12, :color => false).should == %{
+            |     name  |     male |
+            |     aslak |     true |
+          }
+        end
+
+        it "should allow column mapping of argument before diffing" do
+          t1 = Table.new([
+            ['name',  'male'],
+            ['aslak', true]
+          ])
+          t1.map_column!('male') { 
+            'true'
+          }
+          t2 = Table.new([
+            ['name',  'male'],
+            ['aslak', 'true']
+          ])
+          t2.diff!(t1)
+          t1.to_s(:indent => 12, :color => false).should == %{
+            |     name  |     male |
+            |     aslak |     true |
+          }
+        end
+
+        it "should allow header mapping before diffing" do
+          t1 = Table.new([
+            ['Name',  'Male'],
+            ['aslak', 'true']
+          ])
+          t1.map_headers!('Name' => 'name', 'Male' => 'male')
+          t1.map_column!('male') { |m| m == 'true' }
+          t2 = Table.new([
+            ['name',  'male'],
+            ['aslak', true]
+          ])
+          t1.diff!(t2)
+          t1.to_s(:indent => 12, :color => false).should == %{
+            |     name  |     male |
+            |     aslak |     true |
+          }
+        end
+
+        it "should not allow mappings that match more than 1 column" do
+          t1 = Table.new([
+            ['Cuke',  'Duke'],
+            ['Foo', 'Bar']
+          ])
+          lambda do
+            t1.map_headers!(/uk/ => 'u')
+          end.should raise_error(%{2 headers matched /uk/: ["Cuke", "Duke"]})
+        end
+        
+        describe "raising" do
+          before do
+            @t = table(%{
+              | a | b |
+              | c | d |
+            })
+          end
+          
+          it "should raise on missing rows" do
+            t = table(%{
+              | a | b |
+            })
+            lambda { @t.dup.diff!(t) }.should raise_error
+            lambda { @t.dup.diff!(t, :missing_row => false) }.should_not raise_error
+          end
+
+          it "should raise on surplus rows" do
+            t = table(%{
+              | a | b |
+              | c | d |
+              | e | f |
+            })
+            lambda { @t.dup.diff!(t) }.should raise_error
+            lambda { @t.dup.diff!(t, :surplus_row => false) }.should_not raise_error
+          end
+
+          it "should raise on missing columns" do
+            t = table(%{
+              | a |
+              | c |
+            })
+            lambda { @t.dup.diff!(t) }.should raise_error
+            lambda { @t.dup.diff!(t, :missing_col => false) }.should_not raise_error
+          end
+
+          it "should not raise on surplus columns" do
+            t = table(%{
+              | a | b | x |
+              | c | d | y |
+            })
+            lambda { @t.dup.diff!(t) }.should_not raise_error
+            lambda { @t.dup.diff!(t, :surplus_col => true) }.should raise_error
+          end
+        end
+
+        def table(text, file=nil, line_offset=0)
+          @table_parser ||= Parser::TableParser.new
+          @table_parser.parse_or_fail(text.strip, file, line_offset)
+        end
+      end
+
+      describe "#new" do
+        it "should allow Array of Hash" do
+          t1 = Table.new([{'name' => 'aslak', 'male' => 'true'}])
+          t1.to_s(:indent => 12, :color => false).should == %{
+            |     name  |     male |
+            |     aslak |     true |
+          }
+        end
+      end
+
+      it "should convert to sexp" do
+        @table.to_sexp.should == 
+          [:table, 
+            [:row, -1,
+              [:cell, "one"], 
+              [:cell, "four"],
+              [:cell, "seven"]
+            ],
+            [:row, -1,
+              [:cell, "4444"], 
+              [:cell, "55555"],
+              [:cell, "666666"]]]
+      end
+    end
+  end
+end