mongrel2 0.52.2 → 0.53.0

data/lib/mongrel2/xmlrequest.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 
 require 'libxml'
 require 'loggability'

data/spec/constants.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 
 require 'uri'
 
@@ -115,7 +116,7 @@ module Mongrel2::TestConstants # :nodoc:all
 
 		TEST_WEBSOCKET_HEADERS = {
 			 'connection'               => 'Upgrade',
-			 'FLAGS'                    => '0x8A',
+			 'FLAGS'                    => '0x89',
 			 'host'                     => 'host.example.com:80',
 			 'METHOD'                   => 'WEBSOCKET',
 			 'origin'                   => 'http://host.example.com:80',

data/spec/helpers.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 # coding: utf-8
 
 # SimpleCov test coverage reporting; enable this using the :coverage rake task

data/spec/matchers.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 # coding: utf-8
 
 require 'mongrel2' unless defined?( Mongrel2 )

data/spec/mongrel2/config/directory_spec.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 
 require_relative '../../helpers'
 

data/spec/mongrel2/config/dsl_spec.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 
 require_relative '../../helpers'
 

data/spec/mongrel2/config/filter_spec.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 
 require_relative '../../helpers'
 

data/spec/mongrel2/config/handler_spec.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 
 require_relative '../../helpers'
 

data/spec/mongrel2/config/host_spec.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 
 require_relative '../../helpers'
 

data/spec/mongrel2/config/log_spec.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 
 require_relative '../../helpers'
 

data/spec/mongrel2/config/proxy_spec.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 
 require_relative '../../helpers'
 

data/spec/mongrel2/config/route_spec.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 
 require_relative '../../helpers'
 

data/spec/mongrel2/config/server_spec.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 
 require_relative '../../helpers'
 

data/spec/mongrel2/config/setting_spec.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 
 require_relative '../../helpers'
 

data/spec/mongrel2/config/statistic_spec.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 
 require_relative '../../helpers'
 

data/spec/mongrel2/config/xrequest_spec.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 
 require_relative '../../helpers'
 

data/spec/mongrel2/config_spec.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 
 require_relative '../helpers'
 

data/spec/mongrel2/connection_spec.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 
 require_relative '../helpers'
 

data/spec/mongrel2/constants_spec.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 
 require_relative '../helpers'
 

data/spec/mongrel2/control_spec.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 
 require_relative '../helpers'
 

data/spec/mongrel2/handler_spec.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 
 require_relative '../helpers'
 
@@ -191,7 +192,7 @@ describe Mongrel2::Handler, :db do
 
 		expect( handler.conn ).to receive( :reply_close ).with( request )
 		expect( handler.conn ).to receive( :reply ) do |reply|
-			expect( reply ).to be_a( Mongrel2::WebSocket::Frame )
+			expect( reply ).to be_a( Mongrel2::WebSocket::Response )
 			expect( reply.opcode ).to eq( :close )
 			reply.payload.rewind
 			expect( reply.payload.read ).to start_with( '1008 ' )
@@ -214,7 +215,7 @@ describe Mongrel2::Handler, :db do
 
 		response = handler.dispatch_request( request )
 
-		expect( response ).to be_a( Mongrel2::WebSocket::Frame )
+		expect( response ).to be_a( Mongrel2::WebSocket::Response )
 	end
 
 

data/spec/mongrel2/httprequest_spec.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 
 require_relative '../helpers'
 

data/spec/mongrel2/httpresponse_spec.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 #encoding: utf-8
 
 require_relative '../helpers'

data/spec/mongrel2/request_spec.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 
 require_relative '../helpers'
 
@@ -164,6 +165,11 @@ describe Mongrel2::Request, :db do
 			expect( @req.server_chroot.to_s ).to eq( '/' )
 		end
 
+
+		it "can return an ID for which sender and connection it's from" do
+			expect( @req.socket_id ).to eq( "#{@req.sender_id}:#{@req.conn_id}" )
+		end
+
 	end
 
 

data/spec/mongrel2/response_spec.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 
 require_relative '../helpers'
 
@@ -68,6 +69,13 @@ describe Mongrel2::Response do
 	end
 
 
+	it "can return an ID for which sender and connection it's for" do
+		response = Mongrel2::Response.new( TEST_UUID, 8 )
+
+		expect( response.socket_id ).to eq( "#{response.sender_id}:#{response.conn_id}" )
+	end
+
+
 	context	"an instance with default values" do
 
 		let( :response ) { Mongrel2::Response.new(TEST_UUID, 8) }

data/spec/mongrel2/table_spec.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 
 require_relative '../helpers'
 
@@ -111,8 +112,8 @@ describe Mongrel2::Table do
 
 
 	it "dupes its inner hash when duped" do
-		@table['foom'] = 'a string'
-		@table['frong'] = %w[eenie meenie mynie moe]
+		@table['foom'] = +'a string'
+		@table['frong'] = [+'eenie', +'meenie', +'mynie', +'moe']
 
 		newtable = @table.dup
 		newtable['idkfa'] = 'god'

data/spec/mongrel2/testing_spec.rb

@@ -0,0 +1,142 @@
+#!/usr/bin/env rspec -cfd
+
+require_relative '../helpers'
+
+require 'mongrel2/testing'
+
+
+describe Mongrel2, "testing library" do
+
+
+	describe "RequestFactory" do
+
+		let( :described_class ) { Mongrel2::RequestFactory }
+
+		let( :factory ) { described_class.new( route: '/testing' ) }
+
+
+		it "can be created with reasonable defaults" do
+			factory = described_class.new
+
+			expect( factory ).to be_a( described_class )
+			expect( factory.sender_id ).to eq( described_class.default_factory_config[:sender_id] )
+			expect( factory.host ).to eq( described_class.default_factory_config[:host] )
+			expect( factory.port ).to eq( described_class.default_factory_config[:port] )
+			expect( factory.route ).to eq( described_class.default_factory_config[:route] )
+			expect( factory.conn_id ).to eq( described_class.default_factory_config[:conn_id] )
+
+			expect( factory.headers ).to eq( described_class.default_headers )
+		end
+
+
+		it "can be created with overridden config values" do
+			factory = described_class.new( sender_id: 'another_sender_id', conn_id: 202 )
+
+			expect( factory ).to be_a( described_class )
+			expect( factory.sender_id ).to eq( 'another_sender_id' )
+			expect( factory.host ).to eq( described_class.default_factory_config[:host] )
+			expect( factory.port ).to eq( described_class.default_factory_config[:port] )
+			expect( factory.route ).to eq( described_class.default_factory_config[:route] )
+			expect( factory.conn_id ).to eq( 202 )
+
+			expect( factory.headers ).to eq( described_class.default_headers )
+		end
+
+
+		it "can create a valid OPTIONS request" do
+			req = factory.options( '/testing' )
+
+			expect( req ).to be_a( Mongrel2::HTTPRequest )
+			expect( req.path ).to eq( '/testing' )
+			expect( req.headers[:method] ).to eq( 'OPTIONS' )
+			expect( req.body ).to be_a( StringIO ).and( be_eof )
+			expect( req.scheme ).to eq( 'http' )
+		end
+
+
+		it "can create a valid GET request" do
+			req = factory.get( '/testing' )
+
+			expect( req ).to be_a( Mongrel2::HTTPRequest )
+			expect( req.path ).to eq( '/testing' )
+			expect( req.headers[:method] ).to eq( 'GET' )
+			expect( req.body ).to be_a( StringIO ).and( be_eof )
+		end
+
+
+		it "can create a valid HEAD request" do
+			req = factory.head( '/testing' )
+
+			expect( req ).to be_a( Mongrel2::HTTPRequest )
+			expect( req.path ).to eq( '/testing' )
+			expect( req.headers[:method] ).to eq( 'HEAD' )
+			expect( req.body ).to be_a( StringIO ).and( be_eof )
+			expect( req.scheme ).to eq( 'http' )
+		end
+
+
+		it "can create a valid POST request" do
+			body = <<~END_OF_BODY
+			collection=screening
+			page=3
+			page_size=50
+			END_OF_BODY
+
+			req = factory.post( '/testing', body )
+
+			expect( req ).to be_a( Mongrel2::HTTPRequest )
+			expect( req.path ).to eq( '/testing' )
+			expect( req.headers[:method] ).to eq( 'POST' )
+			expect( req.body ).to be_a( StringIO )
+			expect( req.body.string ).to eq( body )
+			expect( req.scheme ).to eq( 'http' )
+		end
+
+	end
+
+
+	describe "WebSocketRequestFactory" do
+
+		let( :described_class ) { Mongrel2::WebSocketRequestFactory }
+
+
+		it "can be created with reasonable defaults" do
+			factory = described_class.new
+
+			expect( factory ).to be_a( described_class )
+			expect( factory.sender_id ).to eq( described_class.default_factory_config[:sender_id] )
+			expect( factory.host ).to eq( described_class.default_factory_config[:host] )
+			expect( factory.port ).to eq( described_class.default_factory_config[:port] )
+			expect( factory.route ).to eq( described_class.default_factory_config[:route] )
+			expect( factory.conn_id ).to eq( described_class.default_factory_config[:conn_id] )
+
+			expect( factory.headers ).to eq( described_class.default_headers )
+		end
+
+
+		it "can be created with overridden config values" do
+			factory = described_class.new( sender_id: 'another_sender_id', conn_id: 202 )
+
+			expect( factory ).to be_a( described_class )
+			expect( factory.sender_id ).to eq( 'another_sender_id' )
+			expect( factory.host ).to eq( described_class.default_factory_config[:host] )
+			expect( factory.port ).to eq( described_class.default_factory_config[:port] )
+			expect( factory.route ).to eq( described_class.default_factory_config[:route] )
+			expect( factory.conn_id ).to eq( 202 )
+
+			expect( factory.headers ).to eq( described_class.default_headers )
+		end
+
+
+		it "can create a valid handshake request" do
+			factory = described_class.new( route: '/ws_testing' )
+
+			req = factory.handshake( '/ws_testing' )
+
+			expect( req ).to be_a( Mongrel2::WebSocket::ClientHandshake )
+		end
+
+	end
+
+end
+

data/spec/mongrel2/websocket_spec.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 #encoding: utf-8
 
 require_relative '../helpers'
@@ -19,7 +20,7 @@ require 'mongrel2/websocket'
 describe Mongrel2::WebSocket do
 
 	before( :all ) do
-		@factory = Mongrel2::WebSocketFrameFactory.new( route: '/websock' )
+		@factory = Mongrel2::WebSocketRequestFactory.new( route: '/websock' )
 	end
 
 
@@ -43,7 +44,8 @@ describe Mongrel2::WebSocket do
 	describe 'ClientHandshake' do
 
 		it "is the registered request type for WEBSOCKET_HANDSHAKE requests" do
-			expect( Mongrel2::Request.request_types[:WEBSOCKET_HANDSHAKE] ).to eq( Mongrel2::WebSocket::ClientHandshake )
+			expect( Mongrel2::Request.request_types[:WEBSOCKET_HANDSHAKE] ).
+				to eq( Mongrel2::WebSocket::ClientHandshake )
 		end
 
 
@@ -104,121 +106,345 @@ describe Mongrel2::WebSocket do
 			}.to raise_error( Mongrel2::WebSocket::HandshakeError, /map_updates/i )
 		end
 
+	end
 
-		it "has a socket identifier" do
-			handshake = @factory.handshake( '/websock', 'echo', 'superecho' )
-			expect( handshake.socket_id ).to eq( "#{handshake.sender_id}:#{handshake.conn_id}" )
+
+	describe 'Request' do
+
+		it "is the registered request type for WEBSOCKET requests" do
+			expect( Mongrel2::Request.request_types[:WEBSOCKET] ).
+				to eq( Mongrel2::WebSocket::Request )
+		end
+
+
+		it "creates a correct inner frame from the request data" do
+			request = @factory.text( '/websock', 'Hi, here is a message!', :fin )
+
+			expect( request.frame ).to be_a( Mongrel2::WebSocket::Frame )
+			expect( request.frame.opcode ).to eq( :text )
+			expect( request.frame ).to be_fin()
+
+			expect( request.frame.payload.string ).to eq( 'Hi, here is a message!' )
+			expect( request.frame.payload.external_encoding ).to eq( Encoding::UTF_8 )
 		end
 
-	end
 
+		it "can create a response for itself" do
+			request = @factory.text( '/websock', 'Hi, here is a message!', :fin )
+
+			result = request.response
+
+			expect( result ).to be_a( Mongrel2::WebSocket::Response )
+			expect( result.sender_id ).to eq( request.sender_id )
+			expect( result.conn_id ).to eq( request.conn_id )
+
+			expect( result.frame ).to be_a( Mongrel2::WebSocket::Frame )
+			expect( result.frame.opcode ).to eq( :text )
+
+			expect( result.frame.payload ).to be_a( StringIO )
+			expect( result.frame.payload.string ).to eq( '' )
+		end
+
+
+		it "creates PONG responses with the same payload for PING frames" do
+			request = @factory.ping( '/websock', 'WOO', :fin )
+
+			result = request.response
+
+			expect( result ).to be_a( Mongrel2::WebSocket::Response )
+			expect( result.sender_id ).to eq( request.sender_id )
+			expect( result.conn_id ).to eq( request.conn_id )
+			expect( result.opcode ).to eq( :pong )
+
+			result.payload.rewind
+			expect( result.payload.read ).to eq( 'WOO' )
+		end
+
+
+		it "allows header flags and/or opcode to be specified when creating a response" do
+			request = @factory.text( '/websock', 'some bad data', :fin )
+
+			result = request.response( :close, :fin )
+
+			expect( result ).to be_a( Mongrel2::WebSocket::Response )
+			expect( result.sender_id ).to eq( request.sender_id )
+			expect( result.conn_id ).to eq( request.conn_id )
+			expect( result.opcode ).to eq( :close )
+			expect( result ).to be_fin()
+
+			result.payload.rewind
+			expect( result.payload.read ).to eq( '' )
+		end
+
+
+		it "allows reserved opcodes to be specified when creating a response" do
+			request = @factory.text( '/websock', 'some bad data', :fin )
+
+			result = request.response( 0xB )
+
+			expect( result ).to be_a( Mongrel2::WebSocket::Response )
+			expect( result.sender_id ).to eq( request.sender_id )
+			expect( result.conn_id ).to eq( request.conn_id )
+			expect( result.opcode ).to eq( :reserved )
+			expect( result.numeric_opcode ).to eq( 0xB )
+
+			result.payload.rewind
+			expect( result.payload.read ).to eq( '' )
+		end
+
+	end
 
 
 	describe 'Frame' do
 
-		it "is the registered request type for WEBSOCKET requests" do
-			expect( Mongrel2::Request.request_types[:WEBSOCKET] ).to eq( Mongrel2::WebSocket::Frame )
+		it "has an iterator for fragmentation" do
+			data = <<~END_DATA
+			That the only purpose for which power can be rightfully exercised
+			over any member of a civilised community, against his will, is to
+			prevent harm to others.
+			END_DATA
+
+            io = StringIO.new( data )
+			iter = Mongrel2::WebSocket::Frame.each_fragment( io, :text, size: 64 )
+
+			expect( iter ).to be_a( Enumerator )
+			frames = iter.to_a
+
+			expect( frames ).to all( be_a Mongrel2::WebSocket::Frame )
+			expect( frames.size ).to eq( 3 )
+
+			expect( frames[0] ).to_not be_fin()
+			expect( frames[0].opcode ).to eq( :text )
+			expect( frames[0].payload.string ).to eq( data[0..63] )
+
+			expect( frames[1] ).to_not be_fin()
+			expect( frames[1].opcode ).to eq( :continuation )
+			expect( frames[1].payload.string ).to eq( data[64..127] )
+
+			expect( frames[2] ).to be_fin()
+			expect( frames[2].opcode ).to eq( :continuation )
+			expect( frames[2].payload.string ).to eq( data[128..191] )
+		end
+
+
+		it "doesn't fragment if the data read by the fragmentation iterator fits in one frame" do
+			data = <<~END_DATA
+			That the only purpose for which power can be rightfully exercised
+			over any member of a civilised community, against his will, is to
+			prevent harm to others.
+			END_DATA
+
+            io = StringIO.new( data )
+			iter = Mongrel2::WebSocket::Frame.each_fragment( io, :text, size: 4096 )
+
+			expect( iter ).to be_a( Enumerator )
+			frames = iter.to_a
+
+			expect( frames ).to all( be_a Mongrel2::WebSocket::Frame )
+			expect( frames.size ).to eq( 1 )
+
+			expect( frames[0] ).to be_fin()
+			expect( frames[0].opcode ).to eq( :text )
+			expect( frames[0].payload.string ).to eq( data[0..4096] )
+		end
+
+
+		it "has a constructor for CONTINUATION frames" do
+			frame = Mongrel2::WebSocket::Frame.continuation
+			expect( frame ).to be_a( Mongrel2::WebSocket::Frame )
+			expect( frame ).to be_fin()
+			expect( frame ).to_not be_control()
+			expect( frame.opcode ).to eq( :continuation )
+		end
+
+
+		it "has a constructor for TEXT frames" do
+			frame = Mongrel2::WebSocket::Frame.text
+			expect( frame ).to be_a( Mongrel2::WebSocket::Frame )
+			expect( frame ).to be_fin()
+			expect( frame ).to_not be_control()
+			expect( frame.opcode ).to eq( :text )
+		end
+
+
+		it "has a constructor for BINARY frames" do
+			frame = Mongrel2::WebSocket::Frame.binary
+			expect( frame ).to be_a( Mongrel2::WebSocket::Frame )
+			expect( frame ).to be_fin()
+			expect( frame ).to_not be_control()
+			expect( frame.opcode ).to eq( :binary )
+		end
+
+
+		it "has a constructor for PING frames" do
+			frame = Mongrel2::WebSocket::Frame.ping
+			expect( frame ).to be_a( Mongrel2::WebSocket::Frame )
+			expect( frame ).to be_fin()
+			expect( frame ).to be_control()
+			expect( frame.opcode ).to eq( :ping )
+		end
+
+
+		it "has a constructor for PONG frames" do
+			frame = Mongrel2::WebSocket::Frame.pong
+			expect( frame ).to be_a( Mongrel2::WebSocket::Frame )
+			expect( frame ).to be_fin()
+			expect( frame ).to be_control()
+			expect( frame.opcode ).to eq( :pong )
+		end
+
+
+		it "has a constructor for CLOSE frames" do
+			frame = Mongrel2::WebSocket::Frame.close
+			expect( frame ).to be_a( Mongrel2::WebSocket::Frame )
+			expect( frame ).to be_fin()
+			expect( frame ).to be_control()
+			expect( frame.opcode ).to eq( :close )
+		end
+
+
+		it "is parsed from the body of a Mongrel2::WebSocket::Request" do
+			request = @factory.ping( '/websock', 'Ping!' )
+			frame = request.frame
+
+			expect( frame ).to be_a( Mongrel2::WebSocket::Frame )
+			expect( frame.flags ).to be_an( Integer )
+			expect( frame ).to be_fin
+		end
+
+
+		it "can set its flags by name" do
+			frame = Mongrel2::WebSocket::Frame.new
+			frame.flags = 0x00
+
+			frame.set_flags( :fin, :rsv2, :continuation )
+
+			expect( frame.flags ).to eq( FIN_FLAG | RSV2_FLAG | OPCODE[:continuation] )
+		end
+
+
+		it "can set its flags with an integer" do
+			frame = Mongrel2::WebSocket::Frame.new
+			frame.flags = 0x00
+
+			frame.set_flags( FIN_FLAG | OPCODE[:close] )
+
+			expect( frame ).to be_fin()
+			expect( frame.opcode ).to eq( :close )
+		end
+
+
+		it "can set its flags with a hex string" do
+			frame = Mongrel2::WebSocket::Frame.new
+			frame.flags = 0x00
+
+			frame.set_flags( '0x8A' )
+
+			expect( frame ).to be_fin()
+			expect( frame.opcode ).to eq( :pong )
 		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 = Mongrel2::WebSocket::Frame.text( 'Hello!' )
+			frame.flags ^= ( frame.flags & FIN_FLAG )
 			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 = Mongrel2::WebSocket::Frame.text( 'Hello!' )
+			frame.flags |= FIN_FLAG
 			expect( frame ).to be_fin()
 		end
 
 
-		it "can unset its FIN flag" do
-			frame = @factory.text( '/websock', 'Hello!', :fin )
+		it "can unset its FIN flag via an accessor" do
+			frame = Mongrel2::WebSocket::Frame.text( 'Hello!', :fin )
 			frame.fin = false
 			expect( frame ).to_not be_fin()
 		end
 
 
 		it "can set its FIN flag" do
-			frame = @factory.text( '/websock', 'Hello!' )
+			frame = Mongrel2::WebSocket::Frame.text( 'Hello!' )
+			frame.flags ^= ( frame.flags & FIN_FLAG )
 			frame.fin = true
 			expect( frame ).to be_fin()
 		end
 
 
 		it "knows that its opcode is continuation if its opcode is 0x0" do
-			expect( @factory.continuation( '/websock' ).opcode ).to eq( :continuation )
+			expect( @factory.continuation('/websock').opcode ).to eq( :continuation )
 		end
 
 
 		it "knows that is opcode is 'text' if its opcode is 0x1" do
-			expect( @factory.text( '/websock', 'Hello!' ).opcode ).to eq( :text )
+			expect( Mongrel2::WebSocket::Frame.text('Hello!').opcode ).to eq( :text )
 		end
 
 
 		it "knows that is opcode is 'binary' if its opcode is 0x2" do
-			expect( @factory.binary( '/websock', 'Hello!' ).opcode ).to eq( :binary )
+			expect( Mongrel2::WebSocket::Frame.binary('Hello!').opcode ).to eq( :binary )
 		end
 
 
 		it "knows that is opcode is 'close' if its opcode is 0x8" do
-			expect( @factory.close( '/websock' ).opcode ).to eq( :close )
+			expect( Mongrel2::WebSocket::Frame.close.opcode ).to eq( :close )
 		end
 
 
 		it "knows that is opcode is 'ping' if its opcode is 0x9" do
-			expect( @factory.ping( '/websock' ).opcode ).to eq( :ping )
+			expect( Mongrel2::WebSocket::Frame.ping.opcode ).to eq( :ping )
 		end
 
 
 		it "knows that is opcode is 'pong' if its opcode is 0xA" do
-			expect( @factory.pong( '/websock' ).opcode ).to eq( :pong )
+			expect( Mongrel2::WebSocket::Frame.pong.opcode ).to eq( :pong )
 		end
 
 
 		it "knows that its opcode is one of the reserved ones if it's 0x3" do
-			expect( @factory.create( '/websocket', '', 0x3 ).opcode ).to eq( :reserved )
+			expect( Mongrel2::WebSocket::Frame.new('', 0x3).opcode ).to eq( :reserved )
 		end
 
 
 		it "knows that its opcode is one of the reserved ones if it's 0x4" do
-			expect( @factory.create( '/websocket', '', 0x4 ).opcode ).to eq( :reserved )
+			expect( Mongrel2::WebSocket::Frame.new('', 0x4).opcode ).to eq( :reserved )
 		end
 
 
 		it "knows that its opcode is one of the reserved ones if it's 0xB" do
-			expect( @factory.create( '/websocket', '', 0xB ).opcode ).to eq( :reserved )
+			expect( Mongrel2::WebSocket::Frame.new('', 0xB).opcode ).to eq( :reserved )
 		end
 
 
 		it "knows that its opcode is one of the reserved ones if it's 0xD" do
-			expect( @factory.create( '/websocket', '', 0xD ).opcode ).to eq( :reserved )
+			expect( Mongrel2::WebSocket::Frame.new('', 0xD).opcode ).to eq( :reserved )
 		end
 
 
 		it "knows that its opcode is one of the reserved ones if it's 0xF" do
-			expect( @factory.create( '/websocket', '', 0xF ).opcode ).to eq( :reserved )
+			expect( Mongrel2::WebSocket::Frame.new('', 0xF).opcode ).to eq( :reserved )
 		end
 
 
 		it "allows its opcode to be set Symbolically" do
-			frame = @factory.text( '/websocket', 'data' )
+			frame = Mongrel2::WebSocket::Frame.text( 'data' )
 			frame.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 = Mongrel2::WebSocket::Frame.binary( 'data' )
 			frame.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 = Mongrel2::WebSocket::Frame.binary( 'data' )
 			frame.opcode = 0xC
 			expect( frame.opcode ).to eq( :reserved )
 			expect( frame.numeric_opcode ).to eq( 0xC )
@@ -226,152 +452,94 @@ describe Mongrel2::WebSocket do
 
 
 		it "knows that its RSV1 flag is set if its FLAG header includes that bit" do
-			expect( @factory.ping( '/websock', 'test', :rsv1 ) ).to be_rsv1()
+			expect( Mongrel2::WebSocket::Frame.ping('test', :rsv1) ).to be_rsv1()
 		end
 
 
 		it "knows that its RSV2 flag is set if its FLAG header includes that bit" do
-			expect( @factory.ping( '/websock', 'test', :rsv2 ) ).to be_rsv2()
+			expect( Mongrel2::WebSocket::Frame.ping('test', :rsv2) ).to be_rsv2()
 		end
 
 
 		it "knows that its RSV3 flag is set if its FLAG header includes that bit" do
-			expect( @factory.ping( '/websock', 'test', :rsv3 ) ).to be_rsv3()
+			expect( Mongrel2::WebSocket::Frame.ping('test', :rsv3) ).to be_rsv3()
 		end
 
 
 		it "knows that one of its RSV flags is set if its FLAG header includes RSV1" do
-			expect( @factory.ping( '/websock', 'test', :rsv1 ) ).to have_rsv_flags()
+			expect( Mongrel2::WebSocket::Frame.ping('test', :rsv1) ).to have_rsv_flags()
 		end
 
 
 		it "knows that one of its RSV flags is set if its FLAG header includes RSV2" do
-			expect( @factory.ping( '/websock', 'test', :rsv2 ) ).to have_rsv_flags()
+			expect( Mongrel2::WebSocket::Frame.ping('test', :rsv2) ).to have_rsv_flags()
 		end
 
 
 		it "knows that one of its RSV flags is set if its FLAG header includes RSV3" do
-			expect( @factory.ping( '/websock', 'test', :rsv3 ) ).to have_rsv_flags()
+			expect( Mongrel2::WebSocket::Frame.ping('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
-			expect( @factory.ping( '/websock', 'test' ) ).to_not have_rsv_flags()
-		end
-
-
-		it "can create a response WebSocket::Frame for itself" do
-			frame = @factory.text( '/websock', "Hi, here's a message!", :fin )
-
-			result = frame.response
-
-			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
-			expect( result.payload.read ).to eq( '' )
-		end
-
-
-		it "creates PONG responses with the same payload for PING frames" do
-			frame = @factory.ping( '/websock', "WOO" )
-
-			result = frame.response
-
-			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
-			expect( result.payload.read ).to eq( 'WOO' )
-		end
-
-
-		it "allows header flags and/or opcode to be specified when creating a response" do
-			frame = @factory.text( '/websock', "some bad data" )
-
-			result = frame.response( :close, :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
-			expect( result.payload.read ).to eq( '' )
-		end
-
-
-		it "allows reserved opcodes to be specified when creating a response" do
-			frame = @factory.text( '/websock', "some bad data" )
-
-			result = frame.response( 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
-			expect( result.payload.read ).to eq( '' )
+			expect( Mongrel2::WebSocket::Frame.ping('test') ).to_not have_rsv_flags()
 		end
 
 
 		it "can be streamed in chunks instead of read all at once" do
 			data = BINARY_DATA * 256
-			binary = @factory.binary( '/websock', data, :fin )
+			binary = Mongrel2::WebSocket::Frame.binary( data )
 
 			binary.chunksize = 16
 			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'),
+				"\x82\x7F\x00\x00\x00\x00\x00\x01\x00\x00\a\xBD\xB3\xFE\x87\xEB".b,
+				"\xA9\x0En2q\xCE\x85\xAF)\x88w_d\xD6M\x9E".b,
 			])
 		end
 
-
-		it "has a socket identifier" do
-			frame = @factory.text( '/websock', "data" )
-			expect( frame.socket_id ).to eq( "#{frame.sender_id}:#{frame.conn_id}" )
-		end
-
 	end
 
 
 	describe "a WebSocket text frame" do
 
-		before( :each ) do
-			@frame = @factory.text( '/websock', '', :fin )
-		end
+		let( :frame ) { Mongrel2::WebSocket::Frame.text }
 
 
 		it "automatically transcodes its payload to UTF8" do
 			text = "Стрелке!".encode( Encoding::KOI8_U )
-			@frame << text
+			frame << text
 
 			# 2-byte header
-			expect( @frame.bytes.to_a[ 2..-1 ] ).
+			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
 
+
+		it "automatically transcodes multi-part payloads to UTF8" do
+			text1 = "Стрелке!".encode( Encoding::KOI8_U )
+			text2 = "Chiitan 妖精ちぃたん"
+			frame << text1 << text2
+
+			# 2-byte header
+			expect( frame.bytes.to_a[ 2..-1 ] ).
+				to eq([ 0xD0, 0xA1, 0xD1, 0x82, 0xD1, 0x80, 0xD0, 0xB5, 0xD0, 0xBB, 0xD0,
+				        0xBA, 0xD0, 0xB5, 0x21, 0x43, 0x68, 0x69, 0x69, 0x74, 0x61, 0x6e,
+				        0x20, 0xe5, 0xa6, 0x96, 0xe7, 0xb2, 0xbe, 0xe3, 0x81, 0xa1, 0xe3,
+				        0x81, 0x83, 0xe3, 0x81, 0x9f, 0xe3, 0x82, 0x93 ])
+		end
+
 	end
 
 
 	describe "a WebSocket binary frame" do
 
-		before( :each ) do
-			@frame = @factory.binary( '/websock', BINARY_DATA, :fin )
-		end
+		let( :frame ) { Mongrel2::WebSocket::Frame.binary(BINARY_DATA) }
 
 
 		it "doesn't try to transcode non-UTF8 data" do
 			# 4-byte header
-			expect( @frame.bytes.to_a[ 4, 16 ] ).
+			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
@@ -381,15 +549,12 @@ describe Mongrel2::WebSocket do
 
 	describe "a WebSocket close frame" do
 
-		before( :each ) do
-			@frame = @factory.close( '/websock' )
-		end
+		let( :frame ) { Mongrel2::WebSocket::Frame.close }
 
 
 		it "has convenience methods for setting its payload via integer status code" do
-			@frame.set_status( CLOSE_BAD_DATA )
-			@frame.payload.rewind
-			expect( @frame.payload.read ).
+			frame.set_status( CLOSE_BAD_DATA )
+			expect( frame.payload.string ).
 				to eq( "%d %s\n" % [CLOSE_BAD_DATA, CLOSING_STATUS_DESC[CLOSE_BAD_DATA]] )
 		end
 
@@ -398,23 +563,21 @@ describe Mongrel2::WebSocket do
 
 	describe "WebSocket control frames" do
 
-		before( :each ) do
-			@frame = @factory.close( '/websock', "1002 Protocol error" )
-		end
+		let( :frame ) { Mongrel2::WebSocket::Frame.close("1002 Protocol error") }
 
 
 		it "raises an exception if its payload is bigger than 125 bytes" do
-			@frame.body << "x" * 126
+			frame.body << "x" * 126
 			expect {
-				@frame.validate
+				frame.validate
 			}.to raise_error( Mongrel2::WebSocket::FrameError, /cannot exceed 125 bytes/i )
 		end
 
 
 		it "raises an exception if it's fragmented" do
-			@frame.fin = false
+			frame.fin = false
 			expect {
-				@frame.validate
+				frame.validate
 			}.to raise_error( Mongrel2::WebSocket::FrameError, /fragmented/i )
 		end
 
@@ -424,15 +587,16 @@ describe Mongrel2::WebSocket do
 	describe "RFC examples (the applicable ones, anyway)" do
 
 		it "generates a single-frame unmasked text message correctly" do
-			raw_response = @factory.text( '/websock', "Hello", :fin ).to_s
+			raw_response = Mongrel2::WebSocket::Frame.text( "Hello", :fin ).to_s
 			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 = Mongrel2::WebSocket::Frame.text( 'Hel' )
+			first.fin = false
+			last = Mongrel2::WebSocket::Frame.continuation( 'lo' )
 
 			expect( first.bytes.to_a ).to eq( [ 0x01, 0x03, 0x48, 0x65, 0x6c ] )
 			expect( last.bytes.to_a ).to eq( [ 0x80, 0x02, 0x6c, 0x6f ] )
@@ -442,8 +606,8 @@ describe Mongrel2::WebSocket do
 		# The RFC's example is a masked response, but we're never a client, so never
 		# generate masked payloads.
 		it "generates a unmasked Ping request and (un)masked Ping response correctly" do
-			ping = @factory.ping( '/websock', 'Hello' )
-			pong = @factory.pong( '/websock', 'Hello' )
+			ping = Mongrel2::WebSocket::Frame.ping( 'Hello' )
+			pong = Mongrel2::WebSocket::Frame.pong( 'Hello' )
 
 			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 ] )
@@ -451,7 +615,7 @@ describe Mongrel2::WebSocket do
 
 
 		it "generates a 256-byte binary message in a single unmasked frame" do
-			binary = @factory.binary( '/websock', BINARY_DATA, :fin )
+			binary = Mongrel2::WebSocket::Frame.binary( BINARY_DATA, :fin )
 
 			# 1 + 1 + 2
 			expect( binary.bytes.to_a[0,4] ).to eq( [ 0x82, 0x7E, 0x01, 0x00 ] )
@@ -462,7 +626,7 @@ describe Mongrel2::WebSocket do
 		it "generates a 64KiB binary message in a single unmasked frame correctly" do
 			data = BINARY_DATA * 256
 
-			binary = @factory.binary( '/websock', data, :fin )
+			binary = Mongrel2::WebSocket::Frame.binary( data, :fin )
 
 			# 1 + 1 + 8
 			expect( binary.bytes.to_a[0,10] ).