cucumber 0.2.3 → 0.3.0

data/rails_generators/cucumber/templates/paths.rb

@@ -1,4 +1,16 @@
 module NavigationHelpers
+  # Maps a static name to a static route.
+  #
+  # This method is *not* designed to map from a dynamic name to a 
+  # dynamic route like <tt>post_comments_path(post)</tt>. For dynamic 
+  # routes like this you should *not* rely on #path_to, but write 
+  # your own step definitions instead. Example:
+  #
+  #   Given /I am on the comments page for the "(.+)" post/ |name|
+  #     post = Post.find_by_name(name)
+  #     visit post_comments_path(post)
+  #   end
+  #
   def path_to(page_name)
     case page_name
     
@@ -14,7 +26,4 @@ module NavigationHelpers
   end
 end
 
-World do |world|
-  world.extend NavigationHelpers
-  world
-end
+World(NavigationHelpers)

data/rails_generators/cucumber/templates/webrat_steps.rb

@@ -106,6 +106,22 @@ Then /^I should not see "([^\"]*)"$/ do |text|
 <% end -%>
 end
 
+Then /^the "([^\"]*)" field should contain "([^\"]*)"$/ do |field, value|
+  <% if framework == :rspec -%>
+    field_labeled(field).value.should =~ /#{value}/
+  <% else -%>
+    assert_match(/#{value}/, field_labeled(field).value)
+  <% end -%>
+end
+
+Then /^the "([^\"]*)" field should not contain "([^\"]*)"$/ do |field, value|
+  <% if framework == :rspec -%>
+    field_labeled(field).value.should_not =~ /#{value}/
+  <% else -%>
+    assert_no_match(/#{value}/, field_labeled(field).value)
+  <% end -%>
+end
+    
 Then /^the "([^\"]*)" checkbox should be checked$/ do |label|
 <% if framework == :rspec -%>
   field_labeled(label).should be_checked

data/{specs → spec}/cucumber/ast/background_spec.rb

@@ -26,6 +26,7 @@ module Cucumber
           comment=Comment.new(''),
           line=2,
           keyword="", 
+          name="",
           steps=[
             Step.new(7, "Given", "y is 5")
           ])

data/{specs → spec}/cucumber/ast/feature_factory.rb

@@ -30,7 +30,7 @@ module Cucumber
           Cucumber sandwich
         }, 10)
         
-        background = Ast::Background.new(Ast::Comment.new(""), 2, "Background:",
+        background = Ast::Background.new(Ast::Comment.new(""), 2, "Background:", "",
           [
             Step.new(3, "Given", "a passing step")
           ]

data/{specs → spec}/cucumber/ast/feature_spec.rb

@@ -25,9 +25,9 @@ module Cucumber
             [:step_invocation, 3, "Given", "a passing step"], # From the background
             [:step_invocation, 10, "Given", "a passing step with an inline arg:",
               [:table, 
-                [:row, 
+                [:row, -1,
                   [:cell, "1"], [:cell, "22"], [:cell, "333"]], 
-                [:row, 
+                [: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"]], 

data/{specs → spec}/cucumber/ast/scenario_spec.rb

@@ -33,33 +33,6 @@ module Cucumber
         $y.should == nil
       end
 
-      it "should be at exact line" do
-        s = Scenario.new(background=nil, comment=Comment.new(""), 
-          tags=Tags.new(44, []), 45, keyword="", name="", steps=[])
-
-        s.should be_matches_lines([44])
-        s.should be_matches_lines([45])
-      end
-
-      it "should be at line if tags or steps are" do
-        s = Scenario.new(
-          background=nil,
-          comment=Comment.new(""), 
-          tags=Tags.new(43, []), 
-          line=45,
-          keyword="",
-          name="", 
-          steps=[
-            Step.new(46, "Given", ""),
-            Step.new(47, "Given", ""),
-            Step.new(48, "Given", ""),
-          ]
-        )
-
-        s.should be_matches_lines([43])
-        s.should be_matches_lines([47])
-        s.should_not be_matches_lines([49])
-      end
     end
   end
 end

data/{specs → spec}/cucumber/ast/table_spec.rb

@@ -155,12 +155,12 @@ module Cucumber
       it "should convert to sexp" do
         @table.to_sexp.should == 
           [:table, 
-            [:row, 
+            [:row, -1,
               [:cell, "one"], 
               [:cell, "four"],
               [:cell, "seven"]
             ],
-            [:row, 
+            [:row, -1,
               [:cell, "4444"], 
               [:cell, "55555"],
               [:cell, "666666"]]]

data/{specs → spec}/cucumber/cli/main_spec.rb

@@ -1,6 +1,10 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 require 'yaml'
-require 'spec/expectations/differs/default'
+begin
+  require 'spec/runner/differs/default' # RSpec >=1.2.4
+rescue ::LoadError
+  require 'spec/expectations/differs/default' # RSpec <=1.2.3
+end
 
 module Cucumber
 module Cli

data/spec/cucumber/core_ext/proc_spec.rb

@@ -0,0 +1,54 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'cucumber/core_ext/instance_exec'
+
+describe Proc do
+  it "should remove extraneous path info for file" do
+    proc = lambda {|a,b|}
+    proc.file_colon_line.should =~ /^spec\/cucumber\/core_ext\/proc_spec\.rb:6/
+  end
+  
+  it "should raise ArityMismatchError for too many args (expecting 0)" do
+    lambda {
+      Object.new.cucumber_instance_exec(true, 'foo', 1) do
+      end
+    }.should raise_error(Cucumber::ArityMismatchError, "Your block takes 0 arguments, but the Regexp matched 1 argument.")
+  end
+
+  it "should raise ArityMismatchError for too many args (expecting 1)" do
+    lambda {
+      Object.new.cucumber_instance_exec(true, 'foo', 1,2) do |a|
+      end
+    }.should raise_error(Cucumber::ArityMismatchError, "Your block takes 1 argument, but the Regexp matched 2 arguments.")
+  end
+
+  it "should raise ArityMismatchError for too few args (expecting 1)" do
+    lambda {
+      Object.new.cucumber_instance_exec(true, 'foo') do |a|
+      end
+    }.should raise_error(Cucumber::ArityMismatchError, "Your block takes 1 argument, but the Regexp matched 0 arguments.")
+  end
+
+  it "should raise ArityMismatchError for too few args (expecting 2)" do
+    lambda {
+      Object.new.cucumber_instance_exec(true, 'foo', 1) do |a,b|
+      end
+    }.should raise_error(Cucumber::ArityMismatchError, "Your block takes 2 arguments, but the Regexp matched 1 argument.")
+  end
+
+  if Cucumber::RUBY_1_9
+    it "should allow varargs" do
+      lambda {
+        Object.new.cucumber_instance_exec(true, 'foo', 1) do |*args|
+        end
+      }.should_not raise_error(Cucumber::ArityMismatchError)
+    end
+  else
+    # Ruby 1.8
+    it "should not allow varargs because Ruby 1.8 reports same arity as with no args, so we can't really tell the difference." do
+      lambda {
+        Object.new.cucumber_instance_exec(true, 'foo', 1) do |*args|
+        end
+      }.should raise_error(Cucumber::ArityMismatchError, "Your block takes 0 arguments, but the Regexp matched 1 argument.")
+    end
+  end
+end

data/{specs → spec}/cucumber/parser/feature_parser_spec.rb

@@ -13,19 +13,11 @@ module Cucumber
       end
 
       def parse_file(file)
-        @parser.parse_file(File.dirname(__FILE__) + "/../treetop_parser/" + file)
+        @parser.parse_file(File.dirname(__FILE__) + "/../treetop_parser/" + file, {})
       end
 
       def parse_example_file(file)
-        @parser.parse_file(File.dirname(__FILE__) + "/../../../examples/" + file)
-      end
-
-      describe "Header" do
-        it "should parse Feature with blurb" do
-          parse(%{Feature: hi
-with blurb
-})
-        end
+        @parser.parse_file(File.dirname(__FILE__) + "/../../../examples/" + file, {})
       end
 
       describe "Comments" do
@@ -36,23 +28,6 @@ Feature: hi
           [:feature, nil, "Feature: hi\n",
             [:comment, "# My comment\n"]]
         end
-        
-        it "should parse a comment within a scenario" do
-          pending "Store comment in node and output it in pretty formatter"
-          parse(%{Feature: Hi
-  Scenario: Hello
-    Given foo
-    # When bar
-    Then baz
-}).to_sexp.should == 
-          [:feature, nil, "Feature: Hi", 
-            [:scenario, 2, "Scenario:", "Hello", 
-              [:step, 3, "Given", "foo"],
-              [:comment, "# When bar\n"], 
-              [:step, 5, "Then", "baz"] 
-            ]
-          ]
-        end
 
         it "should parse a file with only a multiline comment" do
           parse(%{# Hello
@@ -149,7 +124,7 @@ Given I have a table
             [:scenario, 2, "Scenario:", "Hello",
               [:step_invocation, 3, "Given", "I have a table",
                 [:table,
-                  [:row,
+                  [:row, 4,
                     [:cell, "a"],
                     [:cell, "b"]]]]]]
         end
@@ -187,9 +162,10 @@ Examples:
               [:step, 3, "Given", "a <what> cucumber"],
               [:examples, "Examples:", "",
                 [:table, 
-                  [:row, 
+                  [:row, 5,
                     [:cell, "what"]], 
-                    [:row, [:cell, "green"]]]]]]
+                  [:row, 6,
+                    [:cell, "green"]]]]]]
         end
 
         it "should have line numbered steps with inline table" do
@@ -207,15 +183,15 @@ Examples:
             [:scenario_outline, "Scenario Outline:", "Hello",
               [:step, 4, "Given", "I have a table",
                 [:table, 
-                  [:row, 
+                  [:row, 6,
                     [:cell, "<a>"], 
                     [:cell, "<b>"]]]],
             [:examples, "Examples:", "",
               [:table,
-                [:row, 
+                [:row, 8,
                   [:cell, "a"], 
                   [:cell, "b"]],
-                [:row, 
+                [:row, 9,
                   [:cell, "c"], 
                   [:cell, "d"]]]]]]
         end
@@ -237,23 +213,18 @@ Examples:
             [:scenario_outline, "Scenario Outline:", "Hello",
               [:step, 5, "Given", "I have a table",
                 [:table,
-                  [:row,
+                  [:row, 6, 
                     [:cell, "1"],
                     [:cell, "2"]]]],
               [:examples, "Examples:", "",
                 [:table,
-                  [:row,
+                  [:row, 9,
                     [:cell, "x"],
                     [:cell, "y"]],
-                  [:row,
+                  [:row, 10,
                     [:cell, "5"],
                     [:cell, "6"]]]]]]
         end
-
-        it "should set line numbers on feature" do
-          feature = parse_file("empty_feature.feature:11:12")
-          feature.instance_variable_get('@lines').should == [11, 12]
-        end
       end
 
       describe "Syntax" do
@@ -277,6 +248,37 @@ Examples:
           parse_file("scenario_outline.feature")
         end
       end
+
+      describe "Filtering" do
+        it "should filter outline tables" do
+          f = parse_example_file('self_test/features/outline_sample.feature:12')
+          f.to_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"]]]]]
+              ]]
+        end
+      end
     end
   end
 end

data/{specs → spec}/cucumber/step_mother_spec.rb

@@ -27,8 +27,8 @@ module Cucumber
         @step_mother.step_match("Three blind mice")
       end.should raise_error(Ambiguous, %{Ambiguous match of "Three blind mice":
 
-specs/cucumber/step_mother_spec.rb:23:in `/Three (.*) mice/'
-specs/cucumber/step_mother_spec.rb:24:in `/Three blind (.*)/'
+spec/cucumber/step_mother_spec.rb:23:in `/Three (.*) mice/'
+spec/cucumber/step_mother_spec.rb:24:in `/Three blind (.*)/'
 
 You can run again with --guess to make Cucumber be more smart about it
 })
@@ -43,8 +43,8 @@ You can run again with --guess to make Cucumber be more smart about it
         @step_mother.step_match("Three cute mice")
       end.should raise_error(Ambiguous, %{Ambiguous match of "Three cute mice":
 
-specs/cucumber/step_mother_spec.rb:39:in `/Three (.*) mice/'
-specs/cucumber/step_mother_spec.rb:40:in `/Three cute (.*)/'
+spec/cucumber/step_mother_spec.rb:39:in `/Three (.*) mice/'
+spec/cucumber/step_mother_spec.rb:40:in `/Three cute (.*)/'
 
 })
     end
@@ -85,5 +85,64 @@ specs/cucumber/step_mother_spec.rb:40:in `/Three cute (.*)/'
         @step_mother.Given(/Three (.*) mice/) {|disability|}
       end.should raise_error(Redundant)
     end
+
+    it "should raise an error if the world is nil" do
+      @step_mother.World do
+      end
+
+      begin
+        @step_mother.before_and_after(nil)
+        raise "Should fail"
+      rescue NilWorld => e
+        e.message.should == "World procs should never return nil"
+        e.backtrace.should == ["spec/cucumber/step_mother_spec.rb:90:in `World'"]
+      end
+    end
+
+    module ModuleOne
+    end
+
+    module ModuleTwo
+    end
+
+    class ClassOne
+    end
+
+    it "should implicitly extend world with modules" do
+      @step_mother.World(ModuleOne, ModuleTwo)
+
+      w = @step_mother.__send__(:new_world!)
+      class << w
+        included_modules.index(ModuleOne).should_not == nil
+        included_modules.index(ModuleTwo).should_not == nil
+      end
+      w.class.should == Object
+    end
+
+    it "should raise error when we try to register more than one World proc" do
+      @step_mother.World { Hash.new }
+      lambda do
+        @step_mother.World { Array.new }
+      end.should raise_error(MultipleWorld, %{You can only pass a proc to #World once, but it's happening
+in 2 places:
+
+spec/cucumber/step_mother_spec.rb:123:in `World'
+spec/cucumber/step_mother_spec.rb:125:in `World'
+
+Use Ruby modules instead to extend your worlds. See the #World RDoc.
+
+})
+    end
+
+    it "should find before hooks" do
+      fish = @step_mother.Before('@fish'){}
+      meat = @step_mother.Before('@meat'){}
+      
+      scenario = mock('Scenario')
+      scenario.should_receive(:accept_hook?).with(fish).and_return(true)
+      scenario.should_receive(:accept_hook?).with(meat).and_return(false)
+      
+      @step_mother.hooks_for(:before, scenario).should == [fish]
+    end
   end
 end