cucumber 0.3.11 → 0.3.90

data/rails_generators/cucumber/templates/env.rb

@@ -15,6 +15,7 @@ Cucumber::Rails.use_transactional_fixtures
 Cucumber::Rails.bypass_rescue
 
 require 'webrat'
+require 'cucumber/webrat/table_locator' # Lets you do table.diff!(table_at('#my_table').to_a)
 
 Webrat.configure do |config|
   config.mode = :rails

data/rails_generators/cucumber/templates/spork_env.rb

@@ -3,7 +3,7 @@ require 'spork'
  
 Spork.prefork do
   # Sets up the Rails environment for Cucumber
-  ENV["RAILS_ENV"] ||= "cucumber"
+  ENV["RAILS_ENV"] = "cucumber"
   require File.expand_path(File.dirname(__FILE__) + '/../../config/environment')
  
   require 'webrat'

data/rails_generators/cucumber/templates/webrat_steps.rb

@@ -98,6 +98,15 @@ Then /^I should see "([^\"]*)"$/ do |text|
 <% end -%>
 end
 
+Then /^I should see \/([^\/]*)\/$/ do |regexp|
+  regexp = Regexp.new(regexp)
+<% if framework == :rspec -%>
+  response.should contain(regexp)
+<% else -%>
+  assert_contain regexp
+<% end -%>
+end
+
 Then /^I should not see "([^\"]*)"$/ do |text|
 <% if framework == :rspec -%>
   response.should_not contain(text)
@@ -106,6 +115,14 @@ Then /^I should not see "([^\"]*)"$/ do |text|
 <% end -%>
 end
 
+Then /^I should not see \/([^\/]*)\/$/ do |regexp|
+<% if framework == :rspec -%>
+  response.should_not contain(text)
+<% else -%>
+  assert_not_contain text
+<% end -%>
+end
+
 Then /^the "([^\"]*)" field should contain "([^\"]*)"$/ do |field, value|
 <% if framework == :rspec -%>
   field_labeled(field).value.should =~ /#{value}/

data/rails_generators/feature/templates/feature.erb

@@ -25,7 +25,7 @@ Feature: Manage <%= plural_name %>
 <% end -%>
     When I delete the 3rd <%= singular_name %>
     Then I should see the following <%= plural_name %>:
-      |<%= named_args.map(&:name).join('|') %>|
+      |<%= named_args.map{|arg| arg.name.humanize}.join('|') %>|
 <% [1,2,4].each do |n| -%>
       |<%= named_args.map{|arg| arg.value(n)}.join('|') %>|
 <% end -%>

data/rails_generators/feature/templates/steps.erb

@@ -9,12 +9,6 @@ When /^I delete the (\d+)(?:st|nd|rd|th) <%= singular_name %>$/ do |pos|
   end
 end
 
-Then /^I should see the following <%= plural_name %>:$/ do |<%= plural_name %>|
-  <%= plural_name %>.rows.each_with_index do |row, i|
-    row.each_with_index do |cell, j|
-      response.should have_selector("table > tr:nth-child(#{i+2}) > td:nth-child(#{j+1})") { |td|
-        td.inner_text.should == cell
-      }
-    end
-  end
+Then /^I should see the following <%= plural_name %>:$/ do |expected_<%= plural_name %>_table|
+  expected_<%= plural_name %>_table.diff!(table_at('table').to_a)
 end

data/spec/cucumber/ast/step_collection_spec.rb

@@ -4,10 +4,11 @@ module Cucumber
   module Ast
     describe StepCollection do
       it "should convert And to Given in snippets" do
-        c = StepCollection.new([
-          Step.new(1, 'Given', 'cukes'),
-          Step.new(2, 'And', 'turnips')
-        ])
+        s1 = Step.new(1, 'Given', 'cukes')
+        s2 = Step.new(2, 'And', 'turnips')
+        s1.stub!(:language).and_return(Parser::I18n::Language['en'])
+        s2.stub!(:language).and_return(Parser::I18n::Language['en'])
+        c = StepCollection.new([s1, s2])
         actual_keywords = c.step_invocations.map{|i| i.actual_keyword}
         actual_keywords.should == %w{Given Given}
       end

data/spec/cucumber/ast/table_spec.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 require File.dirname(__FILE__) + '/../../spec_helper'
 require 'cucumber/ast/table'
 
@@ -168,6 +169,150 @@ module Cucumber
 
       end
       
+      describe "diff!" do
+        it "should detect a complex diff" do
+          t1 = table(%{
+            | 1         | 22          | 333         | 4444         |
+            | 55555     | 666666      | 7777777     | 88888888     |
+            | 999999999 | 0000000000  | 01010101010 | 121212121212 |
+            | 4000      | ABC         | DEF         | 50000        |
+          })
+          
+          t2 = table(%{
+            | a     | 4444     | 1         | 
+            | bb    | 88888888 | 55555     | 
+            | ccc   | xxxxxxxx | 999999999 | 
+            | dddd  | 4000     | 300       |
+            | e     | 50000    | 4000      |
+          })
+          lambda{t1.diff!(t2)}.should raise_error
+          t1.to_s(:indent => 12, :color => false).should == %{
+            |     1         | (-) 22         | (-) 333         |     4444         | (+) a    |
+            |     55555     | (-) 666666     | (-) 7777777     |     88888888     | (+) bb   |
+            | (-) 999999999 | (-) 0000000000 | (-) 01010101010 | (-) 121212121212 | (+)      |
+            | (+) 999999999 | (+)            | (+)             | (+) xxxxxxxx     | (+) ccc  |
+            | (+) 300       | (+)            | (+)             | (+) 4000         | (+) dddd |
+            |     4000      | (-) ABC        | (-) DEF         |     50000        | (+) e    |
+          }
+        end
+
+        it "should not change table when diffed with identical" do
+          t = table(%{
+            |a|b|c|
+            |d|e|f|
+            |g|h|i|
+          })
+          t.diff!(t.dup)
+          t.to_s(:indent => 12, :color => false).should == %{
+            |     a |     b |     c |
+            |     d |     e |     f |
+            |     g |     h |     i |
+          }
+        end
+
+        it "should inspect missing and surplus cells" do
+          t1 = Table.new([
+            ['name',  'male', 'lastname', 'swedish'],
+            ['aslak', 'true', 'hellesøy', 'false']
+          ])
+          t2 = Table.new([
+            ['name',  'male', 'lastname', 'swedish'],
+            ['aslak', true,   'hellesøy', false]
+          ])
+          lambda{t1.diff!(t2)}.should raise_error
+          t1.to_s(:indent => 12, :color => false).should == %{
+            |     name  |     male       |     lastname |     swedish     |
+            | (-) aslak | (-) (i) "true" | (-) hellesøy | (-) (i) "false" |
+            | (+) aslak | (+) (i) true   | (+) hellesøy | (+) (i) false   |
+          }
+        end
+
+        it "should allow column mapping before diffing" do
+          t1 = Table.new([
+            ['name',  'male'],
+            ['aslak', 'true']
+          ])
+          t1.map_column!('male') { |m| m == 'true' }
+          t2 = Table.new([
+            ['name',  'male'],
+            ['aslak', true]
+          ])
+          t1.diff!(t2)
+          t1.to_s(:indent => 12, :color => false).should == %{
+            |     name  |     male |
+            |     aslak |     true |
+          }
+        end
+
+        it "should allow header mapping before diffing" do
+          t1 = Table.new([
+            ['Name',  'Male'],
+            ['aslak', 'true']
+          ])
+          t1.map_headers!('Name' => 'name', 'Male' => 'male')
+          t1.map_column!('male') { |m| m == 'true' }
+          t2 = Table.new([
+            ['name',  'male'],
+            ['aslak', true]
+          ])
+          t1.diff!(t2)
+          t1.to_s(:indent => 12, :color => false).should == %{
+            |     name  |     male |
+            |     aslak |     true |
+          }
+        end
+        
+        describe "raising" do
+          before do
+            @t = table(%{
+              | a | b |
+              | c | d |
+            })
+          end
+          
+          it "should raise on missing rows" do
+            t = table(%{
+              | a | b |
+            })
+            lambda { @t.dup.diff!(t) }.should raise_error
+            lambda { @t.dup.diff!(t, :missing_row => false) }.should_not raise_error
+          end
+
+          it "should raise on surplus rows" do
+            t = table(%{
+              | a | b |
+              | c | d |
+              | e | f |
+            })
+            lambda { @t.dup.diff!(t) }.should raise_error
+            lambda { @t.dup.diff!(t, :surplus_row => false) }.should_not raise_error
+          end
+
+          it "should raise on missing columns" do
+            t = table(%{
+              | a |
+              | c |
+            })
+            lambda { @t.dup.diff!(t) }.should raise_error
+            lambda { @t.dup.diff!(t, :missing_col => false) }.should_not raise_error
+          end
+
+          it "should not raise on surplus columns" do
+            t = table(%{
+              | a | b | x |
+              | c | d | y |
+            })
+            lambda { @t.dup.diff!(t) }.should_not raise_error
+            lambda { @t.dup.diff!(t, :surplus_col => true) }.should raise_error
+          end
+        end
+
+        def table(text, file=nil, line_offset=0)
+          @table_parser ||= Parser::TableParser.new
+          @table_parser.parse_or_fail(text.strip, file, line_offset)
+        end
+      end
+      
       it "should convert to sexp" do
         @table.to_sexp.should == 
           [:table, 

data/spec/cucumber/cli/configuration_spec.rb

@@ -55,6 +55,19 @@ module Cli
       ]
     end
 
+    it "should require files in vendor/{plugins,gems}/*/cucumber/*.rb" do
+      given_the_following_files("/vendor/plugins/plugin_a/cucumber/foo.rb",
+                                "/vendor/gems/gem_a/cucumber/bar.rb")
+
+      config = Configuration.new(StringIO.new)
+      config.parse!(%w{--require /features})
+
+      config.files_to_require.should == [
+        "/vendor/plugins/plugin_a/cucumber/foo.rb",
+        "/vendor/gems/gem_a/cucumber/bar.rb"
+      ]
+    end
+
     describe "--exclude" do
 
       it "excludes a ruby file from requiring when the name matches exactly" do
@@ -138,12 +151,22 @@ module Cli
 
     end
 
+    context '--drb in the default profile and no arguments specified' do
+      it "expands the profile's arguments into the args excpet for --drb" do
+        given_cucumber_yml_defined_as({'default' => '--drb features --format pretty'})
+        config = Configuration.new(StringIO.new)
+        args = []
+        config.parse!(args)
+        args.should == %w{features --format pretty}
+      end
+    end
+
     it "should expand args from YAML file" do
       given_cucumber_yml_defined_as({'bongo' => '--require from/yml'})
 
       config = Configuration.new
       config.parse!(%w{--format progress --profile bongo})
-      config.options[:formats].should == {'progress' => STDOUT}
+      config.options[:formats].should == [['progress', STDOUT]]
       config.options[:require].should == ['from/yml']
     end
 
@@ -255,26 +278,34 @@ END_OF_MESSAGE
     it "should accept --out option" do
       config = Configuration.new(StringIO.new)
       config.parse!(%w{--out jalla.txt})
-      config.options[:formats]['pretty'].should == 'jalla.txt'
+      config.options[:formats].should == [['pretty', 'jalla.txt']]
     end
 
     it "should accept multiple --out options" do
       config = Configuration.new(StringIO.new)
       config.parse!(%w{--format progress --out file1 --out file2})
-      config.options[:formats].should == {'progress' => 'file2'}
+      config.options[:formats].should == [['progress', 'file2']]
     end
 
-    it "should accept multiple --format options" do
-      config = Configuration.new(StringIO.new)
-      config.parse!(%w{--format pretty --format progress})
-      config.options[:formats].should have_key('pretty')
-      config.options[:formats].should have_key('progress')
+    it "should accept multiple --format options and put the STDOUT one first so progress is seen" do
+      io = StringIO.new
+      config = Configuration.new(io)
+      config.parse!(%w{--format pretty --out pretty.txt --format progress})
+      config.options[:formats].should == [['progress', io], ['pretty', 'pretty.txt']]
+    end
+
+    it "should not accept multiple --format options when both use implicit STDOUT" do
+      io = StringIO.new
+      config = Configuration.new(io)
+      lambda do
+        config.parse!(%w{--format pretty --format progress})
+      end.should raise_error("All but one formatter must use --out, only one can print to STDOUT")
     end
 
     it "should associate --out to previous --format" do
       config = Configuration.new(StringIO.new)
       config.parse!(%w{--format progress --out file1 --format profile --out file2})
-      config.options[:formats].should == {"profile"=>"file2", "progress"=>"file1"}
+      config.options[:formats].should == [["progress", "file1"], ["profile" ,"file2"]]
     end
 
     it "should accept --color option" do
@@ -358,6 +389,21 @@ END_OF_MESSAGE
       config.feature_files.should == ["cucumber.feature"]
     end
 
+    it "should allow specifying environment variables on the command line" do
+      config = Configuration.new
+      config.parse!(["foo=bar"])
+      ENV["foo"].should == "bar"
+      config.feature_files.should == []
+    end
+    
+    it "should allow specifying environment variables in profiles" do
+      given_cucumber_yml_defined_as({'selenium' => 'RAILS_ENV=selenium'})
+      config = Configuration.new
+      config.parse!(["--profile", "selenium"])
+      ENV["RAILS_ENV"].should == "selenium"
+      config.feature_files.should == []
+    end
+
   end
 end
 end

data/spec/cucumber/cli/drb_client_spec.rb

@@ -28,13 +28,14 @@ module Cucumber
         DRbClient.run(@args, @error_stream, @out_stream)
       end
 
-      it "returns false when it can't connect to the server" do
+      it "returns raises an error when it can't connect to the server" do
         DRbObject.stub!(:new_with_uri).and_raise(DRb::DRbConnError)
-        DRbClient.run(@args, @error_stream, @out_stream).should be_false
+        running { DRbClient.run(@args, @error_stream, @out_stream) }.should raise_error(DRbClientError, "No DRb server is running.")
       end
 
-      it "returns true when it connects to the server and runs the features" do
-        DRbClient.run(@args, @error_stream, @out_stream).should be_true
+      it "returns the result from the DRb server call" do
+        @drb_object.should_receive(:run).and_return('foo')
+        DRbClient.run(@args, @error_stream, @out_stream).should == 'foo'
       end
 
     end

data/spec/cucumber/cli/main_spec.rb

@@ -19,7 +19,6 @@ module Cucumber
 
         before(:each) do
           @empty_feature = Ast::Feature.new(nil, Ast::Comment.new(''), Ast::Tags.new(2, []), "Feature", [])
-          Dir.stub!(:[])
         end
 
         it "should show ruby files required" do
@@ -35,7 +34,7 @@ module Cucumber
           @cli = Main.new(%w{--verbose example.feature}, @out)
           @cli.stub!(:require)
 
-          Parser::FeatureParser.stub!(:new).and_return(mock("feature parser", :parse_file => @empty_feature))
+          FeatureFile.stub!(:new).and_return(mock("feature file", :parse => @empty_feature))
 
           @cli.execute!(Object.new.extend(StepMother))
 
@@ -110,33 +109,31 @@ module Cucumber
           @cli.execute!(@step_mother)
         end
 
+        it "returns the result from the DRbClient" do
+          DRbClient.stub!(:run).and_return('foo')
+          @cli.execute!(@step_mother).should == 'foo'
+        end
+
         it "ceases execution if the DrbClient is able to perform the execution" do
           DRbClient.stub!(:run).and_return(true)
-          @configuration.should_not_receive(:load_language)
+          @configuration.should_not_receive(:build_formatter_broadcaster)
           @cli.execute!(@step_mother)
         end
 
         context "when the DrbClient is unable to perfrom the execution" do
-          before { DRbClient.stub!(:run).and_return(false) }
+          before { DRbClient.stub!(:run).and_raise(DRbClientError.new('error message.')) }
 
           it "alerts the user that execution will be performed locally" do
             @cli.execute!(@step_mother)
-            @err.string.should include("WARNING: No DRb server is running. Running features locally:")
+            @err.string.should include("WARNING: error message. Running features locally:")
           end
 
           it "reparses the configuration since the --drb flag causes the initial parsing to short circuit" do
             @configuration.should_receive(:parse!).exactly(:twice)
             @cli.execute!(@step_mother)
           end
-
-          it "proceeds with the execution locally" do
-            @configuration.should_receive(:load_language)
-            @cli.execute!(@step_mother)
-          end
         end
-
       end
-
     end
   end
 end

data/spec/cucumber/formatter/progress_spec.rb

@@ -17,7 +17,7 @@ module Cucumber
       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', 10, nil)
+          @progress.visit_table_cell_value('value', nil)
 
           @out.string.should == "FF"
         end
@@ -25,7 +25,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', 10, :skipped_param)
+          @progress.visit_table_cell_value('value', :skipped_param)
 
           @out.string.should == ""
         end