From 52cf648827d6fdfe32f5ebc421454b7a2a15df50 Mon Sep 17 00:00:00 2001 From: evanweaver Date: Fri, 19 Oct 2007 09:26:50 +0000 Subject: bring sanity to test_uriclassifier git-svn-id: svn+ssh://rubyforge.org/var/svn/mongrel/trunk@702 19e92222-5c0b-0410-8929-a290d50e31e9 --- test/test_uriclassifier.rb | 156 ++++++++++++++++++++++----------------------- 1 file changed, 78 insertions(+), 78 deletions(-) (limited to 'test') diff --git a/test/test_uriclassifier.rb b/test/test_uriclassifier.rb index 526a921..e9690b2 100644 --- a/test/test_uriclassifier.rb +++ b/test/test_uriclassifier.rb @@ -14,13 +14,13 @@ 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 value + assert_equal 1, value + assert_equal "/test", script_name end @@ -28,121 +28,121 @@ class URIClassifierTest < Test::Unit::TestCase 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 value, "didn't resolve" + 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 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 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" + script_name, path_info, handler = uri_classifier.resolve("chicken") + assert_nil handler + assert_nil script_name + assert_nil path_info end @@ -150,21 +150,21 @@ class URIClassifierTest < Test::Unit::TestCase # such that path info matches the original URI. # This is needed to accomodate 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 @@ -175,15 +175,15 @@ class URIClassifierTest < Test::Unit::TestCase root = "/" path = "/path" - u = URIClassifier.new - u.register(path, 1) - u.register(root, 2) + uri_classifier = URIClassifier.new + uri_classifier.register(path, 1) + uri_classifier.register(root, 2) tests.each do |uri| - sn, pi, h = u.resolve(uri) - assert_equal root, sn, "didn't get right script name" - assert_equal uri, pi, "didn't get right path info" - assert_equal 2, h, "didn't find handler" + script_name, path_info, handler = uri_classifier.resolve(uri) + assert_equal root, script_name + assert_equal uri, path_info + assert_equal 2, handler end end -- cgit v1.2.3-24-ge0c7