cucumber 1.3.20 → 2.0.0.beta.1

data/spec/cucumber/runtime_spec.rb

@@ -1,45 +1,50 @@
 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 Runtime do
+    subject { Runtime.new(options) }
+    let(:options) { {} }
 
-  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
+    describe "#features_paths" do
+      let(:options) { {:paths => ['foo/bar/baz.feature', 'foo/bar/features/baz.feature', 'other_features'] } }
 
-    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)
+      it "returns the value from configuration.paths" do
+        expect(subject.features_paths).to eq options[:paths]
+      end
     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
+    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
+        allow(Runtime::SupportCode).to receive(:new) { support_code }
+        allow(Runtime::Results).to receive(:new) { results }
+      end
+
+      it "tells the support_code and results about the new configuration" do
+        expect(support_code).to receive(:configure).with(new_configuration)
+        expect(results).to receive(:configure).with(new_configuration)
+
+        subject.configure(new_configuration)
+      end
 
-    it '#doc_string' do
-      subject.doc_string('Text').should == 'Text'
+      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']
+
+        allow(new_configuration).to receive(:paths) { some_new_paths }
+
+        subject.configure(new_configuration)
+
+        expect(subject.features_paths).to eq some_new_paths
+      end
+
+      it '#doc_string' do
+        expect(subject.doc_string('Text')).to eq 'Text'
+      end
     end
   end
-
-end
 end

data/spec/cucumber/step_match_spec.rb

@@ -5,7 +5,7 @@ require 'cucumber/rb_support/rb_language'
 
 module Cucumber
   describe StepMatch do
-    WORD = Cucumber::RUBY_1_8_7 ? '\w' : '[[:word:]]'
+    WORD = '[[:word:]]'
 
     before do
       @rb_language = RbSupport::RbLanguage.new(nil)
@@ -20,50 +20,60 @@ module Cucumber
       StepMatch.new(stepdef, name, nil, stepdef.arguments_from(name))
     end
 
-    it "should format one group when we use Unicode" do
+    it "formats 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"
+
+      expect(m.format_args("<span>%s</span>")).to eq "I <span>æøåÆØÅæøåÆØÅæøåÆØÅæøåÆØÅ</span> ok"
     end
 
-    it "should format several groups when we use Unicode" do
+    it "formats 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>"
+
+      expect(m.format_args("<span>%s</span>")).to eq "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/
+    it "deals with Unicode both inside and outside arguments" do
+      expect("Jæ vø ålsker døtte løndet").to match /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"
+
+      expect(m.format_args("<span>%s</span>")).to eq "Jæ <span>vø</span> ålsker <span>døtte</span> løndet"
     end
 
-    it "should format groups with format string" do
+    it "formats 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>"
+
+      expect(m.format_args("<span>%s</span>")).to eq "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
+    it "formats 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>"
+
+      expect(m.format_args("<span>%s</span>")).to eq "I <span>bob</span> <span>1</span> <span>bo</span> this <span>bobs</span>"
     end
 
-    it "should format groups with block" do
+    it "formats 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>"
+
+      expect(m.format_args(&lambda{|m| "<span>#{m}</span>"})).to eq "I <span>ate</span> <span>1</span> <span>egg</span> this <span>morning</span>"
     end
 
-    it "should format groups with proc object" do
+    it "formats 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>"
+
+      expect(m.format_args(lambda{|m| "<span>#{m}</span>"})).to eq "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
+    it "formats 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>'"
+
+      expect(m.format_args("<span>%s</span>")).to eq "I should be flashed '<span>Login failed.</span>'"
     end
 
-    it "should format embedded groups" do
+    it "formats 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"
+
+      expect(m.format_args("<span>%s</span>")).to eq "running<span> 5 times</span> <span>10</span> meters"
     end
   end
 end

data/spec/cucumber/wire_support/configuration_spec.rb

@@ -18,8 +18,9 @@ module Cucumber
           host: localhost
           port: 54321
         }
-        config.host.should == 'localhost'
-        config.port.should == 54321
+
+        expect(config.host).to eq 'localhost'
+        expect(config.port).to eq 54321
       end
 
       it "reads the timeout for a specific message" do
@@ -29,7 +30,8 @@ module Cucumber
           timeout:
             invoke: 99
         }
-        config.timeout('invoke').should == 99
+
+        expect(config.timeout('invoke')).to eq 99
       end
 
       it "reads the timeout for a connect message" do
@@ -39,7 +41,8 @@ module Cucumber
           timeout:
             connect: 99
         }
-        config.timeout('connect').should == 99
+
+        expect(config.timeout('connect')).to eq 99
       end
 
       describe "a wire file with no timeouts specified" do
@@ -52,7 +55,7 @@ module Cucumber
 
         %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
+            expect(config.timeout(message)).to eq 120
           end
         end
       end

data/spec/cucumber/wire_support/connection_spec.rb

@@ -37,23 +37,27 @@ module Cucumber
       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)
+        allow(Timeout).to receive(:timeout).and_raise(Timeout::Error.new(''))
+        expect(-> { @connection.call_remote(nil, :foo, []) }).to raise_error(Timeout::Error)
       end
 
       it "ignores timeout errors when configured to do so" do
         @config.custom_timeout[:foo] = :never
-        @socket.stub(:gets => @response)
+
+        allow(@socket).to receive(:gets) { @response }
+
         handler = double(:handle_response => :response)
-        @connection.call_remote(handler, :foo, []).should == :response
+
+        expect(@connection.call_remote(handler, :foo, [])).to eq :response
       end
 
       it "raises an exception on remote connection closed" do
         @config.custom_timeout[:foo] = :never
-        @socket.stub(:gets => nil)
-        lambda { 
-          @connection.call_remote(nil, :foo, []) 
-        }.should raise_error(WireException, 'Remote Socket with localhost:3902 closed.')
+
+        allow(@socket).to receive(:gets)
+        expect(-> {
+          @connection.call_remote(nil, :foo, [])
+        }).to raise_error(WireException, 'Remote Socket with localhost:3902 closed.')
       end
     end
   end

data/spec/cucumber/wire_support/wire_exception_spec.rb

@@ -7,15 +7,18 @@ module Cucumber
       before(:each) do
         @config = Configuration.new('host' => 'localhost', 'port' => 54321)
       end
+
       def exception
         WireException.new(@data, @config)
       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"
+
+        it "#to_s as expecteds" do
+          expect(exception.to_s).to eq "foo"
         end
       end
 
@@ -23,11 +26,13 @@ module Cucumber
         before(:each) do
           @data = {'message' => 'foo', 'exception' => 'Bar'}
         end
-        it "should #to_s as expected" do
-          exception.to_s.should == "foo"
+
+        it "#to_s as expecteds" do
+          expect(exception.to_s).to eq "foo"
         end
-        it "#class.to_s should return the name of the exception" do
-          exception.class.to_s.should == 'Bar from localhost:54321'
+
+        it "#class.to_s returns the name of the exception" do
+          expect(exception.class.to_s).to eq 'Bar from localhost:54321'
         end
       end
 
@@ -35,8 +40,9 @@ module Cucumber
         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']
+
+        it "#backrace returns the custom backtrace" do
+          expect(exception.backtrace).to eq ['foo', 'bar', 'baz']
         end
       end
     end

data/spec/cucumber/wire_support/wire_language_spec.rb

@@ -5,7 +5,7 @@ module Cucumber
   module WireSupport
     describe WireLanguage do
       def stub_wire_file!(filename, config)
-        Configuration.stub(:from_file).with(filename).and_return config
+        allow(Configuration).to receive(:from_file).with(filename) { config }
       end
 
       describe "#load_code_file" do
@@ -14,16 +14,15 @@ module Cucumber
         end
 
         it "creates a RemoteSteps object" do
-          Connection.should_receive(:new).with(:config)
-          WireLanguage.new(nil).load_code_file('foo.wire')
+          expect(Connection).to receive(:new).with(:config)
+
+          WireLanguage.new.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( double('remote_steps', attributes) )
+          expect(Connection).to receive(:new).with(config) { double('remote_steps', attributes) }
         end
 
         before(:each) do
@@ -31,15 +30,15 @@ module Cucumber
           stub_wire_file! 'two.wire', :config_two
         end
 
-        it "should return the matches from each of the RemoteSteps" do
+        it "returns 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 = WireLanguage.new
           wire_language.load_code_file('one.wire')
           wire_language.load_code_file('two.wire')
 
-          wire_language.step_matches('','').should == [:a, :b, :c]
+          expect(wire_language.step_matches('','')).to eq [:a, :b, :c]
         end
       end
     end

data/spec/cucumber/wire_support/wire_packet_spec.rb

@@ -4,35 +4,39 @@ require 'cucumber/wire_support/wire_language'
 module Cucumber
   module WireSupport
     describe WirePacket do
-
       describe "#to_json" do
-        it "should convert params to a JSON hash" do
+        it "converts params to a JSON hash" do
           packet = WirePacket.new('test_message', :foo => :bar)
-          packet.to_json.should == "[\"test_message\",{\"foo\":\"bar\"}]"
+
+          expect(packet.to_json).to eq "[\"test_message\",{\"foo\":\"bar\"}]"
         end
 
-        it "should not pass blank params" do
+        it "does not pass blank params" do
           packet = WirePacket.new('test_message')
-          packet.to_json.should == "[\"test_message\"]"
+
+          expect(packet.to_json).to eq "[\"test_message\"]"
         end
       end
 
       describe ".parse" do
-        it "should understand a raw packet containing null parameters" do
+        it "understands a raw packet containing null parameters" do
           packet = WirePacket.parse("[\"test_message\",null]")
-          packet.message.should == 'test_message'
-          packet.params.should be_nil
+
+          expect(packet.message).to eq 'test_message'
+          expect(packet.params).to be_nil
         end
 
-        it "should understand a raw packet containing no parameters" do
+        it "understands a raw packet containing no parameters" do
           packet = WirePacket.parse("[\"test_message\"]")
-          packet.message.should == 'test_message'
-          packet.params.should be_nil
+
+          expect(packet.message).to eq 'test_message'
+          expect(packet.params).to be_nil
         end
 
-        it "should understand a raw packet containging parameters data" do
+        it "understands a raw packet containging parameters data" do
           packet = WirePacket.parse("[\"test_message\",{\"foo\":\"bar\"}]")
-          packet.params['foo'].should == 'bar'
+
+          expect(packet.params['foo']).to eq 'bar'
         end
       end
     end

data/spec/cucumber/world/pending_spec.rb

@@ -2,45 +2,45 @@ require 'spec_helper'
 require 'cucumber/rb_support/rb_language'
 
 module Cucumber
-    describe 'Pending' do
-
-      before(:each) do
-        l = RbSupport::RbLanguage.new(Runtime.new)
-        l.begin_rb_scenario(double('scenario').as_null_object)
-        @world = l.current_world
-      end
-
-      it 'should raise a Pending if no block is supplied' do
-        lambda {
-          @world.pending "TODO"
-        }.should raise_error(Cucumber::Pending, /TODO/)
-      end
+  describe 'Pending' do
+    before(:each) do
+      l = RbSupport::RbLanguage.new(Runtime.new)
+      l.begin_rb_scenario(double('scenario').as_null_object)
+      @world = l.current_world
+    end
 
-      it 'should raise a Pending if a supplied block fails as expected' do
-        lambda {
-          @world.pending "TODO" do
-            raise "oops"
-          end
-        }.should raise_error(Cucumber::Pending, /TODO/)
-      end
+    it 'raises a Pending if no block is supplied' do
+      expect(-> {
+        @world.pending "TODO"
+      }).to raise_error(Cucumber::Pending, /TODO/)
+    end
 
-      it 'should raise a Pending if a supplied block fails as expected with a double' do
-        lambda {
-          @world.pending "TODO" do
-            m = double('thing')
-            m.should_receive(:foo)
-            RSpec::Mocks.verify
-          end
-        }.should raise_error(Cucumber::Pending, /TODO/)
-      end
+    it 'raises a Pending if a supplied block fails as expected' do
+      expect(-> {
+        @world.pending "TODO" do
+        raise "oops"
+        end
+      }).to raise_error(Cucumber::Pending, /TODO/)
+    end
 
-      it 'should raise a Pending if a supplied block starts working' do
-        lambda {
-          @world.pending "TODO" do
-            # success!
-          end
-        }.should raise_error(Cucumber::Pending, /TODO/)
-      end
+    it 'raises a Pending if a supplied block fails as expected with a double' do
+      expect do
+        @world.pending "TODO" do
+          m = double('thing')
+          expect(m).to receive(:foo)
+          RSpec::Mocks.verify
+        end
+      end.to raise_error(Cucumber::Pending, /TODO/)
+      # The teardown is needed so that the message expectation does not bubble up.
+      RSpec::Mocks.teardown 
+    end
 
+    it 'raises a Pending if a supplied block starts working' do
+      expect(-> {
+        @world.pending "TODO" do
+        # success!
+        end
+      }).to raise_error(Cucumber::Pending, /TODO/)
     end
+  end
 end