mongrel 1.1.5-x86-mingw32

data/test/test_uriclassifier.rb

@@ -0,0 +1,261 @@
+# Copyright (c) 2005 Zed A. Shaw 
+# You can redistribute it and/or modify it under the same terms as Ruby.
+#
+# Additional work donated by contributors.  See http://mongrel.rubyforge.org/attributions.html 
+# for more information.
+
+require 'test/testhelp'
+
+include Mongrel
+
+class URIClassifierTest < Test::Unit::TestCase
+
+  def test_uri_finding
+    uri_classifier = URIClassifier.new
+    uri_classifier.register("/test", 1)
+    
+    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"
+
+    uri_classifier = URIClassifier.new
+    uri_classifier.register(prefix,1)
+
+    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 uri_classifier.inspect
+    assert_equal prefix, uri_classifier.uris[0]
+  end
+
+  def test_not_finding
+    test = "/cant/find/me"
+    uri_classifier = URIClassifier.new
+    uri_classifier.register(test, 1)
+
+    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
+    uri_classifier = URIClassifier.new
+
+    uri_classifier.register("/test", 1)
+    
+    failed = false
+    begin 
+      uri_classifier.register("/test", 1)
+    rescue => e
+      failed = true
+    end
+
+    assert failed
+
+    failed = false
+    begin
+      uri_classifier.register("", 1)
+    rescue => e
+      failed = true
+    end
+
+    assert failed
+  end
+
+
+  def test_register_unregister
+    uri_classifier = URIClassifier.new
+    
+    100.times do
+      uri_classifier.register("/stuff", 1)
+      value = uri_classifier.unregister("/stuff")
+      assert_equal 1, value
+    end
+
+    uri_classifier.register("/things",1)
+    script_name, path_info, value = uri_classifier.resolve("/things")
+    assert_equal 1, value
+
+    uri_classifier.unregister("/things")
+    script_name, path_info, value = uri_classifier.resolve("/things")
+    assert_nil value
+
+  end
+
+
+  def test_uri_branching
+    uri_classifier = URIClassifier.new
+    uri_classifier.register("/test", 1)
+    uri_classifier.register("/test/this",2)
+  
+    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"
+    uri_classifier = URIClassifier.new
+    
+    current = ""
+    uri.each_byte do |c|
+      current << c.chr
+      uri_classifier.register(current, c)
+    end
+    
+
+    # Try to resolve everything with no asserts as a fuzzing
+    tests.each do |prefix|
+      current = ""
+      prefix.each_byte do |c|
+        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
+    tests.each do |t|
+      script_name, path_info, handler = uri_classifier.resolve(t)
+      assert handler
+    end
+
+    # 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 accommodate real usage of handlers.
+  def test_root_mounted
+    uri_classifier = URIClassifier.new
+    root = "/"
+    path = "/this/is/a/test"
+
+    uri_classifier.register(root, 1)
+
+    script_name, path_info, handler = uri_classifier.resolve(root)
+    assert_equal 1, handler
+    assert_equal root, path_info
+    assert_equal root, script_name
+
+    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)
+      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
+

data/test/test_ws.rb

@@ -0,0 +1,115 @@
+# Copyright (c) 2005 Zed A. Shaw 
+# You can redistribute it and/or modify it under the same terms as Ruby.
+#
+# Additional work donated by contributors.  See http://mongrel.rubyforge.org/attributions.html 
+# for more information.
+
+require 'test/testhelp'
+
+include Mongrel
+
+class TestHandler < Mongrel::HttpHandler
+  attr_reader :ran_test
+
+  def process(request, response)
+    @ran_test = true
+    response.socket.write("HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\n\r\nhello!\n")
+  end
+end
+
+
+class WebServerTest < Test::Unit::TestCase
+
+  def setup
+    @valid_request = "GET / HTTP/1.1\r\nHost: www.zedshaw.com\r\nContent-Type: text/plain\r\n\r\n"
+    
+    redirect_test_io do
+      # We set num_processors=1 so that we can test the reaping code
+      @server = HttpServer.new("127.0.0.1", 9998, num_processors=1)
+    end
+    
+    @tester = TestHandler.new
+    @server.register("/test", @tester)
+    redirect_test_io do
+      @server.run 
+    end
+  end
+
+  def teardown
+    redirect_test_io do
+      @server.stop(true)
+    end
+  end
+
+  def test_simple_server
+    hit(['http://localhost:9998/test'])
+    assert @tester.ran_test, "Handler didn't really run"
+  end
+
+
+  def do_test(string, chunk, close_after=nil, shutdown_delay=0)
+    # Do not use instance variables here, because it needs to be thread safe
+    socket = TCPSocket.new("127.0.0.1", 9998);
+    request = StringIO.new(string)
+    chunks_out = 0
+
+    while data = request.read(chunk)
+      chunks_out += socket.write(data)
+      socket.flush
+      sleep 0.2
+      if close_after and chunks_out > close_after
+        socket.close
+        sleep 1
+      end
+    end
+    sleep(shutdown_delay)
+    socket.write(" ") # Some platforms only raise the exception on attempted write
+    socket.flush
+  end
+
+  def test_trickle_attack
+    do_test(@valid_request, 3)
+  end
+
+  def test_close_client
+    assert_raises IOError do
+      do_test(@valid_request, 10, 20)
+    end
+  end
+
+  def test_bad_client
+    redirect_test_io do
+      do_test("GET /test HTTP/BAD", 3)
+    end
+  end
+
+  def test_header_is_too_long
+    redirect_test_io do
+      long = "GET /test HTTP/1.1\r\n" + ("X-Big: stuff\r\n" * 15000) + "\r\n"
+      assert_raises Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNABORTED, Errno::EINVAL, IOError do
+        do_test(long, long.length/2, 10)
+      end
+    end
+  end
+
+  def test_num_processors_overload
+    redirect_test_io do
+      assert_raises Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNABORTED, Errno::EINVAL, IOError do
+        tests = [
+          Thread.new { do_test(@valid_request, 1) },
+          Thread.new { do_test(@valid_request, 10) },
+        ]
+
+        tests.each {|t| t.join}
+      end
+    end
+  end
+
+  def test_file_streamed_request
+    body = "a" * (Mongrel::Const::MAX_BODY * 2)
+    long = "GET /test HTTP/1.1\r\nContent-length: #{body.length}\r\n\r\n" + body
+    do_test(long, Mongrel::Const::CHUNK_SIZE * 2 -400)
+  end
+
+end
+

data/test/testhelp.rb

@@ -0,0 +1,79 @@
+# Copyright (c) 2005 Zed A. Shaw 
+# You can redistribute it and/or modify it under the same terms as Ruby.
+#
+# Additional work donated by contributors.  See http://mongrel.rubyforge.org/attributions.html 
+# for more information.
+
+
+HERE = File.dirname(__FILE__)
+%w(lib ext bin test).each do |dir| 
+  $LOAD_PATH.unshift "#{HERE}/../#{dir}"
+end
+
+require 'rubygems'
+require 'test/unit'
+require 'net/http'
+require 'timeout'
+require 'cgi/session'
+require 'fileutils'
+require 'benchmark'
+require 'digest/sha1'
+require 'uri'
+require 'stringio'
+require 'pp'
+
+require 'mongrel'
+require 'mongrel/stats'
+
+if ENV['DEBUG']
+  require 'ruby-debug'
+  Debugger.start
+end
+
+def redirect_test_io
+  orig_err = STDERR.dup
+  orig_out = STDOUT.dup
+  STDERR.reopen("test_stderr.log")
+  STDOUT.reopen("test_stdout.log")
+
+  begin
+    yield
+  ensure
+    STDERR.reopen(orig_err)
+    STDOUT.reopen(orig_out)
+  end
+end
+    
+# Either takes a string to do a get request against, or a tuple of [URI, HTTP] where
+# HTTP is some kind of Net::HTTP request object (POST, HEAD, etc.)
+def hit(uris)
+  results = []
+  uris.each do |u|
+    res = nil
+
+    if u.kind_of? String
+      res = Net::HTTP.get(URI.parse(u))
+    else
+      url = URI.parse(u[0])
+      res = Net::HTTP.new(url.host, url.port).start {|h| h.request(u[1]) }
+    end
+
+    assert res != nil, "Didn't get a response: #{u}"
+    results << res
+  end
+
+  return results
+end
+
+# process_based_port provides a port number, usable for TCP and UDP  
+# connections based on $$ and with a 6000 as base. 
+# this is required if you perform several builds of mongrel in parallel 
+# (like continuous integration systems) 
+def process_based_port
+  6000 + $$ % 1000
+end
+
+# Platform check helper ;-)
+def windows?
+  result = RUBY_PLATFORM =~ /djgpp|(cyg|ms|bcc)win|mingw/
+end