mongrel2 0.38.0 → 0.39.0

data/spec/mongrel2/handler_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'
@@ -47,7 +35,7 @@ describe Mongrel2::Handler do
 
 
 	before( :all ) do
-		setup_logging( :fatal )
+		setup_logging()
 		setup_config_db()
 	end
 
@@ -59,13 +47,13 @@ describe Mongrel2::Handler do
 	# Ensure 0MQ never actually gets called
 	before( :each ) do
 		@ctx = double( '0mq context', close: nil )
-		@request_sock = double( "request socket", setsockopt: nil, connect: nil, close: nil )
-		@response_sock = double( "response socket", setsockopt: nil, connect: nil, close: nil )
+		@request_sock = double( "request socket", :linger= => nil, :connect => nil, :close => nil )
+		@response_sock = double( "response socket", :linger= => nil, :connect => nil, :close => 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 )
 
-		ZMQ.stub( :select ).and_return([ [@request_sock], [], [] ])
+		allow( ZMQ ).to receive( :select ).and_return([ [@request_sock], [], [] ])
 
 		Mongrel2.instance_variable_set( :@zmq_ctx, @ctx )
 	end
@@ -98,25 +86,25 @@ describe Mongrel2::Handler do
 		   "application ID" do
 
 			req = make_request()
-			@request_sock.should_receive( :recv ).and_return( req )
+			expect( @request_sock ).to receive( :recv ).and_return( req )
 
 			res = OneShotHandler.run( TEST_UUID )
 
 			# It should have pulled its connection info from the Handler entry in the database
-			res.conn.app_id.should == TEST_UUID
-			res.conn.sub_addr.should == TEST_SEND_SPEC
-			res.conn.pub_addr.should == TEST_RECV_SPEC
+			expect( res.conn.app_id ).to eq( TEST_UUID )
+			expect( res.conn.sub_addr ).to eq( TEST_SEND_SPEC )
+			expect( res.conn.pub_addr ).to eq( TEST_RECV_SPEC )
 		end
 
 		it "knows what handler config corresponds to its" do
 			req = make_request()
-			@request_sock.should_receive( :recv ).and_return( req )
+			expect( @request_sock ).to receive( :recv ).and_return( req )
 
 			res = OneShotHandler.run( TEST_UUID )
 
-			res.handler_config.should be_a( Mongrel2::Config::Handler )
-			res.handler_config.send_spec.should == TEST_SEND_SPEC
-			res.handler_config.recv_spec.should == TEST_RECV_SPEC
+			expect( res.handler_config ).to be_a( Mongrel2::Config::Handler )
+			expect( res.handler_config.send_spec ).to eq( TEST_SEND_SPEC )
+			expect( res.handler_config.recv_spec ).to eq( TEST_RECV_SPEC )
 		end
 
 	end
@@ -132,7 +120,7 @@ describe Mongrel2::Handler do
 			Mongrel2::Config::Handler.dataset.truncate
 			expect {
 				Mongrel2::Handler.connection_info_for( TEST_UUID )
-			}.should raise_error()
+			}.to raise_error()
 		end
 
 	end
@@ -140,27 +128,27 @@ describe Mongrel2::Handler do
 
 	it "dispatches HTTP requests to the #handle method" do
 		req = make_request()
-		@request_sock.should_receive( :recv ).and_return( req )
+		expect( @request_sock ).to receive( :recv ).and_return( req )
 
 		res = OneShotHandler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC ).run
 
-		res.transactions.should have( 1 ).member
+		expect( res.transactions ).to have( 1 ).member
 		request, response = res.transactions.first
-		request.should be_a( Mongrel2::HTTPRequest )
-		response.should be_a( Mongrel2::HTTPResponse )
-		response.status.should == 204
+		expect( request ).to be_a( Mongrel2::HTTPRequest )
+		expect( response ).to be_a( Mongrel2::HTTPResponse )
+		expect( response.status ).to eq( 204 )
 	end
 
 	it "ignores JSON messages by default" do
 		req = make_json_request()
-		@request_sock.should_receive( :recv ).and_return( req )
+		expect( @request_sock ).to receive( :recv ).and_return( req )
 
 		res = OneShotHandler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC ).run
 
-		res.transactions.should have( 1 ).member
+		expect( res.transactions ).to have( 1 ).member
 		request, response = res.transactions.first
-		request.should be_a( Mongrel2::JSONRequest )
-		response.should be_nil()
+		expect( request ).to be_a( Mongrel2::JSONRequest )
+		expect( response ).to be_nil()
 	end
 
 	it "dispatches JSON message to the #handle_json method" do
@@ -171,26 +159,26 @@ describe Mongrel2::Handler do
 		end
 
 		req = make_json_request()
-		@request_sock.should_receive( :recv ).and_return( req )
+		expect( @request_sock ).to receive( :recv ).and_return( req )
 
 		res = json_handler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC ).run
 
-		res.transactions.should have( 1 ).member
+		expect( res.transactions ).to have( 1 ).member
 		request, response = res.transactions.first
-		request.should be_a( Mongrel2::JSONRequest )
-		response.should be_a( Mongrel2::Response )
+		expect( request ).to be_a( Mongrel2::JSONRequest )
+		expect( response ).to be_a( Mongrel2::Response )
 	end
 
 	it "ignores XML messages by default" do
 		req = make_xml_request()
-		@request_sock.should_receive( :recv ).and_return( req )
+		expect( @request_sock ).to receive( :recv ).and_return( req )
 
 		res = OneShotHandler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC ).run
 
-		res.transactions.should have( 1 ).member
+		expect( res.transactions ).to have( 1 ).member
 		request, response = res.transactions.first
-		request.should be_a( Mongrel2::XMLRequest )
-		response.should be_nil()
+		expect( request ).to be_a( Mongrel2::XMLRequest )
+		expect( response ).to be_nil()
 	end
 
 	it "dispatches XML message to the #handle_xml method" do
@@ -201,14 +189,14 @@ describe Mongrel2::Handler do
 		end
 
 		req = make_xml_request()
-		@request_sock.should_receive( :recv ).and_return( req )
+		expect( @request_sock ).to receive( :recv ).and_return( req )
 
 		res = xml_handler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC ).run
 
-		res.transactions.should have( 1 ).member
+		expect( res.transactions ).to have( 1 ).member
 		request, response = res.transactions.first
-		request.should be_a( Mongrel2::XMLRequest )
-		response.should be_a( Mongrel2::Response )
+		expect( request ).to be_a( Mongrel2::XMLRequest )
+		expect( response ).to be_a( Mongrel2::Response )
 	end
 
 	it "dispatches WebSocket opening handshakes to the #handle_websocket_handshake method" do
@@ -219,14 +207,14 @@ describe Mongrel2::Handler do
 		end
 
 		req = make_websocket_handshake()
-		@request_sock.should_receive( :recv ).and_return( req )
+		expect( @request_sock ).to receive( :recv ).and_return( req )
 
 		res = ws_handler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC ).run
 
-		res.transactions.should have( 1 ).member
+		expect( res.transactions ).to have( 1 ).member
 		request, response = res.transactions.first
-		request.should be_a( Mongrel2::WebSocket::ClientHandshake )
-		response.should be_a( Mongrel2::WebSocket::ServerHandshake )
+		expect( request ).to be_a( Mongrel2::WebSocket::ClientHandshake )
+		expect( response ).to be_a( Mongrel2::WebSocket::ServerHandshake )
 	end
 
 	it "dispatches WebSocket protocol frames to the #handle_websocket method" do
@@ -237,41 +225,41 @@ describe Mongrel2::Handler do
 		end
 
 		req = make_websocket_frame()
-		@request_sock.should_receive( :recv ).and_return( req )
+		expect( @request_sock ).to receive( :recv ).and_return( req )
 
 		res = ws_handler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC ).run
 
-		res.transactions.should have( 1 ).member
+		expect( res.transactions ).to have( 1 ).member
 		request, response = res.transactions.first
-		request.should be_a( Mongrel2::WebSocket::Frame )
-		response.should be_a( Mongrel2::WebSocket::Frame )
+		expect( request ).to be_a( Mongrel2::WebSocket::Frame )
+		expect( response ).to be_a( Mongrel2::WebSocket::Frame )
 	end
 
 	it "continues when a ZMQ::Error is received but the connection remains open" do
 		req = make_request()
 
-		@request_sock.should_receive( :recv ).and_raise( ZMQ::Error.new("Interrupted system call.") )
-		@request_sock.should_receive( :recv ).and_return( req )
+		expect( @request_sock ).to receive( :recv ).and_raise( ZMQ::Error.new("Interrupted system call.") )
+		expect( @request_sock ).to receive( :recv ).and_return( req )
 
 		res = OneShotHandler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC ).run
 
-		res.transactions.should have( 1 ).member
+		expect( res.transactions ).to have( 1 ).member
 		request, response = res.transactions.first
-		request.should be_a( Mongrel2::HTTPRequest )
-		response.should be_a( Mongrel2::HTTPResponse )
-		response.status.should == 204
+		expect( request ).to be_a( Mongrel2::HTTPRequest )
+		expect( response ).to be_a( Mongrel2::HTTPResponse )
+		expect( response.status ).to eq( 204 )
 	end
 
 	it "ignores disconnect notices by default" do
 		req = make_json_request( :path => '@*', :body => {'type' => 'disconnect'} )
-		@request_sock.should_receive( :recv ).and_return( req )
+		expect( @request_sock ).to receive( :recv ).and_return( req )
 
 		res = OneShotHandler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC ).run
 
-		res.transactions.should have( 1 ).member
+		expect( res.transactions ).to have( 1 ).member
 		request, response = res.transactions.first
-		request.should be_a( Mongrel2::JSONRequest )
-		response.should be_nil()
+		expect( request ).to be_a( Mongrel2::JSONRequest )
+		expect( response ).to be_nil()
 	end
 
 	it "dispatches disconnect notices to the #handle_disconnect method" do
@@ -282,33 +270,33 @@ describe Mongrel2::Handler do
 		end
 
 		req = make_json_request( :path => '@*', :body => {'type' => 'disconnect'} )
-		@request_sock.should_receive( :recv ).and_return( req )
+		expect( @request_sock ).to receive( :recv ).and_return( req )
 
 		res = disconnect_handler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC ).run
 
-		res.transactions.should have( 1 ).member
+		expect( res.transactions ).to have( 1 ).member
 		request, response = res.transactions.first
-		request.should be_a( Mongrel2::JSONRequest )
-		response.should be_nil()
+		expect( request ).to be_a( Mongrel2::JSONRequest )
+		expect( response ).to be_nil()
 	end
 
 	it "cancels async upload notices by default" do
 		req = make_request( 'METHOD' => 'POST', :headers => {'x-mongrel2-upload-start' => 'uploadfile.XXX'} )
-		@request_sock.should_receive( :recv ).and_return( req )
-		@response_sock.should_receive( :send ).with( "#{TEST_UUID} 1:8, " )
+		expect( @request_sock ).to receive( :recv ).and_return( req )
+		expect( @response_sock ).to receive( :send ).with( "#{TEST_UUID} 1:8, " )
 
 		res = OneShotHandler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC ).run
 
-		res.transactions.should have( 1 ).member
+		expect( res.transactions ).to have( 1 ).member
 		request, response = res.transactions.first
-		response.should be_nil()
+		expect( response ).to be_nil()
 	end
 
 	it "re-establishes its connection when told to restart" do
 		res = OneShotHandler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC )
 		original_conn = res.conn
 		res.restart
-		res.conn.should_not equal( original_conn )
+		expect( res.conn ).to_not equal( original_conn )
 	end
 
 end

data/spec/mongrel2/httprequest_spec.rb

@@ -1,20 +1,10 @@
 #!/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_relative '../helpers'
 
 require 'rspec'
 require 'tnetstring'
 
-require 'spec/lib/helpers'
-
 require 'mongrel2'
 require 'mongrel2/httprequest'
 require 'mongrel2/httpresponse'
@@ -27,7 +17,7 @@ require 'mongrel2/httpresponse'
 describe Mongrel2::HTTPRequest do
 
 	before( :all ) do
-		setup_logging( :fatal )
+		setup_logging()
 		@factory = Mongrel2::RequestFactory.new( route: '/glamour' )
 	end
 
@@ -42,55 +32,55 @@ describe Mongrel2::HTTPRequest do
 
 	it "can create an HTTPResponse for itself" do
 		result = @req.response
-		result.should be_a( Mongrel2::HTTPResponse )
-		result.sender_id.should == @req.sender_id
-		result.conn_id.should == @req.conn_id
+		expect( result ).to be_a( Mongrel2::HTTPResponse )
+		expect( result.sender_id ).to eq( @req.sender_id )
+		expect( result.conn_id ).to eq( @req.conn_id )
 	end
 
 	it "remembers its corresponding HTTPResponse if it's created it already" do
 		result = @req.response
-		result.should be_a( Mongrel2::HTTPResponse )
-		result.sender_id.should == @req.sender_id
-		result.conn_id.should == @req.conn_id
+		expect( result ).to be_a( Mongrel2::HTTPResponse )
+		expect( result.sender_id ).to eq( @req.sender_id )
+		expect( result.conn_id ).to eq( @req.conn_id )
 	end
 
 	it "knows that its connection isn't persistent if it's an HTTP/1.0 request" do
 		@req.headers.version = 'HTTP/1.0'
-		@req.should_not be_keepalive()
+		expect( @req ).to_not be_keepalive()
 	end
 
 	it "knows that its connection isn't persistent if has a 'close' token in its Connection header" do
 		@req.headers.version = 'HTTP/1.1'
 		@req.headers[ :connection ] = 'violent, close'
-		@req.should_not be_keepalive()
+		expect( @req ).to_not be_keepalive()
 	end
 
 	it "knows that its connection could be persistent if doesn't have a Connection header, " +
 	   "and it's an HTTP/1.1 request" do
 		@req.headers.version = 'HTTP/1.1'
 		@req.headers.delete( :connection )
-		@req.should be_keepalive()
+		expect( @req ).to be_keepalive()
 	end
 
 	it "knows that its connection is persistent if has a Connection header without a 'close' " +
 	   "token and it's an HTTP/1.1 request" do
 		@req.headers.version = 'HTTP/1.1'
 		@req.headers.connection = 'keep-alive'
-		@req.should be_keepalive()
+		expect( @req ).to be_keepalive()
 	end
 
 	it "knows what its URL scheme was" do
-		@req.scheme.should == 'http'
+		expect( @req.scheme ).to eq( 'http' )
 	end
 
 	it "falls back to 'http' if the url_scheme isn't provided (mongrel2 <= 1.8.0)" do
 		@req.headers.url_scheme = nil
-		@req.scheme.should == 'http'
+		expect( @req.scheme ).to eq( 'http' )
 	end
 
 	it "knows that it was an SSL-encrypted request if its scheme was 'https'" do
 		@req.headers.url_scheme = 'https'
-		@req.should be_secure()
+		expect( @req ).to be_secure()
 	end
 
 
@@ -105,30 +95,30 @@ describe Mongrel2::HTTPRequest do
 		end
 
 		it "provides a convenience method for fetching the 'Content-type' header" do
-			@req.content_type.should == 'application/x-pdf'
+			expect( @req.content_type ).to eq( 'application/x-pdf' )
 		end
 
 		it "provides a convenience method for resetting the 'Content-type' header" do
 			@req.content_type = 'application/json'
-			@req.content_type.should == 'application/json'
+			expect( @req.content_type ).to eq( 'application/json' )
 		end
 
 		it "provides a convenience method for fetching the 'Content-encoding' header" do
-			@req.content_encoding.should == 'gzip'
+			expect( @req.content_encoding ).to eq( 'gzip' )
 		end
 
 		it "provides a convenience method for resetting the 'Content-encoding' header" do
 			@req.content_encoding = 'identity'
-			@req.content_encoding.should == 'identity'
+			expect( @req.content_encoding ).to eq( 'identity' )
 		end
 
 		it "provides a convenience method for fetching the request's Content-length header" do
-			@req.content_length.should == 28113
+			expect( @req.content_length ).to eq( 28113 )
 		end
 
 		it "returns 0 as the content_length if the request doesn't have a Content-length header" do
 			@req.headers.delete( :content_length )
-			@req.content_length.should == 0
+			expect( @req.content_length ).to eq( 0 )
 		end
 
 		it "raises an exception if the Content-length header contains something other than an integer" do

data/spec/mongrel2/httpresponse_spec.rb

@@ -1,19 +1,7 @@
 #!/usr/bin/env ruby
 #encoding: utf-8
 
-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/httprequest'
@@ -27,7 +15,7 @@ require 'mongrel2/httpresponse'
 describe Mongrel2::HTTPResponse do
 
 	before( :all ) do
-		setup_logging( :fatal )
+		setup_logging()
 	end
 
 	before( :each ) do
@@ -40,51 +28,51 @@ describe Mongrel2::HTTPResponse do
 
 
 	it "has a headers table" do
-		@response.headers.should be_a( Mongrel2::Table )
+		expect( @response.headers ).to be_a( Mongrel2::Table )
 	end
 
 	it "allows headers to be set when the response is created" do
 		response = Mongrel2::HTTPResponse.new( TEST_UUID, 299, :content_type => 'image/jpeg' )
-		response.headers.content_type.should == 'image/jpeg'
+		expect( response.headers.content_type ).to eq( 'image/jpeg' )
 	end
 
 	it "is a No Content response if not set otherwise" do
-		@response.status_line.should == 'HTTP/1.1 204 No Content'
+		expect( @response.status_line ).to eq( 'HTTP/1.1 204 No Content' )
 	end
 
 	it "returns an empty response if its status is set to NO_CONTENT" do
 		@response.puts "The response body"
 		@response.status = HTTP::NO_CONTENT
-		@response.header_data.should_not =~ /Content-length/i
-		@response.header_data.should_not =~ /Content-type/i
-		@response.to_s.should_not =~ /The response body/i
+		expect( @response.header_data ).to_not match( /Content-length/i )
+		expect( @response.header_data ).to_not match( /Content-type/i )
+		expect( @response.to_s ).to_not match( /The response body/i )
 	end
 
 	it "sets Date, Content-type, and Content-length headers automatically if they haven't been set" do
 		@response << "Some stuff."
 
-		@response.header_data.should =~ %r{Content-type: #{Mongrel2::HTTPResponse::DEFAULT_CONTENT_TYPE}}i
-		@response.header_data.should =~ /Content-length: 11/i
-		@response.header_data.should =~ /Date: #{HTTP_DATE}/i
+		expect( @response.header_data ).to match( %r{Content-type: #{Mongrel2::HTTPResponse::DEFAULT_CONTENT_TYPE}}i )
+		expect( @response.header_data ).to match( /Content-length: 11/i )
+		expect( @response.header_data ).to match( /Date: #{HTTP_DATE}/i )
 	end
 
 	it "re-calculates the automatically-added headers when re-rendered" do
-		@response.header_data.should =~ /Content-length: 0\b/i
+		expect( @response.header_data ).to match( /Content-length: 0\b/i )
 		@response.status = HTTP::OK
 		@response << "More data!"
-		@response.header_data.should =~ /Content-length: 10\b/i
+		expect( @response.header_data ).to match( /Content-length: 10\b/i )
 	end
 
 	it "doesn't have a body" do
-		@response.body.size.should == 0
+		expect( @response.body.size ).to eq( 0 )
 	end
 
 	it "stringifies to a valid RFC2616 response string" do
-		@response.to_s.should =~ HTTP_RESPONSE
+		expect( @response.to_s ).to match( HTTP_RESPONSE )
 	end
 
 	it "has some default headers" do
-		@response.headers['Server'].should == Mongrel2.version_string( true )
+		expect( @response.headers['Server'] ).to eq( Mongrel2.version_string( true ) )
 	end
 
 	it "can be reset to a pristine state" do
@@ -94,33 +82,33 @@ describe Mongrel2::HTTPResponse do
 
 		@response.reset
 
-		@response.should_not be_handled()
-		@response.body.should be_a( StringIO )
-		@response.body.size.should == 0
-		@response.headers.should have(1).keys
+		expect( @response ).to_not be_handled()
+		expect( @response.body ).to be_a( StringIO )
+		expect( @response.body.size ).to eq( 0 )
+		expect( @response.headers ).to have(1).keys
 	end
 
 	it "sets its status line to 200 OK if the body is set and the status hasn't yet been set" do
 		@response << "Some stuff"
-		@response.status_line.should == 'HTTP/1.1 200 OK'
+		expect( @response.status_line ).to eq( 'HTTP/1.1 200 OK' )
 	end
 
 	it "sets its status line to 204 No Content if the body is set and the status hasn't yet been set" do
-		@response.status_line.should == 'HTTP/1.1 204 No Content'
+		expect( @response.status_line ).to eq( 'HTTP/1.1 204 No Content' )
 	end
 
 	it "can find the length of its body if it's a String" do
 		test_body = 'A string full of stuff'
 		@response.body = test_body
 
-		@response.get_content_length.should == test_body.length
+		expect( @response.get_content_length ).to eq( test_body.length )
 	end
 
 	it "can find the length of its body if it's a String with multi-byte characters in it" do
 		test_body = 'Хорошая собака, Стрелке! Очень хорошо.'
 		@response << test_body
 
-		@response.get_content_length.should == test_body.bytesize
+		expect( @response.get_content_length ).to eq( test_body.bytesize )
 	end
 
 	it "can find the length of its body if it's a seekable IO" do
@@ -131,7 +119,7 @@ describe Mongrel2::HTTPResponse do
 
 		@response.body = test_body
 
-		@response.get_content_length.should == length
+		expect( @response.get_content_length ).to eq( length )
 	end
 
 	it "can find the length of its body even if it's an IO that's been set to do a partial read" do
@@ -142,94 +130,94 @@ describe Mongrel2::HTTPResponse do
 
 		@response.body = test_body
 
-		@response.get_content_length.should == length - 100
+		expect( @response.get_content_length ).to eq( length - 100 )
 	end
 
 	it "knows whether or not it has been handled" do
-		@response.should_not be_handled()
+		expect( @response ).to_not be_handled()
 		@response.status = HTTP::OK
-		@response.should be_handled()
+		expect( @response ).to be_handled()
 	end
 
 	it "knows that it has been handled even if the status is set to NOT_FOUND" do
 		@response.reset
 		@response.status = HTTP::NOT_FOUND
-		@response.should be_handled()
+		expect( @response ).to be_handled()
 	end
 
 
 	it "knows what category of response it is" do
 		@response.status = HTTP::CREATED
-		@response.status_category.should == 2
+		expect( @response.status_category ).to eq( 2 )
 
 		@response.status = HTTP::NOT_ACCEPTABLE
-		@response.status_category.should == 4
+		expect( @response.status_category ).to eq( 4 )
 	end
 
 
 	it "knows if its status indicates it is an informational response" do
 		@response.status = HTTP::PROCESSING
-		@response.status_category.should == 1
-		@response.status_is_informational?.should == true
+		expect( @response.status_category ).to eq( 1 )
+		expect( @response.status_is_informational? ).to eq( true )
 	end
 
 
 	it "knows if its status indicates it is a successful response" do
 		@response.status = HTTP::ACCEPTED
-		@response.status_category.should == 2
-		@response.status_is_successful?.should == true
+		expect( @response.status_category ).to eq( 2 )
+		expect( @response.status_is_successful? ).to eq( true )
 	end
 
 
 	it "knows if its status indicates it is a redirected response" do
 		@response.status = HTTP::SEE_OTHER
-		@response.status_category.should == 3
-		@response.status_is_redirect?.should == true
+		expect( @response.status_category ).to eq( 3 )
+		expect( @response.status_is_redirect? ).to eq( true )
 	end
 
 
 	it "knows if its status indicates there was a client error" do
 		@response.status = HTTP::GONE
-		@response.status_category.should == 4
-		@response.status_is_clienterror?.should == true
+		expect( @response.status_category ).to eq( 4 )
+		expect( @response.status_is_clienterror? ).to eq( true )
 	end
 
 
 	it "knows if its status indicates there was a server error" do
 		@response.status = HTTP::VERSION_NOT_SUPPORTED
-		@response.status_category.should == 5
-		@response.status_is_servererror?.should == true
+		expect( @response.status_category ).to eq( 5 )
+		expect( @response.status_is_servererror? ).to eq( true )
 	end
 
 
 	it "knows that a 100 response shouldn't have a body" do
 		@response.status = HTTP::CONTINUE
-		@response.should be_bodiless()
+		expect( @response ).to be_bodiless()
 	end
 
 
 	it "knows that a 204 response shouldn't have a body" do
 		@response.status = HTTP::NO_CONTENT
-		@response.should be_bodiless()
+		expect( @response ).to be_bodiless()
 	end
 
 
 	it "knows that a response with a body explicitly set to nil is bodiless" do
 		@response.status = HTTP::CREATED
 		@response.body = nil
-		@response.should be_bodiless()
+		expect( @response ).to be_bodiless()
 	end
 
 
 	it "knows what the response content type is" do
 		@response.headers['Content-Type'] = 'text/erotica'
-		@response.content_type.should == 'text/erotica'
+		expect( @response.content_type ).to eq( 'text/erotica' )
 	end
 
 
 	it "can modify the response content type" do
 		@response.content_type = 'image/nude'
-		@response.headers['Content-Type'].should == 'image/nude'
+		expect( @response.headers['Content-Type'] ).to eq( 'image/nude' )
 	end
 
 
@@ -238,21 +226,21 @@ describe Mongrel2::HTTPResponse do
 		test_body = StringIO.new( test_body_content )
 		@response.body = test_body
 
-		@response.get_content_length.should == test_body_content.length
+		expect( @response.get_content_length ).to eq( test_body_content.length )
 	end
 
 
 	it "returns a body length of 0 if it's a bodiless status code" do
 		@response.puts "Some stuff"
 		@response.status = HTTP::NO_CONTENT
-		@response.get_content_length.should == 0
+		expect( @response.get_content_length ).to eq( 0 )
 	end
 
 
 	it "returns a body length of 0 if it has a nil body" do
 		@response.body = nil
 		@response.status = HTTP::CREATED
-		@response.get_content_length.should == 0
+		expect( @response.get_content_length ).to eq( 0 )
 	end
 
 
@@ -265,36 +253,36 @@ describe Mongrel2::HTTPResponse do
 		@response.header.content_length = 2048
 		@response.body = ''
 
-		@response.status_line.should =~ /200 OK/i
+		expect( @response.status_line ).to match( /200 OK/i )
 	end
 
 
 	it "can build a valid HTTP status line for its status" do
 		@response.status = HTTP::SEE_OTHER
-		@response.status_line.should == "HTTP/1.1 303 See Other"
+		expect( @response.status_line ).to eq( "HTTP/1.1 303 See Other" )
 	end
 
 
 	it "has pipelining disabled by default" do
-		@response.should_not be_keepalive()
+		expect( @response ).to_not be_keepalive()
 	end
 
 
 	it "has pipelining disabled if it's explicitly disabled" do
 		@response.keepalive = false
-		@response.should_not be_keepalive()
+		expect( @response ).to_not be_keepalive()
 	end
 
 
 	it "can be set to allow pipelining" do
 		@response.keepalive = true
-		@response.should be_keepalive()
+		expect( @response ).to be_keepalive()
 	end
 
 	it "has a puts method for appending objects to the body" do
 		@response.puts( :something_to_sable )
 		@response.body.rewind
-		@response.body.read.should == "something_to_sable\n"
+		expect( @response.body.read ).to eq( "something_to_sable\n" )
 	end
 
 end