serverside 0.2.0 → 0.2.5

data/doc/rdoc/fr_method_index.html

@@ -24,48 +24,50 @@
     <a href="classes/ServerSide/Connection/Router.html#M000046">cache_constant (ServerSide::Connection::Router)</a><br />
     <a href="classes/ServerSide/Connection/Router.html#M000042">compile_rules (ServerSide::Connection::Router)</a><br />
     <a href="classes/ServerSide/Connection/Router.html#M000044">condition_part (ServerSide::Connection::Router)</a><br />
-    <a href="classes/ServerSide/Application.html#M000027">config= (ServerSide::Application)</a><br />
-    <a href="classes/ServerSide/Application/Base.html#M000030">configuration (ServerSide::Application::Base)</a><br />
-    <a href="classes/ServerSide/Application/Base.html#M000029">configure (ServerSide::Application::Base)</a><br />
+    <a href="classes/ServerSide/Application.html#M000028">config= (ServerSide::Application)</a><br />
     <a href="classes/Object.html#M000003">const_tag (Object)</a><br />
     <a href="classes/Daemon.html#M000007">control (Daemon)</a><br />
     <a href="classes/Daemon/Cluster.html#M000016">daemon_loop (Daemon::Cluster)</a><br />
-    <a href="classes/ServerSide/Application/Static.html#M000032">daemonize (ServerSide::Application::Static)</a><br />
-    <a href="classes/ServerSide/Application.html#M000028">daemonize (ServerSide::Application)</a><br />
+    <a href="classes/ServerSide/Application.html#M000029">daemonize (ServerSide::Application)</a><br />
     <a href="classes/ServerSide/Connection/Router.html#M000049">default_handler (ServerSide::Connection::Router)</a><br />
     <a href="classes/ServerSide/Connection/Router.html#M000045">define_proc (ServerSide::Connection::Router)</a><br />
     <a href="classes/Daemon/Cluster/PidFile.html#M000019">delete (Daemon::Cluster::PidFile)</a><br />
+    <a href="classes/ServerSide/Connection/Base.html#M000039">delete_cookie (ServerSide::Connection::Base)</a><br />
     <a href="classes/Daemon/Cluster.html#M000013">fork_server (Daemon::Cluster)</a><br />
     <a href="classes/ServerSide/Connection/Router.html#M000040">has_routes? (ServerSide::Connection::Router)</a><br />
     <a href="classes/ServerSide/Server.html#M000050">new (ServerSide::Server)</a><br />
-    <a href="classes/ServerSide/Application/Base.html#M000031">new (ServerSide::Application::Base)</a><br />
-    <a href="classes/ServerSide/Connection/Base.html#M000033">new (ServerSide::Connection::Base)</a><br />
-    <a href="classes/ServerSide/Connection/Base.html#M000036">parse_parameters (ServerSide::Connection::Base)</a><br />
-    <a href="classes/ServerSide/Connection/Base.html#M000035">parse_request (ServerSide::Connection::Base)</a><br />
+    <a href="classes/ServerSide/Connection/Base.html#M000030">new (ServerSide::Connection::Base)</a><br />
+    <a href="classes/ServerSide/Connection/Base.html#M000034">parse_cookies (ServerSide::Connection::Base)</a><br />
+    <a href="classes/ServerSide/Connection/Base.html#M000033">parse_parameters (ServerSide::Connection::Base)</a><br />
+    <a href="classes/ServerSide/Connection/Base.html#M000032">parse_request (ServerSide::Connection::Base)</a><br />
     <a href="classes/Daemon/Base.html#M000012">pid_fn (Daemon::Base)</a><br />
     <a href="classes/Proc.html#M000002">proc_tag (Proc)</a><br />
-    <a href="classes/ServerSide/Connection/Base.html#M000034">process (ServerSide::Connection::Base)</a><br />
+    <a href="classes/ServerSide/Connection/Base.html#M000031">process (ServerSide::Connection::Base)</a><br />
     <a href="classes/Daemon/PidFile.html#M000011">recall (Daemon::PidFile)</a><br />
     <a href="classes/Daemon/Cluster/PidFile.html#M000021">recall_pids (Daemon::Cluster::PidFile)</a><br />
-    <a href="classes/ServerSide/Connection/Base.html#M000038">redirect (ServerSide::Connection::Base)</a><br />
-    <a href="classes/ServerSide/Connection/Router.html#M000041">route (ServerSide::Connection::Router)</a><br />
+    <a href="classes/ServerSide/Connection/Base.html#M000036">redirect (ServerSide::Connection::Base)</a><br />
+    <a href="classes/ServerSide/Template.html#M000052">render (ServerSide::Template)</a><br />
     <a href="classes/ServerSide.html#M000022">route (ServerSide)</a><br />
+    <a href="classes/ServerSide/Connection/Router.html#M000041">route (ServerSide::Connection::Router)</a><br />
     <a href="classes/ServerSide.html#M000023">route_default (ServerSide)</a><br />
     <a href="classes/ServerSide/Connection/Router.html#M000047">route_default (ServerSide::Connection::Router)</a><br />
     <a href="classes/ServerSide/Connection/Router.html#M000043">rule_to_statement (ServerSide::Connection::Router)</a><br />
-    <a href="classes/ServerSide/Connection/Base.html#M000037">send_response (ServerSide::Connection::Base)</a><br />
+    <a href="classes/ServerSide/Connection/Base.html#M000035">send_response (ServerSide::Connection::Base)</a><br />
     <a href="classes/ServerSide/StaticFiles.html#M000025">serve_dir (ServerSide::StaticFiles)</a><br />
     <a href="classes/ServerSide/StaticFiles.html#M000024">serve_file (ServerSide::StaticFiles)</a><br />
-    <a href="classes/ServerSide/StaticFiles.html#M000026">serve_static (ServerSide::StaticFiles)</a><br />
-    <a href="classes/Daemon/Cluster.html#M000017">start (Daemon::Cluster)</a><br />
+    <a href="classes/ServerSide/StaticFiles.html#M000027">serve_static (ServerSide::StaticFiles)</a><br />
+    <a href="classes/ServerSide/StaticFiles.html#M000026">serve_template (ServerSide::StaticFiles)</a><br />
+    <a href="classes/ServerSide/Template.html#M000051">set (ServerSide::Template)</a><br />
+    <a href="classes/ServerSide/Connection/Base.html#M000038">set_cookie (ServerSide::Connection::Base)</a><br />
     <a href="classes/Daemon.html#M000008">start (Daemon)</a><br />
+    <a href="classes/Daemon/Cluster.html#M000017">start (Daemon::Cluster)</a><br />
     <a href="classes/Daemon/Cluster.html#M000014">start_servers (Daemon::Cluster)</a><br />
     <a href="classes/Daemon/Cluster.html#M000018">stop (Daemon::Cluster)</a><br />
     <a href="classes/Daemon.html#M000009">stop (Daemon)</a><br />
     <a href="classes/Daemon/Cluster.html#M000015">stop_servers (Daemon::Cluster)</a><br />
     <a href="classes/Daemon/PidFile.html#M000010">store (Daemon::PidFile)</a><br />
     <a href="classes/Daemon/Cluster/PidFile.html#M000020">store_pid (Daemon::Cluster::PidFile)</a><br />
-    <a href="classes/ServerSide/Connection/Base.html#M000039">stream (ServerSide::Connection::Base)</a><br />
+    <a href="classes/ServerSide/Connection/Base.html#M000037">stream (ServerSide::Connection::Base)</a><br />
     <a href="classes/Symbol.html#M000001">to_s (Symbol)</a><br />
     <a href="classes/ServerSide/Connection/Router.html#M000048">unhandled (ServerSide::Connection::Router)</a><br />
     <a href="classes/String.html#M000004">uri_escape (String)</a><br />

data/lib/serverside/application.rb

@@ -21,33 +21,5 @@ module ServerSide
       end
       Daemon.control(daemon_class, cmd)
     end
-
-    class Base < ServerSide::Connection::Base
-      def self.configure(options)
-        @config = options
-      end
-      
-      def self.configuration
-        @config
-      end
-      
-      def initialize(host, port)
-        ServerSide::Server.new(host, port, make_request_class)
-      end
-    end
-    
-    class Static
-      def self.daemonize(config, cmd)
-        daemon_class = Class.new(Daemon::Cluster) do
-          meta_def(:pid_fn) {Daemon::WorkingDirectory/'serverside.pid'}
-          meta_def(:server_loop) do |port|
-            ServerSide::Server.new(config[:host], port, ServerSide::Connection::Static)
-          end
-          meta_def(:ports) {$cmd_config[:ports]}
-        end
-        
-        Daemon.control(daemon_class, cmd)
-      end
-    end
   end
 end

data/lib/serverside/connection.rb

@@ -25,14 +25,20 @@ module ServerSide
       # Regexp for parsing URI parameters.
       ParameterRegexp = /(.+)=(.*)/.freeze
       EqualSign = '='.freeze
-      StatusClose = "HTTP/1.1 %d\r\nConnection: close\r\nContent-Type: %s\r\n%sContent-Length: %d\r\n\r\n".freeze
-      StatusStream = "HTTP/1.1 %d\r\nConnection: close\r\nContent-Type: %s\r\n%s\r\n".freeze
-      StatusPersist = "HTTP/1.1 %d\r\nContent-Type: %s\r\n%sContent-Length: %d\r\n\r\n".freeze
+      StatusClose = "HTTP/1.1 %d\r\nConnection: close\r\nContent-Type: %s\r\n%s%sContent-Length: %d\r\n\r\n".freeze
+      StatusStream = "HTTP/1.1 %d\r\nConnection: close\r\nContent-Type: %s\r\n%s%s\r\n".freeze
+      StatusPersist = "HTTP/1.1 %d\r\nContent-Type: %s\r\n%s%sContent-Length: %d\r\n\r\n".freeze
       StatusRedirect = "HTTP/1.1 %d\r\nConnection: close\r\nLocation: %s\r\n\r\n".freeze
       Header = "%s: %s\r\n".freeze
-      Empty = ''.freeze
+      EmptyString = ''.freeze
+      EmptyHash = {}.freeze
       Slash = '/'.freeze
-      Location = 'Location'
+      Location = 'Location'.freeze
+      Cookie = 'Cookie'
+      SetCookie = "Set-Cookie: %s=%s; path=/; expires=%s\r\n".freeze
+      CookieSplit = /[;,] */n.freeze
+      CookieRegexp = /\s*(.+)=(.*)\s*/.freeze
+      CookieExpiredTime  = Time.at(0).freeze
     end
 
     # This is the base request class. When a new request is created, it starts
@@ -60,10 +66,6 @@ module ServerSide
           break unless @persistent
         end
       rescue => e
-        puts '*******************'
-        puts e.message
-        puts e.backtrace.first
-        puts '*******************'
         # We don't care. Just close the connection.
       ensure
         @conn.close
@@ -86,6 +88,9 @@ module ServerSide
         end
         @persistent = (@version == Const::Version_1_1) && 
           (@headers[Const::Connection] != Const::Close)
+        @cookies = @headers[Const::Cookie] ? parse_cookies : Const::EmptyHash
+        @response_cookies = nil
+        
         @headers
       end
       
@@ -99,20 +104,30 @@ module ServerSide
           m
         end
       end
+      
+      # Parses cookie values passed in the request
+      def parse_cookies
+        @headers[Const::Cookie].split(Const::CookieSplit).inject({}) do |m, i|
+          if i =~ Const::CookieRegexp
+            m[$1.to_sym] = $2.uri_unescape
+          end
+          m
+        end
+      end
     
       # Sends an HTTP response.
       def send_response(status, content_type, body = nil, content_length = nil, 
         headers = nil)
         h = headers ? 
-          headers.inject('') {|m, kv| m << (Const::Header % kv)} : Const::Empty
-
+          headers.inject('') {|m, kv| m << (Const::Header % kv)} : ''
+        
         content_length = body.length if content_length.nil? && body
         @persistent = false if content_length.nil?
         
         # Select the right format to use according to circumstances.
         @conn << ((@persistent ? Const::StatusPersist : 
           (body ? Const::StatusClose : Const::StatusStream)) % 
-          [status, content_type, h, content_length])
+          [status, content_type, h, @response_cookies, content_length])
         @conn << body if body
       rescue
         @persistent = false
@@ -130,6 +145,17 @@ module ServerSide
       def stream(body)
         (@conn << body if body) rescue (@persistent = false)
       end
+      
+      # Sets a cookie to be included in the response.
+      def set_cookie(name, value, expires)
+        @response_cookies ||= ""
+        @response_cookies << (Const::SetCookie % [name, value.to_s.uri_escape, expires.rfc2822])
+      end
+      
+      # Marks a cookie as deleted. The cookie is given an expires stamp in the past.
+      def delete_cookie(name)
+        set_cookie(name, nil, Const::CookieExpiredTime)
+      end
     end
   end
 end

data/lib/serverside/routing.rb

@@ -2,7 +2,24 @@ 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 containing keys corresponding to patterns.
+    # 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 < Base
       # Returns true if routes were defined.
       def self.has_routes?
@@ -12,7 +29,11 @@ module ServerSide
       # 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, in any array member is checked as a pattern.
+      # 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)

data/lib/serverside/server.rb

@@ -6,7 +6,7 @@ module ServerSide
   # 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 the 
+    # 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)

data/lib/serverside/static.rb

@@ -12,12 +12,14 @@ module ServerSide
       NotModifiedClose = "HTTP/1.1 304 Not Modified\r\nConnection: close\r\nContent-Length: 0\r\nETag: %s\r\nCache-Control: #{MaxAge}\r\n\r\n".freeze
       NotModifiedPersist = "HTTP/1.1 304 Not Modified\r\nContent-Length: 0\r\nETag: %s\r\nCache-Control: #{MaxAge}\r\n\r\n".freeze
       TextPlain = 'text/plain'.freeze
+      TextHTML = 'text/html'.freeze
       MaxCacheFileSize = 100000.freeze # 100KB for the moment
       
       DirListingStart = '<html><head><title>Directory Listing for %s</title></head><body><h2>Directory listing for %s:</h2>'.freeze
       DirListing = '<a href="%s">%s</a><br/>'.freeze
       DirListingStop = '</body></html>'.freeze
       FileNotFound = 'File not found.'.freeze
+      RHTML = /\.rhtml$/.freeze
     end
     
     @@mime_types = Hash.new {|h, k| ServerSide::StaticFiles::Const::TextPlain}
@@ -68,15 +70,25 @@ module ServerSide
       send_response(200, 'text/html', html)
     end
     
+    def serve_template(fn, b = nil)
+      if (fn =~ Const::RHTML) || (File.file?(fn = fn + '.rhtml'))
+        send_response(200, Const::TextHTML, Template.render(fn, b || binding))
+      end
+    end
+    
     # Serves static files and directory listings.
     def serve_static(path)
       if File.file?(path)
         serve_file(path)
+      elsif serve_template(path)
+        return
       elsif File.directory?(path)
         serve_dir(path)
       else
         send_response(404, 'text', Const::FileNotFound)
       end
+    rescue => e
+      send_response(500, 'text', e.message)
     end
   end
 end

data/lib/serverside/template.rb

@@ -0,0 +1,36 @@
+require 'erb'
+
+module ServerSide
+  # The Template module implements an ERB template rendering system. Templates
+  # are cached and automatically reloaded if the file changes.
+  class Template
+    # The @@templates variable is a hash keyed by template name. The values are
+    # arrays containing 2 objects: a file stamp (if the template comes from a 
+    # file,) and the template object itself.  
+    @@templates = {}
+    
+    # Stores a template for later use. The stamp parameter is used only when
+    # the content of a template file is stored.
+    def self.set(name, body, stamp = nil)
+      @@templates[name] = [stamp, ERB.new(body)]
+    end
+
+    # Renders a template. If the template name is not found, attemps to load
+    # the template from file. If the template has a non-nil stamp, the render
+    # method compares it to the file stamp, and reloads the template content
+    # if necessary.
+    def self.render(name, binding)
+      t = @@templates[name]
+      return t[1].result(binding) if t && t[0].nil?
+      
+      if File.file?(name)
+        stamp = File.mtime(name)
+        t = set(name, IO.read(name), stamp) if (!t || (stamp != t[0]))
+        t[1].result(binding)
+      else
+        @@templates[name] = nil
+        raise RuntimeError, 'Template not found.'
+      end
+    end
+  end  
+end

data/test/functional/primitive_static_server_test.rb

@@ -5,6 +5,11 @@ class StaticServerTest < Test::Unit::TestCase
   
   class StaticConnection < ServerSide::Connection::Base
     def respond
+      begin
+#        set_cookie(:hello, 'world', Time.now + 30) if @cookies[:test] == 'hello'
+      rescue => e
+        puts e.message
+      end
       status = 200
       body = IO.read('.'/@path)
     rescue => e
@@ -16,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::Server.new('0.0.0.0', 17654, StaticConnection)}
     sleep 0.1
 
     h = Net::HTTP.new('localhost', 17654)
@@ -32,6 +37,25 @@ class StaticServerTest < Test::Unit::TestCase
     # Net::HTTP includes this header in the request, so our server returns
     # likewise.
     assert_equal 'close', resp['Connection']
-    t.exit
+  end
+  
+  def test_cookies
+    @t = Thread.new {ServerSide::Server.new('0.0.0.0', 17655, StaticConnection)}
+    sleep 0.1
+
+    h = Net::HTTP.new('localhost', 17655)
+    resp, data = h.get('/qqq', nil)
+    assert_equal 404, resp.code.to_i
+    assert_nil resp['Set-Cookie']
+    
+    h = Net::HTTP.new('localhost', 17655)
+    resp, data = h.get('/qqq', {'Cookie' => 'test=hello'})
+    assert_equal 404, resp.code.to_i
+    assert_not_nil resp['Set-Cookie'] =~ /hello=world/
+
+    h = Net::HTTP.new('localhost', 17655)
+    resp, data = h.get('/qqq', nil)
+    assert_equal 404, resp.code.to_i
+    assert_nil resp['Set-Cookie']
   end
 end

data/test/functional/static_rfuzz.rb

@@ -6,44 +6,6 @@ require 'rfuzz/client'
 require 'rfuzz/stats'
 include RFuzz
 
-class StatsTracker
-
-  def initialize
-    @stats = {}
-    @begins = {}
-    @error_count = 0
-  end
-
-  def mark(event)
-    @begins[event] = Time.now
-  end
-
-  def sample(event)
-    @stats[event] ||= Stats.new(event.to_s)
-    @stats[event].sample(Time.now - @begins[event])
-  end
-
-  def method_missing(event, *args)
-    case args[0]
-    when :begins
-      mark(:request) if event == :connect
-      mark(event)
-    when :ends
-      sample(:request) if event == :close
-      sample(event)
-    when :error
-      @error_count += 1
-    end
-  end
-
-  def to_s
-    request = @stats[:request]
-    @stats.delete :request
-    "#{request}\n----\n#{@stats.values.join("\n")}\nErrors: #@error_count"
-  end
-end
-
-
 if ARGV.length != 4
   STDERR.puts "usage:  ruby perftest.rb host port uri count"
   exit 1
@@ -59,7 +21,9 @@ count.times do
     code = resp.http_status.to_i
     codes[code] ||= 0
     codes[code] += 1
-  rescue Object
+  rescue => e
+    puts e.message
+    puts e.backtrace.first
   end
 end
 

data/test/spec/core_ext_spec.rb

@@ -0,0 +1,68 @@
+require File.join(File.dirname(__FILE__), '../../lib/serverside')
+
+# String extensions
+
+context "String" do
+  specify "should have URI escaping functionality" do
+    'a b c'.uri_escape.should_equal 'a+b+c'
+    'a/b#1@6%8K'.uri_escape.should_equal 'a%2Fb%231%406%258K'
+  end
+  
+  specify "should have URI unescaping functionality" do
+    'a%20b%20c'.uri_unescape.should_equal 'a b c'
+    'a%2Fb%231%406%258K'.uri_unescape.should_equal 'a/b#1@6%8K'
+    s = 'b!-=&*%aAåabéfak{}":,m"\'Mbac( 12313t awerqwe)'
+    s.uri_escape.uri_unescape.should_equal s
+  end
+
+  specify "should have a / operator for joining paths." do
+    ('abc'/'def').should_equal 'abc/def'
+    ('/hello/'/'there').should_equal '/hello/there'
+    ('touch'/'/me/'/'hold'/'/me').should_equal 'touch/me/hold/me'
+  end
+end
+
+# Symbol extensions
+
+class Symbol
+  attr_reader :_to_s
+end
+
+context "Symbol.to_s" do
+  specify "should convert the symbol to a string" do
+    :abc_def.to_s.should_equal 'abc_def'
+    :def_ghi.to_s.should_be_instance_of String
+    :ghi_jkl.to_s.should_equal :ghi_jkl.id2name
+  end
+  
+  specify "should cache the id2name value" do
+    :kwantz_mit_krantz._to_s.should_be_nil
+    :kwantz_mit_krantz.to_s
+    :kwantz_mit_krantz._to_s.should_equal :kwantz_mit_krantz.id2name
+  end
+  
+  specify "should always return the same cached value" do
+    :item.to_s.should_be :item.to_s
+  end
+end
+
+context "Proc.proc_tag" do
+  setup do
+    @l1 = lambda {1 + 1}
+    @l2 = lambda {1 + 1}
+  end
+  
+  specify "should return a unique tag for the proc object" do
+    @l1.proc_tag.should_not_equal @l2.proc_tag
+  end
+ 
+  specify "should return the same tag always" do
+    @l1.proc_tag.should_equal @l1.proc_tag
+  end
+  
+  specify "should return the object_hash in base 36 prefixed with 'proc_'" do
+    @l1.proc_tag.should_equal 'proc_' + @l1.object_id.to_s(36).sub('-', '_')
+  end
+end
+
+

data/test/unit/connection_test.rb

@@ -52,7 +52,7 @@ class ConnectionTest < Test::Unit::TestCase
   
   class ServerSide::Connection::Base 
     attr_accessor :conn, :method, :query, :version, :path, :parameters,
-      :headers, :persistent
+      :headers, :persistent, :cookies, :response_cookies
   end
   
   class DummyConnection3 < ServerSide::Connection::Base
@@ -88,6 +88,8 @@ class ConnectionTest < Test::Unit::TestCase
     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    
@@ -100,6 +102,8 @@ class ConnectionTest < Test::Unit::TestCase
     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")
@@ -108,10 +112,14 @@ class ConnectionTest < Test::Unit::TestCase
     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
@@ -123,6 +131,13 @@ class ConnectionTest < Test::Unit::TestCase
     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
@@ -203,4 +218,25 @@ class ConnectionTest < Test::Unit::TestCase
     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
+  end
 end

data/test/unit/template_test.rb

@@ -0,0 +1,78 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'stringio'
+require 'fileutils'
+
+class ServerSide::Template
+  def self.reset
+    @@templates = {}
+  end
+
+  def self.templates
+    @@templates
+  end
+end
+
+class TemplateTest < Test::Unit::TestCase
+  def test_set
+    ServerSide::Template.reset
+    assert_equal 0, ServerSide::Template.templates.size
+    ServerSide::Template.set('sharon', 'Hello chilren!')
+    assert_equal 1, ServerSide::Template.templates.size
+    assert_equal ['sharon'], ServerSide::Template.templates.keys
+    t = ServerSide::Template.templates['sharon']
+    assert_kind_of Array, t
+    assert_equal nil, t[0]
+    assert_kind_of ERB, t[1]
+    assert_equal 'Hello chilren!', t[1].result(binding)
+    
+    stamp = Time.now - 100
+    ServerSide::Template.set('zohar', 'FSMV <%= wow %>', stamp)
+    assert_equal 2, ServerSide::Template.templates.size
+    assert_equal true, ServerSide::Template.templates.keys.include?('zohar')
+    t = ServerSide::Template.templates['zohar']
+    assert_kind_of Array, t
+    assert_equal stamp, t[0]
+    assert_kind_of ERB, t[1]
+    wow = 'wow'
+    assert_equal 'FSMV wow', t[1].result(binding)
+  end
+  
+  def test_render
+    ServerSide::Template.reset
+    assert_raise(RuntimeError) {ServerSide::Template.render('sharon', binding)}
+
+    ServerSide::Template.set('sharon', 'Hello <%= name %>!')
+    name = 'world'
+    assert_equal 'Hello world!', ServerSide::Template.render('sharon', binding)
+  end
+  
+  FN = 'test.rhtml'
+  HtmlTemplate = "<% cats.each do |name| %><li><%= name %></li><% end %>"
+    
+  def teardown
+    FileUtils.rm(FN) if File.file?(FN)
+  end
+  
+  def test_render_file
+    FileUtils.rm(FN) if File.file?(FN)
+    assert_raise(RuntimeError) {ServerSide::Template.render(FN, binding)}
+
+    File.open(FN, 'w') {|f| f << HtmlTemplate}
+    assert_raise(NoMethodError) {ServerSide::Template.render(FN, binding)}
+    
+    cats = %w{Ciconia Marie Tipa}
+    s = ServerSide::Template.render(FN, binding)
+    assert_equal "<li>Ciconia</li><li>Marie</li><li>Tipa</li>", s
+    
+    cats = []
+    s = ServerSide::Template.render(FN, binding)
+    assert_nil s.match('<li>')
+    
+    sleep 2
+    
+    cats = %w{Ciconia Marie Tipa}
+    File.open(FN, 'w') {|f| f << "<%= cats.join(', ') %>"}
+    
+    assert_equal 'Ciconia, Marie, Tipa', ServerSide::Template.render(FN, binding)
+  end  
+end