From c362ef8410e93be4ef8009fc89f71154053dd3a7 Mon Sep 17 00:00:00 2001 From: evanweaver Date: Tue, 30 Oct 2007 01:21:22 +0000 Subject: tests git-svn-id: svn+ssh://rubyforge.org/var/svn/mongrel/trunk@843 19e92222-5c0b-0410-8929-a290d50e31e9 --- projects/mongrel_experimental/Manifest | 1 + .../test/test_uriclassifier.rb | 262 +++++++++++++++++++++ 2 files changed, 263 insertions(+) create mode 100644 projects/mongrel_experimental/test/test_uriclassifier.rb (limited to 'projects') diff --git a/projects/mongrel_experimental/Manifest b/projects/mongrel_experimental/Manifest index 942f019..43bfdff 100644 --- a/projects/mongrel_experimental/Manifest +++ b/projects/mongrel_experimental/Manifest @@ -14,3 +14,4 @@ lib/mongrel_experimental.rb LICENSE Manifest README +test/test_uriclassifier.rb diff --git a/projects/mongrel_experimental/test/test_uriclassifier.rb b/projects/mongrel_experimental/test/test_uriclassifier.rb new file mode 100644 index 0000000..b83eac4 --- /dev/null +++ b/projects/mongrel_experimental/test/test_uriclassifier.rb @@ -0,0 +1,262 @@ +# 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 'lib/uri_classifier' +require 'test/unit' + +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 + -- cgit v1.2.3-24-ge0c7