mongrel2 0.38.0 → 0.39.0

data/spec/mongrel2/request_spec.rb

@@ -1,22 +1,13 @@
 #!/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 'tmpdir'
 require 'tempfile'
 
-require 'spec/lib/helpers'
-
 require 'mongrel2'
 require 'mongrel2/request'
 
@@ -28,7 +19,7 @@ require 'mongrel2/request'
 describe Mongrel2::Request do
 
 	before( :all ) do
-		setup_logging( :fatal )
+		setup_logging()
 		@factory = Mongrel2::RequestFactory.new( route: '/form' )
 	end
 
@@ -42,12 +33,12 @@ describe Mongrel2::Request do
 		message = make_request()
 		req = Mongrel2::Request.parse( message )
 
-		req.should be_a( Mongrel2::Request )
-		req.sender_id.should == TEST_UUID
-		req.conn_id.should == TEST_ID
+		expect( req ).to be_a( Mongrel2::Request )
+		expect( req.sender_id ).to eq( TEST_UUID )
+		expect( req.conn_id ).to eq( TEST_ID )
 
-		req.headers.should be_a( Mongrel2::Table )
-		req.headers['Host'].should == TEST_HEADERS['host']
+		expect( req.headers ).to be_a( Mongrel2::Table )
+		expect( req.headers['Host'] ).to eq( TEST_HEADERS['host'] )
 	end
 
 	it "can parse a request message with TNetstring headers" do
@@ -55,12 +46,12 @@ describe Mongrel2::Request do
 		message = make_tn_request()
 		req = Mongrel2::Request.parse( message )
 
-		req.should be_a( Mongrel2::Request )
-		req.sender_id.should == TEST_UUID
-		req.conn_id.should == TEST_ID
+		expect( req ).to be_a( Mongrel2::Request )
+		expect( req.sender_id ).to eq( TEST_UUID )
+		expect( req.conn_id ).to eq( TEST_ID )
 
-		req.headers.should be_a( Mongrel2::Table )
-		req.headers.host.should == TEST_HEADERS['host']
+		expect( req.headers ).to be_a( Mongrel2::Table )
+		expect( req.headers.host ).to eq( TEST_HEADERS['host'] )
 	end
 
 	it "can parse a request message with a JSON body" do
@@ -68,14 +59,14 @@ describe Mongrel2::Request do
 		message = make_json_request()
 		req = Mongrel2::Request.parse( message )
 
-		req.should be_a( Mongrel2::JSONRequest )
-		req.sender_id.should == TEST_UUID
-		req.conn_id.should == TEST_ID
+		expect( req ).to be_a( Mongrel2::JSONRequest )
+		expect( req.sender_id ).to eq( TEST_UUID )
+		expect( req.conn_id ).to eq( TEST_ID )
 
-		req.headers.should be_a( Mongrel2::Table )
-		req.headers.path.should == TEST_JSON_PATH
+		expect( req.headers ).to be_a( Mongrel2::Table )
+		expect( req.headers.path ).to eq( TEST_JSON_PATH )
 
-		req.data.should == TEST_JSON_BODY
+		expect( req.data ).to eq( TEST_JSON_BODY )
 	end
 
 	it "raises an UnhandledMethodError with the name of the method for METHOD verbs that " +
@@ -86,7 +77,7 @@ describe Mongrel2::Request do
 	end
 
 	it "knows what kind of response it should return" do
-		Mongrel2::Request.response_class.should == Mongrel2::Response
+		expect( Mongrel2::Request.response_class ).to eq( Mongrel2::Response )
 	end
 
 
@@ -99,39 +90,39 @@ describe Mongrel2::Request do
 
 		it "can return an appropriate response instance for themselves" do
 			result = @req.response
-			result.should be_a( Mongrel2::Response )
-			result.sender_id.should == @req.sender_id
-			result.conn_id.should == @req.conn_id
+			expect( result ).to be_a( Mongrel2::Response )
+			expect( result.sender_id ).to eq( @req.sender_id )
+			expect( result.conn_id ).to eq( @req.conn_id )
 		end
 
 		it "remembers its response if it's already made one" do
-			@req.response.should equal( @req.response )
+			expect( @req.response ).to equal( @req.response )
 		end
 
 		it "allows the entity body to be replaced by assigning a String" do
 			@req.body = 'something else'
-			@req.body.should be_a( StringIO )
-			@req.body.string.should == 'something else'
+			expect( @req.body ).to be_a( StringIO )
+			expect( @req.body.string ).to eq( 'something else' )
 		end
 
 		it "doesn't try to wrap non-stringish entity body replacements in a StringIO" do
 			testobj = Object.new
 			@req.body = testobj
-			@req.body.should be( testobj )
+			expect( @req.body ).to be( testobj )
 		end
 
 		it "provides a convenience method for fetching the requestor's IP address" do
 			@req.headers.merge!(
 				'X-Forwarded-For' => '127.0.0.1'
 			)
-			@req.remote_ip.to_s.should == '127.0.0.1'
+			expect( @req.remote_ip.to_s ).to eq( '127.0.0.1' )
 		end
 
 		it "fetching the requestor's IP address even when travelling via proxies" do
 			@req.headers.merge!(
 				'X-Forwarded-For' => [ '127.0.0.1', '8.8.8.8', '4.4.4.4' ]
 			)
-			@req.remote_ip.to_s.should == '127.0.0.1'
+			expect( @req.remote_ip.to_s ).to eq( '127.0.0.1' )
 		end
 
 	end
@@ -143,21 +134,21 @@ describe Mongrel2::Request do
 			body = "some data".encode( 'binary' )
 			req = @factory.post( '/form', body, content_type: 'text/plain; charset=iso-8859-1' )
 
-			req.body.string.encoding.should be( Encoding::ISO_8859_1 )
+			expect( req.body.string.encoding ).to be( Encoding::ISO_8859_1 )
 		end
 
 		it "keeps the data as ascii-8bit if no charset is in the content-type header" do
 			body = "some data".encode( 'binary' )
 			req = @factory.post( '/form', body, content_type: 'application/octet-stream' )
 
-			req.body.string.encoding.should be( Encoding::ASCII_8BIT )
+			expect( req.body.string.encoding ).to be( Encoding::ASCII_8BIT )
 		end
 
 		it "keeps the data as ascii-8bit if there is no content-type header" do
 			body = "some data".encode( 'binary' )
 			req = @factory.post( '/form', body )
 
-			req.body.string.encoding.should be( Encoding::ASCII_8BIT )
+			expect( req.body.string.encoding ).to be( Encoding::ASCII_8BIT )
 		end
 
 	end
@@ -185,9 +176,9 @@ describe Mongrel2::Request do
 				register_request_type self, :__default
 			end
 
-			Mongrel2::Request.subclass_for_method( 'GET' ).should == subclass
-			Mongrel2::Request.subclass_for_method( 'POST' ).should == subclass
-			Mongrel2::Request.subclass_for_method( 'JSON' ).should == subclass
+			expect( Mongrel2::Request.subclass_for_method( 'GET' ) ).to eq( subclass )
+			expect( Mongrel2::Request.subclass_for_method( 'POST' ) ).to eq( subclass )
+			expect( Mongrel2::Request.subclass_for_method( 'JSON' ) ).to eq( subclass )
 		end
 
 		it "includes a mechanism for overriding the Request subclass for a particular request " +
@@ -196,9 +187,9 @@ describe Mongrel2::Request do
 				register_request_type self, :GET
 			end
 
-			Mongrel2::Request.subclass_for_method( 'GET' ).should == subclass
-			Mongrel2::Request.subclass_for_method( 'POST' ).should_not == subclass
-			Mongrel2::Request.subclass_for_method( 'JSON' ).should_not == subclass
+			expect( Mongrel2::Request.subclass_for_method( 'GET' ) ).to eq( subclass )
+			expect( Mongrel2::Request.subclass_for_method( 'POST' ) ).to_not eq( subclass )
+			expect( Mongrel2::Request.subclass_for_method( 'JSON' ) ).to_not eq( subclass )
 		end
 
 		it "clears any cached method -> subclass lookups when the default subclass changes" do
@@ -208,7 +199,7 @@ describe Mongrel2::Request do
 				register_request_type self, :__default
 			end
 
-			Mongrel2::Request.subclass_for_method( 'OPTIONS' ).should == subclass
+			expect( Mongrel2::Request.subclass_for_method( 'OPTIONS' ) ).to eq( subclass )
 		end
 
 	end
@@ -243,8 +234,8 @@ describe Mongrel2::Request do
 		it "knows if it's an 'async upload started' notification" do
 			req = @factory.post( '/form', '', x_mongrel2_upload_start: @spoolpath )
 
-			req.should be_upload_started()
-			req.should_not be_upload_done()
+			expect( req ).to be_upload_started()
+			expect( req ).to_not be_upload_done()
 		end
 
 		it "knows if it's an 'async upload done' notification" do
@@ -252,9 +243,9 @@ describe Mongrel2::Request do
 				x_mongrel2_upload_start: @spoolpath,
 				x_mongrel2_upload_done: @spoolpath )
 
-			req.should_not be_upload_started()
-			req.should be_upload_done()
-			req.should be_valid_upload()
+			expect( req ).to_not be_upload_started()
+			expect( req ).to be_upload_done()
+			expect( req ).to be_valid_upload()
 		end
 
 		it "knows if it's not a valid 'async upload done' notification" do
@@ -262,9 +253,9 @@ describe Mongrel2::Request do
 				x_mongrel2_upload_start: @spoolpath,
 				x_mongrel2_upload_done: '/etc/passwd' )
 
-			req.should_not be_upload_started()
-			req.should be_upload_done()
-			req.should_not be_valid_upload()
+			expect( req ).to_not be_upload_started()
+			expect( req ).to be_upload_done()
+			expect( req ).to_not be_valid_upload()
 		end
 
 		it "raises an exception if the uploaded file fetched with mismatched headers" do
@@ -282,10 +273,10 @@ describe Mongrel2::Request do
 				x_mongrel2_upload_start: @spoolpath,
 				x_mongrel2_upload_done:  @spoolpath )
 
-			req.should be_valid_upload()
+			expect( req ).to be_valid_upload()
 
-			req.uploaded_file.should be_a( Pathname )
-			req.uploaded_file.to_s.should == @spoolfile.path
+			expect( req.uploaded_file ).to be_a( Pathname )
+			expect( req.uploaded_file.to_s ).to eq( @spoolfile.path )
 		end
 
 		it "sets the body of the request to the uploaded File if it's valid" do
@@ -293,10 +284,10 @@ describe Mongrel2::Request do
 				x_mongrel2_upload_start: @spoolpath,
 				x_mongrel2_upload_done:  @spoolpath )
 
-			req.should be_valid_upload()
+			expect( req ).to be_valid_upload()
 
-			req.body.should be_a( File )
-			req.body.path.should == @spoolfile.path
+			expect( req.body ).to be_a( File )
+			expect( req.body.path ).to eq( @spoolfile.path )
 		end
 
 	end

data/spec/mongrel2/response_spec.rb

@@ -1,19 +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 'tnetstring'
 
 require 'mongrel2'
 require 'mongrel2/request'
@@ -27,7 +18,7 @@ require 'mongrel2/response'
 describe Mongrel2::Response do
 
 	before( :all ) do
-		setup_logging( :fatal )
+		setup_logging()
 	end
 
 	after( :all ) do
@@ -39,21 +30,21 @@ describe Mongrel2::Response do
 		req = Mongrel2::Request.new( TEST_UUID, 8, '/path', {}, '' )
 		response = Mongrel2::Response.from_request( req )
 
-		response.should be_a( Mongrel2::Response )
-		response.sender_id.should == req.sender_id
-		response.conn_id.should == req.conn_id
-		response.request.should equal( req )
+		expect( response ).to be_a( Mongrel2::Response )
+		expect( response.sender_id ).to eq( req.sender_id )
+		expect( response.conn_id ).to eq( req.conn_id )
+		expect( response.request ).to equal( req )
 	end
 
 
 	it "can be created with a body" do
 		response = Mongrel2::Response.new( TEST_UUID, 8, 'the body' )
-		response.body.read.should == 'the body'
+		expect( response.body.read ).to eq( 'the body' )
 	end
 
 	it "stringifies to its body contents" do
 		response = Mongrel2::Response.new( TEST_UUID, 8, 'the body' )
-		response.to_s.should == 'the body'
+		expect( response.to_s ).to eq( 'the body' )
 	end
 
 	it "can be streamed in chunks" do
@@ -64,15 +55,15 @@ describe Mongrel2::Response do
 	it "wraps stringifiable bodies set via the #body= accessor in a StringIO" do
 		response = Mongrel2::Response.new( TEST_UUID, 8 )
 		response.body = 'a stringioed body'
-		response.body.should be_a( StringIO )
-		response.body.string.should == 'a stringioed body'
+		expect( response.body ).to be_a( StringIO )
+		expect( response.body.string ).to eq( 'a stringioed body' )
 	end
 
 	it "doesn't try to wrap non-stringfiable bodies in a StringIO" do
 		response = Mongrel2::Response.new( TEST_UUID, 8 )
 		testbody = Object.new
 		response.body = testbody
-		response.body.should be( testbody )
+		expect( response.body ).to be( testbody )
 	end
 
 	context	"an instance with default values" do
@@ -83,19 +74,19 @@ describe Mongrel2::Response do
 
 		it "has an empty-IO body" do
 			@response.body.rewind
-			@response.body.read.should == ''
+			expect( @response.body.read ).to eq( '' )
 		end
 
 		it "supports the append operator to append objects to the body IO" do
 			@response << 'some body stuff' << ' and some more body stuff'
 			@response.body.rewind
-			@response.body.read.should == 'some body stuff and some more body stuff'
+			expect( @response.body.read ).to eq( 'some body stuff and some more body stuff' )
 		end
 
 		it "supports #puts for appending objects to the body IO separated by EOL" do
 			@response.puts( "some body stuff\n", " and some more body stuff\n\n", :and_a_symbol )
 			@response.body.rewind
-			@response.body.read.should == "some body stuff\n and some more body stuff\n\nand_a_symbol\n"
+			expect( @response.body.read ).to eq( "some body stuff\n and some more body stuff\n\nand_a_symbol\n" )
 		end
 
 	end

data/spec/mongrel2/table_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/table'
@@ -26,7 +14,7 @@ describe Mongrel2::Table do
 
 
 	before( :all ) do
-		setup_logging( :fatal )
+		setup_logging()
 	end
 
 	before( :each ) do
@@ -46,38 +34,38 @@ describe Mongrel2::Table do
 		@table[:accept_encoding] = :accept_encoding
 		@table.accept_encoding = :accept_encoding
 
-		@table['accept'].should == :accept
-		@table['ACCEPT'].should == :accept
-		@table['Accept'].should == :accept
-		@table[:accept].should == :accept
-		@table.accept.should == :accept
-
-		@table['USER-AGENT'].should == :user_agent
-		@table['User-Agent'].should == :user_agent
-		@table['user-agent'].should == :user_agent
-		@table[:user_agent].should == :user_agent
-		@table.user_agent.should == :user_agent
-
-		@table['ACCEPT-ENCODING'].should == :accept_encoding
-		@table['Accept-Encoding'].should == :accept_encoding
-		@table['accept-encoding'].should == :accept_encoding
-		@table[:accept_encoding].should == :accept_encoding
-		@table.accept_encoding.should == :accept_encoding
+		expect( @table['accept'] ).to eq( :accept )
+		expect( @table['ACCEPT'] ).to eq( :accept )
+		expect( @table['Accept'] ).to eq( :accept )
+		expect( @table[:accept] ).to eq( :accept )
+		expect( @table.accept ).to eq( :accept )
+
+		expect( @table['USER-AGENT'] ).to eq( :user_agent )
+		expect( @table['User-Agent'] ).to eq( :user_agent )
+		expect( @table['user-agent'] ).to eq( :user_agent )
+		expect( @table[:user_agent] ).to eq( :user_agent )
+		expect( @table.user_agent ).to eq( :user_agent )
+
+		expect( @table['ACCEPT-ENCODING'] ).to eq( :accept_encoding )
+		expect( @table['Accept-Encoding'] ).to eq( :accept_encoding )
+		expect( @table['accept-encoding'] ).to eq( :accept_encoding )
+		expect( @table[:accept_encoding] ).to eq( :accept_encoding )
+		expect( @table.accept_encoding ).to eq( :accept_encoding )
 	end
 
 
 	it "should assign a new value when appending to a non-existing key" do
 		@table.append( 'indian-meal' => 'pinecones' )
-		@table['Indian-Meal'].should == 'pinecones'
+		expect( @table['Indian-Meal'] ).to eq( 'pinecones' )
 	end
 
 
 	it "should create an array value and append when appending to an existing key" do
 		@table[:indian_meal] = 'pork sausage'
 		@table.append( 'Indian-MEAL' => 'pinecones' )
-		@table['Indian-Meal'].should have(2).members
-		@table['Indian-Meal'].should include('pinecones')
-		@table['Indian-Meal'].should include('pork sausage')
+		expect( @table['Indian-Meal'] ).to have(2).members
+		expect( @table['Indian-Meal'] ).to include('pinecones')
+		expect( @table['Indian-Meal'] ).to include('pork sausage')
 	end
 
 
@@ -86,9 +74,9 @@ describe Mongrel2::Table do
 
 		table = Mongrel2::Table.new({ :bob => :dan, 'Bob' => :dan_too })
 
-		table[:bob].should have(2).members
-		table['Bob'].should include( :dan )
-		table['bob'].should include( :dan_too )
+		expect( table[:bob] ).to have(2).members
+		expect( table['Bob'] ).to include( :dan )
+		expect( table['bob'] ).to include( :dan_too )
 		end
 
 
@@ -100,9 +88,9 @@ describe Mongrel2::Table do
 
 		table.append( 'x-ice-cream-flavor' => 'banana' )
 
-		table.to_s.should =~ %r{Accept: text/html\r\n}
-		table.to_s.should =~ %r{X-Ice-Cream-Flavor: mango\r\n}
-		table.to_s.should =~ %r{X-Ice-Cream-Flavor: banana\r\n}
+		expect( table.to_s ).to match( %r{Accept: text/html\r\n} )
+		expect( table.to_s ).to match( %r{X-Ice-Cream-Flavor: mango\r\n} )
+		expect( table.to_s ).to match( %r{X-Ice-Cream-Flavor: banana\r\n} )
 	end
 
 
@@ -115,8 +103,8 @@ describe Mongrel2::Table do
 		othertable['cookie'] = 'peanut butter'
 
 		ot = @table.merge( othertable )
-		ot['accept'].should == 'thing'
-		ot['cookie'].should == 'peanut butter'
+		expect( ot['accept'] ).to eq( 'thing' )
+		expect( ot['cookie'] ).to eq( 'peanut butter' )
 	end
 
 
@@ -127,8 +115,8 @@ describe Mongrel2::Table do
 		hash = { 'CookiE_FLAVOR' => 'peanut butter' }
 
 		ot = @table.merge( hash )
-		ot['accept'].should == 'thing'
-		ot['cookie-flavor'].should == 'peanut butter'
+		expect( ot['accept'] ).to eq( 'thing' )
+		expect( ot['cookie-flavor'] ).to eq( 'peanut butter' )
 	end
 
 
@@ -141,9 +129,9 @@ describe Mongrel2::Table do
 		newtable[:foom] << " and another string"
 		newtable[:frong][3].replace( "mississipi" )
 
-		@table.should_not include( 'idkfa' )
-		@table[:foom].should == 'a string'
-		@table[:frong][3].should == 'moe'
+		expect( @table ).to_not include( 'idkfa' )
+		expect( @table[:foom] ).to eq( 'a string' )
+		expect( @table[:frong][3] ).to eq( 'moe' )
 	end
 
 
@@ -153,7 +141,7 @@ describe Mongrel2::Table do
 		@table['porntipsguzzardo'] = 'cha-ching'
 
 		results = @table.values_at( :idspispopd, 'PornTipsGuzzARDO' )
-		results.should == [ 'ghosty', 'cha-ching' ]
+		expect( results ).to eq( [ 'ghosty', 'cha-ching' ] )
 	end
 
 
@@ -168,14 +156,14 @@ describe Mongrel2::Table do
 			values << [ header, value ]
 		end
 
-		values.flatten.should have(8).members
-		values.transpose[0].should include( 'Thai-Food', 'With-Absinthe', 'A-Number-Of-Some-Sort' )
-		values.transpose[1].should include( 'normally good', 'seldom hot enough', 'questionable', '2' )
+		expect( values.flatten ).to have(8).members
+		expect( values.transpose[0] ).to include( 'Thai-Food', 'With-Absinthe', 'A-Number-Of-Some-Sort' )
+		expect( values.transpose[1] ).to include( 'normally good', 'seldom hot enough', 'questionable', '2' )
 	end
 
 
 	it "can yield an Enumerator for its header iterator" do
-		@table.each_header.should be_a( Enumerator )
+		expect( @table.each_header ).to be_a( Enumerator )
 	end
 end