cucumber 0.8.5 → 0.8.6

data/spec/cucumber/cli/drb_client_spec.rb

@@ -1,5 +1,4 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
+require 'spec_helper'
 
 module Cucumber
   module Cli
@@ -30,7 +29,7 @@ module Cucumber
 
       it "returns raises an error when it can't connect to the server" do
         DRbObject.stub!(:new_with_uri).and_raise(DRb::DRbConnError)
-        running { DRbClient.run(@args, @error_stream, @out_stream) }.should raise_error(DRbClientError, "No DRb server is running.")
+        lambda { DRbClient.run(@args, @error_stream, @out_stream) }.should raise_error(DRbClientError, "No DRb server is running.")
       end
 
       it "returns the result from the DRb server call" do

data/spec/cucumber/cli/main_spec.rb

@@ -1,5 +1,7 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'spec_helper'
 require 'yaml'
+require 'cucumber/parser/gherkin_builder'
+require 'gherkin/formatter/model'
 
 module Cucumber
   module Cli
@@ -11,11 +13,41 @@ module Cucumber
         File.stub!(:exist?).and_return(false) # When Configuration checks for cucumber.yml
         Dir.stub!(:[]).and_return([]) # to prevent cucumber's features dir to being laoded
       end
+      
+      let(:args)       { [] }
+      let(:out_stream) { nil }
+      let(:err_stream) { nil }
+      subject { Main.new(args, out_stream, err_stream)}
+      
+      describe "#execute!" do
+        context "passed an existing runtime" do
+          let(:existing_runtime) { double('runtime').as_null_object }
+          
+          def do_execute
+            subject.execute!(existing_runtime)
+          end
+          
+          it "configures that runtime" do
+            expected_configuration = double('Configuration', :drb? => false).as_null_object
+            Configuration.stub!(:new => expected_configuration)
+            existing_runtime.should_receive(:configure).with(expected_configuration)
+            do_execute
+          end
+          
+          it "uses that runtime for running and reporting results" do
+            expected_results = double('results', :failure? => true)
+            existing_runtime.should_receive(:run!)
+            existing_runtime.stub!(:results).and_return(expected_results)
+            do_execute.should == expected_results.failure?
+          end
+        end
+      end
 
       describe "verbose mode" do
 
         before(:each) do
-          @empty_feature = Cucumber::Ast::Feature.new(nil, Cucumber::Ast::Comment.new(''), Cucumber::Ast::Tags.new(2, []), "Feature", "Foo", [])
+          b = Cucumber::Parser::GherkinBuilder.new
+          @empty_feature = b.feature(Gherkin::Formatter::Model::Feature.new([], [], "Feature", "Foo", "", 99))
         end
 
         it "should show feature files parsed" do
@@ -24,7 +56,7 @@ module Cucumber
 
           Cucumber::FeatureFile.stub!(:new).and_return(mock("feature file", :parse => @empty_feature))
 
-          @cli.execute!(Cucumber::StepMother.new)
+          @cli.execute!
 
           @out.string.should include('example.feature')
         end
@@ -32,9 +64,7 @@ module Cucumber
       end
 
       describe "--format with class" do
-
-       describe "in module" do
-
+        describe "in module" do
           it "should resolve each module until it gets Formatter class" do
             cli = Main.new(%w{--format ZooModule::MonkeyFormatterClass}, nil)
             mock_module = mock('module')
@@ -46,42 +76,11 @@ module Cucumber
             Object.should_receive(:const_get).with('ZooModule').and_return(mock_module)
             mock_module.should_receive(:const_get).with('MonkeyFormatterClass').and_return(mock('formatter class', :new => f))
 
-            cli.execute!(Cucumber::StepMother.new)
+            cli.execute!
           end
-
         end
       end
 
-      describe "setup step sequence" do
-        
-        it "should load files and execute hooks in order" do
-          Configuration.stub!(:new).and_return(configuration = mock('configuration').as_null_object)
-          step_mother = mock('step mother').as_null_object
-          configuration.stub!(:drb?).and_return false
-          cli = Main.new(%w{--verbose example.feature}, @out)
-          cli.stub!(:require)
-          
-          configuration.stub!(:support_to_load).and_return(['support'])
-          configuration.stub!(:step_defs_to_load).and_return(['step defs'])
-          
-          # Support must be loaded first to ensure post configuration hook can
-          # run before anything else.
-          step_mother.should_receive(:load_code_files).with(['support']).ordered
-          # The post configuration hook/s (if any) need to be run next to enable
-          # extensions to do their thing before features are loaded
-          step_mother.should_receive(:after_configuration).with(configuration).ordered
-          # Feature files must be loaded before step definitions are required.
-          # This is because i18n step methods are only aliased when
-          # features are loaded. If we swap the order, the requires
-          # will fail.
-          step_mother.should_receive(:load_plain_text_features).ordered
-          step_mother.should_receive(:load_code_files).with(['step defs']).ordered
-
-          cli.execute!(step_mother)
-        end
-        
-      end
-      
       [ProfilesNotDefinedError, YmlLoadError, ProfileNotFound].each do |exception_klass|
 
         it "rescues #{exception_klass}, prints the message to the error stream and returns true" do
@@ -89,7 +88,7 @@ module Cucumber
           configuration.stub!(:parse!).and_raise(exception_klass.new("error message"))
 
           main = Main.new('', out = StringIO.new, error = StringIO.new)
-          main.execute!(Cucumber::StepMother.new).should be_true
+          main.execute!.should be_true
           error.string.should == "error message\n"
         end
       end
@@ -103,30 +102,31 @@ module Cucumber
 
           @cli = Main.new(@args, @out, @err)
           @step_mother = mock('StepMother').as_null_object
+          StepMother.stub!(:new).and_return(@step_mother)
         end
 
         it "delegates the execution to the DRB client passing the args and streams" do
           @configuration.stub :drb_port => 1450
           DRbClient.should_receive(:run).with(@args, @err, @out, 1450).and_return(true)
-          @cli.execute!(@step_mother)
+          @cli.execute!
         end
 
         it "returns the result from the DRbClient" do
           DRbClient.stub!(:run).and_return('foo')
-          @cli.execute!(@step_mother).should == 'foo'
+          @cli.execute!.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(:build_formatter_broadcaster)
-          @cli.execute!(@step_mother)
+          @cli.execute!
         end
 
         context "when the DrbClient is unable to perfrom the execution" do
           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)
+            @cli.execute!
             @err.string.should include("WARNING: error message. Running features locally:")
           end
 

data/spec/cucumber/cli/options_spec.rb

@@ -1,5 +1,6 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'spec_helper'
 require 'yaml'
+require 'cucumber/cli/options'
 
 module Cucumber
 module Cli
@@ -111,6 +112,13 @@ module Cli
         end
       end
 
+      context '-l LINES or --lines LINES' do
+        it "adds line numbers to args" do
+          options.parse!(%w{-l24 FILE})
+          options.instance_variable_get(:@args).should == ['FILE:24']
+        end
+      end
+
       context '-p PROFILE or --profile PROFILE' do
 
         it "notifies the user that an individual profile is being used" do
@@ -324,6 +332,25 @@ module Cli
 
     end
 
+    describe "dry-run" do 
+      it "should have the default value for snippets" do
+        given_cucumber_yml_defined_as({'foo' => %w[--dry-run]})
+        options.parse!(%w{--dry-run})
+        options[:snippets].should == true
+      end
+
+      it "should set snippets to false when no-snippets provided after dry-run" do 
+        given_cucumber_yml_defined_as({'foo' => %w[--dry-run --no-snippets]})
+        options.parse!(%w{--dry-run --no-snippets})
+        options[:snippets].should == false
+      end
+
+      it "should set snippets to false when no-snippets provided before dry-run" do 
+        given_cucumber_yml_defined_as({'foo' => %w[--no-snippet --dry-run]})
+        options.parse!(%w{--no-snippets --dry-run})
+        options[:snippets].should == false
+      end
+    end
   end
 
 end

data/spec/cucumber/cli/profile_loader_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'spec_helper'
 require 'yaml'
 
 module Cucumber

data/spec/cucumber/core_ext/proc_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'spec_helper'
 require 'cucumber/core_ext/proc'
 
 describe Proc do

data/spec/cucumber/formatter/ansicolor_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'spec_helper'
 require 'cucumber/formatter/ansicolor'
 
 module Cucumber

data/spec/cucumber/formatter/duration_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'spec_helper'
 require 'cucumber/formatter/duration'
 
 module Cucumber

data/spec/cucumber/formatter/html_spec.rb

@@ -1,5 +1,5 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'spec_helper'
+require 'cucumber/formatter/spec_helper'
 require 'cucumber/formatter/html'
 require 'nokogiri'
 require 'cucumber/rb_support/rb_language'
@@ -11,9 +11,7 @@ module Cucumber
       extend SpecHelperDsl
       include SpecHelper
 
-      matcher = defined?(Spec::Matchers) ? Spec::Matchers : RSpec::Matchers
-
-      matcher.define :have_css_node do |css, regexp|
+      RSpec::Matchers.define :have_css_node do |css, regexp|
         match do |doc|
           nodes = doc.css(css)
           nodes.detect{ |node| node.text =~ regexp }

data/spec/cucumber/formatter/junit_spec.rb

@@ -1,5 +1,5 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'spec_helper'
+require 'cucumber/formatter/spec_helper'
 
 require 'cucumber/formatter/junit'
 require 'nokogiri'
@@ -51,6 +51,19 @@ module Cucumber::Formatter
         
         it { @doc.to_s.should =~ /One passing scenario, one failing scenario/ }
       end
+
+      describe "with a scenario in a subdirectory" do
+        define_feature %{
+          Feature: One passing scenario, one failing scenario
+
+            Scenario: Passing
+              Given a passing scenario
+        }, File.join('features', 'some', 'path', 'spec.feature')
+
+        it 'writes the filename including the subdirectory' do
+          @formatter.written_files.keys.first.should == File.join('', 'TEST-some_path_spec.xml')
+        end
+      end
       
       describe "with a scenario outline table" do
         define_steps do
@@ -81,6 +94,7 @@ module Cucumber::Formatter
         it { @doc.to_s.should =~ /Big Mac/ }
         it { @doc.to_s.should_not =~ /Things/ }
         it { @doc.to_s.should_not =~ /Good|Evil/ }
+        it { @doc.to_s.should_not =~ /type="skipped"/}
       end
   
       describe "with a regular data table scenario" do

data/spec/cucumber/formatter/progress_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'spec_helper'
 require 'cucumber/formatter/progress'
 
 module Cucumber

data/spec/cucumber/formatter/spec_helper.rb

@@ -2,10 +2,11 @@ module Cucumber
   module Formatter
 
     module SpecHelperDsl
-      attr_reader :feature_content, :step_defs
+      attr_reader :feature_content, :step_defs, :feature_filename
     
-      def define_feature(string)
+      def define_feature(string, feature_file = 'spec.feature')
         @feature_content = string
+        @feature_filename = feature_file
       end
     
       def define_steps(&block)
@@ -21,33 +22,31 @@ module Cucumber
       end
       
       def step_mother
-        @step_mother ||= StepMother.new
+        @step_mother ||= Runtime.new
       end
       
       def load_features(content)
-        feature_file = FeatureFile.new('spec.feature', content)
+        feature_file = FeatureFile.new(self.class.feature_filename, content)
         features = Ast::Features.new
-        feature = feature_file.parse(options, {})
+        filters = []
+        feature = feature_file.parse(filters, {})
         features.add_feature(feature) if feature
         features
       end
     
       def run(features)
-        tree_walker = Cucumber::Ast::TreeWalker.new(@step_mother, [@formatter], options, STDOUT)
+        configuration = Cucumber::Configuration.default
+        tree_walker = Cucumber::Ast::TreeWalker.new(step_mother, [@formatter], configuration)
         tree_walker.visit_features(features)
       end
     
       def define_steps
         return unless step_defs = self.class.step_defs
-        rb = @step_mother.load_programming_language('rb')
-        dsl = Object.new 
+        rb = step_mother.load_programming_language('rb')
+        dsl = Object.new
         dsl.extend RbSupport::RbDsl
         dsl.instance_exec &step_defs
       end 
-
-      def options
-        @options ||= mock(Cucumber::Cli::Options, :filters => [], :[] => nil)
-      end
     end
   end
 end

data/spec/cucumber/rb_support/rb_language_spec.rb

@@ -1,69 +1,282 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
+require 'spec_helper'
 require 'cucumber/step_mother'
 require 'cucumber/rb_support/rb_language'
 
 module Cucumber
   module RbSupport
     describe RbStepDefinition do
-      before do      
-        @step_mother = Cucumber::StepMother.new
-        @rb = @step_mother.load_programming_language('rb')
+      let(:user_interface) { double('user interface') }
+      let(:rb)             { support_code.load_programming_language('rb')}
+      let(:support_code) do
+        Cucumber::Runtime::SupportCode.new(user_interface, {})
+      end
+      let(:dsl) do 
+        rb
+        Object.new.extend(RbSupport::RbDsl)
       end
 
       def unindented(s)
         s.split("\n")[1..-2].join("\n").indent(-10)
       end
+      
+      describe "snippets" do
     
-      it "should recognise numbers in name and make according regexp" do
-        @rb.snippet_text('Given', 'Cloud 9 yeah', nil).should == unindented(%{
+        it "should recognise numbers in name and make according regexp" do
+          rb.snippet_text('Given', 'Cloud 9 yeah', nil).should == unindented(%{
           Given /^Cloud (\\d+) yeah$/ do |arg1|
             pending # express the regexp above with the code you wish you had
           end
-        })
-      end
+          })
+        end
 
-      it "should recognise a mix of ints, strings and why not a table too" do
-        @rb.snippet_text('Given', 'I have 9 "awesome" cukes in 37 "boxes"', Cucumber::Ast::Table).should == unindented(%{
+        it "should recognise a mix of ints, strings and why not a table too" do
+          rb.snippet_text('Given', 'I have 9 "awesome" cukes in 37 "boxes"', Cucumber::Ast::Table).should == unindented(%{
           Given /^I have (\\d+) "([^"]*)" cukes in (\\d+) "([^"]*)"$/ do |arg1, arg2, arg3, arg4, table|
             # table is a Cucumber::Ast::Table
             pending # express the regexp above with the code you wish you had
           end
-        })
-      end
+          })
+        end
 
-      it "should recognise quotes in name and make according regexp" do
-        @rb.snippet_text('Given', 'A "first" arg', nil).should == unindented(%{
+        it "should recognise quotes in name and make according regexp" do
+          rb.snippet_text('Given', 'A "first" arg', nil).should == unindented(%{
           Given /^A "([^"]*)" arg$/ do |arg1|
             pending # express the regexp above with the code you wish you had
           end
-        })
-      end
+          })
+        end
 
-      it "should recognise several quoted words in name and make according regexp and args" do
-        @rb.snippet_text('Given', 'A "first" and "second" arg', nil).should == unindented(%{
+        it "should recognise several quoted words in name and make according regexp and args" do
+          rb.snippet_text('Given', 'A "first" and "second" arg', nil).should == unindented(%{
           Given /^A "([^"]*)" and "([^"]*)" arg$/ do |arg1, arg2|
             pending # express the regexp above with the code you wish you had
           end
-        })
-      end
+          })
+        end
       
-      it "should not use quote group when there are no quotes" do
-        @rb.snippet_text('Given', 'A first arg', nil).should == unindented(%{
+        it "should not use quote group when there are no quotes" do
+          rb.snippet_text('Given', 'A first arg', nil).should == unindented(%{
           Given /^A first arg$/ do
             pending # express the regexp above with the code you wish you had
           end
-        })
-      end
+          })
+        end
 
-      it "should be helpful with tables" do
-        @rb.snippet_text('Given', 'A "first" arg', Cucumber::Ast::Table).should == unindented(%{
+        it "should be helpful with tables" do
+          rb.snippet_text('Given', 'A "first" arg', Cucumber::Ast::Table).should == unindented(%{
           Given /^A "([^"]*)" arg$/ do |arg1, table|
             # table is a Cucumber::Ast::Table
             pending # express the regexp above with the code you wish you had
           end
-        })
+          })
+        end
+      
+      end
+    
+      describe "#load_code_file" do
+        after do
+          FileUtils.rm_rf('tmp.rb')
+        end
+        
+        def a_file_called(name)
+          File.open('tmp.rb', 'w') do |f|
+            f.puts yield
+          end
+        end
+        
+        it "re-loads the file when called multiple times" do
+          a_file_called('tmp.rb') do
+            "$foo = 1"
+          end
+          
+          rb.load_code_file('tmp.rb')
+          $foo.should == 1
+          
+          a_file_called('tmp.rb') do
+            "$foo = 2"
+          end
+          
+          rb.load_code_file('tmp.rb')
+          $foo.should == 2
+        end
+      end
+
+      describe "Handling the World" do
+
+        it "should raise an error if the world is nil" do
+          dsl.World {}
+
+          begin
+            rb.before(nil)
+            raise "Should fail"
+          rescue RbSupport::NilWorld => e
+            e.message.should == "World procs should never return nil"
+            e.backtrace.length.should == 1
+            e.backtrace[0].should =~ /spec\/cucumber\/rb_support\/rb_language_spec\.rb\:\d+\:in `World'/
+          end
+        end
+
+        module ModuleOne
+        end
+
+        module ModuleTwo
+        end
+
+        class ClassOne
+        end
+
+        it "should implicitly extend world with modules" do
+          dsl.World(ModuleOne, ModuleTwo)
+          rb.before(mock('scenario').as_null_object)
+          class << rb.current_world
+            included_modules.inspect.should =~ /ModuleOne/ # Workaround for RSpec/Ruby 1.9 issue with namespaces
+            included_modules.inspect.should =~ /ModuleTwo/
+          end
+          rb.current_world.class.should == Object
+        end
+
+        it "should raise error when we try to register more than one World proc" do
+          expected_error = %{You can only pass a proc to #World once, but it's happening
+in 2 places:
+
+spec/cucumber/rb_support/rb_language_spec.rb:\\d+:in `World'
+spec/cucumber/rb_support/rb_language_spec.rb:\\d+:in `World'
+
+Use Ruby modules instead to extend your worlds. See the Cucumber::RbSupport::RbDsl#World RDoc
+or http://wiki.github.com/cucumber/cucumber/a-whole-new-world.
+
+}
+          dsl.World { Hash.new }
+          lambda do
+            dsl.World { Array.new }
+          end.should raise_error(RbSupport::MultipleWorld, /#{expected_error}/)
+
+        end
+      end
+
+      describe "step argument transformations" do
+
+        describe "without capture groups" do
+          it "complains when registering with a with no transform block" do
+            lambda do
+              dsl.Transform('^abc$')
+            end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
+          end
+
+          it "complains when registering with a zero-arg transform block" do
+            lambda do
+              dsl.Transform('^abc$') {42}
+            end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
+          end
+
+          it "complains when registering with a splat-arg transform block" do
+            lambda do
+              dsl.Transform('^abc$') {|*splat| 42 }
+            end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
+          end
+
+          it "complains when transforming with an arity mismatch" do
+            lambda do
+              dsl.Transform('^abc$') {|one, two| 42 }
+              rb.execute_transforms(['abc'])
+            end.should raise_error(Cucumber::ArityMismatchError)
+          end
+
+          it "allows registering a regexp pattern that yields the step_arg matched" do
+            dsl.Transform(/^ab*c$/) {|arg| 42}
+            rb.execute_transforms(['ab']).should == ['ab']
+            rb.execute_transforms(['ac']).should == [42]
+            rb.execute_transforms(['abc']).should == [42]
+            rb.execute_transforms(['abbc']).should == [42]
+          end
+        end
+
+        describe "with capture groups" do
+          it "complains when registering with a with no transform block" do
+            lambda do
+              dsl.Transform('^a(.)c$')
+            end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
+          end
+
+          it "complains when registering with a zero-arg transform block" do
+            lambda do
+              dsl.Transform('^a(.)c$') { 42 }
+            end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
+          end
+
+          it "complains when registering with a splat-arg transform block" do
+            lambda do
+              dsl.Transform('^a(.)c$') {|*splat| 42 }
+            end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
+          end
+
+          it "complains when transforming with an arity mismatch" do
+            lambda do
+              dsl.Transform('^a(.)c$') {|one, two| 42 }
+              rb.execute_transforms(['abc'])
+            end.should raise_error(Cucumber::ArityMismatchError)
+          end
+
+          it "allows registering a regexp pattern that yields capture groups" do
+            dsl.Transform(/^shape: (.+), color: (.+)$/) do |shape, color|
+              {shape.to_sym => color.to_sym}
+            end
+            rb.execute_transforms(['shape: circle, color: blue']).should == [{:circle => :blue}]
+            rb.execute_transforms(['shape: square, color: red']).should == [{:square => :red}]
+            rb.execute_transforms(['not shape: square, not color: red']).should == ['not shape: square, not color: red']
+          end
+        end
+
+        it "allows registering a string pattern" do
+          dsl.Transform('^ab*c$') {|arg| 42}
+          rb.execute_transforms(['ab']).should == ['ab']
+          rb.execute_transforms(['ac']).should == [42]
+          rb.execute_transforms(['abc']).should == [42]
+          rb.execute_transforms(['abbc']).should == [42]
+        end
+
+        it "gives match priority to transforms defined last" do
+          dsl.Transform(/^transform_me$/) {|arg| :foo }
+          dsl.Transform(/^transform_me$/) {|arg| :bar }
+          dsl.Transform(/^transform_me$/) {|arg| :baz }
+          rb.execute_transforms(['transform_me']).should == [:baz]
+        end
+
+        it "allows registering a transform which returns nil" do
+          dsl.Transform('^ac$') {|arg| nil}
+          rb.execute_transforms(['ab']).should == ['ab']
+          rb.execute_transforms(['ac']).should == [nil]
+        end
+      end
+
+      describe "hooks" do
+
+        it "should find before hooks" do
+          fish = dsl.Before('@fish'){}
+          meat = dsl.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)
+
+          rb.hooks_for(:before, scenario).should == [fish]
+        end
+
+        it "should find around hooks" do
+          a = dsl.Around do |scenario, block|
+          end
+
+          b = dsl.Around('@tag') do |scenario, block|
+          end
+
+          scenario = mock('Scenario')
+          scenario.should_receive(:accept_hook?).with(a).and_return(true)
+          scenario.should_receive(:accept_hook?).with(b).and_return(false)
+
+          rb.hooks_for(:around, scenario).should == [a]
+        end
       end
+
     end
   end
 end