serverside 0.2.9 → 0.3.0

data/test/unit/request_test.rb

@@ -1,278 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper'
-require 'stringio'
-
-class RequestTest < Test::Unit::TestCase
-  class DummyConnection
-    attr_reader :opened
-    
-    def initialize
-      @opened = true
-    end
-    
-    def close
-      @opened = false
-    end
-  end
-  
-  class DummyRequest2 < ServerSide::HTTP::Request
-    attr_accessor :count
-    
-    def parse
-      @count = 1
-    end
-    
-    def respond
-      @count += 1
-      @persistent = @count < 2
-    end
-  end
-  
-  def test_process
-    r = DummyRequest2.new(nil)
-    sleep 0.2
-    assert_equal false, r.process
-    assert_equal 2, r.count
-    assert_equal false, r.persistent
-  end
-  
-  class DummyRequest3 < ServerSide::HTTP::Request
-    attr_accessor :parse_result, :respond_result
-    def parse; @parse_result; end
-    def respond; @respond_result; end
-  end
-  
-  class ServerSide::HTTP::Request
-    attr_writer :socket, :persistent, :response_headers
-  end
-  
-  def test_process_result
-    r = DummyRequest3.new(nil)
-    r.parse_result = nil
-    r.persistent = true
-    assert_equal nil, r.process
-    r.parse_result = nil
-    r.respond_result = true
-    assert_equal nil, r.process
-    r.parse_result = {}
-    r.respond_result = nil
-    r.persistent = false
-    assert_equal false, r.process
-    r.parse_result = {}
-    r.respond_result = true
-    r.persistent = true
-    assert_equal true, r.process
-    r.parse_result = {}
-    r.persistent = 'hello'
-    assert_equal 'hello', r.process
-  end
-  
-  def test_parse_request_invalid
-    r = ServerSide::HTTP::Request.new(nil)
-    r.socket = StringIO.new('POST /test')
-    assert_nil r.parse
-    r.socket = StringIO.new('invalid string')
-    assert_nil r.parse
-    r.socket = StringIO.new('GET HTTP/1.1')
-    assert_nil r.parse
-    r.socket = StringIO.new('GET /test http')
-    assert_nil r.parse
-    r.socket = StringIO.new('GET /test HTTP')
-    assert_nil r.parse
-    r.socket = StringIO.new('GET /test HTTP/')
-    assert_nil r.parse
-    r.socket = StringIO.new('POST /test HTTP/1.1')
-    assert_nil r.parse
-  end
-  
-  def test_parse_request
-    r = ServerSide::HTTP::Request.new(nil)
-    r.socket = StringIO.new("POST /test HTTP/1.1\r\n\r\n")
-    assert_kind_of Hash, r.parse
-    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 = ServerSide::HTTP::Request.new(nil)
-    r.socket = StringIO.new("POST /test/asdf/qw/?time=24%20hours HTTP/1.1\r\n\r\n")
-    assert_kind_of Hash, r.parse
-    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.socket = StringIO.new("GET /cex?q=node_state HTTP/1.1\r\n\r\n")
-    assert_kind_of Hash, r.parse
-    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.socket = StringIO.new("GET / HTTP/1.0\r\n\r\n")
-    assert_kind_of Hash, r.parse
-    assert_equal false, r.persistent
-    assert_equal({}, r.cookies)
-    assert_nil r.response_cookies
-
-    r.socket = StringIO.new("GET / HTTP/invalid\r\n\r\n")
-    assert_kind_of Hash, r.parse
-    assert_equal 'invalid', r.version
-    assert_equal false, r.persistent
-    
-    r.socket = StringIO.new("GET / HTTP/1.1\r\nConnection: close\r\n\r\n")
-    assert_kind_of Hash, r.parse
-    assert_equal '1.1', r.version
-    assert_equal 'close', r.headers['Connection']
-    assert_equal false, r.persistent
-    
-    # cookies
-    r.socket = 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
-    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 = ServerSide::HTTP::Request.new(nil)
-    # simple case
-    r.response_headers = {}
-    r.socket = StringIO.new
-    r.persistent = true
-    r.send_response(200, 'text', 'Hello there!')
-    r.socket.rewind
-    assert_equal "HTTP/1.1 200\r\nDate: #{Time.now.httpdate}\r\nContent-Type: text\r\nContent-Length: 12\r\n\r\nHello there!",
-      r.socket.read
-
-    # include content-length    
-    r.response_headers = {}
-    r.socket = StringIO.new
-    r.persistent = true
-    r.send_response(404, 'text/html', '<h1>404!</h1>', 10) # incorrect length
-    r.socket.rewind
-    assert_equal "HTTP/1.1 404\r\nDate: #{Time.now.httpdate}\r\nContent-Type: text/html\r\nContent-Length: 10\r\n\r\n<h1>404!</h1>",
-      r.socket.read
-
-    # headers
-    r.response_headers = {}
-    r.socket = StringIO.new
-    r.persistent = true
-    r.send_response(404, 'text/html', '<h1>404!</h1>', nil, {'ETag' => 'xxyyzz'})
-    r.socket.rewind
-    assert_equal "HTTP/1.1 404\r\nDate: #{Time.now.httpdate}\r\nContent-Type: text/html\r\nETag: xxyyzz\r\nContent-Length: 13\r\n\r\n<h1>404!</h1>",
-      r.socket.read
-
-    # no body
-    r.response_headers = {}
-    r.socket = StringIO.new
-    r.persistent = true
-    r.send_response(404, 'text/html', nil, nil, {'Set-Cookie' => 'abc=123'})
-    r.socket.rewind
-    assert_equal "HTTP/1.1 404\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nContent-Type: text/html\r\nSet-Cookie: abc=123\r\n\r\n",
-      r.socket.read
-    assert_equal false, r.persistent
-
-    # not persistent
-    r.response_headers = {}
-    r.socket = StringIO.new
-    r.persistent = false
-    r.send_response(200, 'text', 'Hello there!')
-    r.socket.rewind
-    assert_equal "HTTP/1.1 200\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nContent-Type: text\r\nContent-Length: 12\r\n\r\nHello there!",
-      r.socket.read
-      
-    # socket error
-    r.response_headers = {}
-    r.socket = nil
-    r.persistent = true
-    assert_nothing_raised {r.send_response(200, 'text', 'Hello there!')}
-    assert_equal false, r.persistent
-  end
-  
-  def test_stream
-    r = ServerSide::HTTP::Request.new(nil)
-    r.socket = StringIO.new
-    r.stream 'hey there'
-    r.socket.rewind
-    assert_equal 'hey there', r.socket.read
-    
-    r.socket = StringIO.new
-    r.persistent = true
-    r.send_response(404, 'text/html', nil, nil, {'Set-Cookie' => 'abc=123'})
-    r.stream('hey there')
-    r.socket.rewind
-    assert_equal "HTTP/1.1 404\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nContent-Type: text/html\r\nSet-Cookie: abc=123\r\n\r\nhey there",
-      r.socket.read
-  end
-  
-  def test_redirect
-    r = ServerSide::HTTP::Request.new(nil)
-    r.socket = StringIO.new
-    r.redirect('http://mau.com/132')
-    r.socket.rewind
-    assert_equal "HTTP/1.1 302\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nLocation: http://mau.com/132\r\n\r\n", r.socket.read
-
-    r.response_headers = {}
-    r.socket = StringIO.new
-    r.redirect('http://www.google.com/search?q=meaning%20of%20life', true)
-    r.socket.rewind
-    assert_equal "HTTP/1.1 301\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nLocation: http://www.google.com/search?q=meaning%20of%20life\r\n\r\n", r.socket.read
-  end
-  
-  def test_set_cookie
-    r = ServerSide::HTTP::Request.new(nil)
-    r.socket = 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.socket.rewind
-    assert_equal "HTTP/1.1 200\r\nDate: #{Time.now.httpdate}\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.socket.read
-  end
-  
-  def test_delete_cookie
-    r = ServerSide::HTTP::Request.new(nil)
-    r.socket = 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.socket.rewind
-    assert_equal "HTTP/1.1 200\r\nDate: #{Time.now.httpdate}\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.socket.read
-  end
-  
-  def test_response_headers
-    r = ServerSide::HTTP::Request.new(nil)
-    r.socket = StringIO.new
-    assert_equal({}, r.response_headers)
-    r.response_headers = {'A' => '1', 'B' => 2}
-    r.send_response(200, 'text', 'Hi!')
-    r.socket.rewind
-    resp = r.socket.read
-    assert_not_nil resp.match("A: 1\r\n")
-    assert_not_nil resp.match("B: 2\r\n")
-    
-    r.response_headers = {}
-    r.socket = StringIO.new
-    assert_equal({}, r.response_headers)
-    r.response_headers = {'D' => '1', 'E' => 2}
-    r.send_response(200, 'text', 'Hi!', nil, {'F' => 3})
-    r.socket.rewind
-    resp = r.socket.read
-    assert_not_nil resp.match("D: 1\r\n")
-    assert_not_nil resp.match("E: 2\r\n")
-    assert_not_nil resp.match("F: 3\r\n")
-  end
-end

data/test/unit/routing_test.rb

@@ -1,171 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper'
-require 'stringio'
-
-class ServerSide::Router
-  attr_accessor :t, :parameters
-  
-  def self.rules
-    @@rules
-  end
-  
-  def self.remove_rules
-    @@rules = nil
-  end
-  
-  def self.reset_rules
-    @@rules = []
-  end
-  
-  def self.reset_respond
-    define_method(:respond) {nil}
-  end
-end
-
-class RoutingTest < Test::Unit::TestCase
-  R = ServerSide::Router
-  
-  def test_has_routes?
-    R.remove_rules
-    assert_nil R.has_routes?
-    R.reset_rules
-    assert_equal false, R.has_routes?
-    R.route('/controller/:action/:id') {}
-    assert_equal true, R.has_routes?
-  end
-  
-  def test_route
-    l1 = lambda {1 + 1}
-    R.reset_rules
-    R.route('/controller/:action/:id', &l1)
-    assert_equal 1, R.rules.length
-    assert_equal({:path => '/controller/:action/:id'}, R.rules[0][0])
-    assert_equal l1, R.rules[0][1]
-    
-    l2 = lambda {2 + 2}
-    R.route(:host => '^static\..+', &l2)
-    assert_equal 2, R.rules.length
-    assert_equal({:host => '^static\..+'}, R.rules[0][0])
-    assert_equal l2, R.rules[0][1]
-    assert_equal({:path => '/controller/:action/:id'}, R.rules[1][0])
-    assert_equal l1, R.rules[1][1]
-    
-    l3 = lambda {3 + 3}
-    l4 = lambda {4 + 4}
-    
-    R.route(l3, &l4)
-    assert_equal 3, R.rules.length
-    assert_equal l3, R.rules[0][0]
-    assert_equal l4, R.rules[0][1]
-    assert_equal({:host => '^static\..+'}, R.rules[1][0])
-    assert_equal l2, R.rules[1][1]
-    assert_equal({:path => '/controller/:action/:id'}, R.rules[2][0])
-    assert_equal l1, R.rules[2][1]
-  end
-  
-  def test_compile_rules
-    R.reset_rules
-    R.reset_respond
-
-    assert_equal nil, R.new(StringIO.new).respond
-    R.rules << [{:t => 'abc'}, lambda{1}]
-    R.rules << [{:t => 'def'}, lambda{2}]
-    R.default_route {3}
-    R.compile_rules
-    r = R.new(StringIO.new)
-    r.t = 'abc'
-    assert_equal 1, r.respond
-    r.t = 'def'
-    assert_equal 2, r.respond
-    r.t = ''
-    assert_equal 3, r.respond
-  end
-  
-  def test_rule_to_statement
-    l1 = lambda {1 + 1}
-    l2 = lambda {2 + 2}
-    s = R.rule_to_statement(l1, l2)
-    assert_equal "return #{l2.proc_tag} if #{l1.proc_tag}\n" ,s
-    r = R.new(StringIO.new)
-    assert_equal true, r.respond_to?(l1.proc_tag)
-    assert_equal true, r.respond_to?(l2.proc_tag)
-    
-    l3 = lambda {3 + 3}
-    s = R.rule_to_statement({:path => '/.*'}, l3)
-    assert_not_nil s =~ /^return\s#{l3.proc_tag}\sif\s\(@path\s=~\s(.*)\)\n$/, s
-    assert_equal /\/.*/, eval("R::#{$1}")
-    assert_equal true, r.respond_to?(l3.proc_tag)
-    
-    l4 = lambda {4 + 4}
-    s = R.rule_to_statement({:path => '/controller', :host => 'static'}, l4)
-    assert_not_nil s =~ /^return\s#{l4.proc_tag}\sif\s\(.+\)&&\(.+\)\n$/
-    assert_not_nil s =~ /\(@path\s=~\s([^\)]+)\)/
-    assert_equal /\/controller/, eval("R::#{$1}")
-    assert_not_nil s =~ /\(@host\s=~\s([^\)]+)\)/
-    assert_equal /static/, eval("R::#{$1}")
-    assert_equal true, r.respond_to?(l4.proc_tag)
-    
-    l5 = lambda {5 + 5}
-    s = R.rule_to_statement({:path => ['/x', '/y']}, l5)
-    assert_not_nil s =~ /^return\s#{l5.proc_tag}\sif\s\(\(@path\s=~\s(.*)\)\|\|\(@path\s=~\s(.*)\)\)\n$/
-    assert_equal /\/x/, eval("R::#{$1}")
-    assert_equal /\/y/, eval("R::#{$2}")
-    assert_equal true, r.respond_to?(l5.proc_tag)
-  end
-  
-  def test_condition_part
-    s = R.condition_part(:t, 'abc')
-    assert_not_nil s =~ /^\(@t\s=~\s(.*)\)$/
-    assert_equal /abc/, eval("R::#{$1}")
-    
-    s = R.condition_part(:t, ':action/:id')
-    assert_not_nil s =~ /^\((.*)\)$/
-    tag = $1
-    r = R.new(StringIO.new)
-    assert_equal true, r.respond_to?(tag)
-    r.parameters = {}
-    r.t = 'abc'
-    assert_equal false, r.send(tag)
-    r.t = 'show/16'
-    assert_equal true, r.send(tag)
-    assert_equal 'show', r.parameters[:action]
-    assert_equal '16', r.parameters[:id]
-  end
-  
-  def test_define_proc
-    l1 = lambda {1 + 1}
-    tag = R.define_proc(&l1)
-    assert_kind_of Symbol, tag
-    assert_equal l1.proc_tag.to_sym, tag
-    r = R.new(StringIO.new)
-    assert 2, r.send(tag)
-  end
-  
-  def test_cache_constant
-    c = rand(100000)
-    tag = R.cache_constant(c)
-    assert_kind_of String, tag
-    assert_equal c.const_tag, tag
-    assert_equal c, eval("R::#{tag}")
-  end
-  
-  def test_default_route
-    R.default_route {'mau m'}
-    assert_equal 'mau m', R.new(StringIO.new).default_handler
-
-    R.default_route {654321}
-    assert_equal 654321, R.new(StringIO.new).default_handler
-  end
-  
-  def test_serverside_route
-    R.reset_rules
-    ServerSide::Router.route(:path => 'abc') {1 + 1}
-    assert_equal 1, R.rules.length
-    assert_equal({:path => 'abc'}, R.rules[0][0])
-    assert_equal 2, R.rules[0][1].call
-  end
-  
-  def test_serverside_default_route
-    ServerSide::Router.default_route {1234}
-    assert_equal 1234, R.new(StringIO.new).default_handler
-  end
-end

data/test/unit/server_test.rb

@@ -1,28 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper'
-require 'net/http'
-
-class ServerTest < Test::Unit::TestCase
-  class DummyRequest < ServerSide::HTTP::Request
-    def respond
-      @socket << "HTTP/1.1 200\r\nContent-Length: 9\r\n\r\nHi there!"
-    end
-  end
-
-  def test_server_creation
-    t = Thread.new do
-      begin
-        ServerSide::HTTP::Server.new('0.0.0.0', 17543, DummyRequest)
-      rescue => e
-        puts e.message
-        puts e.backtrace.first
-      end
-    end
-    sleep 0.1
-
-    h = Net::HTTP.new('localhost', 17543)
-    resp, data = h.get('/', nil)
-    assert_equal 200, resp.code.to_i
-    assert_equal 'Hi there!', data
-    t.exit
-  end
-end

data/test/unit/static_test.rb

@@ -1,171 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper'
-require 'stringio'
-require 'fileutils'
-
-class StaticTest < Test::Unit::TestCase
-  class Dummy < ServerSide::HTTP::Request
-    def self.static_files
-      @@static_files
-    end
-    
-    def self.mime_types
-      @@mime_types
-    end
-    
-    attr_accessor :path, :socket, :headers
-    
-    def initialize
-      super(nil)
-      @headers = {}
-    end
-  end
-  
-  def test_cache
-    assert_kind_of Hash, Dummy.static_files
-    Dummy.static_files.clear
-    c = Dummy.new
-    c.socket = StringIO.new
-    assert_nil Dummy.static_files[__FILE__]
-    c.serve_file(__FILE__)
-    cache = Dummy.static_files[__FILE__]
-    assert_not_nil cache
-    stat = File.stat(__FILE__)
-    etag = (ServerSide::Static::ETAG_FORMAT % 
-      [stat.mtime.to_i, stat.size, stat.ino])
-    assert_equal etag, cache[0]
-    assert_equal IO.read(__FILE__), cache[1]
-  end
-  
-  def test_mime_types
-    assert_kind_of Hash, Dummy.mime_types
-    assert_equal 'text/plain', Dummy.mime_types['.rb']
-    assert_equal 'text/plain', Dummy.mime_types['.invalid']
-    assert_equal 'text/html', Dummy.mime_types['.html']
-    assert_equal 'text/css', Dummy.mime_types['.css']
-    assert_equal 'text/javascript', Dummy.mime_types['.js']
-    assert_equal 'image/gif', Dummy.mime_types['.gif']
-    assert_equal 'image/jpeg', Dummy.mime_types['.jpg']
-    assert_equal 'image/jpeg', Dummy.mime_types['.jpeg']
-    assert_equal 'image/png', Dummy.mime_types['.png']
-  end
-  
-  def test_serve_file_normal
-    c = Dummy.new
-    c.socket = StringIO.new
-    c.serve_file(__FILE__)
-    c.socket.rewind
-    resp = c.socket.read
-    
-    assert_equal '200', /HTTP\/1.1\s(.*)\r\n/.match(resp)[1]
-    fc = IO.read(__FILE__)
-    stat = File.stat(__FILE__)
-    etag = (ServerSide::Static::ETAG_FORMAT % 
-      [stat.mtime.to_i, stat.size, stat.ino])
-    assert_not_nil resp =~ /ETag:\s"#{etag}"\r\n/
-    assert_not_nil resp =~ /Cache-Control:\smax-age=#{ServerSide::HTTP::Caching::DEFAULT_MAX_AGE}\r\n/
-    assert_equal stat.size.to_s,
-      /Content-Length:\s(.*)\r\n/.match(resp)[1]
-  end
-  
-  def test_serve_file_etags
-    c = Dummy.new
-    c.socket = StringIO.new
-    Dummy.static_files.clear
-    c.serve_file(__FILE__)
-    c.socket.rewind
-    resp = c.socket.read
-    
-    # normal response
-    assert_equal '200', /HTTP\/1.1\s(.*)\r\n/.match(resp)[1]
-    fc = IO.read(__FILE__)
-    stat = File.stat(__FILE__)
-    etag = (ServerSide::Static::ETAG_FORMAT % 
-      [stat.mtime.to_i, stat.size, stat.ino])
-    assert_not_nil resp =~ /ETag:\s"#{etag}"\r\n/
-    assert_not_nil resp =~ /Cache-Control:\smax-age=#{ServerSide::HTTP::Caching::DEFAULT_MAX_AGE}\r\n/
-    assert_equal stat.size.to_s,
-      /Content-Length:\s(.*)\r\n/.match(resp)[1]
-      
-    c.socket = StringIO.new
-    c.headers[ServerSide::Static::IF_NONE_MATCH] = "\"#{etag}\""
-    c.serve_file(__FILE__)
-    c.socket.rewind
-    resp = c.socket.read
-    
-    # not modified response
-    assert_equal '304 Not Modified', /HTTP\/1.1\s(.*)\r\n/.match(resp)[1]
-    fc = IO.read(__FILE__)
-    stat = File.stat(__FILE__)
-    etag = (ServerSide::Static::ETAG_FORMAT % 
-      [stat.mtime.to_i, stat.size, stat.ino])
-    assert_not_nil resp =~ /ETag:\s"#{etag}"\r\n/
-    assert_not_nil resp =~ /Cache-Control:\smax-age=#{ServerSide::HTTP::Caching::DEFAULT_MAX_AGE}\r\n/
-    
-    FileUtils.touch(__FILE__)
-    c.socket = StringIO.new
-    c.headers[ServerSide::Static::IF_NONE_MATCH] = etag
-    c.serve_file(__FILE__)
-    c.socket.rewind
-    resp = c.socket.read
-    
-    # modified response
-    assert_equal '200', /HTTP\/1.1\s(.*)\r\n/.match(resp)[1]
-    fc = IO.read(__FILE__)
-    stat = File.stat(__FILE__)
-    etag = (ServerSide::Static::ETAG_FORMAT % 
-      [stat.mtime.to_i, stat.size, stat.ino])
-    assert_not_nil resp =~ /ETag:\s"#{etag}"\r\n/
-    assert_not_nil resp =~ /Cache-Control:\smax-age=#{ServerSide::HTTP::Caching::DEFAULT_MAX_AGE}\r\n/
-    assert_equal stat.size.to_s,
-      /Content-Length:\s(.*)\r\n/.match(resp)[1]
-  end
-  
-  def test_serve_dir
-    dir = File.dirname(__FILE__)
-  
-    c = Dummy.new
-    c.socket = StringIO.new
-    Dummy.static_files.clear
-    c.path = dir
-    c.serve_dir(dir)
-    c.socket.rewind
-    resp = c.socket.read
-    
-    Dir.entries(dir).each do |fn|
-      next if fn =~ /^\./
-      assert_not_nil resp =~ /<a href="#{dir/fn}">(#{fn})<\/a>/
-    end
-  end
-  
-  def test_serve_static
-    dir = File.dirname(__FILE__)
-  
-    c = Dummy.new
-    c.socket = StringIO.new
-    c.path = dir
-    c.serve_static(dir)
-    c.socket.rewind
-    resp = c.socket.read
-    
-    Dir.entries(dir).each do |fn|
-      next if fn =~ /^\./
-      assert_not_nil resp =~ /<a href="#{dir/fn}">(#{fn})<\/a>/
-    end
-
-    c.socket = StringIO.new
-    c.serve_file(__FILE__)
-    c.socket.rewind
-    resp = c.socket.read
-    
-    # normal response
-    assert_equal '200', /HTTP\/1.1\s(.*)\r\n/.match(resp)[1]
-    fc = IO.read(__FILE__)
-    stat = File.stat(__FILE__)
-    etag = (ServerSide::Static::ETAG_FORMAT % 
-      [stat.mtime.to_i, stat.size, stat.ino])
-    assert_not_nil resp =~ /ETag:\s"#{etag}"\r\n/
-    assert_not_nil resp =~ /Cache-Control:\smax-age=#{ServerSide::HTTP::Caching::DEFAULT_MAX_AGE}\r\n/
-    assert_equal stat.size.to_s,
-      /Content-Length:\s(.*)\r\n/.match(resp)[1]
-  end
-end