Changeset 702

Show
Ignore:
Timestamp:
10/19/07 04:26:50 (2 years ago)
Author:
evanweaver
Message:

bring sanity to test_uriclassifier

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/test/test_uriclassifier.rb

    r585 r702  
    1515 
    1616  def test_uri_finding 
    17     u = URIClassifier.new 
    18     u.register("/test", 1) 
     17    uri_classifier = URIClassifier.new 
     18    uri_classifier.register("/test", 1) 
    1919     
    20     sn,pi,val = u.resolve("/test") 
    21     assert val != nil, "didn't resolve" 
    22     assert_equal 1, val, "wrong value" 
    23     assert_equal "/test",sn, "wrong SCRIPT_NAME" 
     20    script_name, path_info, value = uri_classifier.resolve("/test") 
     21    assert value 
     22    assert_equal 1, value 
     23    assert_equal "/test", script_name 
    2424  end 
    2525 
    …… 
    2929    prefix = "/pre" 
    3030 
    31     u = URIClassifier.new 
    32     u.register(prefix,1) 
     31    uri_classifier = URIClassifier.new 
     32    uri_classifier.register(prefix,1) 
    3333 
    34     sn,pi,val = u.resolve(prefix) 
    35     sn,pi,val = u.resolve(test) 
    36     assert val != nil, "didn't resolve" 
    37     assert_equal prefix,sn, "wrong script name" 
    38     assert_equal test[sn.length .. -1],pi, "wrong path info" 
     34    script_name, path_info, value = uri_classifier.resolve(prefix) 
     35    script_name, path_info, value = uri_classifier.resolve(test) 
     36    assert value, "didn't resolve" 
     37    assert_equal prefix, script_name 
     38    assert_equal test[script_name.length .. -1], path_info 
    3939 
    40     assert u.inspect != nil, "No inspect for classifier" 
    41     assert u.uris[0] == prefix, "URI list didn't match" 
     40    assert uri_classifier.inspect 
     41    assert_equal prefix, uri_classifier.uris[0] 
    4242  end 
    4343 
    4444  def test_not_finding 
    4545    test = "/cant/find/me" 
    46     u = URIClassifier.new 
    47     u.register(test, 1) 
     46    uri_classifier = URIClassifier.new 
     47    uri_classifier.register(test, 1) 
    4848 
    49     sn,pi,val = u.resolve("/nope/not/here") 
    50     assert_equal nil,sn, "shouldn't be found" 
    51     assert_equal nil,pi, "shouldn't be found" 
    52     assert_equal nil,val, "shouldn't be found" 
     49    script_name, path_info, value = uri_classifier.resolve("/nope/not/here") 
     50    assert_nil script_name 
     51    assert_nil path_info 
     52    assert_nil value 
    5353  end 
    5454 
    5555  def test_exceptions 
    56     u = URIClassifier.new 
     56    uri_classifier = URIClassifier.new 
    5757 
    58     u.register("test", 1) 
     58    uri_classifier.register("test", 1) 
    5959     
    6060    failed = false 
    6161    begin  
    62       u.register("test", 1) 
     62      uri_classifier.register("test", 1) 
    6363    rescue => e 
    6464      failed = true 
    6565    end 
    6666 
    67     assert failed, "it didn't fail as expected" 
     67    assert failed 
    6868 
    6969    failed = false 
    7070    begin 
    71       u.register("", 1) 
     71      uri_classifier.register("", 1) 
    7272    rescue => e 
    7373      failed = true 
    7474    end 
    7575 
    76     assert failed, "it didn't fail as expected" 
     76    assert failed 
    7777  end 
    7878 
    7979 
    8080  def test_register_unregister 
    81     u = URIClassifier.new 
     81    uri_classifier = URIClassifier.new 
    8282     
    8383    100.times do 
    84       u.register("stuff", 1) 
    85       val = u.unregister("stuff") 
    86       assert_equal 1,val, "didn't get the right return value" 
     84      uri_classifier.register("stuff", 1) 
     85      value = uri_classifier.unregister("stuff") 
     86      assert_equal 1, value 
    8787    end 
    8888 
    89     u.register("things",1) 
    90     sn,pi,val = u.resolve("things") 
    91     assert_equal 1, val, "result doesn't match" 
     89    uri_classifier.register("things",1) 
     90    script_name, path_info, value = uri_classifier.resolve("things") 
     91    assert_equal 1, value 
    9292 
    93     u.unregister("things") 
    94     sn,pi,val = u.resolve("things") 
    95     assert_equal nil, val, "result should be nil" 
     93    uri_classifier.unregister("things") 
     94    script_name, path_info, value = uri_classifier.resolve("things") 
     95    assert_nil value 
    9696 
    9797  end 
    …… 
    9999 
    100100  def test_uri_branching 
    101     u = URIClassifier.new 
    102     u.register("/test", 1) 
    103     u.register("/test/this",2) 
     101    uri_classifier = URIClassifier.new 
     102    uri_classifier.register("/test", 1) 
     103    uri_classifier.register("/test/this",2) 
    104104   
    105     sn,pi,h = u.resolve("/test") 
    106     sn,pi,h = u.resolve("/test/that") 
    107     assert_equal "/test", sn, "failed to properly find script off branch portion of uri" 
    108     assert_equal "/that", pi, "didn't get the right patch info" 
    109     assert_equal 1, h, "wrong result for branching uri" 
     105    script_name, path_info, handler = uri_classifier.resolve("/test") 
     106    script_name, path_info, handler = uri_classifier.resolve("/test/that") 
     107    assert_equal "/test", script_name, "failed to properly find script off branch portion of uri" 
     108    assert_equal "/that", path_info 
     109    assert_equal 1, handler, "wrong result for branching uri" 
    110110  end 
    111111 
    …… 
    113113    tests = ["/test","/test/that","/test/this"] 
    114114    uri = "/test/this/that" 
    115     u = URIClassifier.new 
     115    uri_classifier = URIClassifier.new 
    116116     
    117     cur = "" 
     117    current = "" 
    118118    uri.each_byte do |c| 
    119       cur << c.chr 
    120       u.register(cur, c) 
     119      current << c.chr 
     120      uri_classifier.register(current, c) 
    121121    end 
    122122 
    123123    # try to resolve everything with no asserts as a fuzzing 
    124124    tests.each do |prefix| 
    125       cur = "" 
     125      current = "" 
    126126      prefix.each_byte do |c| 
    127         cur << c.chr 
    128         sn, pi, h = u.resolve(cur) 
    129         assert sn != nil, "didn't get a script name" 
    130         assert pi != nil, "didn't get path info" 
    131         assert h != nil, "didn't find the handler" 
     127        current << c.chr 
     128        script_name, path_info, handler = uri_classifier.resolve(current) 
     129        assert script_name 
     130        assert path_info 
     131        assert handler 
    132132      end 
    133133    end 
    …… 
    135135    # assert that we find stuff 
    136136    tests.each do |t| 
    137       sn, pi, h = u.resolve(t) 
    138       assert h != nil, "didn't find handler" 
     137      script_name, path_info, handler = uri_classifier.resolve(t) 
     138      assert handler 
    139139    end 
    140140 
    141141    # assert we don't find stuff 
    142     sn, pi, h = u.resolve("chicken") 
    143     assert_nil h, "shoulnd't find anything" 
    144     assert_nil sn, "shoulnd't find anything" 
    145     assert_nil pi, "shoulnd't find anything" 
     142    script_name, path_info, handler = uri_classifier.resolve("chicken") 
     143    assert_nil handler 
     144    assert_nil script_name 
     145    assert_nil path_info 
    146146  end 
    147147 
    …… 
    151151  # This is needed to accomodate real usage of handlers. 
    152152  def test_root_mounted 
    153     u = URIClassifier.new 
     153    uri_classifier = URIClassifier.new 
    154154    root = "/" 
    155155    path = "/this/is/a/test" 
    156156 
    157     u.register(root, 1) 
     157    uri_classifier.register(root, 1) 
    158158 
    159     sn, pi, h = u.resolve(root) 
    160     assert_equal 1,h, "didn't find handler" 
    161     assert_equal root,pi, "didn't get right path info" 
    162     assert_equal root,sn, "didn't get right script name" 
     159    script_name, path_info, handler = uri_classifier.resolve(root) 
     160    assert_equal 1, handler 
     161    assert_equal root, path_info 
     162    assert_equal root, script_name 
    163163 
    164     sn, pi, h = u.resolve(path) 
    165     assert_equal path,pi, "didn't get right path info" 
    166     assert_equal root,sn, "didn't get right script name" 
    167     assert_equal 1,h, "didn't find handler" 
     164    script_name, path_info, handler = uri_classifier.resolve(path) 
     165    assert_equal path, path_info 
     166    assert_equal root, script_name 
     167    assert_equal 1, handler 
    168168  end 
    169169 
    …… 
    176176    path = "/path" 
    177177 
    178     u = URIClassifier.new 
    179     u.register(path, 1) 
    180     u.register(root, 2) 
     178    uri_classifier = URIClassifier.new 
     179    uri_classifier.register(path, 1) 
     180    uri_classifier.register(root, 2) 
    181181 
    182182    tests.each do |uri| 
    183         sn, pi, h = u.resolve(uri) 
    184         assert_equal root, sn, "didn't get right script name" 
    185         assert_equal uri, pi, "didn't get right path info" 
    186         assert_equal 2, h, "didn't find handler" 
     183      script_name, path_info, handler = uri_classifier.resolve(uri) 
     184      assert_equal root, script_name 
     185      assert_equal uri, path_info 
     186      assert_equal 2, handler 
    187187    end 
    188188  end