aslakhellesoy-cucumber 0.1.5 → 0.1.9

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

@@ -0,0 +1,242 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+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
+      
+      given_cucumber_yml_defined_as({'bongo' => '--require from/yml'})
+
+      cli.parse_options!(%w{--format progress --profile bongo})
+      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
+
+      given_cucumber_yml_defined_as({'default' => '--require from/yml'})
+
+      cli.parse_options!([])
+      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
+
+    it "should accept --out option" do
+      cli = CLI.new
+      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

data/spec/cucumber/core_ext/proc_spec.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Cucumber
+  module CoreExt
+    describe "proc extended with CallIn" do
+      it "should raise ArityMismatchError for too many args (expecting 0)" do
+        proc = lambda {}
+        proc.extend CallIn
+        lambda {
+          proc.call_in(Object.new, 1)
+        }.should raise_error(Cucumber::ArityMismatchError, "expected 0 block argument(s), got 1")
+      end
+
+      it "should raise ArityMismatchError for too many args (expecting 1)" do
+        proc = lambda {|a|}
+        proc.extend CallIn
+        lambda {
+          proc.call_in(Object.new, 1, 2)
+        }.should raise_error(Cucumber::ArityMismatchError, "expected 1 block argument(s), got 2")
+      end
+
+      it "should raise ArityMismatchError for too few args (expecting 1)" do
+        proc = lambda {|a|}
+        proc.extend CallIn
+        lambda {
+          proc.call_in(Object.new)
+        }.should raise_error(Cucumber::ArityMismatchError, "expected 1 block argument(s), got 0")
+      end
+
+      it "should raise ArityMismatchError for too few args (expecting 2)" do
+        proc = lambda {|a,b|}
+        proc.extend CallIn
+        lambda {
+          proc.call_in(Object.new, 1)
+        }.should raise_error(Cucumber::ArityMismatchError, "expected 2 block argument(s), got 1")
+      end
+      
+      it "should remove extraneous path info for file" do
+        proc = lambda {|a,b|}
+        proc.extend CallIn
+        proc.file_colon_line.should == "spec/cucumber/core_ext/proc_spec.rb:39"
+      end
+    end
+  end
+end

data/spec/cucumber/core_ext/string_spec.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/../../../lib/cucumber/core_ext/string'
+
+describe String, "#gzub" do
+  it "should format groups with format string" do
+    "I ate 1 egg this morning".gzub(/I (\w+) (\d+) (\w+) this (\w+)/, "<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
+    "I bob 1 bo this bobs".gzub(/I (\w+) (\d+) (\w+) this (\w+)/, "<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
+    f = "I ate 1 egg this morning".gzub(/I (\w+) (\d+) (\w+) this (\w+)/) do |m|
+      "<span>#{m}</span>"
+    end
+    f.should == "I <span>ate</span> <span>1</span> <span>egg</span> this <span>morning</span>"
+  end
+  
+  it "should format groups with block with not all placeholders having a value" do
+    f = "another member named Bob joins the group".gzub(/(a|another) (user|member) named ([^ ]+)( who is not logged in)?/) do |m|
+      "<span>#{m}</span>"
+    end
+    f.should == "<span>another</span> <span>member</span> named <span>Bob</span> joins the group"
+  end
+
+  it "should format match groups in a textile table row" do
+    f = "I ate 1 egg this morning".gzub(/I (\w+) (\d+) (\w+) this (\w+)/) do |m|
+      "<span>#{m}</span>"
+    end
+    f.should == "I <span>ate</span> <span>1</span> <span>egg</span> this <span>morning</span>"
+  end
+end

data/spec/cucumber/executor_spec.rb

@@ -0,0 +1,222 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'stringio'
+
+module Cucumber
+  describe Executor do
+    before do # TODO: Way more setup and duplication of lib code. Use lib code!
+      @io = StringIO.new
+      @step_mother = StepMother.new
+      @executor = Executor.new(@step_mother)
+      @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
+      @feature = @parser.parse_feature(@feature_file)
+      @features << @feature
+    end
+    
+    it "should pass when blocks are ok" do
+      @step_mother.register_step_proc(/there are (\d*) cucumbers/)     { |n| @n = n.to_i }
+      @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)
+      @formatters.dump
+
+      @io.string.should =~ (/\.+\n+/)
+    end
+
+    it "should print filtered backtrace with feature line" do
+      @step_mother.register_step_proc(/there are (\d*) cucumbers/)     { |n| @n = n }
+      @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 include(%{Failed:
+
+1)
+dang
+#{__FILE__}:32:in `Then /I should owe (\\d*) cucumbers/'
+#{@feature_file}:9:in `Then I should owe 7 cucumbers'
+})
+    end
+
+#     it "should allow calling of other steps from steps" do
+#       @executor.register_step_proc("call me please") { @x = 1 }
+#       @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)
+#       @formatters.each { |formatter| formatter.dump }
+#       @io.string.should == "...\n"
+#     end
+
+    describe "visiting steps" do
+      def make_regex(a,b,c)
+        exp = "#{a}.*#{b}.*#{c}"
+        Regexp.compile(exp)
+      end
+
+      it "should report multiple definitions as an error" do
+        @step_mother.register_step_proc(/there are (\d*) cucumbers/)     {|n|}
+        @step_mother.register_step_proc(/there (.*) (\d*) cucumbers/)    {|n|}
+        @step_mother.register_step_proc(/I sell (\d*) cucumbers/)        {|n|}
+        @executor.visit_features(@features)
+        @io.string.should =~ make_regex('F','_','P')
+      end
+      
+      it "should report subsequent multiple definitions as an skipped" do
+        @step_mother.register_step_proc(/there are (\d*) cucumbers/)     {|n|}
+        @step_mother.register_step_proc(/there (.*) (\d*) cucumbers/)    {|n|}
+        @step_mother.register_step_proc(/I sell (\d*) cucumbers/)        {|n|}
+        @step_mother.register_step_proc(/I sell (\d*) (.*)/)             {|n|}
+        @executor.visit_features(@features)
+        @io.string.should =~ make_regex('F','_','P')
+      end
+      
+      it "should report pending steps after failures" do
+        @step_mother.register_step_proc(/there are (\d*) cucumbers/)     {|n|}
+        @step_mother.register_step_proc(/I sell (\d*) cucumbers/)        {|n| raise "oops"}
+        @executor.visit_features(@features)
+        @io.string.should =~ make_regex('\.','F','P')
+      end
+      
+      it "should skip passing steps after failures" do
+        @step_mother.register_step_proc(/there are (\d*) cucumbers/)     {|n|}
+        @step_mother.register_step_proc(/I sell (\d*) cucumbers/)        {|n| raise "oops"}
+        @step_mother.register_step_proc(/I should owe (\d*) cucumbers/)  {|n|}
+        @executor.visit_features(@features)
+        @io.string.should =~ make_regex('\.','F','_')
+      end
+      
+      it "should skip failing steps after failures" do
+        @step_mother.register_step_proc(/there are (\d*) cucumbers/)     {|n|}
+        @step_mother.register_step_proc(/I sell (\d*) cucumbers/)        {|n| raise "oops"}
+        @step_mother.register_step_proc(/I should owe (\d*) cucumbers/)  {|n| raise "oops again"}
+        @executor.visit_features(@features)
+        @io.string.should =~ make_regex('\.','F','_')
+      end
+      
+
+      it "should report pending steps after pending" do
+        @step_mother.register_step_proc(/I sell (\d*) cucumbers/)        {|n|}
+        @executor.visit_features(@features)
+        @io.string.should =~ make_regex('P','_','P')
+      end
+      
+      it "should skip passing steps after pending" do
+        @step_mother.register_step_proc(/I sell (\d*) cucumbers/)        {|n|}
+        @step_mother.register_step_proc(/I should owe (\d*) cucumbers/)  {|n|}
+        @executor.visit_features(@features)
+        @io.string.should =~ make_regex('P','_','_')
+      end
+      
+      it "should skip failing steps after pending" do
+        @step_mother.register_step_proc(/I sell (\d*) cucumbers/)        {|n| raise "oops"}
+        @step_mother.register_step_proc(/I should owe (\d*) cucumbers/)  {|n| raise "oops again"}
+        @executor.visit_features(@features)
+        @io.string.should =~ make_regex('P','_','_')
+      end
+      
+      it "should report an ArityMismatchError" do
+        @step_mother.register_step_proc(/there are (\d*) cucumbers/) {}
+        @executor.visit_features(@features)
+        @io.string.should =~ /expected 0 block argument\(s\), got 1/m
+      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