cucumber-in-the-yard 1.5.3 → 1.5.4

data/spec/city/feature_parser_spec_examples.rb

@@ -0,0 +1,153 @@
+
+shared_examples_for "a feature file" do
+  it "should have a defined feature" do
+    @parser.features.first.should_not be_nil
+  end
+
+  it "the feature should have a unique name" do
+    @parser.features.first.name.should == @feature[:file].gsub('.','_').to_sym
+  end
+
+  it "the feature should have the specified title" do
+    @parser.features.first.value.should == @feature[:name]
+  end
+
+  it "the feature should have all specified tags" do
+    @feature[:tags].find do |expected_tag|
+      @parser.features.first.tags.find{|tag| tag.value == expected_tag }
+    end.should_not be_nil
+  end
+  
+  it "the feature should have the correct number of tags" do
+    @feature[:tags].each do |expected_tag|
+      @parser.features.first.tags.find_all {|tag| tag.value == expected_tag }.count.should == 1
+    end
+  end
+  
+  it "the feature's tags should have a file" do
+    @parser.features.first.tags.each do |tag|
+      tag.files.should_not be_nil
+      tag.files.should_not be_empty
+      tag.files.first.first.should == @feature[:file]
+    end
+  end
+
+  it "the feature should have a description" do
+    @parser.features.first.description.join("\n") == @feature[:description].join("\n")
+  end
+
+  it "the feature should have a file" do 
+    @parser.features.first.files.first[0].should == @feature[:file]
+  end
+
+  it "the feature should have a line number" do
+    @parser.features.first.files.first[1].should_not be_nil
+  end
+
+end
+
+shared_examples_for "a feature file with a background" do
+
+  it "the feature should have a background" do
+    @parser.features.first.background.should_not be_nil
+  end
+
+  it "the background should have a unique scenario name" do
+    @parser.features.first.background.name.should == "#{@feature[:file]}.background".gsub('.','_').to_sym
+  end
+
+  it "the background should have the correct title" do
+    @parser.features.first.background.value.should == "Background"  
+  end
+
+  it "the background should have a file" do
+    @parser.features.first.background.files.first[0].should == @feature[:file]
+  end
+
+  it "the background should have a line number" do
+    @parser.features.first.background.files.first[1].should_not be_nil
+  end
+
+  it "the background should have all their defined steps" do
+    @parser.features.first.scenarios.first.steps.should_not be_nil
+    if @background
+      @background.each_with_index do |step,index|
+        @parser.features.first.background.steps[index].value.should == step
+      end
+    end
+  end
+  
+  it "the background steps should have files and line numbers" do
+    if @background
+      @background.each_with_index do |step,index|
+        @parser.features.first.background.steps[index].files.first[0].should == @feature[:file]
+        @parser.features.first.background.steps[index].files.first[1].should_not be_nil
+      end
+    end
+  end
+
+end
+
+shared_examples_for "a feature file with scenarios" do
+  it "should have all scenarios" do
+    @scenarios.each_with_index do |scenario,index|
+      @parser.features.first.scenarios[index].should_not be_nil  
+    end
+  end
+
+  it "each scenario should have a unique scenario name" do
+    @parser.features.first.scenarios.first.name.should == "#{@feature[:file]}_scenario_0".gsub('.','_').to_sym
+  end
+
+  it "each scenario should have the correct title" do
+    @parser.features.first.scenarios.each_with_index do |scenario,index|
+      scenario.value.should == @scenarios[index][:title].join("\n")
+    end  
+  end
+
+  it "each scenario should have the correct tags" do
+    @scenarios.each_with_index do |scenario,index|
+      scenario[:tags].each do |expeced_tag|
+        @parser.features.first.scenarios[index].tags.find {|tag| tag.value == expeced_tag}.should_not be_nil
+      end
+    end
+  end
+
+  it "each scenario should have the correct number of tags" do
+    @parser.features.first.scenarios.first.tags.find_all {|tag| tag.value == "@ninja" }.count.should == 1
+  end
+
+  it "each scenario should have a file" do
+    @parser.features.first.scenarios.first.files.first[0].should == @feature[:file]
+  end
+
+  it "each scenario should have a line number" do
+    @parser.features.first.scenarios.first.files.first[1].should_not be_nil
+  end
+
+  it "each scenario should have all their defined steps" do
+    @parser.features.first.scenarios.first.steps.should_not be_nil
+    if @scenarios
+      @scenarios.each_with_index do |scenario,scenario_index|
+        @parser.features.first.scenarios[scenario_index].should_not be_nil
+
+        scenario[:steps].each_with_index do |step,step_index|
+          @parser.features.first.scenarios[scenario_index].steps[step_index].name.should == "#{@feature[:file].gsub('.','_')}_scenario_#{scenario_index}_step_#{step_index}".to_sym
+          @parser.features.first.scenarios[scenario_index].steps[step_index].value.should == step
+        end
+      end
+    end
+  end
+
+  it "each scenario's steps should have files and line numbers" do
+    if @scenarios
+      @scenarios.each_with_index do |scenario,scenario_index|
+        scenario[:steps].each_with_index do |step,step_index|
+          @parser.features.first.scenarios[scenario_index].steps[step_index].files.first[0].should == @feature[:file]
+          @parser.features.first.scenarios[scenario_index].steps[step_index].files.first[1].should_not be_nil
+        end
+      end
+    end
+  end
+  
+end

data/spec/city/gherkin_loader_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Gherkin" do
+
+
+  before(:all) do
+    
+    @source = File.dirname(__FILE__) + '/test.feature'
+    File.should exist(@source)
+    @data = File.open(@source, 'r').read
+    
+    @parser = YARD::Parser::Cucumber::FeatureParser.new(@data,@source)
+  
+  end
+
+
+  it "should not be nil" do
+    @parser.should_not be_nil
+  end
+
+  it "should parse" do
+    @parser.parse
+  end
+  
+  it "should tokenize" do
+    @parser.tokenize
+  end
+  
+  it "should enumerator" do
+    @parser.enumerator
+  end
+    
+
+
+
+
+
+
+end

data/spec/city/test.feature

@@ -0,0 +1,36 @@
+@customer
+Feature: Customer Logout Feature
+  As a customer of the product I am able to logout
+
+  Background:
+    Given this undefined step definition
+
+  @bvt
+  Scenario: Customer that is logged in is able to log out
+    Given that a customer is a valid customer
+    And a customer logs in as username 'frank' with password 'default'
+    And I expect them to have logged in successfully
+    When the customer logs out
+	Then I expect the customer to be shown the logout page
+
+  Scenario: Customers with a complete profile are allowed to post
+    Given that a customer is a valid customer
+    And the customer has the following details:
+      | Name  | Email       | Age |
+      | Frank | f@email.com | 22  | 
+    When a customer logs in as username 'frank' with password 'default'
+	And visits the customer update page
+	Then I expect the customer is able able to post to their profile
+	
+  @product
+  Scenario Outline: Customers that bought a product are included in their product groups
+    Given that <Customer> is a valid customer
+    And that the product, named '<Product>', is a valid product
+    When the customer has purchased the product
+    Then I expect the customer to be a member of the '<Product>' group
+
+    Examples:
+     | Customer   | Product   |
+     | Customer A | Product A |
+     | Customer A | Product B |
+     | Customer A | Product C |

data/spec/city/yard_handlers_cucumber_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module YARD::Handlers::Cucumber
+
+  describe Base do
+    
+    it "should respond to method handles?" do
+      Base.should respond_to(:handles?)
+    end
+    
+  end
+  
+  describe FeatureHandler do
+    
+    it "should respond to method process" do
+      FeatureHandler.should respond_to(:process)  
+    end
+    
+  end
+  
+  
+  
+  
+end

data/spec/city/yard_namespace_object_spec.rb

@@ -0,0 +1,8 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module YARD::CodeObjects
+
+  describe NamespaceObject do
+  end
+
+end

data/spec/city/yard_parser_cucumber_spec.rb

@@ -0,0 +1,215 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require File.dirname(__FILE__) + '/feature_parser_spec_examples.rb'
+
+module YARD::Parser::Cucumber
+
+  describe YARD::CodeObjects::Cucumber::Tag do
+    
+    [:value].each do |attribute|
+      it "should respond to method #{attribute}" do
+        YARD::CodeObjects::Cucumber::Tag.new(:root,"tag_name").should respond_to(attribute)
+      end
+    end
+    
+  end
+
+  describe YARD::CodeObjects::Cucumber::Step do
+    
+    [:value, :definition].each do |attribute|
+      it "should respond to method #{attribute}" do
+        YARD::CodeObjects::Cucumber::Step.new(:root,"name").should respond_to(attribute)
+      end
+    end
+    
+    it "should return the line prefix and the remainder" do
+      step = YARD::CodeObjects::Cucumber::Step.new(:root,"name") {|s| s.value = "Given something something" }
+      step.keyword.should == "Given"
+      step.line.should == "something something"
+    end
+    
+  end
+  
+  describe YARD::CodeObjects::Cucumber::Scenario do
+    
+    [:value, :description, :steps, :tags ].each do |attribute|
+      it "should respond to method #{attribute}" do
+        YARD::CodeObjects::Cucumber::Scenario.new(:root,"name").should respond_to(attribute)
+      end
+    end
+    
+  end
+  
+  describe YARD::CodeObjects::Cucumber::Feature do
+    
+    [:value, :description, :scenarios, :background, :tags ].each do |attribute|
+      it "should respond to method #{attribute}" do
+        YARD::CodeObjects::Cucumber::Feature.new(:root,"name").should respond_to(attribute)
+      end
+    end
+    
+  end
+  
+
+  describe FeatureParser do
+
+
+    it "should accept source and a file when created" do
+      lambda { FeatureParser.new("source code","filename") }.should_not raise_exception(Exception)
+    end
+
+    [ "parse", "tokenize", "enumerator" ].each do |required_method|
+      it "should have a method named #{required_method}" do
+        FeatureParser.instance_methods.should include(required_method)
+      end
+    end
+
+    it "should return itself when parse is called" do
+      parser = FeatureParser.new("source","filename")
+      parser.parse.should == parser
+    end
+
+    context "feature file with tags, feature, and description" do
+
+      before(:all) do
+        @feature = { :file => 'new.exciting.feature',
+          :name => "New Exciting Feature", 
+          :tags => [ "@bvt", "@build", "@wip" ],
+          :description => [ "This feature is going to save the company." ] }
+        
+        @parser = FeatureParser.new(%{
+          #{@feature[:tags].join(" ")}
+          Feature: #{@feature[:name]}
+          #{@feature[:description].join("\n")}
+          },@feature[:file])
+
+          @parser = @parser.parse
+      end
+
+      after(:all) do
+        @parser = nil
+      end
+
+      it_should_behave_like "a feature file"
+
+    end
+    
+    context "feature file with a description that uses step keywords" do
+
+      before(:all) do
+        @feature = { :file => 'description.with.keywords.feature',
+          :name => "Fully Described Feature", 
+          :tags => [ "@bvt", "@build", "@wip" ],
+          :description => ["As a product owner",
+            "When I ask about the work done",
+            "Then I want to see what this cukes things is all about",
+            "And I really want a straight answer",
+            "Given that I can be provided with one"] }
+        
+        @parser = FeatureParser.new(%{
+          #{@feature[:tags].join(" ")}
+          Feature: #{@feature[:name]}
+          #{@feature[:description].join("\n")}
+          },@feature[:file])
+
+          @parser = @parser.parse
+      end
+
+      after(:all) do
+        @parser = nil
+      end
+
+      it_should_behave_like "a feature file"
+
+    end
+    
+
+    context "feature file with background and one scenario" do
+
+      before(:all) do
+
+        @feature = { :file => "ninja.exciting.feature",
+          :name => "Ninja Feature Set", 
+          :tags => [ "@bvt", "@build", "@wip" ],
+          :description => ["This feature is going to save the company"] }
+
+        @background = [ "Given that I have taken a nap" ]
+          
+        @scenarios = [ { :tags => ["@ninja"],
+          :title => ["Ninja striking an opponent in the morning"],
+          :steps => [ "Given that there is an opponent", 
+          "And a reason to fight him", 
+          "When I karate strike him", 
+          "Then I expect him to fall" ] } ]
+
+          @parser = FeatureParser.new(%{
+            #{@feature[:tags].join(" ")}
+            Feature: #{@feature[:name]}
+            #{@feature[:description].join("\n")}
+              Background:
+            #{@background.join("\n")}
+              #{@scenarios.first[:tags].join(" ")}
+            Scenario: #{@scenarios.first[:title].join("\n")}
+            #{@scenarios.first[:steps].join("\n")}
+            },@feature[:file])
+          @parser = @parser.parse
+      end
+            
+      after(:all) do
+        @parser = nil
+      end
+
+      it_should_behave_like "a feature file"
+      it_should_behave_like "a feature file with a background"
+      it_should_behave_like "a feature file with scenarios"
+            
+    end
+
+    context "feature file no background and multiple scenarios" do
+
+      before(:all) do
+
+        @feature = { :file => "ninja.strike.feature",
+          :name => "Ninja Feature Set", 
+          :tags => [ "@kill", "@silently", "@sneak" ],
+          :description => ["This feature is going to save the company"] }
+
+        @scenarios = [  
+          { :tags => ["@ninja"], 
+            :title => ["Killing Scenario"],
+            :steps => [ "Given that there is an opponent", 
+                        "And a reason to fight him", 
+                        "When I karate strike him", 
+                        "Then I expect him to fall" ] },
+          { :tags => [], 
+            :title => ["Dissappearing Scenario"],
+            :steps => [ "Given that I have defeated an opponent", 
+                        "And there are no more opponents", 
+                        "When I stop to take a breath", 
+                        "Then I expect to dissapear" ] } ]
+
+          @parser = FeatureParser.new(%{
+            #{@feature[:tags].join(" ")}
+            Feature: #{@feature[:name]}
+            #{@feature[:description].join("\n")} 
+            #{@scenarios.collect {|scenario|
+              scenario[:tags].join(" ") + 
+              "\nScenario: " + scenario[:title].join("\n") + "\n" +
+              scenario[:steps].join("\n")  
+            }.join("\n")}},@feature[:file])
+          @parser = @parser.parse
+      end
+            
+      after(:all) do
+        @parser = nil
+      end
+
+      it_should_behave_like "a feature file"
+      it_should_behave_like "a feature file with scenarios"
+            
+    end
+
+
+
+  end
+  
+end

data/spec/city/yard_rb_extensions_spec.rb

@@ -0,0 +1,128 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module YARD::CodeObjects
+
+  describe YARD::CodeObjects do
+
+    shared_examples_for "CodeObjects" do
+      it "should respond to all defined attributes" do
+        @attributes.each {|attribute| @object.should respond_to(attribute) }
+      end
+    end
+
+    describe StepDefinitionObject do
+
+      before(:each) do
+        @attributes = [ :value, :keyword, :constants, :compare_value ]
+        @object = StepDefinitionObject.new(:root,:unique_name)
+      end
+
+      class TestObject
+        attr_accessor :name, :value
+        def initialize ; yield self ; end
+      end
+
+      it_should_behave_like "CodeObjects"
+      
+      describe "compare_value" do
+
+        [ { :value => "/THERE (?:IS|ARE) THREE \#\{ CONSTANTS \} IN HERE \#\{ FOR\} YOU TO \#\{FIND \}",
+          :results => [ 'CONSTANTS', 'FOR', 'FIND' ] } ].each do |data|
+
+            it "should find all the constants within the step definition" do
+              
+              stepdef = StepDefinitionObject.new(:root,"name")
+              stepdef.value = data[:value]
+
+              
+              data[:results].each do |result|
+                stepdef._value_constants(data[:value]).should include(result)
+                stepdef._value_constants.should include(result)
+              end
+              
+            end
+          end
+        
+        
+        [ { :value => "/WHEN THE \#\{NOUN\} HITS THE FAN/", 
+                  :constants => [ TestObject.new{|c| c.name = "NOUN" ; c.value = "/SMURF/" } ], :result => "WHEN THE SMURF HITS THE FAN" },
+
+                  { :value => "/\#\{ SUBJECT \} WALK INTO THE \#\{ PLACE\} AND ASK THE \#\{PERSON \}/", 
+                  :constants => [ TestObject.new{|c| c.name = "SUBJECT" ; c.value = "/1 PERSON/" }, 
+                    TestObject.new{|c| c.name = "PLACE" ; c.value = "/BAR/" },
+                    TestObject.new{|c| c.name = "PERSON" ; c.value = "/BARTENDER/" } ], 
+                    :result => "1 PERSON WALK INTO THE BAR AND ASK THE BARTENDER" },
+                            
+           ].each do |data|
+
+          it "should replace all constants found within (#{data[:value]}) the value" do
+            
+            stepdef = StepDefinitionObject.new(:root,"name")
+            stepdef.value = data[:value]
+            stepdef.constants = data[:constants]
+            
+            stepdef.compare_value.should == data[:result]
+
+          end
+
+        end
+
+
+      end
+      
+      
+
+    end
+
+    describe StepTransformObject do
+
+      before(:each) do
+        @attributes = [ :value ]
+        @object = StepTransformObject.new(:root,:unique_name)
+      end
+
+      it_should_behave_like "CodeObjects"
+
+    end
+
+  end
+
+end
+
+module YARD::Handlers::Ruby::Legacy
+
+  describe YARD::Handlers::Ruby::Legacy do
+
+    shared_examples_for "Handlers" do
+      it "should match #{@match_criteria}" do
+        @handler::MATCH.should == @match_criteria
+      end
+
+      it "should respond to the method process" do
+        @handler.should respond_to(:process)
+      end
+
+    end
+
+    describe StepDefinitionHandler do
+      before(:each) do
+        @handler = StepDefinitionHandler
+        @match_criteria = /^((When|Given|And|Then)\s*(\/[^\/]+\/).+)$/
+      end
+      
+      it_should_behave_like "Handlers"
+    end
+    
+    describe StepTransformHandler do
+      before(:each) do
+        @handler = StepTransformHandler
+        @match_criteria = /^Transform\s*(\/[^\/]+\/).+$/
+      end
+      
+      it_should_behave_like "Handlers"
+    end
+
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+$:.unshift(File.dirname(__FILE__))
+
+require 'city'