stefl-cucumber 0.10.1

data/lib/cucumber/wire_support/wire_step_definition.rb

@@ -0,0 +1,26 @@
+module Cucumber
+  module WireSupport
+    class WireStepDefinition
+      attr_reader :regexp_source, :file_colon_line
+      
+      def initialize(connection, data)
+        @connection = connection
+        @id              = data['id']
+        @regexp_source   = data['regexp'] || "Unknown"
+        @file_colon_line = data['source'] || "Unknown"
+      end
+      
+      def invoke(args)
+        prepared_args = args.map{ |arg| prepare(arg) }
+        @connection.invoke(@id, prepared_args)
+      end
+
+      private
+      
+      def prepare(arg)
+        return arg unless arg.is_a?(Cucumber::Ast::Table)
+        arg.raw
+      end
+    end
+  end
+end

data/spec/cucumber/ast/background_spec.rb

@@ -0,0 +1,110 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'cucumber/ast'
+require 'cucumber/rb_support/rb_language'
+
+module Cucumber
+  module Ast
+    describe Background do
+
+      before do
+        extend(Cucumber::RbSupport::RbDsl)
+        @runtime = Cucumber::Runtime.new
+        @rb = @runtime.load_programming_language('rb')
+
+        $x = $y = nil
+        Before do
+          $x = 2
+        end
+        Given /y is (\d+)/ do |n|
+          $y = $x * n.to_i
+        end
+
+        @visitor = TreeWalker.new(@runtime)
+
+        @feature = mock('feature', :visit? => true).as_null_object
+      end
+
+      it "should execute Before blocks before background steps" do
+        background = Background.new(
+          comment=Comment.new(''),
+          line=2,
+          keyword="", 
+          name="",
+          steps=[
+            Step.new(7, "Given", "y is 5")
+          ])
+
+        scenario = Scenario.new(
+          background,
+          comment=Comment.new(""), 
+          tags=Tags.new(98,[]),
+          line=99,
+          keyword="", 
+          name="", 
+          steps=[]
+        )
+        background.feature = @feature
+        @visitor.visit_background(background)
+        $x.should == 2
+        $y.should == 10
+      end
+
+      describe "should respond to #name" do
+        it "with a value" do
+          background = Background.new(
+            comment=Comment.new(''),
+            line=2,
+            keyword="",
+            name="background name",
+            steps=[])
+          lambda{ background.name }.should_not raise_error
+          background.name.should == 'background name'
+        end
+        it "without a value" do
+          background = Background.new(
+            comment=Comment.new(''),
+            line=2,
+            keyword="",
+            name=nil,
+            steps=[])
+        lambda{ background.name }.should_not raise_error
+        end
+      end
+
+      describe "failures in a Before hook" do
+
+        before do
+          Before do
+            raise Exception, "Exception from Before hook"
+          end
+        end
+
+        it "should state that the background has failed" do
+          # Assign
+          background = Background.new(
+            comment=Comment.new(''),
+            line=2,
+            keyword="",
+            name="",
+            steps=[
+              Step.new(7, "Given", "y is 5")
+            ])
+          background.feature = @feature
+
+          # Expect
+          @visitor.should_receive( :visit_exception ) do |exception, status|
+            exception.should be_instance_of( Exception )
+            exception.message.should == "Exception from Before hook"
+            status.should == :failed
+           end
+
+          # Assert
+          lambda{ @visitor.visit_background(background) }.should_not raise_error
+          background.should be_failed
+        end
+
+      end
+    end
+    
+  end
+end

data/spec/cucumber/ast/feature_factory.rb

@@ -0,0 +1,60 @@
+require 'cucumber/ast'
+require 'cucumber/step_mother'
+
+module Cucumber
+  module Ast
+    module FeatureFactory
+      class MyWorld
+        def flunk
+          raise "I flunked"
+        end
+      end
+      
+      def create_feature(dsl)
+        dsl.Given /^a (.*) step with an inline arg:$/ do |what, table|
+        end
+        dsl.Given /^a (.*) step$/ do |what|
+          flunk if what == 'failing'
+        end
+        dsl.World do
+          MyWorld.new
+        end
+
+        table = Ast::Table.new([
+          %w{1 22 333},
+          %w{4444 55555 666666}
+        ])
+        py_string = Ast::PyString.new(%{\n I like\nCucumber sandwich\n})
+        
+        background = Ast::Background.new(Ast::Comment.new(""), 2, "Background:", "",
+          [
+            Step.new(3, "Given", "a passing step")
+          ]
+        )
+        
+        f = Ast::Feature.new(
+          background,
+          Ast::Comment.new("# My feature comment\n"),
+          Ast::Tags.new(6, ['one', 'two']),
+          "Feature",
+          "Pretty printing",
+          [Ast::Scenario.new(
+            background,
+            Ast::Comment.new("    # My scenario comment  \n# On two lines \n"),
+            Ast::Tags.new(8, ['three', 'four']),
+            9,
+            "Scenario:", "A Scenario",
+            [
+              Step.new(10, "Given", "a passing step with an inline arg:", table),
+              Step.new(11, "Given", "a happy step with an inline arg:", py_string),
+              Step.new(12, "Given", "a failing step")
+            ]
+          )]
+        )
+        f.file = 'features/pretty_printing.feature'
+        f.features = Features.new
+        f
+      end
+    end
+  end
+end

data/spec/cucumber/ast/feature_spec.rb

@@ -0,0 +1,63 @@
+require File.expand_path(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 = Cucumber::Runtime.new
+        step_mother.load_programming_language('rb')
+        dsl = Object.new 
+        dsl.extend Cucumber::RbSupport::RbDsl
+
+        feature = create_feature(dsl)
+        if Cucumber::WINDOWS
+          feature_file_path = "features\\pretty_printing.feature"
+        else
+          feature_file_path = "features/pretty_printing.feature"
+        end
+        feature.to_sexp.should == 
+        [:feature,
+          feature_file_path,
+          "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
+
+      it "should store OS specific file paths" do
+        step_mother = Cucumber::Runtime.new
+        step_mother.load_programming_language('rb')
+        dsl = Object.new 
+        dsl.extend Cucumber::RbSupport::RbDsl
+        feature = create_feature(dsl)
+
+        if Cucumber::WINDOWS
+          feature.file.should == 'features\pretty_printing.feature'
+        else
+          feature.file.should == 'features/pretty_printing.feature'
+        end                
+      end
+
+    end
+  end
+end

data/spec/cucumber/ast/outline_table_spec.rb

@@ -0,0 +1,21 @@
+require File.expand_path(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,40 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'cucumber/ast/py_string'
+
+module Cucumber
+  module Ast
+    describe PyString do
+      describe "replacing arguments" do
+
+        before(:each) do
+          @ps = PyString.new("<book>\n<qty>\n")
+        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_step_definition_arg.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("'<book>'")
+          py_string_with_replaced_arg = ps.arguments_replaced({'<book>' => nil}) 
+          
+          py_string_with_replaced_arg.to_step_definition_arg.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,68 @@
+require File.expand_path(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 = Cucumber::Runtime.new
+        @step_mother.load_programming_language('rb')
+        @dsl = Object.new
+        @dsl.extend(Cucumber::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}
+                ]
+              ],
+              Gherkin::Formatter::Model::Examples.new(nil, nil, nil, nil, nil, nil)
+            ]
+          ]
+
+        )
+      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
+    end
+  end
+end

data/spec/cucumber/ast/scenario_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path(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 = Cucumber::Runtime.new
+        @step_mother.load_programming_language('rb')
+        @dsl = Object.new
+        @dsl.extend(Cucumber::RbSupport::RbDsl)
+
+        $x = $y = nil
+        @dsl.Given /y is (\d+)/ do |n|
+          $y = n.to_i
+        end
+        @visitor = TreeWalker.new(@step_mother)
+      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').as_null_object
+        @visitor.visit_feature_element(scenario)
+
+        $y.should == nil
+      end
+
+    end
+  end
+end

data/spec/cucumber/ast/step_spec.rb

@@ -0,0 +1,66 @@
+require File.expand_path(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('taste_<taste> color_<color>')
+
+        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_step_definition_arg.should == 'taste_juicy color_green'
+      end
+    end
+  end
+end