mongrel 1.0.1 → 1.0.2

data/test/test_command.rb

@@ -4,10 +4,7 @@
 # Additional work donated by contributors.  See http://mongrel.rubyforge.org/attributions.html 
 # for more information.
 
-require 'test/unit'
-require 'mongrel'
-require File.dirname(__FILE__) + '/testhelp.rb'
-
+require 'test/testhelp'
 
 class TestCommand < GemPlugin::Plugin "/commands"
   include Mongrel::Command::Base

data/test/test_conditional.rb

@@ -4,19 +4,17 @@
 # Additional work donated by contributors.  See http://mongrel.rubyforge.org/attributions.html 
 # for more information.
 
-require 'test/unit'
-require 'net/http'
-require 'mongrel'
+require 'test/testhelp'
 
 include Mongrel
 
 class ConditionalResponseTest < Test::Unit::TestCase
   def setup
-    @h = HttpServer.new('127.0.0.1', 3501)
-    @h.register('/', Mongrel::DirHandler.new('.'))
-    @h.run
+    @server = HttpServer.new('127.0.0.1', 3501)
+    @server.register('/', Mongrel::DirHandler.new('.'))
+    @server.run
     
-    @http = Net::HTTP.new(@h.host, @h.port)
+    @http = Net::HTTP.new(@server.host, @server.port)
 
     # get the ETag and Last-Modified headers
     @path = '/README'
@@ -27,17 +25,7 @@ class ConditionalResponseTest < Test::Unit::TestCase
   end
 
   def teardown
-    orig_stderr = STDERR.dup
-
-    # temporarily disable the puts method in STDERR to silence warnings from stop
-    class << STDERR
-      define_method(:puts) {}
-    end
-
-    @h.stop
-  ensure
-    # restore STDERR
-    STDERR.reopen(orig_stderr)
+    @server.stop(true)
   end
 
   # status should be 304 Not Modified when If-None-Match is the matching ETag

data/test/test_configurator.rb

@@ -4,10 +4,7 @@
 # Additional work donated by contributors.  See http://mongrel.rubyforge.org/attributions.html 
 # for more information.
 
-require 'test/unit'
-require 'mongrel'
-require 'net/http'
-require File.dirname(__FILE__) + "/testhelp.rb"
+require 'test/testhelp'
 
 $test_plugin_fired = 0
 
@@ -32,10 +29,10 @@ end
 class ConfiguratorTest < Test::Unit::TestCase
 
   def test_base_handler_config
-    config = nil
+    @config = nil
 
     redirect_test_io do
-      config = Mongrel::Configurator.new :host => "localhost" do
+      @config = Mongrel::Configurator.new :host => "localhost" do
         listener :port => 4501 do
           # 2 in front should run, but the sentinel shouldn't since dirhandler processes the request
           uri "/", :handler => plugin("/handlers/testplugin")
@@ -60,7 +57,7 @@ class ConfiguratorTest < Test::Unit::TestCase
     end
 
 
-    config.listeners.each do |host,listener| 
+    @config.listeners.each do |host,listener| 
       assert listener.classifier.uris.length == 3, "Wrong number of registered URIs"
       assert listener.classifier.uris.include?("/"),  "/ not registered"
       assert listener.classifier.uris.include?("/test"), "/test not registered"
@@ -78,7 +75,7 @@ class ConfiguratorTest < Test::Unit::TestCase
     end
 
     redirect_test_io do
-      config.stop
+      @config.stop(false, true)
     end
 
     assert_raise Errno::EBADF, Errno::ECONNREFUSED do

data/test/test_debug.rb

@@ -4,23 +4,15 @@
 # Additional work donated by contributors.  See http://mongrel.rubyforge.org/attributions.html 
 # for more information.
 
-require 'fileutils'
-FileUtils.mkdir_p "log/mongrel_debug"
-
-require 'test/unit'
-require 'mongrel/rails'
+require 'test/testhelp'
 require 'mongrel/debug'
 
-
 class MongrelDbgTest < Test::Unit::TestCase
 
-  def setup
+  def test_tracing_to_log
     FileUtils.rm_rf "log/mongrel_debug"
-    MongrelDbg::configure
-  end
-
 
-  def test_tracing_to_log
+    MongrelDbg::configure
     out = StringIO.new
 
     MongrelDbg::begin_trace(:rails)

data/test/test_handlers.rb

@@ -4,11 +4,7 @@
 # Additional work donated by contributors.  See http://mongrel.rubyforge.org/attributions.html 
 # for more information.
 
-require 'test/unit'
-require 'net/http'
-require 'mongrel'
-require 'timeout'
-require File.dirname(__FILE__) + "/testhelp.rb"
+require 'test/testhelp'
 
 class SimpleHandler < Mongrel::HttpHandler
   def process(request, response)
@@ -48,15 +44,16 @@ class HandlersTest < Test::Unit::TestCase
         uri "/dumb", :handler => Mongrel::DeflateFilter.new
         uri "/dumb", :handler => DumbHandler.new, :in_front => true
         uri "/files", :handler => Mongrel::DirHandler.new("doc")
-        uri "/files_nodir", :handler => Mongrel::DirHandler.new("doc",listing_allowed=false, index_html="none")
+        uri "/files_nodir", :handler => Mongrel::DirHandler.new("doc", listing_allowed=false, index_html="none")
         uri "/status", :handler => Mongrel::StatusHandler.new(:stats_filter => stats)
+        uri "/relative", :handler => Mongrel::DirHandler.new(nil, listing_allowed=false, index_html="none")
       end
     end
     @config.run
   end
 
   def teardown
-    @config.stop
+    @config.stop(false, true)
   end
 
   def test_more_web_server
@@ -70,6 +67,7 @@ class HandlersTest < Test::Unit::TestCase
           "http://localhost:9998/status",
     ])
 
+    # XXX This can't possibly have good coverage.
     check_status res, String
   end
 
@@ -78,14 +76,14 @@ class HandlersTest < Test::Unit::TestCase
       # test that no accept-encoding returns a non-deflated response
       req = h.get("/dumb")
       assert(
-        !req.header['Content-Encoding'] ||
-        !req.header['Content-Encoding'].include?('deflate'))
+        !req['Content-Encoding'] ||
+        !req['Content-Encoding'].include?('deflate'))
       assert_equal "test", req.body
 
       req = h.get("/dumb", {"Accept-Encoding" => "deflate"})
       # -MAX_WBITS stops zlib from looking for a zlib header
       inflater = Zlib::Inflate.new(-Zlib::MAX_WBITS)
-      assert req.header['Content-Encoding'].include?('deflate')
+      assert req['Content-Encoding'].include?('deflate')
       assert_equal "test", inflater.inflate(req.body)
     end
   end

data/test/test_http11.rb

@@ -4,11 +4,7 @@
 # Additional work donated by contributors.  See http://mongrel.rubyforge.org/attributions.html 
 # for more information.
 
-require 'test/unit'
-require 'http11'
-require 'mongrel'
-require 'benchmark'
-require 'digest/sha1'
+require 'test/testhelp'
 
 include Mongrel
 
@@ -19,10 +15,21 @@ class HttpParserTest < Test::Unit::TestCase
     req = {}
     http = "GET / HTTP/1.1\r\n\r\n"
     nread = parser.execute(req, http, 0)
+
     assert nread == http.length, "Failed to parse the full HTTP request"
     assert parser.finished?, "Parser didn't finish"
     assert !parser.error?, "Parser had error"
     assert nread == parser.nread, "Number read returned from execute does not match"
+
+    assert_equal 'HTTP/1.1', req['SERVER_PROTOCOL']
+    assert_equal '/', req['REQUEST_PATH']
+    assert_equal 'HTTP/1.1', req['HTTP_VERSION']
+    assert_equal '/', req['REQUEST_URI']
+    assert_equal 'CGI/1.2', req['GATEWAY_INTERFACE']
+    assert_equal 'GET', req['REQUEST_METHOD']    
+    assert_nil req['FRAGMENT']
+    assert_nil req['QUERY_STRING']
+    
     parser.reset
     assert parser.nread == 0, "Number read after reset should be 0"
   end
@@ -62,6 +69,18 @@ class HttpParserTest < Test::Unit::TestCase
     assert parser.error?, "Parser SHOULD have error"
   end
 
+  def test_fragment_in_uri
+    parser = HttpParser.new
+    req = {}
+    get = "GET /forums/1/topics/2375?page=1#posts-17408 HTTP/1.1\r\n\r\n"
+    assert_nothing_raised do
+      parser.execute(req, get, 0)
+    end
+    assert parser.finished?
+    assert_equal '/forums/1/topics/2375?page=1', req['REQUEST_URI']
+    assert_equal 'posts-17408', req['FRAGMENT']
+  end
+
   # lame random garbage maker
   def rand_data(min, max, readable=true)
     count = min + ((rand(max)+1) *10).to_i

data/test/test_redirect_handler.rb

@@ -4,11 +4,7 @@
 # Additional work donated by contributors.  See http://mongrel.rubyforge.org/attributions.html 
 # for more information.
 
-require 'test/unit'
-require 'mongrel'
-require 'net/http'
-require 'uri'
-require 'timeout'
+require 'test/testhelp'
 
 class RedirectHandlerTest < Test::Unit::TestCase
 
@@ -19,7 +15,7 @@ class RedirectHandlerTest < Test::Unit::TestCase
   end
 
   def teardown
-    @server.stop
+    @server.stop(true)
   end
 
   def test_simple_redirect

data/test/test_request_progress.rb

@@ -4,11 +4,7 @@
 # Additional work donated by contributors.  See http://mongrel.rubyforge.org/attributions.html 
 # for more information.
 
-require 'test/unit'
-require 'mongrel'
-require 'net/http'
-require File.dirname(__FILE__) + '/testhelp.rb'
-
+require 'test/testhelp'
 
 class UploadBeginHandler < Mongrel::HttpHandler
   attr_reader :request_began, :request_progressed, :request_processed
@@ -18,9 +14,9 @@ class UploadBeginHandler < Mongrel::HttpHandler
   end
 
   def reset
-    @request_began = 
-      @request_progressed = 
-        @request_processed = false
+    @request_began = false
+    @request_progressed = false
+    @request_processed = false
   end
 
   def request_begins(params)
@@ -49,7 +45,7 @@ class RequestProgressTest < Test::Unit::TestCase
   end
 
   def teardown
-    @server.stop
+    @server.stop(true)
   end
 
   def test_begin_end_progress

data/test/test_response.rb

@@ -4,9 +4,7 @@
 # Additional work donated by contributors.  See http://mongrel.rubyforge.org/attributions.html 
 # for more information.
 
-require 'test/unit'
-require 'mongrel'
-require 'benchmark'
+require 'test/testhelp'
 
 include Mongrel
 
@@ -102,5 +100,28 @@ class ResponseTest < Test::Unit::TestCase
     assert io.length > 0, "output didn't have data"
     assert io.read[-contents.length..-1] == contents, "output doesn't end with file payload"
   end
+
+  def test_response_with_custom_reason
+    reason = "You made a bad request"
+    io = StringIO.new
+    resp = HttpResponse.new(io)
+    resp.start(400, false, reason) { |head,out| }
+    resp.finished
+
+    io.rewind
+    assert_match(/.* #{reason}$/, io.readline.chomp, "wrong custom reason phrase")
+  end
+
+  def test_response_with_default_reason
+    code = 400
+    io = StringIO.new
+    resp = HttpResponse.new(io)
+    resp.start(code) { |head,out| }
+    resp.finished
+
+    io.rewind
+    assert_match(/.* #{HTTP_STATUS_CODES[code]}$/, io.readline.chomp, "wrong default reason phrase")
+  end
+
 end
 

data/test/test_stats.rb

@@ -4,9 +4,7 @@
 # Additional work donated by contributors.  See http://mongrel.rubyforge.org/attributions.html 
 # for more information.
 
-require 'test/unit'
-require 'mongrel/stats'
-require 'stringio'
+require 'test/testhelp'
 
 class StatsTest < Test::Unit::TestCase
 

data/test/test_uriclassifier.rb

@@ -4,169 +4,258 @@
 # Additional work donated by contributors.  See http://mongrel.rubyforge.org/attributions.html 
 # for more information.
 
-require 'test/unit'
-require 'net/http'
-require 'mongrel'
-require 'benchmark'
+require 'test/testhelp'
 
 include Mongrel
 
 class URIClassifierTest < Test::Unit::TestCase
 
   def test_uri_finding
-    u = URIClassifier.new
-    u.register("/test", 1)
+    uri_classifier = URIClassifier.new
+    uri_classifier.register("/test", 1)
     
-    sn,pi,val = u.resolve("/test")
-    assert val != nil, "didn't resolve"
-    assert_equal 1, val, "wrong value"
-    assert_equal "/test",sn, "wrong SCRIPT_NAME"
+    script_name, path_info, value = uri_classifier.resolve("/test")
+    assert_equal 1, value
+    assert_equal "/test", script_name
+  end
+  
+  def test_root_handler_only
+    uri_classifier = URIClassifier.new
+    uri_classifier.register("/", 1)
+    
+    script_name, path_info, value = uri_classifier.resolve("/test")
+    assert_equal 1, value
+    assert_equal "/", script_name 
+    assert_equal "/test", path_info
   end
-
 
   def test_uri_prefix_ops
     test = "/pre/fix/test"
     prefix = "/pre"
 
-    u = URIClassifier.new
-    u.register(prefix,1)
+    uri_classifier = URIClassifier.new
+    uri_classifier.register(prefix,1)
 
-    sn,pi,val = u.resolve(prefix)
-    sn,pi,val = u.resolve(test)
-    assert val != nil, "didn't resolve"
-    assert_equal prefix,sn, "wrong script name"
-    assert_equal test[sn.length .. -1],pi, "wrong path info"
+    script_name, path_info, value = uri_classifier.resolve(prefix)
+    script_name, path_info, value = uri_classifier.resolve(test)
+    assert_equal 1, value
+    assert_equal prefix, script_name
+    assert_equal test[script_name.length .. -1], path_info
 
-    assert u.inspect != nil, "No inspect for classifier"
-    assert u.uris[0] == prefix, "URI list didn't match"
+    assert uri_classifier.inspect
+    assert_equal prefix, uri_classifier.uris[0]
   end
 
   def test_not_finding
     test = "/cant/find/me"
-    u = URIClassifier.new
-    u.register(test, 1)
+    uri_classifier = URIClassifier.new
+    uri_classifier.register(test, 1)
 
-    sn,pi,val = u.resolve("/nope/not/here")
-    assert_equal nil,sn, "shouldn't be found"
-    assert_equal nil,pi, "shouldn't be found"
-    assert_equal nil,val, "shouldn't be found"
+    script_name, path_info, value = uri_classifier.resolve("/nope/not/here")
+    assert_nil script_name
+    assert_nil path_info
+    assert_nil value
   end
 
   def test_exceptions
-    u = URIClassifier.new
+    uri_classifier = URIClassifier.new
 
-    u.register("test", 1)
+    uri_classifier.register("/test", 1)
     
     failed = false
     begin 
-      u.register("test", 1)
+      uri_classifier.register("/test", 1)
     rescue => e
       failed = true
     end
 
-    assert failed, "it didn't fail as expected"
+    assert failed
 
     failed = false
     begin
-      u.register("", 1)
+      uri_classifier.register("", 1)
     rescue => e
       failed = true
     end
 
-    assert failed, "it didn't fail as expected"
+    assert failed
   end
 
 
   def test_register_unregister
-    u = URIClassifier.new
+    uri_classifier = URIClassifier.new
     
     100.times do
-      u.register("stuff", 1)
-      val = u.unregister("stuff")
-      assert_equal 1,val, "didn't get the right return value"
+      uri_classifier.register("/stuff", 1)
+      value = uri_classifier.unregister("/stuff")
+      assert_equal 1, value
     end
 
-    u.register("things",1)
-    sn,pi,val = u.resolve("things")
-    assert_equal 1, val, "result doesn't match"
+    uri_classifier.register("/things",1)
+    script_name, path_info, value = uri_classifier.resolve("/things")
+    assert_equal 1, value
 
-    u.unregister("things")
-    sn,pi,val = u.resolve("things")
-    assert_equal nil, val, "result should be nil"
+    uri_classifier.unregister("/things")
+    script_name, path_info, value = uri_classifier.resolve("/things")
+    assert_nil value
 
   end
 
 
   def test_uri_branching
-    u = URIClassifier.new
-    u.register("/test", 1)
-    u.register("/test/this",2)
+    uri_classifier = URIClassifier.new
+    uri_classifier.register("/test", 1)
+    uri_classifier.register("/test/this",2)
   
-    sn,pi,h = u.resolve("/test")
-    sn,pi,h = u.resolve("/test/that")
-    assert_equal "/test", sn, "failed to properly find script off branch portion of uri"
-    assert_equal "/that", pi, "didn't get the right patch info"
-    assert_equal 1, h, "wrong result for branching uri"
+    script_name, path_info, handler = uri_classifier.resolve("/test")
+    script_name, path_info, handler = uri_classifier.resolve("/test/that")
+    assert_equal "/test", script_name, "failed to properly find script off branch portion of uri"
+    assert_equal "/that", path_info
+    assert_equal 1, handler, "wrong result for branching uri"
   end
 
   def test_all_prefixing
     tests = ["/test","/test/that","/test/this"]
     uri = "/test/this/that"
-    u = URIClassifier.new
+    uri_classifier = URIClassifier.new
     
-    cur = ""
+    current = ""
     uri.each_byte do |c|
-      cur << c.chr
-      u.register(cur, c)
+      current << c.chr
+      uri_classifier.register(current, c)
     end
 
-    # try to resolve everything with no asserts as a fuzzing
+    # Try to resolve everything with no asserts as a fuzzing
     tests.each do |prefix|
-      cur = ""
+      current = ""
       prefix.each_byte do |c|
-        cur << c.chr
-        sn, pi, h = u.resolve(cur)
-        assert sn != nil, "didn't get a script name"
-        assert pi != nil, "didn't get path info"
-        assert h != nil, "didn't find the handler"
+        current << c.chr
+        script_name, path_info, handler = uri_classifier.resolve(current)
+        assert script_name
+        assert path_info
+        assert handler
       end
     end
 
-    # assert that we find stuff
+    # Assert that we find stuff
     tests.each do |t|
-      sn, pi, h = u.resolve(t)
-      assert h != nil, "didn't find handler"
+      script_name, path_info, handler = uri_classifier.resolve(t)
+      assert handler
     end
 
-    # assert we don't find stuff
-    sn, pi, h = u.resolve("chicken")
-    assert_nil h, "shoulnd't find anything"
-    assert_nil sn, "shoulnd't find anything"
-    assert_nil pi, "shoulnd't find anything"
+    # Assert we don't find stuff
+    script_name, path_info, handler = uri_classifier.resolve("chicken")
+    assert_nil handler
+    assert_nil script_name
+    assert_nil path_info
   end
 
 
   # Verifies that a root mounted ("/") handler resolves
   # such that path info matches the original URI.
-  # This is needed to accomodate real usage of handlers.
+  # This is needed to accommodate real usage of handlers.
   def test_root_mounted
-    u = URIClassifier.new
+    uri_classifier = URIClassifier.new
     root = "/"
     path = "/this/is/a/test"
 
-    u.register(root, 1)
+    uri_classifier.register(root, 1)
 
-    sn, pi, h = u.resolve(root)
-    assert_equal 1,h, "didn't find handler"
-    assert_equal root,pi, "didn't get right path info"
-    assert_equal root,sn, "didn't get right script name"
+    script_name, path_info, handler = uri_classifier.resolve(root)
+    assert_equal 1, handler
+    assert_equal root, path_info
+    assert_equal root, script_name
 
-    sn, pi, h = u.resolve(path)
-    assert_equal path,pi, "didn't get right path info"
-    assert_equal root,sn, "didn't get right script name"
-    assert_equal 1,h, "didn't find handler"
+    script_name, path_info, handler = uri_classifier.resolve(path)
+    assert_equal path, path_info
+    assert_equal root, script_name
+    assert_equal 1, handler
   end
 
-
+  # Verifies that a root mounted ("/") handler
+  # is the default point, doesn't matter the order we use
+  # to register the URIs
+  def test_classifier_order
+    tests = ["/before", "/way_past"]
+    root = "/"
+    path = "/path"
+
+    uri_classifier = URIClassifier.new
+    uri_classifier.register(path, 1)
+    uri_classifier.register(root, 2)
+
+    tests.each do |uri|
+      script_name, path_info, handler = uri_classifier.resolve(uri)
+#      p uri_classifier.resolve(uri)
+      assert_equal root, script_name, "#{uri} did not resolve to #{root}"
+      assert_equal uri, path_info
+      assert_equal 2, handler
+    end
+  end
+  
+  if ENV['BENCHMARK']
+    # Eventually we will have a suite of benchmarks instead of lamely installing a test
+    
+    def test_benchmark    
+
+      # This URI set should favor a TST. Both versions increase linearly until you hit 14 
+      # URIs, then the TST flattens out.
+      @uris = %w(
+        / 
+        /dag /dig /digbark /dog /dogbark /dog/bark /dug /dugbarking /puppy 
+        /c /cat /cat/tree /cat/tree/mulberry /cats /cot /cot/tree/mulberry /kitty /kittycat
+#        /eag /eig /eigbark /eog /eogbark /eog/bark /eug /eugbarking /iuppy 
+#        /f /fat /fat/tree /fat/tree/mulberry /fats /fot /fot/tree/mulberry /jitty /jittyfat
+#        /gag /gig /gigbark /gog /gogbark /gog/bark /gug /gugbarking /kuppy 
+#        /h /hat /hat/tree /hat/tree/mulberry /hats /hot /hot/tree/mulberry /litty /littyhat
+#        /ceag /ceig /ceigbark /ceog /ceogbark /ceog/cbark /ceug /ceugbarking /ciuppy 
+#        /cf /cfat /cfat/ctree /cfat/ctree/cmulberry /cfats /cfot /cfot/ctree/cmulberry /cjitty /cjittyfat
+#        /cgag /cgig /cgigbark /cgog /cgogbark /cgog/cbark /cgug /cgugbarking /ckuppy 
+#        /ch /chat /chat/ctree /chat/ctree/cmulberry /chats /chot /chot/ctree/cmulberry /citty /cittyhat
+      )
+      
+      @requests = %w(
+        /
+        /dig
+        /digging
+        /dogging
+        /dogbarking/
+        /puppy/barking
+        /c
+        /cat
+        /cat/shrub
+        /cat/tree
+        /cat/tree/maple
+        /cat/tree/mulberry/tree
+        /cat/tree/oak
+        /cats/
+        /cats/tree
+        /cod
+        /zebra
+      )
+    
+      @classifier = URIClassifier.new
+      @uris.each do |uri|
+        @classifier.register(uri, 1)
+      end
+      
+      puts "#{@uris.size} URIs / #{@requests.size * 10000} requests"
+  
+      Benchmark.bm do |x|
+        x.report do
+  #        require 'ruby-prof'
+  #        profile = RubyProf.profile do
+            10000.times do
+              @requests.each do |request|
+                @classifier.resolve(request)
+              end
+            end
+  #        end
+  #        File.open("profile.html", 'w') { |file| RubyProf::GraphHtmlPrinter.new(profile).print(file, 0) }
+        end
+      end          
+    end
+  end
+  
 end