cucumber 0.1.8 → 0.1.9

data/lib/cucumber/version.rb

@@ -2,7 +2,7 @@ module Cucumber #:nodoc:
   class VERSION #:nodoc:
     MAJOR = 0
     MINOR = 1
-    TINY  = 8
+    TINY  = 9
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/rails_generators/cucumber/USAGE

@@ -0,0 +1,11 @@
+Description:
+    Sets up Cucumber in your Rails project. After running this generator you will
+    get a new rake task called features.
+    
+    This also generates the necessary files in the features directory.
+    
+    Also see the feature generator, which you can use to generate skeletons
+    for new features.
+    
+Examples:
+    `./script/generate cucumber`

data/rails_generators/cucumber/cucumber_generator.rb

@@ -6,15 +6,18 @@ class CucumberGenerator < Rails::Generator::Base
                               Config::CONFIG['ruby_install_name'])
   def manifest
     record do |m|
-      script_options     = { :chmod => 0755, :shebang => options[:shebang] == DEFAULT_SHEBANG ? nil : options[:shebang] }
+      m.directory 'features/step_definitions'
+      m.file      'webrat_steps.rb', 'features/step_definitions/webrat_steps.rb'
 
-      m.directory 'features/steps'
-      m.file      'env.rb', 'features/steps/env.rb'
-      m.file      'common_webrat.rb', 'features/steps/common_webrat.rb'
+      m.directory 'features/support'
+      m.file      'env.rb',           'features/support/env.rb'
 
       m.directory 'lib/tasks'
-      m.file      'cucumber.rake', 'lib/tasks/cucumber.rake'
-      m.file      'cucumber',      'script/cucumber',        script_options
+      m.file      'cucumber.rake',    'lib/tasks/cucumber.rake'
+
+      m.file      'cucumber',         'script/cucumber', {
+        :chmod => 0755, :shebang => options[:shebang] == DEFAULT_SHEBANG ? nil : options[:shebang]
+      }
     end
   end
 

data/rails_generators/cucumber/templates/cucumber

@@ -1,2 +1,7 @@
 #!/usr/bin/env ruby
-load File.expand_path(File.dirname(__FILE__) + "/../vendor/plugins/cucumber/bin/cucumber")
+begin
+  load File.expand_path(File.dirname(__FILE__) + "/../vendor/plugins/cucumber/bin/cucumber")
+rescue LoadError
+  require "rubygems"
+  load File.join(Gem.bindir, "cucumber")
+end

data/rails_generators/cucumber/templates/{common_webrat.rb → webrat_steps.rb}

@@ -40,3 +40,7 @@ end
 Then /^I should not see "(.*)"$/ do |text|
   response.body.should_not =~ /#{text}/m
 end
+
+Then /^the "(.*)" checkbox should be checked$/ do |label|
+  field_labeled(label).should be_checked
+end

data/rails_generators/feature/USAGE

@@ -0,0 +1,12 @@
+Description:
+    Generates a skeleton for a new feature. Both a simple .feature file and
+    a steps.rb file is generated. This generator should be used with moderation.
+    See http://github.com/aslakhellesoy/cucumber/wikis/feature-coupled-steps-antipattern
+    for details about the dangers involved.
+
+    This generator can take an optional list of attribute pairs similar to Rails'
+    built-in resource generator.
+
+Examples:
+    `./script/generate feature post` # no attributes
+    `./script/generate feature post title:string body:text published:boolean`

data/rails_generators/feature/feature_generator.rb

@@ -2,16 +2,15 @@
 class FeatureGenerator < Rails::Generator::NamedBase
   def manifest
     record do |m|
-      m.directory 'features/steps'
+      m.directory 'features/step_definitions'
       m.template  'feature.erb', "features/manage_#{plural_name}.feature"
-      m.template  'steps.erb', "features/steps/#{singular_name}_steps.rb"
+      m.template  'steps.erb', "features/step_definitions/#{singular_name}_steps.rb"
     end
   end
 
 protected
 
   def banner
-    "Usage: #{$0} cucumber"
+    "Usage: #{$0} feature ModelName [field:type, field:type]"
   end
-
 end

data/spec/cucumber/broadcaster_spec.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+module Cucumber
+  describe Broadcaster do
+    
+    it "should broadcast methods to registered objects" do
+      broadcaster = Broadcaster.new
+      mock_receiver = mock('receiver')
+      
+      mock_receiver.should_receive(:konbanwa).with('good evening')
+      broadcaster.register(mock_receiver)
+      
+      broadcaster.konbanwa('good evening')
+    end
+
+    it "should not call methods on registered objects if they dont support the method" do
+      broadcaster = Broadcaster.new
+      mock_receiver = mock('receiver', :respond_to? => false)
+
+      mock_receiver.should_not_receive(:konbanwa)
+      broadcaster.register(mock_receiver)
+      
+      broadcaster.konbanwa()
+    end
+    
+  end
+end

data/spec/cucumber/cli_spec.rb

@@ -3,44 +3,101 @@ require 'yaml'
 
 module Cucumber
   describe CLI do
+    
+    def mock_executor(stubs = {})
+      stub('executor', {:visit_features => nil, :failed => false, :formatters= => nil}.merge(stubs))
+    end
+    
+    def mock_broadcaster(stubs = {})
+      stub(Broadcaster, {:register => nil}.merge(stubs))
+    end
+    
+    before(:each) do
+      Kernel.stub!(:exit)
+    end
+    
+    def given_cucumber_yml_defined_as(hash)
+      File.stub!(:exist?).and_return(true)
+      cucumber_yml = hash.to_yaml
+      IO.stub!(:read).with('cucumber.yml').and_return(cucumber_yml)
+    end
+    
     it "should expand args from YAML file" do
       cli = CLI.new
-
-      cucumber_yml = {'bongo' => '--require from/yml'}.to_yaml
-      IO.should_receive(:read).with('cucumber.yml').and_return(cucumber_yml)
+      
+      given_cucumber_yml_defined_as({'bongo' => '--require from/yml'})
 
       cli.parse_options!(%w{--format progress --profile bongo})
-      cli.options.should == {
-        :format => 'progress',
-        :require => ['from/yml'], 
-        :dry_run => false, 
-        :lang => 'en',
-        :source => true,
-        :out => STDOUT
-      }
+      cli.options[:formats].should == {'progress' => [STDOUT]}
+      cli.options[:require].should == ['from/yml']
     end
 
     it "should expand args from YAML file's default if there are no args" do
       cli = CLI.new
 
-      cucumber_yml = {'default' => '--require from/yml'}.to_yaml
-      IO.should_receive(:read).with('cucumber.yml').and_return(cucumber_yml)
+      given_cucumber_yml_defined_as({'default' => '--require from/yml'})
 
       cli.parse_options!([])
-      cli.options.should == {
-        :format => 'pretty',
-        :require => ['from/yml'], 
-        :dry_run => false, 
-        :lang => 'en',
-        :source => true,
-        :out => STDOUT
-      }
+      cli.options[:require].should == ['from/yml']
+    end
+    
+    it "should provide a helpful error message when a specified profile does not exists in YAML file" do
+      cli = CLI.new(StringIO.new, error = StringIO.new)
+      
+      given_cucumber_yml_defined_as({'default' => '--require from/yml', 'html_report' =>  '--format html'})
+    
+      cli.parse_options!(%w{--profile i_do_not_exist})
+      
+      expected_message = <<-END_OF_MESSAGE
+Could not find profile: 'i_do_not_exist'
+
+Defined profiles in cucumber.yml:
+  * default
+  * html_report
+      END_OF_MESSAGE
+        
+      error.string.should == expected_message
+    end
+    
+    it "should provide a helpful error message when a specified profile is not a String" do
+      cli = CLI.new(StringIO.new, error = StringIO.new)
+
+      given_cucumber_yml_defined_as({'foo' => [1,2,3]})
+
+      cli.parse_options!(%w{--profile foo})
+
+      error.string.should == "Profiles must be defined as a String.  The 'foo' profile was [1, 2, 3] (Array).\n"
     end
     
+    it "should provide a helpful error message when no YAML file exists and a profile is specified" do
+      cli = CLI.new(StringIO.new, error = StringIO.new)
+      
+      File.should_receive(:exist?).with('cucumber.yml').and_return(false)
+    
+      cli.parse_options!(%w{--profile i_do_not_exist})
+        
+      error.string.should match(/cucumber.yml was not found.  Please define your 'i_do_not_exist' and other profiles in cucumber.yml./)
+    end
+
     it "should accept --no-source option" do
       cli = CLI.new
       cli.parse_options!(%w{--no-source})
+
+      cli.options[:source].should be_false
+    end
+
+    it "should accept --no-snippets option" do
+      cli = CLI.new
+      cli.parse_options!(%w{--no-snippets})
       
+      cli.options[:snippets].should be_false
+    end
+
+    it "should accept --quiet option" do
+      cli = CLI.new
+      cli.parse_options!(%w{--quiet})
+      
+      cli.options[:snippets].should be_false
       cli.options[:source].should be_false
     end
 
@@ -49,6 +106,137 @@ module Cucumber
       File.should_receive(:open).with('jalla.txt', 'w')
       cli.parse_options!(%w{--out jalla.txt})
     end
-        
+
+    it "should accept multiple --out options" do
+      cli = CLI.new
+      mock_file1 = stub(File, :open => nil)
+      mock_file2 = stub(File, :open => nil)
+      File.stub!(:open).and_return(mock_file1, mock_file2)
+
+      cli.parse_options!(%w{--format progress --out file1 --out file2})
+      cli.options[:formats].should == {'progress' => [mock_file1, mock_file2]}
+    end
+
+    it "should accept multiple --format options" do
+      cli = CLI.new
+      cli.parse_options!(%w{--format pretty --format progress})
+      cli.options[:formats].should have_key('pretty')
+      cli.options[:formats].should have_key('progress')
+    end
+
+    it "should associate --out to previous --format" do
+      cli = CLI.new
+      mock_file1 = stub(File, :open => nil)
+      mock_file2 = stub(File, :open => nil)
+      File.stub!(:open).and_return(mock_file1, mock_file2)
+
+      cli.parse_options!(%w{--format progress --out file1 --format profile --out file2})
+      cli.options[:formats].should == {'progress' => [mock_file1], 'profile' => [mock_file2]}
+    end
+
+    it "should allow a single formatter to have STDOUT and a file" do
+      cli = CLI.new
+      mock_file = stub(File, :open => nil)
+      File.stub!(:open).and_return(mock_file)
+
+      cli.parse_options!(%w{--format progress --format progress --out file})
+      cli.options[:formats].should == {'progress' => [STDOUT, mock_file]}
+    end
+
+    it "should register --out files with an output broadcaster" do
+      cli = CLI.new
+      mock_file = stub(File)
+      File.stub!(:open).and_return(mock_file)
+      mock_output_broadcaster = mock_broadcaster
+      Broadcaster.stub!(:new).and_return(mock_broadcaster, mock_output_broadcaster)
+      
+      mock_output_broadcaster.should_receive(:register).with(mock_file)
+      cli.parse_options!(%w{--out test.file})
+
+      cli.execute!(stub('step mother'), mock_executor, stub('features'))
+    end
+
+    it "should register --formatters with the formatter broadcaster" do
+      cli = CLI.new
+      mock_progress_formatter = stub(Formatters::ProgressFormatter)
+      Formatters::ProgressFormatter.stub!(:new).and_return(mock_progress_formatter)
+      mock_formatter_broadcaster = mock_broadcaster
+      Broadcaster.stub!(:new).and_return(mock_formatter_broadcaster, mock_broadcaster)
+   
+      mock_formatter_broadcaster.should_receive(:register).with(mock_progress_formatter)
+      cli.parse_options!(%w{--format progress})
+      
+      cli.execute!(stub('step mother'), mock_executor, stub('features'))
+    end
+
+    it "should setup the executor with the formatter broadcaster" do
+      cli = CLI.new
+      broadcaster = Broadcaster.new
+      Broadcaster.stub!(:new).and_return(broadcaster)
+      mock_executor = mock_executor()
+      mock_executor.should_receive(:formatters=).with(broadcaster)
+      cli.parse_options!(%w{--format progress})
+
+      cli.execute!(stub('step mother'), mock_executor, stub('features'))
+    end
+
+    it "should accept multiple --scenario options" do
+      cli = CLI.new
+      cli.parse_options!(['--scenario', "User logs in", '--scenario', "User signs up"])
+      cli.options[:scenario_names].should include("User logs in")
+      cli.options[:scenario_names].should include("User signs up")
+    end
+
+    it "should register --scenario options with the executor" do
+      cli = CLI.new
+      cli.parse_options!(['--scenario', "User logs in", '--scenario', "User signs up"])
+      executor = mock_executor
+      executor.should_receive(:scenario_names=).with(["User logs in", "User signs up"])
+      cli.execute!(stub('step mother'), executor, stub('features'))
+    end
+
+    it "should accept --color option" do
+      cli = CLI.new
+      cli.parse_options!(['--color'])
+      cli.options[:color].should == true
+      Term::ANSIColor.should_receive(:coloring=).with(true)
+      cli.execute!(stub('step mother'), mock_executor, stub('features'))
+    end
+
+    it "should accept --no-color option" do
+      cli = CLI.new
+      cli.parse_options!(['--no-color'])
+      cli.options[:color].should == false
+      Term::ANSIColor.should_receive(:coloring=).with(false)
+      cli.execute!(stub('step mother'), mock_executor, stub('features'))
+    end
+
+    it "should accept --color and --no-color and use the last one" do
+      cli = CLI.new
+      cli.parse_options!(['--color', '--no-color'])
+      cli.options[:color].should == false
+      Term::ANSIColor.should_receive(:coloring=).with(false)
+      cli.execute!(stub('step mother'), mock_executor, stub('features'))
+    end
+
+    it "should use a default color setting if no option is given" do
+      cli = CLI.new
+      cli.parse_options!(['--'])
+      cli.options[:color].should == nil
+      Term::ANSIColor.should_not_receive(:coloring=)
+      cli.execute!(stub('step mother'), mock_executor, stub('features'))
+    end
+
+    it "should search for all features in the specified directory" do
+      cli = CLI.new
+
+      cli.parse_options!(%w{feature_directory/})
+      File.stub!(:directory?).and_return(true)
+
+      Dir.should_receive(:[]).with("feature_directory/**/*.feature").any_number_of_times.and_return([])
+      
+      cli.execute!(stub('step mother'), mock_executor, stub('features', :<< => nil))
+    end
+
   end
-end
+end

data/spec/cucumber/executor_spec.rb

@@ -7,12 +7,13 @@ module Cucumber
       @io = StringIO.new
       @step_mother = StepMother.new
       @executor = Executor.new(@step_mother)
-      @formatter = Formatters::ProgressFormatter.new(@io)
-      @executor.formatter = @formatter
+      @formatters = Broadcaster.new [Formatters::ProgressFormatter.new(@io)]
+      @executor.formatters = @formatters
       @feature_file = File.dirname(__FILE__) + '/sell_cucumbers.feature'
       @parser = TreetopParser::FeatureParser.new
       @features = Tree::Features.new
-      @features << @parser.parse_feature(@feature_file)
+      @feature = @parser.parse_feature(@feature_file)
+      @features << @feature
     end
     
     it "should pass when blocks are ok" do
@@ -20,12 +21,9 @@ module Cucumber
       @step_mother.register_step_proc(/I sell (\d*) cucumbers/)        { |n| @n -= n.to_i }
       @step_mother.register_step_proc(/I should owe (\d*) cucumbers/)  { |n| @n.should == -n.to_i }
       @executor.visit_features(@features)
-      @formatter.dump
-      @io.string.should == (<<-STDOUT).strip
-\e[0m\e[1m\e[32m.\e[0m\e[0m\e[0m\e[1m\e[32m.\e[0m\e[0m\e[0m\e[1m\e[32m.\e[0m\e[0m\e[0m\e[1m\e[31m\n\e[0m\e[0m\e[1m\e[31m
-\e[0m
-STDOUT
+      @formatters.dump
 
+      @io.string.should =~ (/\.+\n+/)
     end
 
     it "should print filtered backtrace with feature line" do
@@ -33,15 +31,13 @@ STDOUT
       @step_mother.register_step_proc(/I sell (\d*) cucumbers/)        { |n| @n = n }
       @step_mother.register_step_proc(/I should owe (\d*) cucumbers/) { |n| raise "dang" }
       @executor.visit_features(@features)
-      @io.string.should == (<<-STDOUT).strip
-\e[0m\e[1m\e[32m.\e[0m\e[0m\e[0m\e[1m\e[32m.\e[0m\e[0m\e[0m\e[1m\e[31mF\e[0m\e[0m\e[0m\e[1m\e[31m
+      @io.string.should include(%{Failed:
 
 1)
 dang
-#{__FILE__}:34:in `Then /I should owe (\\d*) cucumbers/'
+#{__FILE__}:32:in `Then /I should owe (\\d*) cucumbers/'
 #{@feature_file}:9:in `Then I should owe 7 cucumbers'
-\e[0m
-STDOUT
+})
     end
 
 #     it "should allow calling of other steps from steps" do
@@ -49,7 +45,7 @@ STDOUT
 #       @executor.register_step_proc("I will call you") { @executor.register_step_proc("call me please") }
 #       @executor.register_step_proc(/I should owe (\d*) cucumbers/)  { |n| @n.should == -n.to_i }
 #       @feature.accept(@executor)
-#       @formatter.dump
+#       @formatters.each { |formatter| formatter.dump }
 #       @io.string.should == "...\n"
 #     end
 
@@ -127,6 +123,100 @@ STDOUT
       end
       
     end
+              
+    describe "visiting row scenarios" do
+      
+      def mock_row_scenario(stubs = {})
+        @row_scenario ||= stub("row scenario", {
+          :row? => true, 
+          :name => 'test', 
+          :update_table_column_widths => nil, 
+          :steps => [],
+          :pending? => true
+        }.merge(stubs))
+      end
+
+      describe "without having first run the matching regular scenario" do
+      
+        before(:each) do
+          @scenario = Tree::Scenario.new(nil, 'test', 1)
+          @executor.line=5        
+          @executor.visit_regular_scenario(@scenario)
+        end
+        
+        it "should run the regular scenario before the row scenario" do
+          @scenario.should_receive(:accept)
+
+          @executor.visit_row_scenario(mock_row_scenario(:name => 'test', :at_line? => true, :accept => nil))
+        end
+
+        it "should run the row scenario after running the regular scenario" do
+          mock_row_scenario(:at_line? => true).should_receive(:accept)
+
+          @executor.visit_row_scenario(mock_row_scenario)
+        end
+      
+      end
+
+      describe "having run matching regular scenario" do
+      
+        it "should not run the regular scenario if it has already run" do
+          scenario = Tree::Scenario.new(nil, 'test', 1)
+          @executor.visit_regular_scenario(scenario)
+
+          scenario.should_not_receive(:accept)
+
+          @executor.visit_row_scenario(mock_row_scenario(:name => 'test', :at_line? => true, :accept => nil))
+        end
+      
+      end
+    end
+    
+    describe "caching visited scenarios" do
+
+      def mock_scenario(stubs = {})
+        @scenario ||= stub("scenario", {
+          :row? => false, 
+          :name => 'test', 
+          :accept => nil, 
+          :steps => [],
+          :pending? => true
+        }.merge(stubs))
+      end
+      
+      it "should reset cache after each feature visit" do
+        Tree::Scenario.stub!(:new).and_return(mock_scenario)
+
+        feature = Tree::Feature.new(nil)
+        feature.add_scenario(nil, nil)
+            
+        @executor.visit_feature(feature)
+        
+        @executor.instance_variable_get("@regular_scenario_cache").should == {}
+        @executor.instance_variable_get("@executed_scenarios").should == {}
+      end
+                  
+    end
+    
+    describe "with specified scenarios" do
+      it "should only visit the specified scenarios" do
+        $amounts_sold = []
 
+        @step_mother.register_step_proc(/there are (\d*) cucumbers/) { |n| }
+        @step_mother.register_step_proc(/I should owe (\d*) cucumbers/) { |n| }
+        @step_mother.register_step_proc(/I sell (\d*) cucumbers/) { |n| $amounts_sold << n.to_i }
+
+        @executor.scenario_names = ["Sell a dozen", "Sell fifty"]
+        @executor.visit_features(@features)
+
+        $amounts_sold.should == [12, 50]
+      end
+      
+      it "should only visit features with specified scenarios" do
+        @executor.scenario_names = ["Jump up and down"]
+        @feature.should_not_receive(:accept).with(@executor)
+        @executor.visit_features(@features)
+      end
+    end
   end
 end