stefl-cucumber 0.10.1

data/spec/cucumber/rb_support/regexp_argument_matcher_spec.rb

@@ -0,0 +1,18 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../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 File.expand_path(File.dirname(__FILE__) + '/../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 File.expand_path(File.dirname(__FILE__) + '/../../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 File.expand_path(File.dirname(__FILE__) + '/../../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

data/spec/cucumber/wire_support/wire_exception_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'cucumber/wire_support/wire_language'
+
+module Cucumber
+  module WireSupport
+    describe WireException do
+      before(:each) do
+        @host, @port = 'localhost', '54321'
+      end
+      def exception
+        WireException.new(@data, @host, @port)
+      end
+      describe "with just a message" do
+        before(:each) do
+          @data = {'message' => 'foo'}
+        end
+        it "should #to_s as expected" do
+          exception.to_s.should == "foo"
+        end
+      end
+      
+      describe "with a message and an exception" do
+        before(:each) do
+          @data = {'message' => 'foo', 'exception' => 'Bar'}
+        end
+        it "should #to_s as expected" do
+          exception.to_s.should == "foo"
+        end
+        it "#class.to_s should return the name of the exception" do
+          exception.class.to_s.should == 'Bar from localhost:54321'
+        end
+      end
+      
+      describe "with a custom backtrace" do
+        before(:each) do
+          @data = {'message' => 'foo', 'backtrace' => ['foo', 'bar', 'baz']}
+        end
+        it "#backrace should return the custom backtrace" do
+          exception.backtrace.should == ['foo', 'bar', 'baz']
+        end
+      end
+    end
+  end
+end

data/spec/cucumber/wire_support/wire_language_spec.rb

@@ -0,0 +1,47 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'cucumber/wire_support/wire_language'
+
+module Cucumber
+  module WireSupport
+    describe WireLanguage do
+      def stub_wire_file!(filename, config)
+        Configuration.stub!(:new).with(filename).and_return config
+      end
+      
+      describe "#load_code_file" do
+        before(:each) do
+          stub_wire_file! 'foo.wire', :config
+        end
+      
+        it "creates a RemoteSteps object" do
+          Connection.should_receive(:new).with(:config)
+          WireLanguage.new(nil).load_code_file('foo.wire')
+        end
+      end
+
+      describe "#step_matches" do
+        def stub_remote_steps!(config, attributes)
+          Connection.should_receive(:new).
+            with(config).
+            and_return( mock('remote_steps', attributes) )
+        end
+        
+        before(:each) do
+          stub_wire_file! 'one.wire', :config_one
+          stub_wire_file! 'two.wire', :config_two
+        end
+
+        it "should return the matches from each of the RemoteSteps" do
+          stub_remote_steps! :config_one, :step_matches => [:a, :b]
+          stub_remote_steps! :config_two, :step_matches => [:c]
+
+          wire_language = WireLanguage.new(nil)
+          wire_language.load_code_file('one.wire')
+          wire_language.load_code_file('two.wire')
+
+          wire_language.step_matches('','').should == [:a, :b, :c]
+        end
+      end
+    end
+  end
+end