mongrel2 0.38.0 → 0.39.0

data/spec/mongrel2/websocket_spec.rb

@@ -1,22 +1,13 @@
 #!/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_relative '../helpers'
 
 require 'rspec'
+
 require 'tnetstring'
 require 'securerandom'
 
-require 'spec/lib/helpers'
-
 require 'mongrel2'
 require 'mongrel2/websocket'
 
@@ -28,7 +19,7 @@ require 'mongrel2/websocket'
 describe Mongrel2::WebSocket do
 
 	before( :all ) do
-		setup_logging( :fatal )
+		setup_logging()
 		@factory = Mongrel2::WebSocketFrameFactory.new( route: '/websock' )
 	end
 
@@ -56,17 +47,17 @@ describe Mongrel2::WebSocket do
 	describe 'ClientHandshake' do
 
 		it "is the registered request type for WEBSOCKET_HANDSHAKE requests" do
-			Mongrel2::Request.request_types[:WEBSOCKET_HANDSHAKE].should == Mongrel2::WebSocket::ClientHandshake
+			expect( Mongrel2::Request.request_types[:WEBSOCKET_HANDSHAKE] ).to eq( Mongrel2::WebSocket::ClientHandshake )
 		end
 
 		it "knows what subprotocols were requested" do
 			handshake = @factory.handshake( '/websock', 'echo', 'superecho' )
-			handshake.protocols.should == ['echo', 'superecho']
+			expect( handshake.protocols ).to eq( ['echo', 'superecho'] )
 		end
 
 		it "doesn't error if no subprotocols were requested" do
 			handshake = @factory.handshake( '/websock' )
-			handshake.protocols.should == []
+			expect( handshake.protocols ).to eq( [] )
 		end
 
 		it "can create a response WebSocket::ServerHandshake for itself" do
@@ -74,16 +65,16 @@ describe Mongrel2::WebSocket do
 			result = handshake.response
 			handshake.body.rewind
 
-			result.should be_a( Mongrel2::WebSocket::ServerHandshake )
-			result.sender_id.should == handshake.sender_id
-			result.conn_id.should == handshake.conn_id
-			result.header.sec_websocket_accept.should == handshake.body.string
-			result.status.should == HTTP::SWITCHING_PROTOCOLS
-			result.header.connection.should =~ /upgrade/i
-			result.header.upgrade.should =~ /websocket/i
+			expect( result ).to be_a( Mongrel2::WebSocket::ServerHandshake )
+			expect( result.sender_id ).to eq( handshake.sender_id )
+			expect( result.conn_id ).to eq( handshake.conn_id )
+			expect( result.header.sec_websocket_accept ).to eq( handshake.body.string )
+			expect( result.status ).to eq( HTTP::SWITCHING_PROTOCOLS )
+			expect( result.header.connection ).to match( /upgrade/i )
+			expect( result.header.upgrade ).to match( /websocket/i )
 
 			result.body.rewind
-			result.body.read.should == ''
+			expect( result.body.read ).to eq( '' )
 		end
 
 		it "can create a response WebSocket::ServerHandshake with a valid sub-protocol for itself" do
@@ -91,17 +82,17 @@ describe Mongrel2::WebSocket do
 			result = handshake.response( :superecho )
 			handshake.body.rewind
 
-			result.should be_a( Mongrel2::WebSocket::ServerHandshake )
-			result.sender_id.should == handshake.sender_id
-			result.conn_id.should == handshake.conn_id
-			result.header.sec_websocket_accept.should == handshake.body.string
-			result.status.should == HTTP::SWITCHING_PROTOCOLS
-			result.header.connection.should =~ /upgrade/i
-			result.header.upgrade.should =~ /websocket/i
-			result.protocols.should == ['superecho']
+			expect( result ).to be_a( Mongrel2::WebSocket::ServerHandshake )
+			expect( result.sender_id ).to eq( handshake.sender_id )
+			expect( result.conn_id ).to eq( handshake.conn_id )
+			expect( result.header.sec_websocket_accept ).to eq( handshake.body.string )
+			expect( result.status ).to eq( HTTP::SWITCHING_PROTOCOLS )
+			expect( result.header.connection ).to match( /upgrade/i )
+			expect( result.header.upgrade ).to match( /websocket/i )
+			expect( result.protocols ).to eq( ['superecho'] )
 
 			result.body.rewind
-			result.body.read.should == ''
+			expect( result.body.read ).to eq( '' )
 		end
 
 		it "raises an exception if the specified protocol is not one of the client's advertised ones" do
@@ -114,7 +105,7 @@ describe Mongrel2::WebSocket do
 
 		it "has a socket identifier" do
 			handshake = @factory.handshake( '/websock', 'echo', 'superecho' )
-			handshake.socket_id.should == "#{handshake.sender_id}:#{handshake.conn_id}"
+			expect( handshake.socket_id ).to eq( "#{handshake.sender_id}:#{handshake.conn_id}" )
 		end
 
 	end
@@ -124,121 +115,121 @@ describe Mongrel2::WebSocket do
 	describe 'Frame' do
 
 		it "is the registered request type for WEBSOCKET requests" do
-			Mongrel2::Request.request_types[:WEBSOCKET].should == Mongrel2::WebSocket::Frame
+			expect( Mongrel2::Request.request_types[:WEBSOCKET] ).to eq( Mongrel2::WebSocket::Frame )
 		end
 
 		it "knows that its FIN flag is not set if its FLAG header doesn't include that bit" do
 			frame = @factory.text( '/websock', 'Hello!' )
 			frame.flags ^= ( frame.flags & Mongrel2::WebSocket::FIN_FLAG )
-			frame.should_not be_fin()
+			expect( frame ).to_not be_fin()
 		end
 
 		it "knows that its FIN flag is set if its FLAG header includes that bit" do
 			frame = @factory.text( '/websock', 'Hello!', :fin )
-			frame.should be_fin()
+			expect( frame ).to be_fin()
 		end
 
 		it "can unset its FIN flag" do
 			frame = @factory.text( '/websock', 'Hello!', :fin )
 			frame.fin = false
-			frame.should_not be_fin()
+			expect( frame ).to_not be_fin()
 		end
 
 		it "can set its FIN flag" do
 			frame = @factory.text( '/websock', 'Hello!' )
 			frame.fin = true
-			frame.should be_fin()
+			expect( frame ).to be_fin()
 		end
 
 		it "knows that its opcode is continuation if its opcode is 0x0" do
-			@factory.continuation( '/websock' ).opcode.should == :continuation
+			expect( @factory.continuation( '/websock' ).opcode ).to eq( :continuation )
 		end
 
 		it "knows that is opcode is 'text' if its opcode is 0x1" do
-			@factory.text( '/websock', 'Hello!' ).opcode.should == :text
+			expect( @factory.text( '/websock', 'Hello!' ).opcode ).to eq( :text )
 		end
 
 		it "knows that is opcode is 'binary' if its opcode is 0x2" do
-			@factory.binary( '/websock', 'Hello!' ).opcode.should == :binary
+			expect( @factory.binary( '/websock', 'Hello!' ).opcode ).to eq( :binary )
 		end
 
 		it "knows that is opcode is 'close' if its opcode is 0x8" do
-			@factory.close( '/websock' ).opcode.should == :close
+			expect( @factory.close( '/websock' ).opcode ).to eq( :close )
 		end
 
 		it "knows that is opcode is 'ping' if its opcode is 0x9" do
-			@factory.ping( '/websock' ).opcode.should == :ping
+			expect( @factory.ping( '/websock' ).opcode ).to eq( :ping )
 		end
 
 		it "knows that is opcode is 'pong' if its opcode is 0xA" do
-			@factory.pong( '/websock' ).opcode.should == :pong
+			expect( @factory.pong( '/websock' ).opcode ).to eq( :pong )
 		end
 
 		it "knows that its opcode is one of the reserved ones if it's 0x3" do
-			@factory.create( '/websocket', '', 0x3 ).opcode.should == :reserved
+			expect( @factory.create( '/websocket', '', 0x3 ).opcode ).to eq( :reserved )
 		end
 
 		it "knows that its opcode is one of the reserved ones if it's 0x4" do
-			@factory.create( '/websocket', '', 0x4 ).opcode.should == :reserved
+			expect( @factory.create( '/websocket', '', 0x4 ).opcode ).to eq( :reserved )
 		end
 
 		it "knows that its opcode is one of the reserved ones if it's 0xB" do
-			@factory.create( '/websocket', '', 0xB ).opcode.should == :reserved
+			expect( @factory.create( '/websocket', '', 0xB ).opcode ).to eq( :reserved )
 		end
 
 		it "knows that its opcode is one of the reserved ones if it's 0xD" do
-			@factory.create( '/websocket', '', 0xD ).opcode.should == :reserved
+			expect( @factory.create( '/websocket', '', 0xD ).opcode ).to eq( :reserved )
 		end
 
 		it "knows that its opcode is one of the reserved ones if it's 0xF" do
-			@factory.create( '/websocket', '', 0xF ).opcode.should == :reserved
+			expect( @factory.create( '/websocket', '', 0xF ).opcode ).to eq( :reserved )
 		end
 
 		it "allows its opcode to be set Symbolically" do
 			frame = @factory.text( '/websocket', 'data' )
 			frame.opcode = :binary
-			frame.numeric_opcode.should == OPCODE[:binary]
+			expect( frame.numeric_opcode ).to eq( OPCODE[:binary] )
 		end
 
 		it "allows its opcode to be set Numerically" do
 			frame = @factory.binary( '/websocket', 'data' )
 			frame.opcode = :text
-			frame.numeric_opcode.should == OPCODE[:text]
+			expect( frame.numeric_opcode ).to eq( OPCODE[:text] )
 		end
 
 		it "allows its opcode to be set to one of the reserved opcodes Numerically" do
 			frame = @factory.binary( '/websocket', 'data' )
 			frame.opcode = 0xC
-			frame.opcode.should == :reserved
-			frame.numeric_opcode.should == 0xC
+			expect( frame.opcode ).to eq( :reserved )
+			expect( frame.numeric_opcode ).to eq( 0xC )
 		end
 
 		it "knows that its RSV1 flag is set if its FLAG header includes that bit" do
-			@factory.ping( '/websock', 'test', :rsv1 ).should be_rsv1()
+			expect( @factory.ping( '/websock', 'test', :rsv1 ) ).to be_rsv1()
 		end
 
 		it "knows that its RSV2 flag is set if its FLAG header includes that bit" do
-			@factory.ping( '/websock', 'test', :rsv2 ).should be_rsv2()
+			expect( @factory.ping( '/websock', 'test', :rsv2 ) ).to be_rsv2()
 		end
 
 		it "knows that its RSV3 flag is set if its FLAG header includes that bit" do
-			@factory.ping( '/websock', 'test', :rsv3 ).should be_rsv3()
+			expect( @factory.ping( '/websock', 'test', :rsv3 ) ).to be_rsv3()
 		end
 
 		it "knows that one of its RSV flags is set if its FLAG header includes RSV1" do
-			@factory.ping( '/websock', 'test', :rsv1 ).should have_rsv_flags()
+			expect( @factory.ping( '/websock', 'test', :rsv1 ) ).to have_rsv_flags()
 		end
 
 		it "knows that one of its RSV flags is set if its FLAG header includes RSV2" do
-			@factory.ping( '/websock', 'test', :rsv2 ).should have_rsv_flags()
+			expect( @factory.ping( '/websock', 'test', :rsv2 ) ).to have_rsv_flags()
 		end
 
 		it "knows that one of its RSV flags is set if its FLAG header includes RSV3" do
-			@factory.ping( '/websock', 'test', :rsv3 ).should have_rsv_flags()
+			expect( @factory.ping( '/websock', 'test', :rsv3 ) ).to have_rsv_flags()
 		end
 
 		it "knows that no RSV flags are set if its FLAG header doesn't have any RSV bits" do
-			@factory.ping( '/websock', 'test' ).should_not have_rsv_flags()
+			expect( @factory.ping( '/websock', 'test' ) ).to_not have_rsv_flags()
 		end
 
 		it "can create a response WebSocket::Frame for itself" do
@@ -246,13 +237,13 @@ describe Mongrel2::WebSocket do
 
 			result = frame.response
 
-			result.should be_a( Mongrel2::WebSocket::Frame )
-			result.sender_id.should == frame.sender_id
-			result.conn_id.should == frame.conn_id
-			result.opcode.should == :text
+			expect( result ).to be_a( Mongrel2::WebSocket::Frame )
+			expect( result.sender_id ).to eq( frame.sender_id )
+			expect( result.conn_id ).to eq( frame.conn_id )
+			expect( result.opcode ).to eq( :text )
 
 			result.payload.rewind
-			result.payload.read.should == ''
+			expect( result.payload.read ).to eq( '' )
 		end
 
 		it "creates PONG responses with the same payload for PING frames" do
@@ -260,13 +251,13 @@ describe Mongrel2::WebSocket do
 
 			result = frame.response
 
-			result.should be_a( Mongrel2::WebSocket::Frame )
-			result.sender_id.should == frame.sender_id
-			result.conn_id.should == frame.conn_id
-			result.opcode.should == :pong
+			expect( result ).to be_a( Mongrel2::WebSocket::Frame )
+			expect( result.sender_id ).to eq( frame.sender_id )
+			expect( result.conn_id ).to eq( frame.conn_id )
+			expect( result.opcode ).to eq( :pong )
 
 			result.payload.rewind
-			result.payload.read.should == 'WOO'
+			expect( result.payload.read ).to eq( 'WOO' )
 		end
 
 		it "allows header flags and/or opcode to be specified when creating a response" do
@@ -274,14 +265,14 @@ describe Mongrel2::WebSocket do
 
 			result = frame.response( :close, :fin )
 
-			result.should be_a( Mongrel2::WebSocket::Frame )
-			result.sender_id.should == frame.sender_id
-			result.conn_id.should == frame.conn_id
-			result.opcode.should == :close
-			result.should be_fin()
+			expect( result ).to be_a( Mongrel2::WebSocket::Frame )
+			expect( result.sender_id ).to eq( frame.sender_id )
+			expect( result.conn_id ).to eq( frame.conn_id )
+			expect( result.opcode ).to eq( :close )
+			expect( result ).to be_fin()
 
 			result.payload.rewind
-			result.payload.read.should == ''
+			expect( result.payload.read ).to eq( '' )
 		end
 
 		it "allows reserved opcodes to be specified when creating a response" do
@@ -289,14 +280,14 @@ describe Mongrel2::WebSocket do
 
 			result = frame.response( 0xB )
 
-			result.should be_a( Mongrel2::WebSocket::Frame )
-			result.sender_id.should == frame.sender_id
-			result.conn_id.should == frame.conn_id
-			result.opcode.should == :reserved
-			result.numeric_opcode.should == 0xB
+			expect( result ).to be_a( Mongrel2::WebSocket::Frame )
+			expect( result.sender_id ).to eq( frame.sender_id )
+			expect( result.conn_id ).to eq( frame.conn_id )
+			expect( result.opcode ).to eq( :reserved )
+			expect( result.numeric_opcode ).to eq( 0xB )
 
 			result.payload.rewind
-			result.payload.read.should == ''
+			expect( result.payload.read ).to eq( '' )
 		end
 
 		it "can be streamed in chunks instead of read all at once" do
@@ -304,15 +295,15 @@ describe Mongrel2::WebSocket do
 			binary = @factory.binary( '/websock', data, :fin )
 
 			binary.chunksize = 16
-			binary.each_chunk.to_a[0,2].should == [
+			expect( binary.each_chunk.to_a[0,2] ).to eq([
 				"\x82\x7F\x00\x00\x00\x00\x00\x01\x00\x00\a\xBD\xB3\xFE\x87\xEB".force_encoding('binary'),
 				"\xA9\x0En2q\xCE\x85\xAF)\x88w_d\xD6M\x9E".force_encoding('binary'),
-			]
+			])
 		end
 
 		it "has a socket identifier" do
 			frame = @factory.text( '/websock', "data" )
-			frame.socket_id.should == "#{frame.sender_id}:#{frame.conn_id}"
+			expect( frame.socket_id ).to eq( "#{frame.sender_id}:#{frame.conn_id}" )
 		end
 
 	end
@@ -329,9 +320,9 @@ describe Mongrel2::WebSocket do
 			@frame << text
 
 			# 2-byte header
-			@frame.bytes.to_a[ 2..-1 ].should ==
-				[0xD0, 0xA1, 0xD1, 0x82, 0xD1, 0x80, 0xD0, 0xB5, 0xD0, 0xBB, 0xD0,
-				 0xBA, 0xD0, 0xB5, 0x21]
+			expect( @frame.bytes.to_a[ 2..-1 ] ).
+				to eq([0xD0, 0xA1, 0xD1, 0x82, 0xD1, 0x80, 0xD0, 0xB5, 0xD0, 0xBB, 0xD0,
+				 0xBA, 0xD0, 0xB5, 0x21])
 		end
 
 	end
@@ -344,9 +335,9 @@ describe Mongrel2::WebSocket do
 
 		it "doesn't try to transcode non-UTF8 data" do
 			# 4-byte header
-			@frame.bytes.to_a[ 4, 16 ].should ==
-				[ 0x07, 0xbd, 0xb3, 0xfe, 0x87, 0xeb, 0xa9, 0x0e, 0x6e, 0x32, 0x71,
-				  0xce, 0x85, 0xaf, 0x29, 0x88 ]
+			expect( @frame.bytes.to_a[ 4, 16 ] ).
+				to eq([ 0x07, 0xbd, 0xb3, 0xfe, 0x87, 0xeb, 0xa9, 0x0e, 0x6e, 0x32, 0x71,
+				  0xce, 0x85, 0xaf, 0x29, 0x88 ])
 		end
 	end
 
@@ -359,8 +350,8 @@ describe Mongrel2::WebSocket do
 		it "has convenience methods for setting its payload via integer status code" do
 			@frame.set_status( CLOSE_BAD_DATA )
 			@frame.payload.rewind
-			@frame.payload.read.should == "%d %s\n" %
-				[ CLOSE_BAD_DATA, CLOSING_STATUS_DESC[CLOSE_BAD_DATA] ]
+			expect( @frame.payload.read ).
+				to eq( "%d %s\n" % [CLOSE_BAD_DATA, CLOSING_STATUS_DESC[CLOSE_BAD_DATA]] )
 		end
 
 	end
@@ -393,16 +384,16 @@ describe Mongrel2::WebSocket do
 
 		it "generates a single-frame unmasked text message correctly" do
 			raw_response = @factory.text( '/websock', "Hello", :fin ).to_s
-			raw_response.bytes.to_a.should == [ 0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f ]
-			raw_response.encoding.should == Encoding::BINARY
+			expect( raw_response.bytes.to_a ).to eq( [ 0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f ] )
+			expect( raw_response.encoding ).to eq( Encoding::BINARY )
 		end
 
 		it "generates both parts of a fragmented unmasked text message correctly" do
 			first = @factory.text( '/websock', 'Hel' )
 			last = @factory.continuation( '/websock', 'lo', :fin )
 
-			first.bytes.to_a.should == [ 0x01, 0x03, 0x48, 0x65, 0x6c ]
-			last.bytes.to_a.should == [ 0x80, 0x02, 0x6c, 0x6f ]
+			expect( first.bytes.to_a ).to eq( [ 0x01, 0x03, 0x48, 0x65, 0x6c ] )
+			expect( last.bytes.to_a ).to eq( [ 0x80, 0x02, 0x6c, 0x6f ] )
 		end
 
 		# The RFC's example is a masked response, but we're never a client, so never
@@ -411,8 +402,8 @@ describe Mongrel2::WebSocket do
 			ping = @factory.ping( '/websock', 'Hello' )
 			pong = @factory.pong( '/websock', 'Hello' )
 
-			ping.bytes.to_a.should == [ 0x89, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f ]
-			pong.bytes.to_a.should == [ 0x8a, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f ]
+			expect( ping.bytes.to_a ).to eq( [ 0x89, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f ] )
+			expect( pong.bytes.to_a ).to eq( [ 0x8a, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f ] )
 		end
 
 
@@ -420,8 +411,8 @@ describe Mongrel2::WebSocket do
 			binary = @factory.binary( '/websock', BINARY_DATA, :fin )
 
 			# 1 + 1 + 2
-			binary.bytes.to_a[0,4].should == [ 0x82, 0x7E, 0x01, 0x00 ]
-			binary.to_s[4..-1].should == BINARY_DATA
+			expect( binary.bytes.to_a[0,4] ).to eq( [ 0x82, 0x7E, 0x01, 0x00 ] )
+			expect( binary.to_s[4..-1] ).to eq( BINARY_DATA )
 		end
 
 		it "generates a 64KiB binary message in a single unmasked frame correctly" do
@@ -430,9 +421,9 @@ describe Mongrel2::WebSocket do
 			binary = @factory.binary( '/websock', data, :fin )
 
 			# 1 + 1 + 8
-			binary.bytes.to_a[0,10].should ==
-				[ 0x82, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00 ]
-			binary.to_s[10..-1].should == data
+			expect( binary.bytes.to_a[0,10] ).
+				to eq([ 0x82, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00 ])
+			expect( binary.to_s[10..-1] ).to eq( data )
 		end
 
 	end

data/spec/mongrel2_spec.rb

@@ -1,18 +1,9 @@
 #!/usr/bin/env rspec -cfd -b
 
-BEGIN {
-	require 'pathname'
-	basedir = Pathname( __FILE__ ).dirname.parent
-	libdir = basedir + 'lib'
-
-	$LOAD_PATH.unshift( basedir.to_s ) unless $LOAD_PATH.include?( basedir.to_s )
-	$LOAD_PATH.unshift( libdir.to_s ) unless $LOAD_PATH.include?( libdir.to_s )
-}
+require_relative 'helpers'
 
 require 'rspec'
 
-require 'spec/lib/helpers'
-
 require 'loggability'
 require 'mongrel2'
 
@@ -21,12 +12,12 @@ describe Mongrel2 do
 
 	describe "version methods" do
 		it "returns a version string if asked" do
-			Mongrel2.version_string.should =~ /\w+ [\d.]+/
+			expect( Mongrel2.version_string ).to match( /\w+ [\d.]+/ )
 		end
 
 
 		it "returns a version string with a build number if asked" do
-			Mongrel2.version_string(true).should =~ /\w+ [\d.]+ \(build [[:xdigit:]]+\)/
+			expect( Mongrel2.version_string(true) ).to match( /\w+ [\d.]+ \(build [[:xdigit:]]+\)/ )
 		end
 	end