cucumber 0.3.102 → 0.3.103

data/lib/cucumber/version.rb

@@ -2,7 +2,7 @@ module Cucumber #:nodoc:
   class VERSION #:nodoc:
     MAJOR = 0
     MINOR = 3
-    TINY  = 102
+    TINY  = 103
     PATCH = nil # Set to nil for official release
 
     STRING = [MAJOR, MINOR, TINY, PATCH].compact.join('.')

data/rails_generators/cucumber/templates/env.rb

@@ -3,6 +3,20 @@ ENV["RAILS_ENV"] ||= "cucumber"
 require File.expand_path(File.dirname(__FILE__) + '/../../config/environment')
 require 'cucumber/rails/world'
 
+# Whether or not to run each scenario within a database transaction.
+#
+# If you leave this to true, you can turn off traqnsactions on a
+# per-scenario basis, simply tagging it with @no-txn
+Cucumber::Rails::World.use_transactional_fixtures = true
+
+# Whether or not to allow Rails to rescue errors and render them on
+# an error page. Default is false, which will cause an error to be
+# raised.
+#
+# If you leave this to false, you can turn on Rails rescuing on a
+# per-scenario basis, simply tagging it with @allow-rescue
+ActionController::Base.allow_rescue = false
+
 # Comment out the next line if you don't want Cucumber Unicode support
 require 'cucumber/formatter/unicode'
 

data/spec/cucumber/ast/background_spec.rb

@@ -22,8 +22,7 @@ module Cucumber
 
         register
 
-        @visitor = Visitor.new(@step_mother)
-        @visitor.options = {}
+        @visitor = TreeWalker.new(@step_mother)
 
         @feature = mock('feature', :visit? => true).as_null_object
       end

data/spec/cucumber/ast/scenario_outline_spec.rb

@@ -57,14 +57,15 @@ module Cucumber
       end
 
       it "should replace all variables and call outline once for each table row" do
-        visitor = Visitor.new(@step_mother)
+        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'
-        visitor = Formatter::Pretty.new(@step_mother, STDOUT, {:comment => true, :tag_names => {}})
+        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

data/spec/cucumber/ast/scenario_spec.rb

@@ -17,7 +17,7 @@ module Cucumber
         @dsl.Given /y is (\d+)/ do |n|
           $y = n.to_i
         end
-        @visitor = Visitor.new(@step_mother)
+        @visitor = TreeWalker.new(@step_mother)
         @visitor.options = {}
       end
 

data/spec/cucumber/ast/tree_walker_spec.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Cucumber::Ast
+  describe TreeWalker do
+    describe "when one of the listeners implements the method #visit_features" do
+      it "should issue a warning about that interface being deprecated" do
+        tw = TreeWalker.new(nil, [mock('listener', :visit_features => nil)], {})
+        tw.should_receive(:warn).with /no longer supported/
+        tw.visit_features(mock('features', :accept => nil))
+      end
+    end
+    it "should visit features" do
+      tw = TreeWalker.new(nil, [mock('listener', :before_visit_features => nil)], {})
+      tw.should_not_receive(:warn)
+      tw.visit_features(mock('features', :accept => nil))
+    end
+  end
+end

data/spec/cucumber/formatter/html_spec.rb

@@ -1,16 +1,235 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 require 'cucumber/formatter/html'
+require 'nokogiri'
+require 'cucumber/rb_support/rb_language'
 
 module Cucumber
   module Formatter
+    module SpecHelperDsl
+      attr_reader :feature_content, :step_defs
+      
+      def define_feature(string)
+        @feature_content = string
+      end
+      
+      def define_steps(&block)
+        @step_defs = block
+      end
+    end
+    module SpecHelper
+      def load_features(content)
+        feature_file = FeatureFile.new(nil, content)
+        features = Ast::Features.new
+        features.add_feature feature_file.parse(@step_mother, {})
+        features
+      end
+      
+      def run(features)
+        # options = { :verbose => true }
+        options = {}
+        tree_walker = Cucumber::Ast::TreeWalker.new(@step_mother, [@formatter], options, STDOUT)
+        tree_walker.visit_features(features)
+      end
+      
+      def define_steps
+        return unless step_defs = self.class.step_defs
+        rb = @step_mother.load_programming_language('rb')
+        dsl = Object.new 
+        dsl.extend RbSupport::RbDsl
+        dsl.instance_exec &step_defs
+        @step_mother.register_step_definitions(rb.step_definitions)
+      end
+      
+      Spec::Matchers.define :have_css_node do |css, regexp|
+        match do |doc|
+          nodes = doc.css(css)
+          nodes.detect{ |node| node.text =~ regexp }
+        end
+      end
+    end
+    
     describe Html do
       before(:each) do
         @out = StringIO.new
-        @html = Html.new(mock("step mother"), @out, {})
+        @formatter = Html.new(mock("step mother"), @out, {})
+        @step_mother = StepMother.new
       end
+      
+      extend SpecHelperDsl
+      include SpecHelper
 
       it "should not raise an error when visiting a blank feature name" do
-        lambda { @html.visit_feature_name("") }.should_not raise_error
+        lambda { @formatter.feature_name("") }.should_not raise_error
+      end
+      
+      describe "given a single feature" do
+        before(:each) do
+          features = load_features(self.class.feature_content || raise("No feature content defined!"))
+          define_steps
+          run(features)
+          @doc = Nokogiri.HTML(@out.string)
+        end
+        
+        describe "with a comment" do
+          define_feature <<-FEATURE
+            # Healthy
+          FEATURE
+          
+          it { @out.string.should =~ /^\<!DOCTYPE/ }
+          it { @out.string.should =~ /\<\/html\>$/ }
+          it { @doc.should have_css_node('.feature .comment', /Healthy/) }
+        end
+        
+        describe "with a tag" do
+          define_feature <<-FEATURE
+            @foo
+          FEATURE
+
+          it { @doc.should have_css_node('.feature .tag', /foo/) }
+        end
+        
+        describe "with a narrative" do
+          define_feature <<-FEATURE
+            Feature: Bananas
+              In order to find my inner monkey
+              As a human
+              I must eat bananas
+          FEATURE
+
+          it { @doc.should have_css_node('.feature h2', /Bananas/) }
+          it { @doc.should have_css_node('.feature .narrative', /must eat bananas/) }
+        end
+        
+        describe "with a background" do
+          define_feature <<-FEATURE
+            Feature: Bananas
+            
+            Background:
+              Given there are bananas
+          FEATURE
+
+          it { @doc.should have_css_node('.feature .background', /there are bananas/) }
+        end
+        
+        describe "with a scenario" do
+          define_feature <<-FEATURE
+            Scenario: Monkey eats banana
+              Given there are bananas
+          FEATURE
+
+          it { @doc.should have_css_node('.feature h3', /Monkey eats banana/) }
+          it { @doc.should have_css_node('.feature .scenario .step', /there are bananas/) }
+        end
+        
+        describe "with a scenario outline" do
+          define_feature <<-FEATURE
+            Scenario Outline: Monkey eats a balanced diet
+              Given there are <Things>
+            
+              Examples: Fruit
+               | Things  |
+               | apples  |
+               | bananas |
+              Examples: Vegetables
+               | Things   |
+               | broccoli |
+               | carrots  |
+          FEATURE
+          
+          it { @doc.should have_css_node('.feature .scenario.outline h4', /Fruit/) }
+          it { @doc.should have_css_node('.feature .scenario.outline h4', /Vegetables/) }
+          it { @doc.css('.feature .scenario.outline h4').length.should == 2}
+          it { @doc.should have_css_node('.feature .scenario.outline table', //) }
+          it { @doc.should have_css_node('.feature .scenario.outline table td', /carrots/) }
+        end
+        
+        describe "with a step with a py string" do
+          define_feature <<-FEATURE
+            Scenario: Monkey goes to town
+              Given there is a monkey called:
+               """
+               foo
+               """
+          FEATURE
+          
+          it { @doc.should have_css_node('.feature .scenario .val', /foo/) }
+        end
+
+        describe "with a multiline step arg" do
+          define_feature <<-FEATURE
+            Scenario: Monkey goes to town
+              Given there are monkeys:
+               | name |
+               | foo  |
+               | bar  |
+          FEATURE
+          
+          it { @doc.should have_css_node('.feature .scenario table td', /foo/) }
+        end
+        
+        describe "with a table in the background and the scenario" do
+          define_feature <<-FEATURE
+            Background:
+              Given table:
+                | a | b |
+                | c | d |
+            Scenario:
+              Given another table:
+               | e | f |
+               | g | h |
+          FEATURE
+          
+          it { @doc.css('td').length.should == 8 }
+        end
+        
+        describe "with a py string in the background and the scenario" do
+          define_feature <<-FEATURE
+            Background:
+              Given stuff:
+                """
+                foo
+                """
+            Scenario:
+              Given more stuff:
+                """
+                bar
+                """
+          FEATURE
+
+          it { @doc.css('.feature .background pre.val').length.should == 1 }
+          it { @doc.css('.feature .scenario pre.val').length.should == 1 }
+        end
+        
+        describe "with a step that fails in the scenario" do
+          define_steps do
+            Given(/boo/) { raise 'eek' }
+          end
+          
+          define_feature(<<-FEATURE)
+            Scenario: Monkey gets a fright
+              Given boo
+            FEATURE
+        
+          it { @doc.should have_css_node('.feature .scenario .step.failed', /eek/) }
+        end
+        
+        describe "with a step that fails in the backgound" do
+          define_steps do
+            Given(/boo/) { raise 'eek' }
+          end
+          
+          define_feature(<<-FEATURE)
+            Background:
+              Given boo
+            Scenario:
+              Given yay
+            FEATURE
+          
+          it { @doc.should have_css_node('.feature .background .step.failed', /eek/) }
+          it { @doc.should_not have_css_node('.feature .scenario .step.failed', //) }
+          it { @doc.should have_css_node('.feature .scenario .step.undefined', /yay/) }
+        end
+        
       end
     end
   end

data/spec/cucumber/formatter/progress_spec.rb

@@ -8,13 +8,18 @@ module Cucumber
       before(:each) do
         Term::ANSIColor.coloring = false
         @out = StringIO.new
-        @progress = Progress.new(mock("step mother"), @out, {})
+        progress = Progress.new(mock("step mother"), @out, {})
+        @visitor = Ast::TreeWalker.new(nil, [progress])
       end
  
       describe "visiting a table cell value without a status" do
         it "should take the status from the last run step" do
-          @progress.visit_step_result('', '', nil, :failed, nil, 10, nil)
-          @progress.visit_table_cell_value('value', nil)
+          @visitor.visit_step_result('', '', nil, :failed, nil, 10, nil)
+          outline_table = mock()
+          outline_table.should_receive(:accept) do |visitor|
+            visitor.visit_table_cell_value('value', nil)
+          end
+          @visitor.visit_outline_table(outline_table)
 
           @out.string.should == "FF"
         end
@@ -22,7 +27,7 @@ module Cucumber
 
       describe "visiting a table cell which is a table header" do
         it "should not output anything" do
-          @progress.visit_table_cell_value('value', :skipped_param)
+          @visitor.visit_table_cell_value('value', :skipped_param)
 
           @out.string.should == ""
         end

data/spec/cucumber/parser/feature_parser_spec.rb

@@ -361,34 +361,38 @@ Given I am a step
 
       describe "Filtering" do
         it "should filter outline tables" do
-          ff = FeatureFile.new(
-            File.dirname(__FILE__) + '/../../../examples/self_test/features/outline_sample.feature:12')
-          f = ff.parse(@step_mother, {:lang => 'en'})
-          f.to_sexp.should ==
+          path = '/self_test/features/outline_sample.feature'
+          f = parse_example_file("#{path}:12")
+          actual_sexp = f.to_sexp
+          
+          # check path is equivalent, if not same
+          File.expand_path(actual_sexp[1]).should == File.expand_path(File.dirname(__FILE__) + "/../../../examples#{path}")
+          actual_sexp[1] = 'made/up/path.feature'
+          actual_sexp.should ==
           [:feature,
-           "./spec/cucumber/parser/../../../examples/self_test/features/outline_sample.feature",
-           "Feature: Outline Sample",
-           [:scenario_outline,
-            "Scenario Outline:",
-            "Test state",
-            [:step, 6, "Given", "<state> without a table"],
-            [:step, 7, "Given", "<other_state> without a table"],
-            [:examples,
-             "Examples:",
-             "Rainbow colours",
-             [:table,
-              [:row, 9, [:cell, "state"], [:cell, "other_state"]],
-#              [:row, 10, [:cell, "missing"], [:cell, "passing"]],
-#              [:row, 11, [:cell, "passing"], [:cell, "passing"]],
-              [:row, 12, [:cell, "failing"], [:cell, "passing"]]]]
-            # ,
-            # [:examples,
-            #  "Examples:",
-            #  "Only passing",
-            #  [:table,
-            #   [:row, 14, [:cell, "state"], [:cell, "other_state"]],
-            #   [:row, 15, [:cell, "passing"], [:cell, "passing"]]]]]
-              ]]
+            'made/up/path.feature',
+            "Feature: Outline Sample",
+            [:scenario_outline,
+              "Scenario Outline:",
+              "Test state",
+              [:step, 6, "Given", "<state> without a table"],
+              [:step, 7, "Given", "<other_state> without a table"],
+              [:examples,
+                "Examples:",
+                "Rainbow colours",
+                [:table,
+                  [:row, 9, 
+                    [:cell, "state"], 
+                    [:cell, "other_state"]
+                  ],
+                  [:row, 12, 
+                    [:cell, "failing"], 
+                    [:cell, "passing"]
+                  ]
+                ]
+              ]
+            ]
+          ]
         end
       end
     end

data/spec/cucumber/rb_support/regexp_argument_matcher_spec.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'cucumber/rb_support/regexp_argument_matcher'
+
+module Cucumber
+  module RbSupport
+    describe RegexpArgumentMatcher do
+      it "should create 2 arguments" do
+        arguments = RegexpArgumentMatcher.arguments_from(/I (\w+) (\w+)/, "I like fish")
+        arguments.map{|argument| [argument.val, argument.pos]}.should == [["like", 2], ["fish", 7]]
+      end
+
+      it "should create 2 arguments when first group is optional" do
+        arguments = RegexpArgumentMatcher.arguments_from(/should( not)? be flashed '([^']*?)'$/, "I should be flashed 'Login failed.'")
+        arguments.map{|argument| [argument.val, argument.pos]}.should == [[nil, nil], ["Login failed.", 21]]
+      end
+    end
+  end
+end

data/spec/cucumber/step_match_spec.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'cucumber/rb_support/rb_step_definition'
+require 'cucumber/rb_support/rb_language'
+
+module Cucumber
+  describe StepMatch do
+    before do
+      @rb_language = RbSupport::RbLanguage.new(nil)
+    end
+
+    def stepdef(regexp)
+      RbSupport::RbStepDefinition.new(@rb_language, regexp, lambda{})
+    end
+
+    it "should format groups with format string" do
+      m = stepdef(/I (\w+) (\d+) (\w+) this (\w+)/).step_match("I ate 1 egg this morning", nil)
+      m.format_args("<span>%s</span>").should == "I <span>ate</span> <span>1</span> <span>egg</span> this <span>morning</span>"
+    end
+
+    it "should format groups with format string when there are dupes" do
+      m = stepdef(/I (\w+) (\d+) (\w+) this (\w+)/).step_match("I bob 1 bo this bobs", nil)
+      m.format_args("<span>%s</span>").should == "I <span>bob</span> <span>1</span> <span>bo</span> this <span>bobs</span>"
+    end
+
+    it "should format groups with block" do
+      m = stepdef(/I (\w+) (\d+) (\w+) this (\w+)/).step_match("I ate 1 egg this morning", nil)
+      m.format_args(&lambda{|m| "<span>#{m}</span>"}).should == "I <span>ate</span> <span>1</span> <span>egg</span> this <span>morning</span>"
+    end
+
+    it "should format groups with proc object" do
+      m = stepdef(/I (\w+) (\d+) (\w+) this (\w+)/).step_match("I ate 1 egg this morning", nil)
+      m.format_args(lambda{|m| "<span>#{m}</span>"}).should == "I <span>ate</span> <span>1</span> <span>egg</span> this <span>morning</span>"
+    end
+
+    it "should format groups even when first group is optional and not matched" do
+      m = stepdef(/should( not)? be flashed '([^']*?)'$/).step_match("I should be flashed 'Login failed.'", nil)
+      m.format_args("<span>%s</span>").should == "I should be flashed '<span>Login failed.</span>'"
+    end
+  end
+end