serverside 0.2.9 → 0.3.0

data/{test/spec → spec}/core_ext_spec.rb

@@ -1,24 +1,29 @@
-require File.join(File.dirname(__FILE__), '../../lib/serverside')
+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'
+    'a b c'.uri_escape.should == 'a+b+c'
+    'a/b#1@6%8K'.uri_escape.should == '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'
+    'a%20b%20c'.uri_unescape.should == 'a b c'
+    'a%2Fb%231%406%258K'.uri_unescape.should == 'a/b#1@6%8K'
     s = 'b!-=&*%aAåabéfak{}":,m"\'Mbac( 12313t awerqwe)'
-    s.uri_escape.uri_unescape.should_equal s
+    s.uri_escape.uri_unescape.should == 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'
+    ('abc'/'def').should == 'abc/def'
+    ('/hello/'/'there').should == '/hello/there'
+    ('touch'/'/me/'/'hold'/'/me').should == 'touch/me/hold/me'
+  end
+  
+  specify ".underscore should turn camel-cased phrases to underscored ones" do
+    'CamelCase'.underscore.should == 'camel_case'
+    'Content-Type'.underscore.should == 'content_type'
   end
 end
 
@@ -30,15 +35,15 @@ end
 
 context "Symbol.to_s" do
   specify "should convert the symbol to a string" do
-    :abc_def.to_s.should_equal 'abc_def'
+    :abc_def.to_s.should == 'abc_def'
     :def_ghi.to_s.should_be_instance_of String
-    :ghi_jkl.to_s.should_equal :ghi_jkl.id2name
+    :ghi_jkl.to_s.should == :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
+    :kwantz_mit_krantz._to_s.should == :kwantz_mit_krantz.id2name
   end
   
   specify "should always return the same cached value" do
@@ -57,11 +62,11 @@ context "Proc.proc_tag" do
   end
  
   specify "should return the same tag always" do
-    @l1.proc_tag.should_equal @l1.proc_tag
+    @l1.proc_tag.should == @l1.proc_tag
   end
   
   specify "should return the object id in base 36 prefixed with 'proc_'" do
-    @l1.proc_tag.should_equal 'proc_' + @l1.object_id.to_s(36).sub('-', '_')
+    @l1.proc_tag.should == 'proc_' + @l1.object_id.to_s(36).sub('-', '_')
   end
 end
 
@@ -76,12 +81,12 @@ context "Object.const_tag" do
   end
   
   specify "should return the same tag always" do
-    @o1.const_tag.should_equal @o1.const_tag
-    @o2.const_tag.should_equal @o2.const_tag
+    @o1.const_tag.should == @o1.const_tag
+    @o2.const_tag.should == @o2.const_tag
   end
   
   specify "should return the object id in base 36 (upcase) prefixed with 'C'" do
-    @o1.const_tag.should_equal 'C' + @o1.object_id.to_s(36).upcase.sub('-', '_')
-    @o2.const_tag.should_equal 'C' + @o2.object_id.to_s(36).upcase.sub('-', '_')
+    @o1.const_tag.should == 'C' + @o1.object_id.to_s(36).upcase.sub('-', '_')
+    @o2.const_tag.should == 'C' + @o2.object_id.to_s(36).upcase.sub('-', '_')
   end
 end

data/spec/daemon_spec.rb

@@ -0,0 +1,99 @@
+require File.join(File.dirname(__FILE__), '../lib/serverside')
+
+class TestDaemon < Daemon::Base
+  def self.start
+    @count = 0
+    loop {@count += 1; sleep 0.1}
+    puts "finished"
+  end
+  
+  def self.result_fn
+    File.join(Daemon::WorkingDirectory, 'test.result')
+  end
+  
+  def self.stop
+    #File.open(result_fn, 'w') {|f| f << @count}
+  end
+end
+
+context "Daemon::WorkingDirectory" do
+  specify "should be the working directory (pwd)" do
+    Daemon::WorkingDirectory.should == FileUtils.pwd
+  end
+end
+
+context "Daemon::Base.pid_fn" do
+  specify "should construct the pid_fn according to the class name" do
+    Daemon::Base.pid_fn.should == 
+      File.join(Daemon::WorkingDirectory, 'daemon.base.pid')
+
+    TestDaemon.pid_fn.should == 
+      File.join(Daemon::WorkingDirectory, 'testdaemon.pid')
+  end
+end
+
+context "Daemon::PidFile" do
+  specify "should store the pid in a file" do
+    pid = rand(1_000_000)
+    Daemon::PidFile.store(TestDaemon, pid)
+    File.file?(TestDaemon.pid_fn).should == true
+    IO.read(TestDaemon.pid_fn).should == pid.to_s
+    Daemon::PidFile.remove(TestDaemon)
+  end
+  
+  specify "should recall the pid from the pid file" do
+    pid = rand(1_000_000)
+    Daemon::PidFile.store(TestDaemon, pid)
+    Daemon::PidFile.recall(TestDaemon).should == pid
+    Daemon::PidFile.recall(TestDaemon).should_be_a_kind_of Fixnum
+    Daemon::PidFile.remove(TestDaemon)
+  end
+  
+  specify "should raise an exception if can't recall pid" do
+    Daemon::PidFile.remove(TestDaemon) # make sure the file doesn't exist
+    proc {Daemon::PidFile.recall(TestDaemon)}.should_raise
+  end
+  
+  specify "should remove the pid file" do
+    File.file?(TestDaemon.pid_fn).should == false
+    Daemon::PidFile.store(TestDaemon, 1024)
+    File.file?(TestDaemon.pid_fn).should == true
+  end
+end
+
+context "Daemon.control" do
+#  teardown {Daemon.control(TestDaemon, :stop) rescue nil}
+  
+#  specify "should start and stop the daemon" do
+#    Daemon::PidFile.remove(TestDaemon)
+#    Daemon.control(TestDaemon, :start)
+#    sleep 0.2
+#    File.file?(TestDaemon.pid_fn).should == true
+#    sleep 0.5
+#    proc {Daemon::PidFile.recall(TestDaemon)}.should_not_raise
+#    Daemon.control(TestDaemon, :stop)
+#    sleep 0.2
+#    File.file?(TestDaemon.result_fn).should == false
+#  end
+  
+#  specify "should restart the daemon" do
+#    Daemon::PidFile.remove(TestDaemon)
+#    Daemon.control(TestDaemon, :start)
+#    begin
+#      sleep 1
+#      pid1 = Daemon::PidFile.recall(TestDaemon)
+#      Daemon.control(TestDaemon, :restart)
+#      sleep 1
+#      pid2 = Daemon::PidFile.recall(TestDaemon)
+#      pid1.should_not == pid2
+#    ensure
+#      Daemon.control(TestDaemon, :stop)
+#      Daemon::PidFile.remove(TestDaemon)
+#    end
+#  end
+  
+  specify "should raise RuntimeError for invalid command" do
+    proc {Daemon.control(TestDaemon, :invalid)}.should_raise RuntimeError
+  end
+end
+

data/{test/spec → spec}/request_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), '../../lib/serverside')
+require File.join(File.dirname(__FILE__), '../lib/serverside')
 require 'stringio'
 
 class DummyRequest2 < ServerSide::HTTP::Request
@@ -20,24 +20,24 @@ context "HTTP::Request.process" do
   specify "should call parse and and short-circuit if the result is nil" do
     r = DummyRequest2.new(nil)
     r.process.should_be_nil
-    r.calls.should_equal [:parse]
+    r.calls.should == [:parse]
 
     r.calls = []
     r.parse_result = false
     r.process.should_be false
-    r.calls.should_equal [:parse]
+    r.calls.should == [:parse]
   end
   
   specify "should follow parse with respond and return @persistent" do
     r = DummyRequest2.new(nil)
     r.parse_result = true
     r.process.should_be_nil
-    r.calls.should_equal [:parse, :respond]
+    r.calls.should == [:parse, :respond]
     
     r.calls = []
     r.persistent = 'mau'
-    r.process.should_equal 'mau'
-    r.calls.should_equal [:parse, :respond]
+    r.process.should == 'mau'
+    r.calls.should == [:parse, :respond]
   end
 end
 
@@ -69,27 +69,27 @@ context "HTTP::Request.parse" do
     r.socket = StringIO.new(
       "POST /test HTTP/1.1\r\nContent-Type: text/html\r\n\r\n")
     r.parse.should_be r.headers
-    r.method.should_equal :post
-    r.path.should_equal '/test'
+    r.method.should == :post
+    r.path.should == '/test'
     r.query.should_be_nil
-    r.version.should_equal '1.1'
-    r.parameters.should_equal({})
-    r.headers.should_equal({'Content-Type' => 'text/html'})
-    r.cookies.should_equal({})
+    r.version.should == '1.1'
+    r.parameters.should == {}
+    r.headers.should == {'Content-Type' => 'text/html'}
+    r.cookies.should == {}
     r.response_cookies.should_be_nil
-    r.persistent.should_equal true
+    r.persistent.should == true
   end
   
   specify "should correctly handle trailing slash in path" do
     r = ServerSide::HTTP::Request.new(nil)
     r.socket = StringIO.new("POST /test/asdf/qw/ HTTP/1.1\r\n\r\n")
     r.parse.should_not_be_nil
-    r.path.should_equal '/test/asdf/qw'
+    r.path.should == '/test/asdf/qw'
 
     r.socket = StringIO.new(
       "POST /test/asdf/qw/?time=24%20hours HTTP/1.1\r\n\r\n")
     r.parse.should_not_be_nil
-    r.path.should_equal '/test/asdf/qw'
+    r.path.should == '/test/asdf/qw'
   end
   
   specify "should parse URL-encoded parameters" do
@@ -97,9 +97,9 @@ context "HTTP::Request.parse" do
     r.socket = StringIO.new(
       "POST /test?q=node_history&time=24%20hours HTTP/1.1\r\n\r\n")
     r.parse.should_not_be_nil
-    r.parameters.size.should_equal 2
-    r.parameters[:time].should_equal '24 hours'
-    r.parameters[:q].should_equal 'node_history'
+    r.parameters.size.should == 2
+    r.parameters[:time].should == '24 hours'
+    r.parameters[:q].should == 'node_history'
   end
   
   specify "should correctly parse the HTTP version" do
@@ -107,30 +107,30 @@ context "HTTP::Request.parse" do
     r.socket = StringIO.new(
       "POST / HTTP/1.0\r\n\r\n")
     r.parse.should_not_be_nil
-    r.version.should_equal '1.0'
+    r.version.should == '1.0'
     r.socket = StringIO.new(
       "POST / HTTP/3.2\r\n\r\n")
     r.parse.should_not_be_nil
-    r.version.should_equal '3.2'
+    r.version.should == '3.2'
   end
   
   specify "should set @persistent correctly" do
     r = ServerSide::HTTP::Request.new(nil)
     r.socket = StringIO.new("POST / HTTP/1.0\r\n\r\n")
     r.parse.should_not_be_nil
-    r.persistent.should_equal false
+    r.persistent.should == false
     r.socket = StringIO.new("POST / HTTP/1.1\r\n\r\n")
     r.parse.should_not_be_nil
-    r.persistent.should_equal true
+    r.persistent.should == true
     r.socket = StringIO.new("POST / HTTP/0.6\r\n\r\n")
     r.parse.should_not_be_nil
-    r.persistent.should_equal false
+    r.persistent.should == false
     r.socket = StringIO.new("POST / HTTP/1.1\r\nConnection: close\r\n\r\n")
     r.parse.should_not_be_nil
-    r.persistent.should_equal false
+    r.persistent.should == false
     r.socket = StringIO.new("POST / HTTP/1.1\r\nConnection: keep-alive\r\n\r\n")
     r.parse.should_not_be_nil
-    r.persistent.should_equal true
+    r.persistent.should == true
   end
   
   specify "should parse cookies" do
@@ -138,10 +138,10 @@ context "HTTP::Request.parse" do
     r.socket = StringIO.new(
       "POST / HTTP/1.0\r\nCookie: abc=1342; def=7%2f4\r\n\r\n")
     r.parse.should_not_be_nil
-    r.headers['Cookie'].should_equal 'abc=1342; def=7%2f4'
-    r.cookies.size.should_equal 2
-    r.cookies[:abc].should_equal '1342'
-    r.cookies[:def].should_equal '7/4'
+    r.headers['Cookie'].should == 'abc=1342; def=7%2f4'
+    r.cookies.size.should == 2
+    r.cookies[:abc].should == '1342'
+    r.cookies[:def].should == '7/4'
   end
   
   specify "should parse the post body" do
@@ -149,9 +149,9 @@ context "HTTP::Request.parse" do
     r.socket = StringIO.new(
       "POST /?q=node_history HTTP/1.0\r\nContent-Type: application/x-www-form-urlencoded\r\nContent-Length: 15\r\n\r\ntime=24%20hours")
     r.parse.should_not_be_nil
-    r.parameters.size.should_equal 2
-    r.parameters[:q].should_equal 'node_history'
-    r.parameters[:time].should_equal '24 hours'
+    r.parameters.size.should == 2
+    r.parameters[:q].should == 'node_history'
+    r.parameters[:time].should == '24 hours'
   end
 end
 
@@ -161,7 +161,7 @@ context "HTTP::Request.send_response" do
     r.socket = StringIO.new
     r.send_response(200, 'text', 'Hello there!')
     r.socket.rewind
-    r.socket.read.should_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.should == "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!"
   end
   
   specify "should format a response without connect-close when persistent" do
@@ -170,7 +170,7 @@ context "HTTP::Request.send_response" do
     r.persistent = true
     r.send_response(200, 'text', 'Hello there!')
     r.socket.rewind
-    r.socket.read.should_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.should == "HTTP/1.1 200\r\nDate: #{Time.now.httpdate}\r\nContent-Type: text\r\nContent-Length: 12\r\n\r\nHello there!"
   end
   
   specify "should format a response without content-length for streaming response" do
@@ -179,10 +179,10 @@ context "HTTP::Request.send_response" do
     r.persistent = true
     r.send_response(200, 'text')
     r.socket.rewind
-    r.socket.read.should_equal "HTTP/1.1 200\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nContent-Type: text\r\n\r\n"
+    r.socket.read.should == "HTTP/1.1 200\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nContent-Type: text\r\n\r\n"
     r.stream('hey there')
     r.socket.rewind
-    r.socket.read.should_equal "HTTP/1.1 200\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nContent-Type: text\r\n\r\nhey there"
+    r.socket.read.should == "HTTP/1.1 200\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nContent-Type: text\r\n\r\nhey there"
   end
   
   specify "should include response_headers and headers in the response" do
@@ -192,21 +192,21 @@ context "HTTP::Request.send_response" do
     r.response_headers['XXX'] = 'Test'
     r.send_response(200, 'text')
     r.socket.rewind
-    r.socket.read.should_equal "HTTP/1.1 200\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nContent-Type: text\r\nXXX: Test\r\n\r\n"
+    r.socket.read.should == "HTTP/1.1 200\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nContent-Type: text\r\nXXX: Test\r\n\r\n"
 
     r = ServerSide::HTTP::Request.new(nil)
     r.socket = StringIO.new
     r.persistent = true
     r.send_response(200, 'text', nil, nil, {'YYY' => 'TTT'})
     r.socket.rewind
-    r.socket.read.should_equal "HTTP/1.1 200\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nContent-Type: text\r\nYYY: TTT\r\n\r\n"
+    r.socket.read.should == "HTTP/1.1 200\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nContent-Type: text\r\nYYY: TTT\r\n\r\n"
   end
   
   specify "should set persistent to false if exception is raised" do
     r = ServerSide::HTTP::Request.new(nil)
     r.persistent = true
     proc {r.send_response(200, 'text', 'Hello there!')}.should_not_raise
-    r.persistent.should_equal false
+    r.persistent.should == false
   end
 
   specify "should include cookies in the response" do
@@ -214,18 +214,18 @@ context "HTTP::Request.send_response" do
     r.socket = StringIO.new
     t = Time.now + 360
     r.set_cookie(:session, "ABCDEFG", t)
-    r.response_cookies.should_equal "Set-Cookie: session=ABCDEFG; path=/; expires=#{t.rfc2822}\r\n" 
+    r.response_cookies.should == "Set-Cookie: session=ABCDEFG; path=/; expires=#{t.rfc2822}\r\n" 
     r.send_response(200, 'text', 'Hi!')
     r.socket.rewind
-    r.socket.read.should_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.should == "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 = ServerSide::HTTP::Request.new(nil)
     r.socket = StringIO.new
     r.delete_cookie(:session)
-    r.response_cookies.should_equal "Set-Cookie: session=; path=/; expires=#{Time.at(0).rfc2822}\r\n"
+    r.response_cookies.should == "Set-Cookie: session=; path=/; expires=#{Time.at(0).rfc2822}\r\n"
     r.send_response(200, 'text', 'Hi!')
     r.socket.rewind
-    r.socket.read.should_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.should == "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!"
   end
 end
 
@@ -275,7 +275,7 @@ context "HTTP::Request.redirect" do
     r.socket = StringIO.new
     r.redirect('http://mau.com/132')
     r.socket.rewind
-    r.socket.read.should_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.should == "HTTP/1.1 302\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nLocation: http://mau.com/132\r\n\r\n"
   end
   
   specify "should send a 301 response for permanent redirect" do
@@ -283,6 +283,6 @@ context "HTTP::Request.redirect" do
     r.socket = StringIO.new
     r.redirect('http://mau.com/132', true)
     r.socket.rewind
-    r.socket.read.should_equal "HTTP/1.1 301\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nLocation: http://mau.com/132\r\n\r\n"
+    r.socket.read.should == "HTTP/1.1 301\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nLocation: http://mau.com/132\r\n\r\n"
   end
 end

data/spec/routing_spec.rb

@@ -0,0 +1,240 @@
+require File.join(File.dirname(__FILE__), '../lib/serverside')
+require 'stringio'
+
+class ServerSide::Router
+  attr_accessor :t, :parameters, :path
+  
+  def self.rules
+    @@rules
+  end
+  
+  def self.reset
+    @@rules = []
+    @@default_route = nil
+    define_method(:respond) {nil}
+  end
+end
+
+R = ServerSide::Router
+
+context "Router.routes_defined?" do
+  specify "should return nil if no routes were defined" do
+    R.reset
+    R.routes_defined?.should_be_nil
+  end
+  
+  specify "should return true if routes were defined" do
+    R.reset
+    R.route('/controller') {}
+    R.routes_defined?.should_be true
+  end
+end
+
+context "Router.route" do
+  specify "should add the rule to @@rules" do
+    l = proc {1 + 1}
+    R.reset
+    R.route(:path => '/t', &l)
+    R.rules.size.should == 1
+    R.rules[0][0].should == {:path => '/t'}
+    R.rules[0][1].should == l
+  end
+  
+  specify "should convert a string argument to a path rule" do
+    R.reset
+    R.route('/test') {}
+    R.rules[0][0].should == {:path => '/test'}
+  end
+  
+  specify "should convert a regexp argument to a path rule" do
+    R.reset
+    R.route(/abc/) {}
+    R.rules[0][0].should == {:path => /abc/}
+  end
+  
+  specify "should convert an array argument into a multiple path rule" do
+    R.reset
+    R.route(['/a', '/b', '/c']) {}
+    R.rules[0][0].should == {:path => ['/a', '/b', '/c']}
+  end
+  
+  specify "should store a hash argument as the rule" do
+    R.reset
+    R.route(:a => 'abc', :b => 'def') {}
+    R.rules[0][0].should_be_a_kind_of Hash
+    R.rules[0][0].size.should == 2
+    R.rules[0][0][:a].should == 'abc'
+    R.rules[0][0][:b].should == 'def'
+  end
+  
+  specify "should unshift new rules into the rules array" do
+    R.reset
+    R.route('abc') {}
+    R.route('def') {}
+    R.route('ghi') {}
+    R.rules.size.should == 3
+    R.rules[0][0][:path].should == 'ghi'
+    R.rules[1][0][:path].should == 'def'
+    R.rules[2][0][:path].should == 'abc'
+  end
+  
+  specify "should accept a proc as a rule" do
+    R.reset
+    l1 = proc {}
+    l2 = proc {}
+    R.route(l1, &l2)
+    R.rules.size.should == 1
+    R.rules[0][0].should_be l1
+    R.rules[0][1].should_be l2
+  end
+end
+
+context "Router.compile_rules" do
+  specify "should compile a respond method for routing requests" do
+    R.reset
+    R.new(StringIO.new).respond.should_be_nil
+    R.rules << [{:t => 'abc'}, proc{:abc}]
+    R.rules << [{:t => 'def'}, proc{:def}]
+    R.default_route {:default}
+    # R.compile_rules - already called by default_route
+    r = R.new(StringIO.new)
+    r.t = 'abc'
+    r.respond.should == :abc
+    r.t = 'def'
+    r.respond.should == :def
+    r.t = ''
+    r.respond.should == :default
+  end
+  
+  specify "should allow handlers to give up on a request, and then pass it on." do
+    R.reset
+    R.default_route {:default}
+    R.new(StringIO.new).respond.should == :default
+    R.route('.*') {@path == '/first' ? :first : nil}
+    R.route('.*') {@path == '/second' ? :second : nil}
+    r = R.new(StringIO.new)
+    r.path = '/second'
+    r.respond.should == :second
+    r.path = '/first'
+    r.respond.should == :first
+    r.path = '/other'
+    r.respond.should == :default
+  end
+end
+
+context "Router.rule_to_statement" do
+  specify "should define procs as methods and construct a test expression" do
+    l1 = proc {}
+    l2 = proc {}
+    R.rule_to_statement(l1, l2).should == "if #{l1.proc_tag} && (r = #{l2.proc_tag}); return r; end\n"
+    r = R.new(StringIO.new)
+    r.should_respond_to l1.proc_tag
+    r.should_respond_to l2.proc_tag
+  end
+  
+  specify "should convert hash rule with single key-value to a test expression" do
+    l3 = proc {}
+    s = R.rule_to_statement({:path => '/.*'}, l3)
+    s =~ /^if \(@path =~ ([^\(]*)\)/
+    eval("R::#{$1}").should == /\/.*/
+    r = R.new(StringIO.new)
+    r.should_respond_to l3.proc_tag
+  end
+    
+  specify "should convert hash with multiple key-values to an OR test expression" do
+    l4 = proc {}
+    
+    s = R.rule_to_statement({:path => '/controller', :host => 'static'}, l4)
+    s.should_match /\(@path\s=~\s([^\)]+)\)/
+    s =~ /\(@path\s=~\s([^\)]+)\)/
+    eval("R::#{$1}").should == /\/controller/
+    s.should_match /\(@host\s=~\s([^\)]+)\)/
+    s =~ /\(@host\s=~\s([^\)]+)\)/
+    eval("R::#{$1}").should == /static/ 
+    r = R.new(StringIO.new)
+    r.should_respond_to l4.proc_tag
+  end
+  
+  specify "should convert hash with Array value to a test expression" do
+    l5 = proc {}
+    s = R.rule_to_statement({:path => ['/x', '/y']}, l5)
+    s =~ /^if\s\(\(@path\s=~\s([^\)]*)\)\|\|\(@path\s=~\s([^\)]*)\)\)/
+    eval("R::#{$1}").should == /\/x/
+    eval("R::#{$2}").should == /\/y/
+    r = R.new(StringIO.new)
+    r.should_respond_to l5.proc_tag
+  end
+end
+
+context "Router.condition part" do
+  specify "should compile a condition expression with key and value" do
+    s = R.condition_part(:path, 'abc')
+    s.should_match /\(@path\s=~\s(.*)\)$/
+    s =~ /\(@path\s=~\s(.*)\)$/
+    eval("R::#{$1}").should == /abc/
+  end
+  
+  specify "should parse parametrized value and compile it into a lambda" do
+    s = R.condition_part(:t, ':action/:id')
+    (s =~ /^\((.*)\)$/).should_not_be_nil
+    tag = $1
+    r = R.new(StringIO.new)
+    r.should_respond_to tag
+    r.parameters = {}
+    r.t = 'abc'
+    r.send(tag).should_be false
+    r.t = 'show/16'
+    r.send(tag).should_be true
+    r.parameters[:action].should == 'show'
+    r.parameters[:id].should == '16' 
+  end
+end
+
+context "Router.define_proc" do
+  specify "should convert a lambda into an instance method" do
+    l1 = proc {1 + 1}
+    tag = R.define_proc(&l1)
+    tag.should_be_a_kind_of Symbol
+    tag.should == l1.proc_tag.to_sym
+    r = R.new(StringIO.new)
+    r.should_respond_to(tag)
+    r.send(tag).should == 2
+  end
+end
+
+context "Router.cache_constant" do
+  specify "should cache a value as a constant inside the Router namespace" do
+    c = rand(100000)
+    tag = R.cache_constant(c)
+    tag.should_be_a_kind_of String
+    tag.should == c.const_tag
+    eval("R::#{tag}").should == c
+  end
+end
+
+context "Router.default_route" do
+  specify "should set the default route" do
+    R.default_route {'mau m'}
+    R.new(StringIO.new).default_handler.should == 'mau m'
+
+    R.default_route {654321}
+    R.new(StringIO.new).default_handler.should == 654321
+  end
+  
+  specify "should affect the result of routes_defined?" do
+    R.reset
+    R.routes_defined?.should_be_nil
+    R.default_route {654321}
+    R.routes_defined?.should_not_be_nil
+  end
+end
+
+context "Router.unhandled" do
+  specify "should send a 403 response" do
+    r = R.new(StringIO.new)
+    r.unhandled
+    r.socket.rewind
+    resp = r.socket.read
+    resp.should_match /HTTP\/1.1\s403(.*)\r\n/
+  end
+end