casecumber 1.0.2.1

data/lib/cucumber/wire_support/wire_protocol/requests.rb

@@ -0,0 +1,123 @@
+require 'cucumber/wire_support/request_handler'
+module Cucumber
+  module WireSupport
+    module WireProtocol
+      module Requests
+        class StepMatches < RequestHandler
+          def execute(name_to_match, name_to_report)
+            @name_to_match, @name_to_report = name_to_match, name_to_report
+            request_params = {
+              :name_to_match => name_to_match
+            }
+            super(request_params)
+          end
+
+          def handle_success(params)
+            params.map do |raw_step_match|
+              create_step_match(raw_step_match)
+            end
+          end
+          
+          alias :handle_step_matches :handle_success
+        
+          private
+          
+          def create_step_match(raw_step_match)
+            step_definition = WireStepDefinition.new(@connection, raw_step_match)
+            step_args = raw_step_match['args'].map do |raw_arg|
+              StepArgument.new(raw_arg['val'], raw_arg['pos'])
+            end
+            step_match(step_definition, step_args)
+          end
+        
+          def step_match(step_definition, step_args)
+            StepMatch.new(step_definition, @name_to_match, @name_to_report, step_args)
+          end
+        end
+
+        class SnippetText < RequestHandler
+          def execute(step_keyword, step_name, multiline_arg_class_name)
+            request_params = { 
+              :step_keyword => step_keyword, 
+              :step_name => step_name, 
+              :multiline_arg_class => multiline_arg_class_name 
+            }
+            super(request_params)
+          end
+          
+          def handle_success(snippet_text)
+            snippet_text
+          end
+          
+          alias :handle_snippet_text :handle_success
+        end
+
+        class Invoke < RequestHandler
+          def execute(step_definition_id, args)
+            request_params = { 
+              :id => step_definition_id, 
+              :args => args
+            }
+            super(request_params)
+          end
+
+          def handle_pending(message)
+            raise Pending, message || "TODO"
+          end
+          
+          def handle_diff!(tables)
+            table1 = Ast::Table.new(tables[0])
+            table2 = Ast::Table.new(tables[1])
+            table1.diff!(table2)
+          end
+        
+          def handle_diff(tables)
+            begin
+              handle_diff!(tables)
+            rescue Cucumber::Ast::Table::Different
+              @connection.diff_failed
+            end
+            @connection.diff_ok
+          end
+          
+          alias :handle_step_failed :handle_fail
+        end
+
+        class DiffFailed < RequestHandler
+          alias :handle_step_failed :handle_fail
+        end
+      
+        class DiffOk < RequestHandler
+          alias :handle_step_failed :handle_fail
+        end
+      
+        module Tags
+          def clean_tags(scenario)
+            scenario.source_tag_names.map { |tag| tag.gsub(/^@/, '') }.sort
+          end
+          
+          def request_params(scenario)
+            return nil unless scenario.source_tag_names.any?
+            { "tags" => clean_tags(scenario) }
+          end
+        end
+      
+        class BeginScenario < RequestHandler
+          include Tags
+
+          def execute(scenario)
+            super(request_params(scenario))
+          end
+        end
+
+        class EndScenario < RequestHandler
+          include Tags
+
+          def execute(scenario)
+            super(request_params(scenario))
+          end
+        end
+      end
+    end
+  end
+end

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,115 @@
+require '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="", 
+          title="",
+          description="",
+          steps=[
+            Step.new(7, "Given", "y is 5")
+          ])
+
+        scenario = Scenario.new(
+          background,
+          comment=Comment.new(""), 
+          tags=Tags.new(98,[]),
+          line=99,
+          keyword="", 
+          title="",
+          description="",
+          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="",
+            title="background name",
+            description="",
+            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="",
+            title="",
+            description="",
+            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="",
+            title="",
+            description="",
+            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/doc_string_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'cucumber/ast/doc_string'
+
+module Cucumber
+  module Ast
+    describe DocString do
+      describe "replacing arguments" do
+
+        before(:each) do
+          @ps = DocString.new("<book>\n<qty>\n")
+        end
+      
+        it "should return a new doc_string with arguments replaced with values" do
+          doc_string_with_replaced_arg = @ps.arguments_replaced({'<book>' => 'Life is elsewhere', '<qty>' => '5'})
+                
+          doc_string_with_replaced_arg.to_step_definition_arg.should == "Life is elsewhere\n5\n"
+        end
+        
+        it "should not change the original doc_string" do
+          doc_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 = DocString.new("'<book>'")
+          doc_string_with_replaced_arg = ps.arguments_replaced({'<book>' => nil}) 
+          
+          doc_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/feature_factory.rb

@@ -0,0 +1,61 @@
+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}
+        ])
+        doc_string = Ast::DocString.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:", doc_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 '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:", 
+              [:doc_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 '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