serverside 0.2.5 → 0.2.6

data/lib/serverside/routing.rb

@@ -1,140 +1,131 @@
+require File.join(File.dirname(__FILE__), 'request')
+
 module ServerSide
-  module Connection
-    # The Router class defines a kind of connection that can route requests
-    # to different handlers based on rules that can be specified either by
-    # lambdas or by hashes that contain variable names corresponding to patterns.
-    #
-    # The simplest form of a routing rule specifies a path pattern:
-    #
-    #   ServerSide.route('/static') {serve_static('.'/@path)}
-    # 
-    # But you can also check for other attributes of the request:
-    #
-    #   ServerSide.route(:path => '/static', :host => '^:subdomain\.mydomain') {
-    #     serve_static(@parameters[:subdomain]/@path)
-    #   }
-    # 
-    # It also possible to pass a lambda as a rule:
-    #
-    #   ServerSide.route(lambda {@headers['Agent'] =~ /Moz/}) {serve_static('moz'/@path)}
+  # The Router class defines a kind of connection that can route requests
+  # to different handlers based on rules that can be specified either by
+  # lambdas or by hashes that contain variable names corresponding to patterns.
+  #
+  # The simplest form of a routing rule specifies a path pattern:
+  #
+  #   ServerSide.route('/static') {serve_static('.'/@path)}
+  # 
+  # But you can also check for other attributes of the request:
+  #
+  #   ServerSide.route(:path => '/static', :host => '^:subdomain\.mydomain') {
+  #     serve_static(@parameters[:subdomain]/@path)
+  #   }
+  # 
+  # It also possible to pass a lambda as a rule:
+  #
+  #   ServerSide.route(lambda {@headers['Agent'] =~ /Moz/}) {serve_static('moz'/@path)}
+  #
+  # Routing rules are evaluated in backwards, so the rules should be ordered
+  # from the general to the specific.
+  class Router < HTTP::Request
+    # Returns true if routes were defined.
+    def self.has_routes?
+      @@rules && !@@rules.empty? rescue false
+    end
+    
+    # Adds a routing rule. The normalized rule is a hash containing keys (acting
+    # as instance variable names) with patterns as values. If the rule is not a
+    # hash, it is normalized into a pattern checked against the request path.
+    # Pattern values can also be arrays, any member of which is checked as a
+    # pattern. The rule can also be a Proc or lambda which is run with the
+    # connection object's binding. A contrived example:
     #
-    # Routing rules are evaluated in backwards, so the rules should be ordered
-    # from the general to the specific.
-    class Router < Base
-      # Returns true if routes were defined.
-      def self.has_routes?
-        @@rules && !@@rules.empty? rescue false
-      end
-      
-      # Adds a routing rule. The normalized rule is a hash containing keys (acting
-      # as instance variable names) with patterns as values. If the rule is not a
-      # hash, it is normalized into a pattern checked against the request path.
-      # Pattern values can also be arrays, any member of which is checked as a
-      # pattern. The rule can also be a Proc or lambda which is run with the
-      # connection object's binding. A contrived example:
-      #
-      #   ServerSide.route(lambda{path = 'mypage'}) {serve_static('mypage.html')}
-      def self.route(rule, &block)
-        @@rules ||= []
-        rule = {:path => rule} unless (Hash === rule) || (Proc === rule)
-        @@rules.unshift [rule, block]
-        compile_rules
-      end
-      
-      # Compiles all rules into a respond method that is invoked when a request
-      # is received.
-      def self.compile_rules
-        @@rules ||= []
-        code = @@rules.inject('lambda {') {|m, r| m << rule_to_statement(r[0], r[1])}
-        code << 'default_handler}'
-        define_method(:respond, &eval(code))
-      end
-      
-      # Converts a rule into an if statement. All keys in the rule are matched
-      # against their respective values.
-      def self.rule_to_statement(rule, block)
-        proc_tag = define_proc(&block)
-        if Proc === rule
-          cond = define_proc(&rule).to_s
-        else
-          cond = rule.to_a.map {|kv|
-            if Array === kv[1]
-              '(' + kv[1].map {|v| condition_part(kv[0], v)}.join('||') + ')'
-            else
-              condition_part(kv[0], kv[1])
-            end
-          }.join('&&')
-        end
-        "return #{proc_tag} if #{cond}\n"
+    #   ServerSide.route(lambda{path = 'mypage'}) {serve_static('mypage.html')}
+    def self.route(rule, &block)
+      @@rules ||= []
+      rule = {:path => rule} unless (Hash === rule) || (Proc === rule)
+      @@rules.unshift [rule, block]
+      compile_rules
+    end
+    
+    # Compiles all rules into a respond method that is invoked when a request
+    # is received.
+    def self.compile_rules
+      @@rules ||= []
+      code = @@rules.inject('lambda {') {|m, r| m << rule_to_statement(r[0], r[1])}
+      code << 'default_handler}'
+      define_method(:respond, &eval(code))
+    end
+    
+    # Converts a rule into an if statement. All keys in the rule are matched
+    # against their respective values.
+    def self.rule_to_statement(rule, block)
+      proc_tag = define_proc(&block)
+      if Proc === rule
+        cond = define_proc(&rule).to_s
+      else
+        cond = rule.to_a.map {|kv|
+          if Array === kv[1]
+            '(' + kv[1].map {|v| condition_part(kv[0], v)}.join('||') + ')'
+          else
+            condition_part(kv[0], kv[1])
+          end
+        }.join('&&')
       end
+      "return #{proc_tag} if #{cond}\n"
+    end
 
-      # Pattern for finding parameters inside patterns. Parameters are parts of the
-      # pattern, which the routing pre-processor turns into sub-regexp that are
-      # used to extract parameter values from the pattern.
-      #
-      # For example, matching '/controller/show' against '/controller/:action' will
-      # give us @parameters[:action] #=> "show"
-      ParamRegexp = /(?::([a-z]+))/
+    # Pattern for finding parameters inside patterns. Parameters are parts of the
+    # pattern, which the routing pre-processor turns into sub-regexp that are
+    # used to extract parameter values from the pattern.
+    #
+    # For example, matching '/controller/show' against '/controller/:action' will
+    # give us @parameters[:action] #=> "show"
+    ParamRegexp = /(?::([a-z]+))/
 
-      # Returns the condition part for the key and value specified. The key is the
-      # name of an instance variable and the value is a pattern to match against.
-      # If the pattern contains parameters (for example, /controller/:action,) the
-      # method creates a lambda for extracting the parameter values.
-      def self.condition_part(key, value)
-        p_parse, p_count = '', 0
-        while (String === value) && (value =~ ParamRegexp)
-          value = value.dup
-          p_name = $1
-          p_count += 1
-          value.sub!(ParamRegexp, '(.+)')
-          p_parse << "@parameters[:#{p_name}] = $#{p_count}\n"
-        end
-        cond = "(@#{key} =~ #{cache_constant(Regexp.new(value))})"
-        if p_count == 0
-          cond
-        else
-          tag = define_proc(&eval(
-            "lambda {if #{cond}\n#{p_parse}true\nelse\nfalse\nend}"))
-          "(#{tag})"
-        end
+    # Returns the condition part for the key and value specified. The key is the
+    # name of an instance variable and the value is a pattern to match against.
+    # If the pattern contains parameters (for example, /controller/:action,) the
+    # method creates a lambda for extracting the parameter values.
+    def self.condition_part(key, value)
+      p_parse, p_count = '', 0
+      while (String === value) && (value =~ ParamRegexp)
+        value = value.dup
+        p_name = $1
+        p_count += 1
+        value.sub!(ParamRegexp, '(.+)')
+        p_parse << "@parameters[:#{p_name}] = $#{p_count}\n"
       end
-
-      # Converts a proc into a method, returning the method's name (as a symbol)
-      def self.define_proc(&block)
-        tag = block.proc_tag
-        define_method(tag.to_sym, &block) unless instance_methods.include?(tag)
-        tag.to_sym
+      cond = "(@#{key} =~ #{cache_constant(Regexp.new(value))})"
+      if p_count == 0
+        cond
+      else
+        tag = define_proc(&eval(
+          "lambda {if #{cond}\n#{p_parse}true\nelse\nfalse\nend}"))
+        "(#{tag})"
       end
+    end
 
-      # Converts a value into a local constant and freezes it. Returns the 
-      # constant's tag name
-      def self.cache_constant(value)
-        tag = value.const_tag
-        class_eval "#{tag} = #{value.inspect}.freeze" rescue nil
-        tag
-      end
+    # Converts a proc into a method, returning the method's name (as a symbol)
+    def self.define_proc(&block)
+      tag = block.proc_tag
+      define_method(tag.to_sym, &block) unless instance_methods.include?(tag)
+      tag.to_sym
+    end
 
-      # Sets the default handler for incoming requests.
-      def self.route_default(&block)
-        define_method(:default_handler, &block)
-        compile_rules
-      end
+    # Converts a value into a local constant and freezes it. Returns the 
+    # constant's tag name
+    def self.cache_constant(value)
+      tag = value.const_tag
+      class_eval "#{tag} = #{value.inspect}.freeze" rescue nil
+      tag
+    end
 
-      def unhandled
-        send_response(403, 'text', 'No handler found.')
-      end
+    # Sets the default handler for incoming requests.
+    def self.route_default(&block)
+      define_method(:default_handler, &block)
+      compile_rules
+    end
 
-      alias_method :default_handler, :unhandled
+    # Generic responder for unhandled requests.
+    def unhandled
+      send_response(403, 'text', 'No handler found.')
     end
-  end
-  
-  # Adds a routing rule. This is a convenience method.
-  def self.route(rule, &block)
-    Connection::Router.route(rule, &block)
-  end
-  
-  # Sets the default request handler. This is a convenience method.
-  def self.route_default(&block)
-    Connection::Router.route_default(&block)
+
+    alias_method :default_handler, :unhandled
   end
 end

data/lib/serverside/server.rb

@@ -1,18 +1,19 @@
 require 'socket'
 
 module ServerSide
-  # The ServerSide HTTP server is designed to be fast and simple. It is also
-  # designed to support both HTTP 1.1 persistent connections, and HTTP streaming
-  # for applications which use Comet techniques.
-  class Server
-    # Creates a new server by opening a listening socket and starting an accept
-    # loop. When a new connection is accepted, a new instance of the 
-    # supplied connection class is instantiated and passed the connection for
-    # processing.
-    def initialize(host, port, connection_class)
-      @connection_class = connection_class
-      @server = TCPServer.new(host, port)
-      loop {@connection_class.new(@server.accept)}
+  module HTTP
+    # The ServerSide HTTP server is designed to be fast and simple. It is also
+    # designed to support both HTTP 1.1 persistent connections, and HTTP streaming
+    # for applications which use Comet techniques.
+    class Server
+      # Creates a new server by opening a listening socket and starting an accept
+      # loop. When a new connection is accepted, a new instance of the 
+      # supplied connection class is instantiated and passed the connection for
+      # processing.
+      def initialize(host, port, request_class)
+        @server = TCPServer.new(host, port)
+        loop {Connection.new(@server.accept, request_class)}
+      end
     end
   end
 end

data/lib/serverside/static.rb

@@ -1,6 +1,6 @@
 module ServerSide
   # This module provides functionality for serving files and directory listings
-  # over HTTP. It is mainly used by ServerSide::Connection::Static.
+  # over HTTP.
   module StaticFiles
     # Frozen constants to be used by the module.
     module Const

data/test/functional/primitive_static_server_test.rb

@@ -3,7 +3,7 @@ require 'net/http'
 
 class StaticServerTest < Test::Unit::TestCase
   
-  class StaticConnection < ServerSide::Connection::Base
+  class StaticRequest < ServerSide::HTTP::Request
     def respond
       begin
 #        set_cookie(:hello, 'world', Time.now + 30) if @cookies[:test] == 'hello'
@@ -21,7 +21,7 @@ class StaticServerTest < Test::Unit::TestCase
   end
   
   def test_basic
-    @t = Thread.new {ServerSide::Server.new('0.0.0.0', 17654, StaticConnection)}
+    @t = Thread.new {ServerSide::HTTP::Server.new('0.0.0.0', 17654, StaticRequest)}
     sleep 0.1
 
     h = Net::HTTP.new('localhost', 17654)
@@ -40,7 +40,7 @@ class StaticServerTest < Test::Unit::TestCase
   end
   
   def test_cookies
-    @t = Thread.new {ServerSide::Server.new('0.0.0.0', 17655, StaticConnection)}
+    @t = Thread.new {ServerSide::HTTP::Server.new('0.0.0.0', 17655, StaticRequest)}
     sleep 0.1
 
     h = Net::HTTP.new('localhost', 17655)

data/test/functional/routing_server.rb

@@ -11,4 +11,4 @@ ServerSide.route(:path => '/xml/:flavor/feed.xml') do
   redirect('http://feeds.feedburner.com/RobbyOnRails')
 end
 
-ServerSide::Server.new('0.0.0.0', 8000, ServerSide::Connection::Router)
+ServerSide::HTTP::Server.new('0.0.0.0', 8000, ServerSide::Router)

data/test/functional/routing_server_test.rb

@@ -9,7 +9,7 @@ class StaticServerTest < Test::Unit::TestCase
       redirect('http://feeds.feedburner.com/RobbyOnRails')
     end
     
-    t = Thread.new {ServerSide::Server.new('0.0.0.0', 17654, ServerSide::Connection::Router)}
+    t = Thread.new {ServerSide::HTTP::Server.new('0.0.0.0', 17654, ServerSide::Router)}
     sleep 0.1
 
     h = Net::HTTP.new('localhost', 17654)

data/test/functional/static_profile.rb

@@ -7,7 +7,7 @@ FileUtils.cd(File.dirname(__FILE__))
 pid = fork do
   trap('TERM') {exit}
   require 'profile'
-  ServerSide::Server.new('0.0.0.0', 8000, ServerSide::Connection::Static)
+  ServerSide::HTTP::Server.new('0.0.0.0', 8000, nil)
 end
 
 puts "Please wait..."

data/test/functional/static_server_test.rb

@@ -3,14 +3,14 @@ require 'net/http'
 
 class StaticServerTest < Test::Unit::TestCase
   
-  class StaticServer < ServerSide::Connection::Base
+  class StaticRequest < ServerSide::HTTP::Request
     def respond
       serve_static('.'/@path)
     end
   end
   
   def test_basic
-    t = Thread.new {ServerSide::Server.new('0.0.0.0', 17654, StaticServer)}
+    t = Thread.new {ServerSide::HTTP::Server.new('0.0.0.0', 17654, StaticRequest)}
     sleep 0.1
 
     h = Net::HTTP.new('localhost', 17654)

data/test/unit/connection_test.rb

@@ -2,241 +2,47 @@ require File.dirname(__FILE__) + '/../test_helper'
 require 'stringio'
 
 class ConnectionTest < Test::Unit::TestCase
-  class DummyConnection1 < ServerSide::Connection::Base
-    attr_reader :count, :conn
-    
-    def process
-      @count ||= 0
-      @count += 1
-    end
-  end
-
-  def test_new
-    r = DummyConnection1.new('hello')
-    assert_equal 'hello', r.conn
-    assert_equal 1, r.count
+  class ServerSide::HTTP::Connection
+    attr_reader :conn, :request_class, :thread
   end
   
-  class DummyConnection
-    attr_reader :opened
-    
-    def initialize
-      @opened = true
-    end
+  class DummyRequest1 < ServerSide::HTTP::Request
+    @@instance_count = 0
     
-    def close
-      @opened = false
+    def initialize(conn)
+      @@instance_count += 1
+      super(conn)
     end
-  end
-  
-  class DummyConnection2 < ServerSide::Connection::Base
-    attr_accessor :count, :persistent
     
-    def parse_request
-      @count ||= 0
-      @count += 1
-      @persistent = @count < 1000
+    def self.instance_count
+      @@instance_count
     end
     
-    def respond
-    end
-  end
-  
-  def test_process
-    c = DummyConnection.new
-    r = DummyConnection2.new(c)
-    sleep 0.2
-    assert_equal false, c.opened
-    assert_equal 1000, r.count
-  end
-  
-  class ServerSide::Connection::Base 
-    attr_accessor :conn, :method, :query, :version, :path, :parameters,
-      :headers, :persistent, :cookies, :response_cookies
-  end
-  
-  class DummyConnection3 < ServerSide::Connection::Base
-    def initialize
+    def process
+      @conn[:count] ||= 0
+      @conn[:count] += 1
+      @conn[:count] < 1000
     end
   end
   
-  def test_parse_request_invalid
-    r = DummyConnection3.new
-    r.conn = StringIO.new('POST /test')
-    assert_nil r.parse_request
-    r.conn = StringIO.new('invalid string')
-    assert_nil r.parse_request
-    r.conn = StringIO.new('GET HTTP/1.1')
-    assert_nil r.parse_request
-    r.conn = StringIO.new('GET /test http')
-    assert_nil r.parse_request
-    r.conn = StringIO.new('GET /test HTTP')
-    assert_nil r.parse_request
-    r.conn = StringIO.new('GET /test HTTP/')
-    assert_nil r.parse_request
-    r.conn = StringIO.new('POST /test HTTP/1.1')
-    assert_nil r.parse_request
+  class DummyConn < Hash
+    attr_accessor :closed
+    def close; @closed = true; end
   end
-  
-  def test_parse_request
-    r = DummyConnection3.new
-    r.conn = StringIO.new("POST /test HTTP/1.1\r\n\r\n")
-    assert_kind_of Hash, r.parse_request
-    assert_equal :post, r.method
-    assert_equal '/test', r.path
-    assert_nil r.query
-    assert_equal '1.1', r.version
-    assert_equal({}, r.parameters)
-    assert_equal({}, r.headers)
-    assert_equal({}, r.cookies)
-    assert_nil r.response_cookies
-    assert_equal true, r.persistent
 
-    # trailing slash in path    
-    r = DummyConnection3.new
-    r.conn = StringIO.new("POST /test/asdf/qw/?time=24%20hours HTTP/1.1\r\n\r\n")
-    assert_kind_of Hash, r.parse_request
-    assert_equal :post, r.method
-    assert_equal '/test/asdf/qw', r.path
-    assert_equal 'time=24%20hours', r.query
-    assert_equal '1.1', r.version
-    assert_equal({:time => '24 hours'}, r.parameters)
-    assert_equal({}, r.headers)
-    assert_equal({}, r.cookies)
-    assert_nil r.response_cookies
-    assert_equal true, r.persistent
-    
-    r.conn = StringIO.new("GET /cex?q=node_state HTTP/1.1\r\n\r\n")
-    assert_kind_of Hash, r.parse_request
-    assert_equal :get, r.method
-    assert_equal '/cex', r.path
-    assert_equal 'q=node_state', r.query
-    assert_equal({:q => 'node_state'}, r.parameters)
-    assert_equal({}, r.cookies)
-    assert_nil r.response_cookies
-    
-    r.conn = StringIO.new("GET / HTTP/1.0\r\n\r\n")
-    assert_kind_of Hash, r.parse_request
-    assert_equal false, r.persistent
-    assert_equal({}, r.cookies)
-    assert_nil r.response_cookies
-
-    r.conn = StringIO.new("GET / HTTP/invalid\r\n\r\n")
-    assert_kind_of Hash, r.parse_request
-    assert_equal 'invalid', r.version
-    assert_equal false, r.persistent
-    
-    r.conn = StringIO.new("GET / HTTP/1.1\r\nConnection: close\r\n\r\n")
-    assert_kind_of Hash, r.parse_request
-    assert_equal '1.1', r.version
-    assert_equal 'close', r.headers['Connection']
-    assert_equal false, r.persistent
-    
-    # cookies
-    r.conn = StringIO.new("GET / HTTP/1.1\r\nConnection: close\r\nCookie: abc=1342; def=7%2f4\r\n\r\n")
-    assert_kind_of Hash, r.parse_request
-    assert_equal 'abc=1342; def=7%2f4', r.headers['Cookie']
-    assert_equal '1342', r.cookies[:abc]
-    assert_equal '7/4', r.cookies[:def]
-  end
-  
-  def test_send_response
-    r = DummyConnection3.new
-    # simple case
-    r.conn = StringIO.new
-    r.persistent = true
-    r.send_response(200, 'text', 'Hello there!')
-    r.conn.rewind
-    assert_equal "HTTP/1.1 200\r\nContent-Type: text\r\nContent-Length: 12\r\n\r\nHello there!",
-      r.conn.read
-
-    # include content-length    
-    r.conn = StringIO.new
-    r.persistent = true
-    r.send_response(404, 'text/html', '<h1>404!</h1>', 10) # incorrect length
-    r.conn.rewind
-    assert_equal "HTTP/1.1 404\r\nContent-Type: text/html\r\nContent-Length: 10\r\n\r\n<h1>404!</h1>",
-      r.conn.read
-
-    # headers
-    r.conn = StringIO.new
-    r.persistent = true
-    r.send_response(404, 'text/html', '<h1>404!</h1>', nil, {'ETag' => 'xxyyzz'})
-    r.conn.rewind
-    assert_equal "HTTP/1.1 404\r\nContent-Type: text/html\r\nETag: xxyyzz\r\nContent-Length: 13\r\n\r\n<h1>404!</h1>",
-      r.conn.read
-
-    # no body
-    r.conn = StringIO.new
-    r.persistent = true
-    r.send_response(404, 'text/html', nil, nil, {'Set-Cookie' => 'abc=123'})
-    r.conn.rewind
-    assert_equal "HTTP/1.1 404\r\nConnection: close\r\nContent-Type: text/html\r\nSet-Cookie: abc=123\r\n\r\n",
-      r.conn.read
-    assert_equal false, r.persistent
-
-    # not persistent
-    r.conn = StringIO.new
-    r.persistent = false
-    r.send_response(200, 'text', 'Hello there!')
-    r.conn.rewind
-    assert_equal "HTTP/1.1 200\r\nConnection: close\r\nContent-Type: text\r\nContent-Length: 12\r\n\r\nHello there!",
-      r.conn.read
-      
-    # socket error
-    r.conn = nil
-    r.persistent = true
-    assert_nothing_raised {r.send_response(200, 'text', 'Hello there!')}
-    assert_equal false, r.persistent
-  end
-  
-  def test_stream
-    r = DummyConnection3.new
-    r.conn = StringIO.new
-    r.stream 'hey there'
-    r.conn.rewind
-    assert_equal 'hey there', r.conn.read
-    
-    r.conn = StringIO.new
-    r.persistent = true
-    r.send_response(404, 'text/html', nil, nil, {'Set-Cookie' => 'abc=123'})
-    r.stream('hey there')
-    r.conn.rewind
-    assert_equal "HTTP/1.1 404\r\nConnection: close\r\nContent-Type: text/html\r\nSet-Cookie: abc=123\r\n\r\nhey there",
-      r.conn.read
-  end
-  
-  def test_redirect
-    r = DummyConnection3.new
-    r.conn = StringIO.new
-    r.redirect('http://mau.com/132')
-    r.conn.rewind
-    assert_equal "HTTP/1.1 302\r\nConnection: close\r\nLocation: http://mau.com/132\r\n\r\n", r.conn.read
-
-    r.conn = StringIO.new
-    r.redirect('http://www.google.com/search?q=meaning%20of%20life', true)
-    r.conn.rewind
-    assert_equal "HTTP/1.1 301\r\nConnection: close\r\nLocation: http://www.google.com/search?q=meaning%20of%20life\r\n\r\n", r.conn.read
-  end
-  
-  def test_set_cookie
-    r = DummyConnection3.new
-    r.conn = StringIO.new
-    t = Time.now + 360
-    r.set_cookie(:session, "ABCDEFG", t)
-    assert_equal "Set-Cookie: session=ABCDEFG; path=/; expires=#{t.rfc2822}\r\n", r.response_cookies
-    r.send_response(200, 'text', 'Hi!')
-    r.conn.rewind
-    assert_equal "HTTP/1.1 200\r\nConnection: close\r\nContent-Type: text\r\nSet-Cookie: session=ABCDEFG; path=/; expires=#{t.rfc2822}\r\nContent-Length: 3\r\n\r\nHi!", r.conn.read
-  end
-  
-  def test_delete_cookie
-    r = DummyConnection3.new
-    r.conn = StringIO.new
-    r.delete_cookie(:session)
-    assert_equal "Set-Cookie: session=; path=/; expires=#{Time.at(0).rfc2822}\r\n", r.response_cookies
-    r.send_response(200, 'text', 'Hi!')
-    r.conn.rewind
-    assert_equal "HTTP/1.1 200\r\nConnection: close\r\nContent-Type: text\r\nSet-Cookie: session=; path=/; expires=#{Time.at(0).rfc2822}\r\nContent-Length: 3\r\n\r\nHi!", r.conn.read
+  def test_new
+    r = ServerSide::HTTP::Connection.new('hello', ServerSide::HTTP::Request)
+    sleep 0.1
+    assert_equal 'hello', r.conn
+    assert_equal ServerSide::HTTP::Request, r.request_class
+    assert_equal false, r.thread.alive?
+    
+    c = DummyConn.new
+    r = ServerSide::HTTP::Connection.new(c, DummyRequest1)
+    assert_equal DummyRequest1, r.request_class
+    r.thread.join
+    assert_equal 1000, c[:count]
+    assert_equal 1000, DummyRequest1.instance_count
+    assert_equal true, c.closed
   end
 end