square-cucumber 0.3.12.2

data/spec/cucumber/ast/step_collection_spec.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Cucumber
+  module Ast
+    describe StepCollection do
+      it "should convert And to Given in snippets" do
+        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
+    end
+  end
+end

data/spec/cucumber/ast/step_spec.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'cucumber/step_mother'
+require 'cucumber/ast'
+require 'cucumber/core_ext/string'
+
+module Cucumber
+  module Ast
+    describe Step do
+      it "should replace arguments in name" do
+        step = Step.new(1, 'Given', 'a <color> cucumber')
+
+        invocation_table = Table.new([
+          %w{color taste},
+          %w{green juicy}
+        ])
+        cells = invocation_table.cells_rows[1]
+        step_invocation = step.step_invocation_from_cells(cells)
+        
+        step_invocation.name.should == 'a green cucumber'
+      end
+
+      it "should use empty string for the replacement of arguments in name when replace value is nil" do
+        step = Step.new(1, 'Given', 'a <color>cucumber')
+
+        invocation_table = Table.new([
+          ['color'],
+          [nil]
+        ])
+        cells = invocation_table.cells_rows[1]
+        step_invocation = step.step_invocation_from_cells(cells)
+        
+        step_invocation.name.should == 'a cucumber'
+      end
+
+      it "should replace arguments in table arg" do
+        arg_table = Table.new([%w{taste_<taste> color_<color>}])
+
+        step = Step.new(1, 'Given', 'a <color> cucumber', arg_table)
+
+        invocation_table = Table.new([
+          %w{color taste},
+          %w{green juicy}
+        ])
+        cells = invocation_table.cells_rows[1]
+        step_invocation = step.step_invocation_from_cells(cells)
+        
+        step_invocation.instance_variable_get('@multiline_arg').raw.should == [%w{taste_juicy color_green}]
+      end
+
+      it "should replace arguments in py string arg" do
+        py_string = PyString.new(1, 2, 'taste_<taste> color_<color>', 0)
+
+        step = Step.new(1, 'Given', 'a <color> cucumber', py_string)
+
+        invocation_table = Table.new([
+          %w{color taste},
+          %w{green juicy}
+        ])
+        cells = invocation_table.cells_rows[1]
+        step_invocation = step.step_invocation_from_cells(cells)
+        
+        step_invocation.instance_variable_get('@multiline_arg').to_s.should == 'taste_juicy color_green'
+      end
+    end
+  end
+end

data/spec/cucumber/ast/table_spec.rb

@@ -0,0 +1,186 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'cucumber/ast/table'
+
+module Cucumber
+  module Ast
+    describe Table do
+      before do
+        @table = Table.new([
+          %w{one four seven},
+          %w{4444 55555 666666}
+        ])
+        def @table.cells_rows; super; end
+        def @table.columns; super; end
+      end
+
+      it "should have rows" do
+        @table.cells_rows[0].map{|cell| cell.value}.should == %w{one four seven}
+      end
+
+      it "should have columns" do
+        @table.columns[1].map{|cell| cell.value}.should == %w{four 55555}
+      end
+
+      it "should have headers" do
+        @table.headers.should == %w{one four seven}
+      end
+
+      it "should have same cell objects in rows and columns" do
+        # 666666
+        @table.cells_rows[1].__send__(:[], 2).should equal(@table.columns[2].__send__(:[], 1))
+      end
+
+      it "should know about max width of a row" do
+        @table.columns[1].__send__(:width).should == 5
+      end
+
+      it "should be convertible to an array of hashes" do
+        @table.hashes.should == [
+          {'one' => '4444', 'four' => '55555', 'seven' => '666666'}
+        ]
+      end
+
+      it "should accept symbols as keys for the hashes" do
+        @table.hashes.first[:one].should == '4444'
+      end
+
+      it "should allow map'ing columns" do
+        @table.map_column!('one') { |v| v.to_i }
+        @table.hashes.first['one'].should == 4444
+      end
+
+      it "should pass silently if a mapped column does not exist in non-strict mode" do
+        lambda {
+          @table.map_column!('two', false) { |v| v.to_i }
+        }.should_not raise_error
+      end
+
+      it "should fail if a mapped column does not exist in strict mode" do
+        lambda {
+          @table.map_column!('two', true) { |v| v.to_i }
+        }.should raise_error('The column named "two" does not exist')
+      end
+
+      describe "#transpose" do
+        before(:each) do
+          @table = Table.new([
+            %w{one 1111},
+            %w{two 22222}
+          ])
+        end
+                
+        it "should be convertible in to an array where each row is a hash" do 
+          @table.transpose.hashes[0].should == {'one' => '1111', 'two' => '22222'}
+        end
+      end
+      
+      describe "#rows_hash" do
+                
+        it "should return a hash of the rows" do
+          table = Table.new([
+            %w{one 1111},
+            %w{two 22222}
+          ])
+          table.rows_hash.should == {'one' => '1111', 'two' => '22222'}
+        end
+        
+        it "should fail if the table doesn't have two columns" do
+          faulty_table = Table.new([
+            %w{one 1111 abc},
+            %w{two 22222 def}
+          ])
+          lambda {
+            faulty_table.rows_hash
+          }.should raise_error('The table must have exactly 2 columns')
+        end
+      end
+        
+      it "should allow renaming columns" do
+        table2 = @table.map_headers('one' => :three)
+        table2.hashes.first[:three].should == '4444'
+      end
+
+      it "should copy column mappings when mapping headers" do
+        @table.map_column!('one') { |v| v.to_i }
+        table2 = @table.map_headers('one' => 'three')
+        table2.hashes.first['three'].should == 4444
+      end
+
+      describe "replacing arguments" do
+
+        before(:each) do
+          @table = Table.new([
+            %w{qty book},
+            %w{<qty> <book>}
+          ])
+        end
+
+        it "should return a new table with arguments replaced with values" do
+          table_with_replaced_args = @table.arguments_replaced({'<book>' => 'Unbearable lightness of being', '<qty>' => '5'})
+
+          table_with_replaced_args.hashes[0]['book'].should == 'Unbearable lightness of being'
+          table_with_replaced_args.hashes[0]['qty'].should == '5'
+        end
+
+        it "should recognise when entire cell is delimited" do
+          @table.should have_text('<book>')
+        end
+
+        it "should recognise when just a subset of a cell is delimited" do
+          table = Table.new([
+            %w{qty book},
+            [nil, "This is <who>'s book"]
+          ])
+          table.should have_text('<who>')
+        end
+
+        it "should replace nil values with nil" do
+          table_with_replaced_args = @table.arguments_replaced({'<book>' => nil})
+
+          table_with_replaced_args.hashes[0]['book'].should == nil
+        end
+
+        it "should preserve values which don't match a placeholder when replacing with nil" do
+          table = Table.new([
+                              %w{book},
+                              %w{cat}
+                            ])
+          table_with_replaced_args = table.arguments_replaced({'<book>' => nil})
+          
+          table_with_replaced_args.hashes[0]['book'].should == 'cat'
+        end
+
+        it "should not change the original table" do
+          @table.arguments_replaced({'<book>' => 'Unbearable lightness of being'})
+
+          @table.hashes[0]['book'].should_not == 'Unbearable lightness of being'
+        end
+
+        it "should not raise an error when there are nil values in the table" do
+          table = Table.new([
+                              ['book', 'qty'],
+                              ['<book>', nil],
+                            ])
+          lambda{ 
+            table.arguments_replaced({'<book>' => nil, '<qty>' => '5'})
+          }.should_not raise_error
+        end
+
+      end
+      
+      it "should convert to sexp" do
+        @table.to_sexp.should == 
+          [:table, 
+            [:row, -1,
+              [:cell, "one"], 
+              [:cell, "four"],
+              [:cell, "seven"]
+            ],
+            [:row, -1,
+              [:cell, "4444"], 
+              [:cell, "55555"],
+              [:cell, "666666"]]]
+      end
+    end
+  end
+end

data/spec/cucumber/ast/visitor_spec.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'cucumber/step_mother'
+require 'cucumber/ast'
+
+module Cucumber
+  module Ast
+    describe Visitor do
+      
+      it "should support checking scenario name matches regexps" do
+        visitor = Visitor.new(mock("step mother"))
+        scenario = Scenario.new(background=nil,
+          comment=Comment.new(""),
+          tags=Tags.new(0, []), 
+          line=99,
+          keyword="",
+          name="test name", 
+          steps=[])
+
+        visitor.options = {:name_regexps => [/name/]}
+        
+        visitor.matches_scenario_names?(scenario).should be_true
+      end
+      
+    end
+  end
+end
+

data/spec/cucumber/broadcaster_spec.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+module Cucumber
+  describe Broadcaster do
+    before do
+      @receiver = mock('receiver')
+      @broadcaster = Broadcaster.new([@receiver])
+    end
+    
+    it "should broadcast methods to registered objects" do
+      @receiver.should_receive(:konbanwa).with('good evening')
+      @broadcaster.konbanwa('good evening')
+    end
+  end
+end

data/spec/cucumber/cli/configuration_spec.rb

@@ -0,0 +1,396 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'yaml'
+
+module Cucumber
+module Cli
+  describe Configuration do
+
+    def given_cucumber_yml_defined_as(hash_or_string)
+      File.stub!(:exist?).and_return(true)
+      cucumber_yml = hash_or_string.is_a?(Hash) ? hash_or_string.to_yaml : hash_or_string
+      IO.stub!(:read).with('cucumber.yml').and_return(cucumber_yml)
+    end
+
+    def given_the_following_files(*files)
+      File.stub!(:directory?).and_return(true)
+      Dir.stub!(:[]).and_return(files)
+    end
+
+    before(:each) do
+      Kernel.stub!(:exit).and_return(nil)
+    end
+
+    it "should require files in support paths first" do
+      given_the_following_files("/features/step_definitions/foo.rb","/features/support/bar.rb")
+
+      config = Configuration.new(StringIO.new)
+      config.parse!(%w{--require /features})
+
+      config.files_to_require.should == [
+        "/features/support/bar.rb",
+        "/features/step_definitions/foo.rb"
+      ]
+    end
+
+    it "should require env.rb files first" do
+      given_the_following_files("/features/support/a_file.rb","/features/support/env.rb")
+
+      config = Configuration.new(StringIO.new)
+      config.parse!(%w{--require /features})
+
+      config.files_to_require.should == [
+        "/features/support/env.rb",
+        "/features/support/a_file.rb"
+      ]
+    end
+
+    it "should not require env.rb files when --dry-run" do
+      given_the_following_files("/features/support/a_file.rb","/features/support/env.rb")
+
+      config = Configuration.new(StringIO.new)
+      config.parse!(%w{--require /features --dry-run})
+
+      config.files_to_require.should == [
+        "/features/support/a_file.rb"
+      ]
+    end
+
+    describe "--exclude" do
+
+      it "excludes a ruby file from requiring when the name matches exactly" do
+        given_the_following_files("/features/support/a_file.rb","/features/support/env.rb")
+
+        config = Configuration.new(StringIO.new)
+        config.parse!(%w{--require /features --exclude a_file.rb})
+
+        config.files_to_require.should == [
+          "/features/support/env.rb"
+        ]
+      end
+
+      it "excludes all ruby files that match the provided patterns from requiring" do
+        given_the_following_files("/features/support/foof.rb","/features/support/bar.rb",
+                                  "/features/support/food.rb","/features/blah.rb",
+                                  "/features/support/fooz.rb")
+
+        config = Configuration.new(StringIO.new)
+        config.parse!(%w{--require /features --exclude foo[df] --exclude blah})
+
+        config.files_to_require.should == [
+          "/features/support/bar.rb",
+          "/features/support/fooz.rb"
+        ]
+      end
+    end
+
+    describe '#drb?' do
+      it "indicates whether the --drb flag was passed in or not" do
+        config = Configuration.new(StringIO.new)
+
+        config.parse!(%w{features})
+        config.drb?.should == false
+
+
+        config.parse!(%w{features --drb})
+        config.drb?.should == true
+      end
+    end
+
+    context '--drb' do
+      it "removes the --drb flag from the args" do
+        config = Configuration.new(StringIO.new)
+
+        args = %w{features --drb}
+        config.parse!(args)
+        args.should == %w{features}
+      end
+
+      it "keeps all other flags intact" do
+        config = Configuration.new(StringIO.new)
+
+        args = %w{features --drb --format profile}
+        config.parse!(args)
+        args.should == %w{features --format profile}
+      end
+
+    end
+
+    context '--drb in a profile' do
+      it "removes the --drb flag from the args" do
+        given_cucumber_yml_defined_as({'server' => '--drb features'})
+        config = Configuration.new(StringIO.new)
+
+        args = %w{--profile server}
+        config.parse!(args)
+        args.should == %w{features}
+      end
+
+      it "keeps all other flags intact from all profiles involved" do
+        given_cucumber_yml_defined_as({'server' => '--drb features --profile nested',
+                                       'nested' => '--verbose'})
+
+        config = Configuration.new(StringIO.new)
+
+        args = %w{--profile server --format profile}
+        config.parse!(args)
+        args.should == %w{features --verbose --format profile}
+      end
+
+    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[:require].should == ['from/yml']
+    end
+
+    it "should expand args from YAML file's default if there are no args" do
+      given_cucumber_yml_defined_as({'default' => '--require from/yml'})
+
+      config = Configuration.new
+      config.parse!([])
+      config.options[:require].should == ['from/yml']
+    end
+
+    it "should provide a helpful error message when a specified profile does not exists in YAML file" do
+      given_cucumber_yml_defined_as({'default' => '--require from/yml', 'html_report' =>  '--format html'})
+
+      config = Configuration.new(StringIO.new, error = StringIO.new)
+      expected_message = <<-END_OF_MESSAGE
+Could not find profile: 'i_do_not_exist'
+
+Defined profiles in cucumber.yml:
+  * default
+  * html_report
+END_OF_MESSAGE
+
+      lambda{config.parse!(%w{--profile i_do_not_exist})}.should raise_error(expected_message)
+    end
+
+    it "should allow array as profile" do
+      given_cucumber_yml_defined_as({'foo' => [1,2,3]})
+
+      config = Configuration.new(StringIO.new, error = StringIO.new)
+      config.parse!(%w{--profile foo})
+      config.paths.should == [1,2,3]
+    end
+
+    it "should provide a helpful error message when a specified profile exists but is nil or blank" do
+      [nil, '   '].each do |bad_input|
+        given_cucumber_yml_defined_as({'foo' => bad_input})
+
+        config = Configuration.new(StringIO.new, error = StringIO.new)
+        expected_error = /The 'foo' profile in cucumber.yml was blank.  Please define the command line arguments for the 'foo' profile in cucumber.yml./
+        lambda{config.parse!(%w{--profile foo})}.should raise_error(expected_error)
+      end
+    end
+
+    it "should provide a helpful error message when no YAML file exists and a profile is specified" do
+      File.should_receive(:exist?).with('cucumber.yml').and_return(false)
+
+      config = Configuration.new(StringIO.new, error = StringIO.new)
+      expected_error = /cucumber.yml was not found.  Please refer to cucumber's documentation on defining profiles in cucumber.yml./
+      lambda{config.parse!(%w{--profile i_do_not_exist})}.should raise_error(expected_error)
+    end
+
+    it "should provide a helpful error message when cucumber.yml is blank or malformed" do
+        expected_error_message = /cucumber.yml was found, but was blank or malformed. Please refer to cucumber's documentation on correct profile usage./
+
+      ['', 'sfsadfs', "--- \n- an\n- array\n", "---dddfd"].each do |bad_input|
+        given_cucumber_yml_defined_as(bad_input)
+
+        config = Configuration.new(StringIO.new, error = StringIO.new)
+        lambda{config.parse!([])}.should raise_error(expected_error_message)
+      end
+    end
+
+    it "should procide a helpful error message when the YAML can not be parsed" do
+      expected_error_message = /cucumber.yml was found, but could not be parsed. Please refer to cucumber's documentation on correct profile usage./
+
+      given_cucumber_yml_defined_as("input that causes an exception in YAML loading")
+      YAML.should_receive(:load).and_raise ArgumentError
+
+      config = Configuration.new(StringIO.new, error = StringIO.new)
+      lambda{config.parse!([])}.should raise_error(expected_error_message)
+    end
+
+    it "should accept --dry-run option" do
+      config = Configuration.new(StringIO.new)
+      config.parse!(%w{--dry-run})
+      config.options[:dry_run].should be_true
+    end
+
+    it "should accept --no-source option" do
+      config = Configuration.new
+      config.parse!(%w{--no-source})
+
+      config.options[:source].should be_false
+    end
+
+    it "should accept --no-snippets option" do
+      config = Configuration.new
+      config.parse!(%w{--no-snippets})
+
+      config.options[:snippets].should be_false
+    end
+
+    it "should set snippets and source to false with --quiet option" do
+      config = Configuration.new
+      config.parse!(%w{--quiet})
+
+      config.options[:snippets].should be_nil
+      config.options[:source].should be_nil
+    end
+
+    it "should accept --verbose option" do
+      config = Configuration.new
+      config.parse!(%w{--verbose})
+
+      config.options[:verbose].should be_true
+    end
+
+    it "should accept --out option" do
+      config = Configuration.new(StringIO.new)
+      config.parse!(%w{--out 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']]
+    end
+
+    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 == [["progress", "file1"], ["profile" ,"file2"]]
+    end
+
+    it "should accept --color option" do
+      Term::ANSIColor.should_receive(:coloring=).with(true)
+      config = Configuration.new(StringIO.new)
+      config.parse!(['--color'])
+    end
+
+    it "should accept --no-color option" do
+      Term::ANSIColor.should_receive(:coloring=).with(false)
+      config = Configuration.new(StringIO.new)
+      config.parse!(['--no-color'])
+    end
+
+    it "should parse tags" do
+      config = Configuration.new(nil)
+      includes, excludes = config.parse_tags("one,~two,@three,~@four")
+      includes.should == ['one', 'three']
+      excludes.should == ['two', 'four']
+    end
+
+    describe "--backtrace" do
+      before do
+        Exception.cucumber_full_backtrace = false
+      end
+
+      it "should show full backtrace when --backtrace is present" do
+        config = Main.new(['--backtrace'])
+        begin
+          "x".should == "y"
+        rescue => e
+          e.backtrace[0].should_not == "#{__FILE__}:#{__LINE__ - 2}"
+        end
+      end
+
+      after do
+        Exception.cucumber_full_backtrace = false
+      end
+    end
+
+    describe "diff output" do
+
+      it "is enabled by default" do
+        config = Configuration.new
+        config.diff_enabled?.should be_true
+      end
+
+      it "is disabled when the --no-diff option is supplied" do
+        config = Configuration.new
+        config.parse!(%w{--no-diff})
+
+        config.diff_enabled?.should be_false
+      end
+
+    end
+
+    it "should accept multiple --name options" do
+      config = Configuration.new
+      config.parse!(['--name', "User logs in", '--name', "User signs up"])
+
+      config.options[:name_regexps].should include(/User logs in/)
+      config.options[:name_regexps].should include(/User signs up/)
+    end
+
+    it "should accept multiple -n options" do
+      config = Configuration.new
+      config.parse!(['-n', "User logs in", '-n', "User signs up"])
+
+      config.options[:name_regexps].should include(/User logs in/)
+      config.options[:name_regexps].should include(/User signs up/)
+    end
+
+    it "should search for all features in the specified directory" do
+      File.stub!(:directory?).and_return(true)
+      Dir.should_receive(:[]).with("feature_directory/**/*.feature").
+        any_number_of_times.and_return(["cucumber.feature"])
+
+      config = Configuration.new(StringIO)
+      config.parse!(%w{feature_directory/})
+
+      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