casecumber 1.0.2.1

data/spec/cucumber/rb_support/rb_step_definition_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+require 'cucumber/ast'
+require 'cucumber/step_mother'
+require 'cucumber/rb_support/rb_language'
+
+module Cucumber
+  module RbSupport
+    describe RbStepDefinition do
+      let(:user_interface) { double('user interface') }
+      let(:support_code) { Cucumber::Runtime::SupportCode.new(user_interface) }
+      let(:rb)      { support_code.load_programming_language('rb')}
+      let(:dsl) do 
+        rb
+        Object.new.extend(Cucumber::RbSupport::RbDsl)
+      end
+      
+      before do      
+        rb.before(mock('scenario').as_null_object)
+
+        $inside = nil
+      end
+      
+      it "should allow calling of other steps" do
+        dsl.Given /Outside/ do
+          Given "Inside"
+        end
+        dsl.Given /Inside/ do
+          $inside = true
+        end
+
+        support_code.step_match("Outside").invoke(nil)
+        $inside.should == true
+      end
+
+      it "should allow calling of other steps with inline arg" do
+        dsl.Given /Outside/ do
+          Given "Inside", Cucumber::Ast::Table.new([['inside']])
+        end
+        dsl.Given /Inside/ do |table|
+          $inside = table.raw[0][0]
+        end
+
+        support_code.step_match("Outside").invoke(nil)
+        $inside.should == 'inside'
+      end
+
+      it "should raise Undefined when inside step is not defined" do
+        dsl.Given /Outside/ do
+          Given 'Inside'
+        end
+
+        lambda do
+          support_code.step_match('Outside').invoke(nil)
+        end.should raise_error(Cucumber::Undefined, 'Undefined step: "Inside"')
+      end
+
+      it "should allow forced pending" do
+        dsl.Given /Outside/ do
+          pending("Do me!")
+        end
+
+        lambda do
+          support_code.step_match("Outside").invoke(nil)
+        end.should raise_error(Cucumber::Pending, "Do me!")
+      end
+
+      it "should raise ArityMismatchError when the number of capture groups differs from the number of step arguments" do
+        dsl.Given /No group: \w+/ do |arg|
+        end
+
+        lambda do
+          support_code.step_match("No group: arg").invoke(nil)
+        end.should raise_error(Cucumber::ArityMismatchError)
+      end
+
+      it "should allow puts" do
+        user_interface.should_receive(:puts).with('wasup')
+        dsl.Given /Loud/ do
+          puts 'wasup'
+        end
+        
+        support_code.step_match("Loud").invoke(nil)
+      end
+      
+      it "should recognize $arg style captures" do
+        dsl.Given "capture this: $arg" do |arg|
+          arg.should == 'this'
+        end
+
+       support_code.step_match('capture this: this').invoke(nil)
+      end
+
+      it "should have a JSON representation of the signature" do
+        RbStepDefinition.new(rb, /I CAN HAZ (\d+) CUKES/i, lambda{}).to_hash.should == {'source' => "I CAN HAZ (\\d+) CUKES", 'flags' => 'i'}
+      end
+    end
+  end
+end

data/spec/cucumber/rb_support/rb_transform_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+require 'cucumber/rb_support/rb_transform'
+
+module Cucumber
+  module RbSupport
+    describe RbTransform do
+      def transform(regexp)
+        RbTransform.new(nil, regexp, lambda { |a| })
+      end
+      describe "#to_s" do
+        it "removes the capture group parentheses" do
+          transform(/(a)bc/).to_s.should == "abc"
+        end
+        
+        it "strips away anchors" do
+          transform(/^xyz$/).to_s.should == "xyz"
+        end
+      end
+    end
+  end
+end

data/spec/cucumber/rb_support/regexp_argument_matcher_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+require 'cucumber/rb_support/regexp_argument_matcher'
+
+module Cucumber
+  module RbSupport
+    describe RegexpArgumentMatcher do
+      it "should create 2 arguments" do
+        arguments = RegexpArgumentMatcher.arguments_from(/I (\w+) (\w+)/, "I like fish")
+        arguments.map{|argument| [argument.val, argument.byte_offset]}.should == [["like", 2], ["fish", 7]]
+      end
+
+      it "should create 2 arguments when first group is optional" do
+        arguments = RegexpArgumentMatcher.arguments_from(/should( not)? be flashed '([^']*?)'$/, "I should be flashed 'Login failed.'")
+        arguments.map{|argument| [argument.val, argument.byte_offset]}.should == [[nil, nil], ["Login failed.", 21]]
+      end
+    end
+  end
+end

data/spec/cucumber/runtime/support_code_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+module Cucumber
+  describe Runtime::SupportCode do
+    let(:user_interface) { double('user interface') }
+    subject { Runtime::SupportCode.new(user_interface, options) }
+    let(:options)     { {} }
+    let(:dsl) do
+      @rb = subject.load_programming_language('rb')
+      Object.new.extend(RbSupport::RbDsl)
+    end
+
+    it "should format step names" do
+      dsl.Given(/it (.*) in (.*)/) { |what, month| }
+      dsl.Given(/nope something else/) { |what, month| }
+
+      format = subject.step_match("it snows in april").format_args("[%s]")
+      format.should == "it [snows] in [april]"
+    end
+    
+    describe "resolving step defintion matches" do
+
+      it "should raise Ambiguous error with guess hint when multiple step definitions match" do
+        expected_error = %{Ambiguous match of "Three blind mice":
+
+spec/cucumber/runtime/support_code_spec.rb:\\d+:in `/Three (.*) mice/'
+spec/cucumber/runtime/support_code_spec.rb:\\d+:in `/Three blind (.*)/'
+
+You can run again with --guess to make Cucumber be more smart about it
+}
+        dsl.Given(/Three (.*) mice/) {|disability|}
+        dsl.Given(/Three blind (.*)/) {|animal|}
+
+        lambda do
+          subject.step_match("Three blind mice")
+        end.should raise_error(Ambiguous, /#{expected_error}/)
+      end
+
+      describe "when --guess is used" do
+        let(:options) { {:guess => true} }
+
+        it "should not show --guess hint" do
+        expected_error = %{Ambiguous match of "Three cute mice":
+
+spec/cucumber/runtime/support_code_spec.rb:\\d+:in `/Three (.*) mice/'
+spec/cucumber/runtime/support_code_spec.rb:\\d+:in `/Three cute (.*)/'
+
+}
+          dsl.Given(/Three (.*) mice/) {|disability|}
+          dsl.Given(/Three cute (.*)/) {|animal|}
+
+          lambda do
+            subject.step_match("Three cute mice")
+          end.should raise_error(Ambiguous, /#{expected_error}/)
+        end
+
+        it "should not raise Ambiguous error when multiple step definitions match" do
+          dsl.Given(/Three (.*) mice/) {|disability|}
+          dsl.Given(/Three (.*)/) {|animal|}
+
+          lambda do
+            subject.step_match("Three blind mice")
+          end.should_not raise_error
+        end
+
+        it "should not raise NoMethodError when guessing from multiple step definitions with nil fields" do
+          dsl.Given(/Three (.*) mice( cannot find food)?/) {|disability, is_disastrous|}
+          dsl.Given(/Three (.*)?/) {|animal|}
+
+          lambda do
+            subject.step_match("Three blind mice")
+          end.should_not raise_error
+        end
+
+        it "should pick right step definition when an equal number of capture groups" do
+          right = dsl.Given(/Three (.*) mice/) {|disability|}
+          wrong = dsl.Given(/Three (.*)/) {|animal|}
+
+          subject.step_match("Three blind mice").step_definition.should == right
+        end
+
+        it "should pick right step definition when an unequal number of capture groups" do
+          right = dsl.Given(/Three (.*) mice ran (.*)/) {|disability|}
+          wrong = dsl.Given(/Three (.*)/) {|animal|}
+
+          subject.step_match("Three blind mice ran far").step_definition.should == right
+        end
+
+        it "should pick most specific step definition when an unequal number of capture groups" do
+          general       = dsl.Given(/Three (.*) mice ran (.*)/) {|disability|}
+          specific      = dsl.Given(/Three blind mice ran far/) do; end
+          more_specific = dsl.Given(/^Three blind mice ran far$/) do; end
+
+          subject.step_match("Three blind mice ran far").step_definition.should == more_specific
+        end
+      end
+
+      it "should raise Undefined error when no step definitions match" do
+        lambda do
+          subject.step_match("Three blind mice")
+        end.should raise_error(Undefined)
+      end
+
+      # http://railsforum.com/viewtopic.php?pid=93881
+      it "should not raise Redundant unless it's really redundant" do
+        dsl.Given(/^(.*) (.*) user named '(.*)'$/) {|a,b,c|}
+        dsl.Given(/^there is no (.*) user named '(.*)'$/) {|a,b|}
+      end
+    end
+
+  end
+end

data/spec/cucumber/runtime_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+module Cucumber
+describe Runtime do
+  subject { Runtime.new(options) }
+  let(:options)     { {} }
+  
+  describe "#features_paths" do
+    let(:options) { {:paths => ['foo/bar/baz.feature', 'foo/bar/features/baz.feature', 'other_features'] } }
+    it "returns the value from configuration.paths" do
+      subject.features_paths.should == options[:paths]
+    end
+  end
+  
+  describe "#configure" do
+    let(:support_code)      { double(Runtime::SupportCode).as_null_object }
+    let(:results)           { double(Runtime::Results).as_null_object     }
+    let(:new_configuration) { double('New configuration')}
+    before(:each) do
+      Runtime::SupportCode.stub(:new => support_code)
+      Runtime::Results.stub(:new => results)
+    end
+    
+    it "tells the support_code and results about the new configuration" do
+      support_code.should_receive(:configure).with(new_configuration)
+      results.should_receive(:configure).with(new_configuration)
+      subject.configure(new_configuration)
+    end
+    
+    it "replaces the existing configuration" do
+      # not really sure how to test this. Maybe we should just expose 
+      # Runtime#configuration with an attr_reader?
+      some_new_paths = ['foo/bar', 'baz']
+      new_configuration.stub(:paths => some_new_paths)
+      subject.configure(new_configuration)
+      subject.features_paths.should == some_new_paths
+    end
+  end
+  
+end
+end

data/spec/cucumber/sell_cucumbers.feature

@@ -0,0 +1,19 @@
+Feature: Sell cucumbers
+  As a cucumber farmer
+  I want to sell cucumbers
+  So that I buy meat
+
+  Scenario: Sell a dozen
+    Given there are 5 cucumbers
+    When I sell 12 cucumbers
+    Then I should owe 7 cucumbers
+
+  Scenario: Sell twenty
+    Given there are 5 cucumbers
+    When I sell 20 cucumbers
+    Then I should owe 15 cucumbers
+
+  Scenario: Sell fifty
+    Given there are 5 cucumbers
+    When I sell 50 cucumbers
+    Then I should owe 45 cucumbers

data/spec/cucumber/step_match_spec.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'cucumber/rb_support/rb_step_definition'
+require 'cucumber/rb_support/rb_language'
+
+module Cucumber
+  describe StepMatch do
+    WORD = Cucumber::RUBY_1_9 ? '[[:word:]]' : '\w'
+
+    before do
+      @rb_language = RbSupport::RbLanguage.new(nil)
+    end
+
+    def stepdef(regexp)
+      RbSupport::RbStepDefinition.new(@rb_language, regexp, lambda{})
+    end
+
+    def step_match(regexp, name)
+      stepdef = stepdef(regexp)
+      StepMatch.new(stepdef, name, nil, stepdef.arguments_from(name))
+    end
+
+    it "should format one group when we use Unicode" do
+      m = step_match(/I (#{WORD}+) ok/, "I æøåÆØÅæøåÆØÅæøåÆØÅæøåÆØÅ ok")
+      m.format_args("<span>%s</span>").should == "I <span>æøåÆØÅæøåÆØÅæøåÆØÅæøåÆØÅ</span> ok"
+    end
+
+    it "should format several groups when we use Unicode" do
+      m = step_match(/I (#{WORD}+) (#{WORD}+) (#{WORD}+) this (#{WORD}+)/, "I ate æøåÆØÅæøåÆØÅæøåÆØÅæøåÆØÅ egg this morning")
+      m.format_args("<span>%s</span>").should == "I <span>ate</span> <span>æøåÆØÅæøåÆØÅæøåÆØÅæøåÆØÅ</span> <span>egg</span> this <span>morning</span>"
+    end
+
+    it "should deal with Unicode both inside and outside arguments" do
+      "Jæ vø ålsker døtte løndet".should =~ /Jæ (.+) ålsker (.+) løndet/
+      m = step_match(/Jæ (#{WORD}+) ålsker (#{WORD}+) løndet/, "Jæ vø ålsker døtte løndet")
+      m.format_args("<span>%s</span>").should == "Jæ <span>vø</span> ålsker <span>døtte</span> løndet"
+    end
+
+    it "should format groups with format string" do
+      m = step_match(/I (#{WORD}+) (\d+) (#{WORD}+) this (#{WORD}+)/, "I ate 1 egg this morning")
+      m.format_args("<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
+      m = step_match(/I (#{WORD}+) (\d+) (#{WORD}+) this (#{WORD}+)/, "I bob 1 bo this bobs")
+      m.format_args("<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
+      m = step_match(/I (#{WORD}+) (\d+) (#{WORD}+) this (#{WORD}+)/, "I ate 1 egg this morning")
+      m.format_args(&lambda{|m| "<span>#{m}</span>"}).should == "I <span>ate</span> <span>1</span> <span>egg</span> this <span>morning</span>"
+    end
+
+    it "should format groups with proc object" do
+      m = step_match(/I (#{WORD}+) (\d+) (#{WORD}+) this (#{WORD}+)/, "I ate 1 egg this morning")
+      m.format_args(lambda{|m| "<span>#{m}</span>"}).should == "I <span>ate</span> <span>1</span> <span>egg</span> this <span>morning</span>"
+    end
+
+    it "should format groups even when first group is optional and not matched" do
+      m = step_match(/should( not)? be flashed '([^']*?)'$/, "I should be flashed 'Login failed.'")
+      m.format_args("<span>%s</span>").should == "I should be flashed '<span>Login failed.</span>'"
+    end
+
+    it "should format embedded groups" do
+      m = step_match(/running( (\d+) times)? (\d+) meters/, "running 5 times 10 meters")
+      m.format_args("<span>%s</span>").should == "running<span> 5 times</span> <span>10</span> meters"
+    end
+  end
+end

data/spec/cucumber/wire_support/configuration_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'cucumber/wire_support/wire_language'
+require 'tempfile'
+
+module Cucumber
+  module WireSupport
+    describe Configuration do
+      let(:wire_file) { Tempfile.new('wire') }
+      let(:config) { Configuration.new(wire_file.path) }
+      
+      def write_wire_file(contents)
+        wire_file << contents
+        wire_file.close
+      end
+      
+      it "reads the hostname / port from the file" do
+        write_wire_file %q{
+          host: localhost
+          port: 54321
+        }
+        config.host.should == 'localhost'
+        config.port.should == 54321
+      end
+      
+      it "reads the timeout for a specific message" do
+        write_wire_file %q{
+          host: localhost
+          port: 54321
+          timeout:
+            invoke: 99
+        }
+        config.timeout('invoke').should == 99
+      end
+      
+      describe "a wire file with no timeouts specified" do
+        before(:each) do
+          write_wire_file %q{
+            host: localhost
+            port: 54321
+          }
+        end
+        
+        %w(invoke begin_scenario end_scenario).each do |message|
+          it "sets the default timeout for '#{message}' to 120 seconds" do
+            config.timeout(message).should == 120
+          end
+        end
+      end
+    end
+  end
+end

data/spec/cucumber/wire_support/connection_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'cucumber/wire_support/wire_language'
+
+module Cucumber
+  module WireSupport
+    describe Connection do
+      class TestConnection < Connection
+        attr_accessor :socket
+      end
+      
+      class TestConfiguration
+        attr_reader :custom_timeout
+        
+        def initialize
+          @custom_timeout = {}
+        end
+        
+        def timeout(message = nil)
+          return :default_timeout if message.nil?
+          @custom_timeout[message] || :custom_timeout
+        end
+      end
+      
+      before(:each) do
+        @config = TestConfiguration.new
+        @connection = TestConnection.new(@config)
+        @connection.socket = @socket = mock('socket')
+        Timeout.stub(:timeout).with(:custom_timeout).and_raise(Timeout::Error.new(''))
+        @response = %q{["response"]}
+        Timeout.stub(:timeout).with(:default_timeout).and_return(@response)
+      end
+      
+      it "re-raises a timeout error" do
+        Timeout.stub!(:timeout).and_raise(Timeout::Error.new(''))
+        lambda { @connection.call_remote(nil, :foo, []) }.should raise_error(Timeout::Error)
+      end
+      
+      it "ignores timeout errors when configured to do so" do
+        @config.custom_timeout[:foo] = :never
+        @socket.should_receive(:gets).and_return(@response)
+        handler = mock(:handle_response => :response)
+        @connection.call_remote(handler, :foo, []).should == :response
+      end
+    end
+  end
+end