mongrel2 0.0.1

data/spec/mongrel2/connection_spec.rb

@@ -0,0 +1,172 @@
+#!/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 'mongrel2'
+require 'mongrel2/connection'
+
+
+#####################################################################
+###	C O N T E X T S
+#####################################################################
+
+describe Mongrel2::Connection do
+	include Mongrel2::Config::DSL
+
+	before( :all ) do
+		setup_logging( :fatal )
+	end
+
+	# Ensure 0MQ never actually gets called
+	before( :each ) do
+		@ctx = double( "0mq context" )
+		Mongrel2.instance_variable_set( :@zmq_ctx, @ctx )
+
+		@conn = Mongrel2::Connection.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC )
+	end
+
+	after( :each ) do
+		Mongrel2.instance_variable_set( :@zmq_ctx, nil )
+	end
+
+	after( :all ) do
+		reset_logging()
+	end
+
+
+	it "doesn't connect to the endpoints when it's created" do
+		@conn.instance_variable_get( :@request_sock ).should be_nil()
+		@conn.instance_variable_get( :@response_sock ).should be_nil()
+	end
+
+	it "connects to the endpoints specified on demand" do
+		request_sock = double( "request socket" )
+		response_sock = double( "response socket" )
+
+		@ctx.should_receive( :socket ).with( ZMQ::PULL ).and_return( request_sock )
+		request_sock.should_receive( :setsockopt ).with( ZMQ::LINGER, 0 )
+		request_sock.should_receive( :connect ).with( TEST_SEND_SPEC )
+
+		@ctx.should_receive( :socket ).with( ZMQ::PUB ).and_return( response_sock )
+		response_sock.should_receive( :setsockopt ).with( ZMQ::LINGER, 0 )
+		response_sock.should_receive( :setsockopt ).with( ZMQ::IDENTITY, TEST_UUID )
+		response_sock.should_receive( :connect ).with( TEST_RECV_SPEC )
+
+		@conn.request_sock.should == request_sock
+		@conn.response_sock.should == response_sock
+	end
+
+	context "after a connection has been established" do
+
+		before( :each ) do
+			@request_sock = double( "request socket", :setsockopt => nil, :connect => nil )
+			@response_sock = double( "response socket", :setsockopt => nil, :connect => nil )
+
+			@ctx.stub( :socket ).with( ZMQ::PULL ).and_return( @request_sock )
+			@ctx.stub( :socket ).with( ZMQ::PUB ).and_return( @response_sock )
+
+			@conn.connect
+		end
+
+
+		it "closes both of its sockets when closed" do
+			@request_sock.should_receive( :close )
+			@response_sock.should_receive( :close )
+
+			@conn.close
+		end
+
+		it "raises an exception if asked to fetch data after being closed" do
+			@request_sock.stub( :close )
+			@response_sock.stub( :close )
+
+			@conn.close
+
+			expect {
+				@conn.recv
+			}.to raise_error( Mongrel2::ConnectionError, /operation on closed connection/i )
+		end
+
+		it "doesn't keep its request and response sockets when duped" do
+			request_sock2 = double( "request socket", :setsockopt => nil, :connect => nil )
+			response_sock2 = double( "response socket", :setsockopt => nil, :connect => nil )
+			@ctx.stub( :socket ).with( ZMQ::PULL ).and_return( request_sock2 )
+			@ctx.stub( :socket ).with( ZMQ::PUB ).and_return( response_sock2 )
+
+			duplicate = @conn.dup
+
+			duplicate.request_sock.should == request_sock2
+			duplicate.response_sock.should == response_sock2
+		end
+
+		it "doesn't keep its closed state when duped" do
+			@request_sock.should_receive( :close )
+			@response_sock.should_receive( :close )
+
+			@conn.close
+
+			duplicate = @conn.dup
+			duplicate.should_not be_closed()
+		end
+
+		it "can read raw request messages off of the request_sock" do
+			@request_sock.should_receive( :recv ).and_return( "the data" )
+			@conn.recv.should == "the data"
+		end
+
+		it "can read request messages off of the request_sock as Mongrel2::Request objects" do
+			msg = make_request()
+			@request_sock.should_receive( :recv ).and_return( msg )
+			@conn.receive.should be_a( Mongrel2::Request )
+		end
+
+		it "can write raw response messages with a TNetString header onto the response_sock" do
+			@response_sock.should_receive( :send ).with( "#{TEST_UUID} 1:8, the data" )
+			@conn.send( TEST_UUID, 8, "the data" )
+		end
+
+		it "can write Mongrel2::Responses to the response_sock" do
+			@response_sock.should_receive( :send ).with( "#{TEST_UUID} 1:8, the data" )
+
+			response = Mongrel2::Response.new( TEST_UUID, 8, 'the data' )
+			@conn.reply( response )
+		end
+
+		it "can write raw response messages to more than one conn_id at the same time" do
+			@response_sock.should_receive( :send ).with( "#{TEST_UUID} 15:8 16 44 45 1833, the data" )
+			@conn.broadcast( TEST_UUID, [8, 16, 44, 45, 1833], 'the data' )
+		end
+
+		it "can write raw response messages to more than one conn_id at the same time" do
+			@response_sock.should_receive( :send ).with( "#{TEST_UUID} 15:8 16 44 45 1833, the data" )
+			@conn.broadcast( TEST_UUID, [8, 16, 44, 45, 1833], 'the data' )
+		end
+
+		it "can tell the connection a request or a response was from to close" do
+			@response_sock.should_receive( :send ).with( "#{TEST_UUID} 1:8, " )
+
+			response = Mongrel2::Response.new( TEST_UUID, 8 )
+			@conn.reply_close( response )
+		end
+
+		it "can broadcast a close to multiple connection IDs" do
+			@response_sock.should_receive( :send ).with( "#{TEST_UUID} 15:8 16 44 45 1833, " )
+			@conn.broadcast_close( TEST_UUID, [8, 16, 44, 45, 1833] )
+		end
+
+	end
+
+end
+

data/spec/mongrel2/constants_spec.rb

@@ -0,0 +1,32 @@
+#!/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 'mongrel2'
+require 'mongrel2/connection'
+
+
+#####################################################################
+###	C O N T E X T S
+#####################################################################
+
+describe Mongrel2::Constants do
+
+	it "defines a default configuration URI" do
+		Mongrel2::Constants.constants.map( &:to_sym ).should include( :DEFAULT_CONFIG_URI )
+	end
+
+end
+

data/spec/mongrel2/control_spec.rb

@@ -0,0 +1,192 @@
+#!/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 'mongrel2'
+require 'mongrel2/control'
+
+
+#####################################################################
+###	C O N T E X T S
+#####################################################################
+
+describe Mongrel2::Control do
+
+	before( :all ) do
+		setup_logging( :fatal )
+	end
+
+	before( :each ) do
+		@ctx = double( "ZMQ::Context" )
+		@socket = double( "ZMQ REQ socket", :connect => nil )
+		@ctx.stub( :socket ).with( ZMQ::REQ ).and_return( @socket )
+
+		Mongrel2.instance_variable_set( :@zmq_ctx, @ctx )
+
+		@control = Mongrel2::Control.new
+	end
+
+	after( :all ) do
+		Mongrel2.instance_variable_set( :@zmq_ctx, nil )
+		reset_logging()
+	end
+
+
+	it "sends a 'stop' command to the control port when #stop is called" do
+		@socket.should_receive( :send ).with( "10:4:stop,0:}]" )
+		@socket.should_receive( :recv ).
+			and_return( "59:7:headers,6:3:msg,]4:rows,29:25:21:signal sent to server,]]}" )
+		@control.stop.should == [{ :msg => "signal sent to server" }]
+	end
+
+	it "sends a 'reload' command to the control port when #reload is called" do
+		@socket.should_receive( :send ).with( "12:6:reload,0:}]" )
+		@socket.should_receive( :recv ).
+			and_return( "59:7:headers,6:3:msg,]4:rows,29:25:21:signal sent to server,]]}" )
+		@control.reload.should == [{ :msg => "signal sent to server" }]
+	end
+
+	it "sends a 'terminate' command to the control port when #terminate is called" do
+		@socket.should_receive( :send ).with( "15:9:terminate,0:}]" )
+		@socket.should_receive( :recv ).
+			and_return( "59:7:headers,6:3:msg,]4:rows,29:25:21:signal sent to server,]]}" )
+		@control.terminate.should == [{ :msg => "signal sent to server" }]
+	end
+
+	it "sends a 'help' command to the control port when #help is called" do
+		@socket.should_receive( :send ).with( "10:4:help,0:}]" )
+		@socket.should_receive( :recv ).
+			and_return( "416:7:headers,14:4:name,4:help,]4:rows,376:35:4:stop" +
+			            ",24:stop the server (SIGINT),]30:6:reload,17:reload " +
+			            "the server,]23:4:help,12:this command,]37:12:control" +
+			            "_stop,17:stop control port,]28:4:kill,17:kill a conn" +
+			            "ection,]41:6:status,28:status, what=['net'|'tasks']," +
+			            "]46:9:terminate,30:terminate the server (SIGTERM),]2" +
+			            "8:4:time,17:the server's time,]28:4:uuid,17:the serv" +
+			            "er's uuid,]40:4:info,29:information about this serve" +
+			            "r,]]}" )
+		@control.help.should == [
+			{:name => "stop",         :help => "stop the server (SIGINT)"},
+			{:name => "reload",       :help => "reload the server"},
+			{:name => "help",         :help => "this command"},
+			{:name => "control_stop", :help => "stop control port"},
+			{:name => "kill",         :help => "kill a connection"},
+			{:name => "status",       :help => "status, what=['net'|'tasks']"},
+			{:name => "terminate",    :help => "terminate the server (SIGTERM)"},
+			{:name => "time",         :help => "the server's time"},
+			{:name => "uuid",         :help => "the server's uuid"},
+			{:name => "info",         :help => "information about this server"}
+		]
+	end
+
+	it "sends a 'uuid' command to the control port when #uuid is called" do
+		@socket.should_receive( :send ).with( "10:4:uuid,0:}]" )
+		@socket.should_receive( :recv ).
+			and_return( "75:7:headers,7:4:uuid,]4:rows,44:40:36:34D8E57C-3E91" +
+			            "-4F24-9BBE-0B53C1827CB4,]]}" )
+		@control.uuid.should == [{ :uuid => '34D8E57C-3E91-4F24-9BBE-0B53C1827CB4' }]
+	end
+
+	it "sends an 'info' command to the control port when #info is called" do
+		@socket.should_receive( :send ).with( "10:4:info,0:}]" )
+		@socket.should_receive( :recv ).
+			and_return( "260:7:headers,92:4:port,9:bind_addr,4:uuid,6:chroot," +
+			            "10:access_log,9:error_log,8:pid_file,16:default_host" +
+			            "name,]4:rows,142:137:4:8113#7:0.0.0.0,36:34D8E57C-3E" +
+			            "91-4F24-9BBE-0B53C1827CB4,2:./,18:.//logs/access.log" +
+			            ",15:/logs/error.log,18:./run/mongrel2.pid,9:localhos" +
+			            "t,]]}" )
+		@control.info.should == [{
+			:port             => 8113,
+			:bind_addr        => "0.0.0.0",
+			:uuid             => "34D8E57C-3E91-4F24-9BBE-0B53C1827CB4",
+			:chroot           => "./",
+			:access_log       => ".//logs/access.log",
+			:error_log        => "/logs/error.log",
+			:pid_file         => "./run/mongrel2.pid",
+			:default_hostname => "localhost"
+		}]
+	end
+
+	it "sends a 'status' command with a 'what' option set to 'tasks' to the control port " +
+	   "when #tasklist is called" do
+
+		@socket.should_receive( :send ).with( "28:6:status,15:4:what,5:tasks,}]" )
+		@socket.should_receive( :recv ).
+			and_return( "343:7:headers,38:2:id,6:system,4:name,5:state,6:status," +
+			            "]4:rows,279:38:1:1#5:false!6:SERVER,7:read fd,4:idle,]5" +
+			            "1:1:2#5:false!12:Handler_task,12:read handler,4:idle,]5" +
+			            "1:1:3#5:false!12:Handler_task,12:read handler,4:idle,]4" +
+			            "8:1:4#5:false!7:control,12:read handler,7:running,]31:1" +
+			            ":5#5:false!6:ticker,0:,4:idle,]36:1:6#4:true!6:fdtask,5" +
+			            ":yield,5:ready,]]}" )
+		@control.tasklist.should == [
+			{:id=>1, :system=>false, :name=>"SERVER",       :state=>"read fd",      :status=>"idle"},
+			{:id=>2, :system=>false, :name=>"Handler_task", :state=>"read handler", :status=>"idle"},
+			{:id=>3, :system=>false, :name=>"Handler_task", :state=>"read handler", :status=>"idle"},
+			{:id=>4, :system=>false, :name=>"control",      :state=>"read handler", :status=>"running"},
+			{:id=>5, :system=>false, :name=>"ticker",       :state=>"",             :status=>"idle"},
+			{:id=>6, :system=>true,  :name=>"fdtask",       :state=>"yield",        :status=>"ready"}
+		]
+	end
+
+	it "sends an 'status' command with a 'what' option set to 'net' to the control port " +
+	   "when #conn_status is called" do
+
+		@socket.should_receive( :send ).with( "26:6:status,13:4:what,3:net,}]" )
+		@socket.should_receive( :recv ).
+			and_return( "150:7:headers,86:2:id,2:fd,4:type,9:last_ping,9:last_read," +
+			            "10:last_write,10:bytes_read,13:bytes_written,]4:rows,39:35" +
+			            ":1:2#2:38#1:1#1:0#1:0#1:0#3:405#1:0#]]}" )
+		@control.conn_status.should == [
+			{:id=>2, :fd=>38, :type=>1, :last_ping=>0, :last_read=>0, :last_write=>0,
+				:bytes_read=>405, :bytes_written=>0}
+		]
+	end
+
+	it "sends a 'time' command to the control port when #time is called" do
+		@socket.should_receive( :send ).with( "10:4:time,0:}]" )
+		@socket.should_receive( :recv ).
+			and_return( "49:7:headers,7:4:time,]4:rows,18:14:10:1315532674,]]}" )
+		@control.time.should == [{ :time => Time.at(1315532674) }]
+	end
+
+	it "sends a 'kill' command with an ID equal to the argument to the control port when #kill " +
+	   "is called" do
+		@socket.should_receive( :send ).with( "19:4:kill,9:2:id,1:0#}]" )
+		@socket.should_receive( :recv ).and_return( "40:7:headers,9:6:status,]4:rows,8:5:2:OK,]]}" )
+		@control.kill( 0 ).should == [{ :status => "OK" }]
+	end
+
+	it "sends a 'control_stop' command to the control port when #info is called" do
+		@socket.should_receive( :send ).with( "19:12:control_stop,0:}]" )
+		@socket.should_receive( :recv ).
+			and_return( "63:7:headers,6:3:msg,]4:rows,33:29:25:stopping the control port,]]}" )
+		@control.control_stop.should == [{:msg => "stopping the control port"}]
+	end
+
+
+	it "raises an exception if the server responds with an error" do
+		@socket.should_receive( :send ).with( "19:4:kill,9:2:id,1:0#}]" )
+		@socket.should_receive( :recv ).
+			and_return( "61:4:code,16:INVALID_ARGUMENT,5:error,22:Invalid argument type.,}" )
+
+		expect {
+			@control.kill( 0 )
+		}.to raise_error( Mongrel2::ControlError, /invalid argument type/i )
+	end
+
+end
+

data/spec/mongrel2/handler_spec.rb

@@ -0,0 +1,261 @@
+#!/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 'mongrel2'
+require 'mongrel2/config'
+require 'mongrel2/handler'
+
+
+#####################################################################
+###	C O N T E X T S
+#####################################################################
+
+describe Mongrel2::Handler do
+
+	# Testing handler config
+	HANDLER_CONFIG = {
+		:send_spec  => TEST_SEND_SPEC,
+		:send_ident => TEST_UUID,
+		:recv_spec  => TEST_RECV_SPEC,
+	}
+
+
+	# Make a handler class for testing that only ever handles one request, and
+	# keeps track of any requests it handles and their responses.
+	class OneShotHandler < Mongrel2::Handler
+		def initialize( * )
+			@transactions = {}
+			super
+		end
+
+		attr_reader :transactions
+
+		# Overridden to accept one request and shut down
+		def dispatch_request( request )
+			response = super
+			self.transactions[ request ] = response
+			self.shutdown
+			return response
+		end
+
+	end # class OneShotHandler
+
+
+	before( :all ) do
+		setup_logging( :fatal )
+		setup_config_db()
+	end
+
+	after( :all ) do
+		reset_logging()
+	end
+
+
+	# Ensure 0MQ never actually gets called
+	before( :each ) do
+		@ctx = double( "0mq context" )
+		@request_sock = double( "request socket", :setsockopt => nil, :connect => nil, :close => nil )
+		@response_sock = double( "response socket", :setsockopt => 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 )
+
+		Mongrel2.instance_variable_set( :@zmq_ctx, @ctx )
+	end
+
+	after( :each ) do
+		Mongrel2.instance_variable_set( :@zmq_ctx, nil )
+	end
+
+
+
+	context "with a Handler entry in the config database" do
+
+		before( :each ) do
+			Mongrel2::Config::Handler.dataset.truncate
+			Mongrel2::Config::Handler.create( HANDLER_CONFIG )
+		end
+
+		it "can look up connection information given an application ID" do
+			Mongrel2::Handler.connection_info_for( TEST_UUID ).
+				should == [ TEST_SEND_SPEC, TEST_RECV_SPEC ]
+		end
+
+		it "has a convenience method for instantiating and running a Handler given an " +
+		   "application ID" do
+
+			req = make_request()
+			@request_sock.should_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
+		end
+
+	end
+
+
+	context "without a Handler entry for it in the config database" do
+
+		before( :each ) do
+			Mongrel2::Config::Handler.dataset.truncate
+		end
+
+		it "raises an exception if no handler with its appid exists in the config DB" do
+			Mongrel2::Config::Handler.dataset.truncate
+			expect {
+				Mongrel2::Handler.connection_info_for( TEST_UUID )
+			}.should raise_error()
+		end
+
+	end
+
+
+	it "dispatches HTTP requests to the #handle method" do
+		req = make_request()
+		@request_sock.should_receive( :recv ).and_return( req )
+
+		res = OneShotHandler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC ).run
+
+		res.transactions.should have( 1 ).member
+		request, response = res.transactions.first
+		request.should be_a( Mongrel2::HTTPRequest )
+		response.should be_a( Mongrel2::HTTPResponse )
+		response.status.should == 204
+	end
+
+
+	it "ignores JSON messages by default" do
+		req = make_json_request()
+		@request_sock.should_receive( :recv ).and_return( req )
+
+		res = OneShotHandler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC ).run
+
+		res.transactions.should have( 1 ).member
+		request, response = res.transactions.first
+		request.should be_a( Mongrel2::JSONRequest )
+		response.should be_nil()
+	end
+
+
+	it "dispatches JSON message to the #handle_json method" do
+		json_handler = Class.new( OneShotHandler ) do
+			def handle_json( request )
+				return request.response
+			end
+		end
+
+		req = make_json_request()
+		@request_sock.should_receive( :recv ).and_return( req )
+
+		res = json_handler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC ).run
+
+		res.transactions.should have( 1 ).member
+		request, response = res.transactions.first
+		request.should be_a( Mongrel2::JSONRequest )
+		response.should be_a( Mongrel2::Response )
+	end
+
+
+	it "ignores XML messages by default" do
+		req = make_xml_request()
+		@request_sock.should_receive( :recv ).and_return( req )
+
+		res = OneShotHandler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC ).run
+
+		res.transactions.should have( 1 ).member
+		request, response = res.transactions.first
+		request.should be_a( Mongrel2::XMLRequest )
+		response.should be_nil()
+	end
+
+
+	it "dispatches XML message to the #handle_xml method" do
+		xml_handler = Class.new( OneShotHandler ) do
+			def handle_xml( request )
+				return request.response
+			end
+		end
+
+		req = make_xml_request()
+		@request_sock.should_receive( :recv ).and_return( req )
+
+		res = xml_handler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC ).run
+
+		res.transactions.should have( 1 ).member
+		request, response = res.transactions.first
+		request.should be_a( Mongrel2::XMLRequest )
+		response.should be_a( Mongrel2::Response )
+	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 )
+
+		res = OneShotHandler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC ).run
+
+		res.transactions.should have( 1 ).member
+		request, response = res.transactions.first
+		request.should be_a( Mongrel2::HTTPRequest )
+		response.should be_a( Mongrel2::HTTPResponse )
+		response.status.should == 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 )
+
+		res = OneShotHandler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC ).run
+
+		res.transactions.should have( 1 ).member
+		request, response = res.transactions.first
+		request.should be_a( Mongrel2::JSONRequest )
+		response.should be_nil()
+	end
+
+	it "dispatches disconnect notices to the #handle_disconnect method" do
+		disconnect_handler = Class.new( OneShotHandler ) do
+			def handle_disconnect( request )
+				self.log.debug "Doing stuff for disconnected connection %d" % [ request.conn_id ]
+			end
+		end
+
+		req = make_json_request( :path => '@*', :body => {'type' => 'disconnect'} )
+		@request_sock.should_receive( :recv ).and_return( req )
+
+		res = disconnect_handler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC ).run
+
+		res.transactions.should have( 1 ).member
+		request, response = res.transactions.first
+		request.should be_a( Mongrel2::JSONRequest )
+		response.should 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 )
+	end
+
+end
+