mongrel2 0.38.0 → 0.39.0

data/spec/mongrel2/config/setting_spec.rb

@@ -1,19 +1,8 @@
 #!/usr/bin/env ruby
 
-BEGIN {
-	require 'pathname'
-	basedir = Pathname.new( __FILE__ ).dirname.parent.parent.parent
-
-	libdir = basedir + "lib"
-
-	$LOAD_PATH.unshift( basedir ) unless $LOAD_PATH.include?( basedir )
-	$LOAD_PATH.unshift( libdir ) unless $LOAD_PATH.include?( libdir )
-}
+require_relative '../../helpers'
 
 require 'rspec'
-
-require 'spec/lib/helpers'
-
 require 'mongrel2'
 require 'mongrel2/config'
 

data/spec/mongrel2/config/statistic_spec.rb

@@ -1,19 +1,8 @@
 #!/usr/bin/env ruby
 
-BEGIN {
-	require 'pathname'
-	basedir = Pathname.new( __FILE__ ).dirname.parent.parent.parent
-
-	libdir = basedir + "lib"
-
-	$LOAD_PATH.unshift( basedir ) unless $LOAD_PATH.include?( basedir )
-	$LOAD_PATH.unshift( libdir ) unless $LOAD_PATH.include?( libdir )
-}
+require_relative '../../helpers'
 
 require 'rspec'
-
-require 'spec/lib/helpers'
-
 require 'mongrel2'
 require 'mongrel2/config'
 

data/spec/mongrel2/config/xrequest_spec.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+require_relative '../../helpers'
+
+require 'rspec'
+require 'mongrel2'
+require 'mongrel2/config'
+
+
+#####################################################################
+###	C O N T E X T S
+#####################################################################
+
+describe Mongrel2::Config::XRequest do
+
+	# No functionality outside of Sequel::Model's purview yet
+
+end
+

data/spec/mongrel2/config_spec.rb

@@ -1,18 +1,6 @@
 #!/usr/bin/env ruby
 
-BEGIN {
-	require 'pathname'
-	basedir = Pathname.new( __FILE__ ).dirname.parent.parent
-
-	libdir = basedir + "lib"
-
-	$LOAD_PATH.unshift( basedir ) unless $LOAD_PATH.include?( basedir )
-	$LOAD_PATH.unshift( libdir ) unless $LOAD_PATH.include?( libdir )
-}
-
-require 'rspec'
-
-require 'spec/lib/helpers'
+require_relative '../helpers'
 
 require 'mongrel2'
 require 'mongrel2/config'
@@ -25,7 +13,7 @@ require 'mongrel2/config'
 describe Mongrel2::Config do
 
 	before( :all ) do
-		setup_logging( :fatal )
+		setup_logging()
 		setup_config_db()
 	end
 
@@ -38,8 +26,8 @@ describe Mongrel2::Config do
 	it "has a factory method for creating derivative classes" do
 		begin
 			model_class = Mongrel2::Config( :hookers )
-			model_class.should < Mongrel2::Config
-			model_class.dataset.first_source.should == :hookers
+			expect( model_class ).to satisfy {|klass| klass < Mongrel2::Config }
+			expect( model_class.dataset.first_source ).to eq( :hookers )
 		ensure
 			# Remove the example class from the list of subclasses so it
 			# doesn't affect later tests
@@ -50,7 +38,7 @@ describe Mongrel2::Config do
 	it "can reset the database handle for the config classes" do
 		db = Mongrel2::Config.in_memory_db
 		Mongrel2::Config.db = db
-		Mongrel2::Config::Directory.db.should equal( db )
+		expect( Mongrel2::Config::Directory.db ).to equal( db )
 	end
 
 	it "has a convenience method for fetching an Array of all of its configured servers" do
@@ -65,47 +53,47 @@ describe Mongrel2::Config do
 			default_host: 'localhost',
 			port: 8275
 		  )
-		Mongrel2::Config.servers.should have( 1 ).member
-		Mongrel2::Config.servers.first.uuid.should == TEST_UUID
+		expect( Mongrel2::Config.servers ).to have( 1 ).member
+		expect( Mongrel2::Config.servers.first.uuid ).to eq( TEST_UUID )
 	end
 
 	it "has a convenience method for getting a setting's value" do
 		Mongrel2::Config.init_database
 		Mongrel2::Config::Setting.dataset.truncate
 		Mongrel2::Config::Setting.create( key: 'control_port', value: 'ipc://var/run/control.sock' )
-		Mongrel2::Config.settings.should respond_to( :[] )
-		Mongrel2::Config.settings.should have( 1 ).member
-		Mongrel2::Config.settings[ :control_port ].should == 'ipc://var/run/control.sock'
+		expect( Mongrel2::Config.settings ).to respond_to( :[] )
+		expect( Mongrel2::Config.settings ).to have( 1 ).member
+		expect( Mongrel2::Config.settings[ :control_port ] ).to eq( 'ipc://var/run/control.sock' )
 	end
 
 	it "can read the configuration schema from a data file" do
-		Mongrel2::Config.load_config_schema.should =~ /create table server/i
+		expect( Mongrel2::Config.load_config_schema ).to match( /create table server/i )
 	end
 
 	it "knows whether or not its database has been initialized" do
 		Mongrel2::Config.db = Mongrel2::Config.in_memory_db
-		Mongrel2::Config.database_initialized?.should be_false()
+		expect( Mongrel2::Config.database_initialized? ).to be_false()
 		Mongrel2::Config.init_database!
-		Mongrel2::Config.database_initialized?.should be_true()
+		expect( Mongrel2::Config.database_initialized? ).to be_true()
 	end
 
 	it "doesn't re-initialize the database if the non-bang version of init_database is used" do
 		Mongrel2::Config.db = Mongrel2::Config.in_memory_db
 		Mongrel2::Config.init_database
 
-		Mongrel2::Config.should_not_receive( :load_config_schema )
+		expect( Mongrel2::Config ).to_not receive( :load_config_schema )
 		Mongrel2::Config.init_database
 	end
 
 	it "can return the path to the config DB as a Pathname if it's pointing at a file" do
 		Mongrel2::Config.db = Sequel.
 			connect( adapter: Mongrel2::Config.sqlite_adapter, database: 'config-spec.sqlite' )
-		Mongrel2::Config.dbname.should == 'config-spec.sqlite'
+		expect( Mongrel2::Config.dbname ).to eq( 'config-spec.sqlite' )
 	end
 
 	it "returns nil if asked for the pathname to an in-memory database" do
 		Mongrel2::Config.db = Mongrel2::Config.in_memory_db
-		Mongrel2::Config.dbname.should be_nil()
+		expect( Mongrel2::Config.dbname ).to be_nil()
 	end
 
 	describe "Configurability support", :if => defined?( Configurability ) do
@@ -114,7 +102,7 @@ describe Mongrel2::Config do
 		it_should_behave_like "an object with Configurability"
 
 		it "uses the 'mongrel2' config section" do
-			Mongrel2::Config.config_key.should == :mongrel2
+			expect( Mongrel2::Config.config_key ).to eq( :mongrel2 )
 		end
 
 	end

data/spec/mongrel2/connection_spec.rb

@@ -1,18 +1,6 @@
 #!/usr/bin/env ruby
 
-BEGIN {
-	require 'pathname'
-	basedir = Pathname.new( __FILE__ ).dirname.parent.parent
-
-	libdir = basedir + "lib"
-
-	$LOAD_PATH.unshift( basedir ) unless $LOAD_PATH.include?( basedir )
-	$LOAD_PATH.unshift( libdir ) unless $LOAD_PATH.include?( libdir )
-}
-
-require 'rspec'
-
-require 'spec/lib/helpers'
+require_relative '../helpers'
 
 require 'mongrel2'
 require 'mongrel2/connection'
@@ -26,7 +14,7 @@ describe Mongrel2::Connection do
 	include Mongrel2::Config::DSL
 
 	before( :all ) do
-		setup_logging( :fatal )
+		setup_logging()
 	end
 
 	# Ensure 0MQ never actually gets called
@@ -47,54 +35,54 @@ describe Mongrel2::Connection do
 
 
 	it "doesn't connect to the endpoints when it's created" do
-		@conn.instance_variable_get( :@request_sock ).should be_nil()
-		@conn.instance_variable_get( :@response_sock ).should be_nil()
+		expect( @conn.instance_variable_get( :@request_sock ) ).to be_nil()
+		expect( @conn.instance_variable_get( :@response_sock ) ).to be_nil()
 	end
 
 	it "connects to the endpoints specified on demand" do
 		request_sock = double( "request socket" )
 		response_sock = double( "response socket" )
 
-		@ctx.should_receive( :socket ).with( ZMQ::PULL ).and_return( request_sock )
-		request_sock.should_receive( :setsockopt ).with( ZMQ::LINGER, 0 )
-		request_sock.should_receive( :connect ).with( TEST_SEND_SPEC )
+		expect( @ctx ).to receive( :socket ).with( :PULL ).and_return( request_sock )
+		expect( request_sock ).to receive( :linger= ).with( 0 )
+		expect( request_sock ).to receive( :connect ).with( TEST_SEND_SPEC )
 
-		@ctx.should_receive( :socket ).with( ZMQ::PUB ).and_return( response_sock )
-		response_sock.should_receive( :setsockopt ).with( ZMQ::LINGER, 0 )
-		response_sock.should_receive( :setsockopt ).with( ZMQ::IDENTITY, /^[[:xdigit:]]{40}$/ )
-		response_sock.should_receive( :connect ).with( TEST_RECV_SPEC )
+		expect( @ctx ).to receive( :socket ).with( :PUB ).and_return( response_sock )
+		expect( response_sock ).to receive( :linger= ).with( 0 )
+		expect( response_sock ).to_not receive( :identity= )
+		expect( response_sock ).to receive( :connect ).with( TEST_RECV_SPEC )
 
-		@conn.request_sock.should == request_sock
-		@conn.response_sock.should == response_sock
+		expect( @conn.request_sock ).to eq( request_sock )
+		expect( @conn.response_sock ).to eq( response_sock )
 	end
 
 	it "stringifies as a description of the appid and both sockets" do
-		@conn.to_s.should == "{#{TEST_UUID}} #{TEST_SEND_SPEC} <-> #{TEST_RECV_SPEC}"
+		expect( @conn.to_s ).to eq( "{#{TEST_UUID}} #{TEST_SEND_SPEC} <-> #{TEST_RECV_SPEC}" )
 	end
 
 	context "after a connection has been established" do
 
 		before( :each ) do
-			@request_sock = double( "request socket", :setsockopt => nil, :connect => nil )
-			@response_sock = double( "response socket", :setsockopt => nil, :connect => nil )
+			@request_sock = double( "request socket", :linger= => nil, :connect => nil )
+			@response_sock = double( "response socket", :linger= => nil, :connect => nil )
 
-			@ctx.stub( :socket ).with( ZMQ::PULL ).and_return( @request_sock )
-			@ctx.stub( :socket ).with( ZMQ::PUB ).and_return( @response_sock )
+			allow( @ctx ).to receive( :socket ).with( :PULL ).and_return( @request_sock )
+			allow( @ctx ).to receive( :socket ).with( :PUB ).and_return( @response_sock )
 
 			@conn.connect
 		end
 
 
 		it "closes both of its sockets when closed" do
-			@request_sock.should_receive( :close )
-			@response_sock.should_receive( :close )
+			expect( @request_sock ).to receive( :close )
+			expect( @response_sock ).to receive( :close )
 
 			@conn.close
 		end
 
 		it "raises an exception if asked to fetch data after being closed" do
-			@request_sock.stub( :close )
-			@response_sock.stub( :close )
+			allow( @request_sock ).to receive( :close )
+			allow( @response_sock ).to receive( :close )
 
 			@conn.close
 
@@ -104,69 +92,69 @@ describe Mongrel2::Connection do
 		end
 
 		it "doesn't keep its request and response sockets when duped" do
-			request_sock2 = double( "request socket", :setsockopt => nil, :connect => nil )
-			response_sock2 = double( "response socket", :setsockopt => nil, :connect => nil )
-			@ctx.stub( :socket ).with( ZMQ::PULL ).and_return( request_sock2 )
-			@ctx.stub( :socket ).with( ZMQ::PUB ).and_return( response_sock2 )
+			request_sock2 = double( "request socket", :linger= => nil, :connect => nil )
+			response_sock2 = double( "response socket", :linger= => nil, :connect => nil )
+			allow( @ctx ).to receive( :socket ).with( :PULL ).and_return( request_sock2 )
+			allow( @ctx ).to receive( :socket ).with( :PUB ).and_return( response_sock2 )
 
 			duplicate = @conn.dup
 
-			duplicate.request_sock.should == request_sock2
-			duplicate.response_sock.should == response_sock2
+			expect( duplicate.request_sock ).to eq( request_sock2 )
+			expect( duplicate.response_sock ).to eq( response_sock2 )
 		end
 
 		it "doesn't keep its closed state when duped" do
-			@request_sock.should_receive( :close )
-			@response_sock.should_receive( :close )
+			expect( @request_sock ).to receive( :close )
+			expect( @response_sock ).to receive( :close )
 
 			@conn.close
 
 			duplicate = @conn.dup
-			duplicate.should_not be_closed()
+			expect( duplicate ).to_not be_closed()
 		end
 
 		it "can read raw request messages off of the request_sock" do
-			@request_sock.should_receive( :recv ).and_return( "the data" )
-			@conn.recv.should == "the data"
+			expect( @request_sock ).to receive( :recv ).and_return( "the data" )
+			expect( @conn.recv ).to eq( "the data" )
 		end
 
 		it "can read request messages off of the request_sock as Mongrel2::Request objects" do
 			msg = make_request()
-			@request_sock.should_receive( :recv ).and_return( msg )
-			@conn.receive.should be_a( Mongrel2::Request )
+			expect( @request_sock ).to receive( :recv ).and_return( msg )
+			expect( @conn.receive ).to be_a( Mongrel2::Request )
 		end
 
 		it "can write raw response messages with a TNetString header onto the response_sock" do
-			@response_sock.should_receive( :send ).with( "#{TEST_UUID} 1:8, the data" )
+			expect( @response_sock ).to receive( :send ).with( "#{TEST_UUID} 1:8, the data" )
 			@conn.send( TEST_UUID, 8, "the data" )
 		end
 
 		it "can write Mongrel2::Responses to the response_sock" do
-			@response_sock.should_receive( :send ).with( "#{TEST_UUID} 1:8, the data" )
+			expect( @response_sock ).to receive( :send ).with( "#{TEST_UUID} 1:8, the data" )
 
 			response = Mongrel2::Response.new( TEST_UUID, 8, 'the data' )
 			@conn.reply( response )
 		end
 
 		it "can write raw response messages to more than one conn_id at the same time" do
-			@response_sock.should_receive( :send ).with( "#{TEST_UUID} 15:8 16 44 45 1833, the data" )
+			expect( @response_sock ).to receive( :send ).with( "#{TEST_UUID} 15:8 16 44 45 1833, the data" )
 			@conn.broadcast( TEST_UUID, [8, 16, 44, 45, 1833], 'the data' )
 		end
 
 		it "can write raw response messages to more than one conn_id at the same time" do
-			@response_sock.should_receive( :send ).with( "#{TEST_UUID} 15:8 16 44 45 1833, the data" )
+			expect( @response_sock ).to receive( :send ).with( "#{TEST_UUID} 15:8 16 44 45 1833, the data" )
 			@conn.broadcast( TEST_UUID, [8, 16, 44, 45, 1833], 'the data' )
 		end
 
 		it "can tell the connection a request or a response was from to close" do
-			@response_sock.should_receive( :send ).with( "#{TEST_UUID} 1:8, " )
+			expect( @response_sock ).to receive( :send ).with( "#{TEST_UUID} 1:8, " )
 
 			response = Mongrel2::Response.new( TEST_UUID, 8 )
 			@conn.reply_close( response )
 		end
 
 		it "can broadcast a close to multiple connection IDs" do
-			@response_sock.should_receive( :send ).with( "#{TEST_UUID} 15:8 16 44 45 1833, " )
+			expect( @response_sock ).to receive( :send ).with( "#{TEST_UUID} 15:8 16 44 45 1833, " )
 			@conn.broadcast_close( TEST_UUID, [8, 16, 44, 45, 1833] )
 		end
 

data/spec/mongrel2/constants_spec.rb

@@ -1,18 +1,6 @@
 #!/usr/bin/env ruby
 
-BEGIN {
-	require 'pathname'
-	basedir = Pathname.new( __FILE__ ).dirname.parent.parent
-
-	libdir = basedir + "lib"
-
-	$LOAD_PATH.unshift( basedir ) unless $LOAD_PATH.include?( basedir )
-	$LOAD_PATH.unshift( libdir ) unless $LOAD_PATH.include?( libdir )
-}
-
-require 'rspec'
-
-require 'spec/lib/helpers'
+require_relative '../helpers'
 
 require 'mongrel2'
 require 'mongrel2/connection'
@@ -25,7 +13,7 @@ require 'mongrel2/connection'
 describe Mongrel2::Constants do
 
 	it "defines a default configuration URI" do
-		Mongrel2::Constants.constants.map( &:to_sym ).should include( :DEFAULT_CONFIG_URI )
+		expect( Mongrel2::Constants.constants.map( &:to_sym ) ).to include( :DEFAULT_CONFIG_URI )
 	end
 
 end

data/spec/mongrel2/control_spec.rb

@@ -1,18 +1,6 @@
 #!/usr/bin/env ruby
 
-BEGIN {
-	require 'pathname'
-	basedir = Pathname.new( __FILE__ ).dirname.parent.parent
-
-	libdir = basedir + "lib"
-
-	$LOAD_PATH.unshift( basedir ) unless $LOAD_PATH.include?( basedir )
-	$LOAD_PATH.unshift( libdir ) unless $LOAD_PATH.include?( libdir )
-}
-
-require 'rspec'
-
-require 'spec/lib/helpers'
+require_relative '../helpers'
 
 require 'mongrel2'
 require 'mongrel2/control'
@@ -25,17 +13,17 @@ require 'mongrel2/control'
 describe Mongrel2::Control do
 
 	before( :all ) do
-		setup_logging( :fatal )
+		setup_logging()
 	end
 
 	before( :each ) do
 		@ctx = double( "ZMQ::Context" )
-		@socket = double( "ZMQ REQ socket", :connect => nil, :setsockopt => nil )
-		@ctx.stub( :socket ).with( ZMQ::REQ ).and_return( @socket )
+		@socket = double( "ZMQ REQ socket", :connect => nil, :linger= => nil )
+		allow( @ctx ).to receive( :socket ).with( :REQ ).and_return( @socket )
 
 		Mongrel2.instance_variable_set( :@zmq_ctx, @ctx )
 
-		FileTest.stub( :socket? ).with( 'var/run/control' ). and_return( true )
+		allow( FileTest ).to receive( :socket? ).with( 'var/run/control' ). and_return( true )
 
 		@control = Mongrel2::Control.new( 'ipc://var/run/control' )
 	end
@@ -47,29 +35,29 @@ describe Mongrel2::Control do
 
 
 	it "sends a 'stop' command to the control port when #stop is called" do
-		@socket.should_receive( :send ).with( "10:4:stop,0:}]" )
-		@socket.should_receive( :recv ).
+		expect( @socket ).to receive( :send ).with( "10:4:stop,0:}]" )
+		expect( @socket ).to receive( :recv ).
 			and_return( "59:7:headers,6:3:msg,]4:rows,29:25:21:signal sent to server,]]}" )
-		@control.stop.should == [{ :msg => "signal sent to server" }]
+		expect( @control.stop ).to eq( [{ :msg => "signal sent to server" }] )
 	end
 
 	it "sends a 'reload' command to the control port when #reload is called" do
-		@socket.should_receive( :send ).with( "12:6:reload,0:}]" )
-		@socket.should_receive( :recv ).
+		expect( @socket ).to receive( :send ).with( "12:6:reload,0:}]" )
+		expect( @socket ).to receive( :recv ).
 			and_return( "59:7:headers,6:3:msg,]4:rows,29:25:21:signal sent to server,]]}" )
-		@control.reload.should == [{ :msg => "signal sent to server" }]
+		expect( @control.reload ).to eq( [{ :msg => "signal sent to server" }] )
 	end
 
 	it "sends a 'terminate' command to the control port when #terminate is called" do
-		@socket.should_receive( :send ).with( "15:9:terminate,0:}]" )
-		@socket.should_receive( :recv ).
+		expect( @socket ).to receive( :send ).with( "15:9:terminate,0:}]" )
+		expect( @socket ).to receive( :recv ).
 			and_return( "59:7:headers,6:3:msg,]4:rows,29:25:21:signal sent to server,]]}" )
-		@control.terminate.should == [{ :msg => "signal sent to server" }]
+		expect( @control.terminate ).to eq( [{ :msg => "signal sent to server" }] )
 	end
 
 	it "sends a 'help' command to the control port when #help is called" do
-		@socket.should_receive( :send ).with( "10:4:help,0:}]" )
-		@socket.should_receive( :recv ).
+		expect( @socket ).to receive( :send ).with( "10:4:help,0:}]" )
+		expect( @socket ).to receive( :recv ).
 			and_return( "416:7:headers,14:4:name,4:help,]4:rows,376:35:4:stop" +
 			            ",24:stop the server (SIGINT),]30:6:reload,17:reload " +
 			            "the server,]23:4:help,12:this command,]37:12:control" +
@@ -79,7 +67,7 @@ describe Mongrel2::Control do
 			            "8:4:time,17:the server's time,]28:4:uuid,17:the serv" +
 			            "er's uuid,]40:4:info,29:information about this serve" +
 			            "r,]]}" )
-		@control.help.should == [
+		expect( @control.help ).to eq([
 			{:name => "stop",         :help => "stop the server (SIGINT)"},
 			{:name => "reload",       :help => "reload the server"},
 			{:name => "help",         :help => "this command"},
@@ -90,27 +78,27 @@ describe Mongrel2::Control do
 			{:name => "time",         :help => "the server's time"},
 			{:name => "uuid",         :help => "the server's uuid"},
 			{:name => "info",         :help => "information about this server"}
-		]
+		])
 	end
 
 	it "sends a 'uuid' command to the control port when #uuid is called" do
-		@socket.should_receive( :send ).with( "10:4:uuid,0:}]" )
-		@socket.should_receive( :recv ).
+		expect( @socket ).to receive( :send ).with( "10:4:uuid,0:}]" )
+		expect( @socket ).to receive( :recv ).
 			and_return( "75:7:headers,7:4:uuid,]4:rows,44:40:36:34D8E57C-3E91" +
 			            "-4F24-9BBE-0B53C1827CB4,]]}" )
-		@control.uuid.should == [{ :uuid => '34D8E57C-3E91-4F24-9BBE-0B53C1827CB4' }]
+		expect( @control.uuid ).to eq( [{ :uuid => '34D8E57C-3E91-4F24-9BBE-0B53C1827CB4' }] )
 	end
 
 	it "sends an 'info' command to the control port when #info is called" do
-		@socket.should_receive( :send ).with( "10:4:info,0:}]" )
-		@socket.should_receive( :recv ).
+		expect( @socket ).to receive( :send ).with( "10:4:info,0:}]" )
+		expect( @socket ).to receive( :recv ).
 			and_return( "260:7:headers,92:4:port,9:bind_addr,4:uuid,6:chroot," +
 			            "10:access_log,9:error_log,8:pid_file,16:default_host" +
 			            "name,]4:rows,142:137:4:8113#7:0.0.0.0,36:34D8E57C-3E" +
 			            "91-4F24-9BBE-0B53C1827CB4,2:./,18:.//logs/access.log" +
 			            ",15:/logs/error.log,18:./run/mongrel2.pid,9:localhos" +
 			            "t,]]}" )
-		@control.info.should == [{
+		expect( @control.info ).to eq([{
 			:port             => 8113,
 			:bind_addr        => "0.0.0.0",
 			:uuid             => "34D8E57C-3E91-4F24-9BBE-0B53C1827CB4",
@@ -119,14 +107,14 @@ describe Mongrel2::Control do
 			:error_log        => "/logs/error.log",
 			:pid_file         => "./run/mongrel2.pid",
 			:default_hostname => "localhost"
-		}]
+		}])
 	end
 
 	it "sends a 'status' command with a 'what' option set to 'tasks' to the control port " +
 	   "when #tasklist is called" do
 
-		@socket.should_receive( :send ).with( "28:6:status,15:4:what,5:tasks,}]" )
-		@socket.should_receive( :recv ).
+		expect( @socket ).to receive( :send ).with( "28:6:status,15:4:what,5:tasks,}]" )
+		expect( @socket ).to receive( :recv ).
 			and_return( "343:7:headers,38:2:id,6:system,4:name,5:state,6:status," +
 			            "]4:rows,279:38:1:1#5:false!6:SERVER,7:read fd,4:idle,]5" +
 			            "1:1:2#5:false!12:Handler_task,12:read handler,4:idle,]5" +
@@ -134,55 +122,55 @@ describe Mongrel2::Control do
 			            "8:1:4#5:false!7:control,12:read handler,7:running,]31:1" +
 			            ":5#5:false!6:ticker,0:,4:idle,]36:1:6#4:true!6:fdtask,5" +
 			            ":yield,5:ready,]]}" )
-		@control.tasklist.should == [
+		expect( @control.tasklist ).to eq([
 			{:id=>1, :system=>false, :name=>"SERVER",       :state=>"read fd",      :status=>"idle"},
 			{:id=>2, :system=>false, :name=>"Handler_task", :state=>"read handler", :status=>"idle"},
 			{:id=>3, :system=>false, :name=>"Handler_task", :state=>"read handler", :status=>"idle"},
 			{:id=>4, :system=>false, :name=>"control",      :state=>"read handler", :status=>"running"},
 			{:id=>5, :system=>false, :name=>"ticker",       :state=>"",             :status=>"idle"},
 			{:id=>6, :system=>true,  :name=>"fdtask",       :state=>"yield",        :status=>"ready"}
-		]
+		])
 	end
 
 	it "sends an 'status' command with a 'what' option set to 'net' to the control port " +
 	   "when #conn_status is called" do
 
-		@socket.should_receive( :send ).with( "26:6:status,13:4:what,3:net,}]" )
-		@socket.should_receive( :recv ).
+		expect( @socket ).to receive( :send ).with( "26:6:status,13:4:what,3:net,}]" )
+		expect( @socket ).to receive( :recv ).
 			and_return( "150:7:headers,86:2:id,2:fd,4:type,9:last_ping,9:last_read," +
 			            "10:last_write,10:bytes_read,13:bytes_written,]4:rows,39:35" +
 			            ":1:2#2:38#1:1#1:0#1:0#1:0#3:405#1:0#]]}" )
-		@control.conn_status.should == [
+		expect( @control.conn_status ).to eq([
 			{:id=>2, :fd=>38, :type=>1, :last_ping=>0, :last_read=>0, :last_write=>0,
 				:bytes_read=>405, :bytes_written=>0}
-		]
+		])
 	end
 
 	it "sends a 'time' command to the control port when #time is called" do
-		@socket.should_receive( :send ).with( "10:4:time,0:}]" )
-		@socket.should_receive( :recv ).
+		expect( @socket ).to receive( :send ).with( "10:4:time,0:}]" )
+		expect( @socket ).to receive( :recv ).
 			and_return( "49:7:headers,7:4:time,]4:rows,18:14:10:1315532674,]]}" )
-		@control.time.should == Time.at( 1315532674 )
+		expect( @control.time ).to eq( Time.at( 1315532674 ) )
 	end
 
 	it "sends a 'kill' command with an ID equal to the argument to the control port when #kill " +
 	   "is called" do
-		@socket.should_receive( :send ).with( "19:4:kill,9:2:id,1:0#}]" )
-		@socket.should_receive( :recv ).and_return( "40:7:headers,9:6:status,]4:rows,8:5:2:OK,]]}" )
-		@control.kill( 0 ).should == [{ :status => "OK" }]
+		expect( @socket ).to receive( :send ).with( "19:4:kill,9:2:id,1:0#}]" )
+		expect( @socket ).to receive( :recv ).and_return( "40:7:headers,9:6:status,]4:rows,8:5:2:OK,]]}" )
+		expect( @control.kill( 0 ) ).to eq( [{ :status => "OK" }] )
 	end
 
 	it "sends a 'control_stop' command to the control port when #info is called" do
-		@socket.should_receive( :send ).with( "19:12:control_stop,0:}]" )
-		@socket.should_receive( :recv ).
+		expect( @socket ).to receive( :send ).with( "19:12:control_stop,0:}]" )
+		expect( @socket ).to receive( :recv ).
 			and_return( "63:7:headers,6:3:msg,]4:rows,33:29:25:stopping the control port,]]}" )
-		@control.control_stop.should == [{:msg => "stopping the control port"}]
+		expect( @control.control_stop ).to eq( [{:msg => "stopping the control port"}] )
 	end
 
 
 	it "raises an exception if the server responds with an error" do
-		@socket.should_receive( :send ).with( "19:4:kill,9:2:id,1:0#}]" )
-		@socket.should_receive( :recv ).
+		expect( @socket ).to receive( :send ).with( "19:4:kill,9:2:id,1:0#}]" )
+		expect( @socket ).to receive( :recv ).
 			and_return( "61:4:code,16:INVALID_ARGUMENT,5:error,22:Invalid argument type.,}" )
 
 		expect {