casecumber 1.0.2.1

data/spec/cucumber/formatter/progress_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'cucumber/formatter/progress'
+
+module Cucumber
+  module Formatter
+    describe Progress do
+
+      before(:each) do
+        Term::ANSIColor.coloring = false
+        @out = StringIO.new
+        progress = Cucumber::Formatter::Progress.new(mock("step mother"), @out, {})
+        @visitor = Cucumber::Ast::TreeWalker.new(nil, [progress])
+      end
+ 
+      describe "visiting a table cell value without a status" do
+        it "should take the status from the last run step" do
+          @visitor.visit_step_result('', '', nil, :failed, nil, 10, nil)
+          outline_table = mock()
+          outline_table.should_receive(:accept) do |visitor|
+            visitor.visit_table_cell_value('value', nil)
+          end
+          @visitor.visit_outline_table(outline_table)
+
+          @out.string.should == "FF"
+        end
+      end
+
+      describe "visiting a table cell which is a table header" do
+        it "should not output anything" do
+          @visitor.visit_table_cell_value('value', :skipped_param)
+
+          @out.string.should == ""
+        end
+      end
+
+    end
+  end
+end

data/spec/cucumber/formatter/spec_helper.rb

@@ -0,0 +1,52 @@
+module Cucumber
+  module Formatter
+
+    module SpecHelperDsl
+      attr_reader :feature_content, :step_defs, :feature_filename
+    
+      def define_feature(string, feature_file = 'spec.feature')
+        @feature_content = string
+        @feature_filename = feature_file
+      end
+    
+      def define_steps(&block)
+        @step_defs = block
+      end
+    end
+
+    module SpecHelper
+      def run_defined_feature
+        define_steps
+        features = load_features(self.class.feature_content || raise("No feature content defined!"))
+        run(features)
+      end
+      
+      def step_mother
+        @step_mother ||= Runtime.new
+      end
+      
+      def load_features(content)
+        feature_file = FeatureFile.new(self.class.feature_filename, content)
+        features = Ast::Features.new
+        filters = []
+        feature = feature_file.parse(filters, {})
+        features.add_feature(feature) if feature
+        features
+      end
+    
+      def run(features)
+        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
+        dsl.extend RbSupport::RbDsl
+        dsl.instance_exec &step_defs
+      end 
+    end
+  end
+end

data/spec/cucumber/rake/forked_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+require 'cucumber/rake/task'
+require 'rake'
+
+module Cucumber
+  module Rake
+
+    describe Task::ForkedCucumberRunner do
+
+      let(:libs) { ['lib'] }
+      let(:binary) { Cucumber::BINARY }
+      let(:cucumber_opts) { ['--cuke-option'] }
+      let(:feature_files) { ['./some.feature'] }
+
+      context "when running with bundler" do
+
+        let(:bundler) { true }
+
+        subject { Task::ForkedCucumberRunner.new(
+            libs, binary, cucumber_opts, bundler, feature_files) }
+
+        it "does use bundler if bundler is set to true" do
+          subject.use_bundler.should be_true
+        end
+
+        it "uses bundle exec to find cucumber and libraries" do
+          subject.cmd.should == [Cucumber::RUBY_BINARY,
+                                 '-S',
+                                 'bundle',
+                                 'exec',
+                                 'cucumber',
+                                 '--cuke-option'] + feature_files
+        end
+
+      end
+
+      context "when running without bundler" do
+
+        let(:bundler) { false }
+
+        subject { Task::ForkedCucumberRunner.new(
+            libs, binary, cucumber_opts, bundler, feature_files) }
+
+        it "does not use bundler if bundler is set to false" do
+          subject.use_bundler.should be_false
+        end
+
+        it "uses well known cucumber location and specified libraries" do
+          subject.cmd.should == [Cucumber::RUBY_BINARY,
+                                 "-I",
+                                 "\"lib\"",
+                                 "\"#{Cucumber::BINARY }\"",
+                                 "--cuke-option"] + feature_files
+        end
+
+      end
+
+
+    end
+
+  end
+end

data/spec/cucumber/rake/rcov_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require 'cucumber/rake/task'
+require 'rake'
+
+module Cucumber
+  module Rake
+
+    describe Task::RCovCucumberRunner do
+
+      let(:libs) { ['lib'] }
+      let(:binary) { Cucumber::BINARY }
+      let(:cucumber_opts) { ['--cuke-option'] }
+      let(:feature_files) { [] }
+      let(:rcov_opts) { ['--rcov-option'] }
+
+
+      context "when running with bundler" do
+
+        let(:bundler) { true }
+
+        subject { Task::RCovCucumberRunner.new(
+            libs, binary, cucumber_opts, bundler, feature_files, rcov_opts) }
+
+        it "does use bundler if bundler is set to true" do
+          subject.use_bundler.should be_true
+        end
+
+        it "uses bundle exec to find cucumber and libraries" do
+          subject.cmd.should == [Cucumber::RUBY_BINARY,
+                                 '-S',
+                                 'bundle',
+                                 'exec',
+                                 'rcov',
+                                 '--rcov-option',
+                                 "\"#{Cucumber::BINARY }\"",
+                                 '--',
+                                 '--cuke-option'] + feature_files
+        end
+
+      end
+
+      context "when running without bundler" do
+
+        let(:bundler) { false }
+
+        subject { Task::RCovCucumberRunner.new(
+            libs, binary, cucumber_opts, bundler, feature_files, rcov_opts) }
+
+        it "does not use bundler if bundler is set to false" do
+          subject.use_bundler.should be_false
+        end
+
+        it "uses well known cucumber location and specified libraries" do
+          subject.cmd.should == [Cucumber::RUBY_BINARY,
+                                 '-I',
+                                 '"lib"',
+                                 '-S',
+                                 'rcov',
+                                 '--rcov-option',
+                                 "\"#{Cucumber::BINARY }\"",
+                                 '--',
+                                 '--cuke-option'] + feature_files
+        end
+        
+      end
+
+
+    end
+
+  end
+end

data/spec/cucumber/rb_support/rb_language_spec.rb

@@ -0,0 +1,282 @@
+require 'spec_helper'
+require 'cucumber/step_mother'
+require 'cucumber/rb_support/rb_language'
+
+module Cucumber
+  module RbSupport
+    describe RbStepDefinition do
+      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(%{
+          Given /^Cloud (\\d+) yeah$/ do |arg1|
+            pending # express the regexp above with the code you wish you had
+          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(%{
+          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
+
+        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
+
+        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
+      
+        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
+
+        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