home *** CD-ROM | disk | FTP | other *** search
/ PC World 2001 April / PCWorld_2001-04_cd.bin / Software / TemaCD / webclean / !!!python!!! / BeOpen-Python-2.0.exe / TEST_CGI.PY < prev    next >
Encoding:
Python Source  |  2000-09-28  |  6.4 KB  |  188 lines
  1. import cgi
  2. import os
  3. import sys
  4.  
  5. class HackedSysModule:
  6.     # The regression test will have real values in sys.argv, which
  7.     # will completely confuse the test of the cgi module 
  8.     argv = []
  9.     stdin = sys.stdin
  10.  
  11. cgi.sys = HackedSysModule()
  12.  
  13. try:
  14.     from cStringIO import StringIO
  15. except ImportError:
  16.     from StringIO import StringIO
  17.  
  18. class ComparableException:
  19.     def __init__(self, err):
  20.         self.err = err
  21.  
  22.     def __str__(self):
  23.         return str(self.err)
  24.  
  25.     def __cmp__(self, anExc):
  26.         if not isinstance(anExc, Exception):
  27.             return -1
  28.         x = cmp(self.err.__class__, anExc.__class__)
  29.         if x != 0:
  30.             return x
  31.         return cmp(self.err.args, anExc.args)
  32.  
  33.     def __getattr__(self, attr):
  34.         return getattr(self, self.err)
  35.  
  36. def do_test(buf, method):
  37.     env = {}
  38.     if method == "GET":
  39.         fp = None
  40.         env['REQUEST_METHOD'] = 'GET'
  41.         env['QUERY_STRING'] = buf
  42.     elif method == "POST":
  43.         fp = StringIO(buf)
  44.         env['REQUEST_METHOD'] = 'POST'
  45.         env['CONTENT_TYPE'] = 'application/x-www-form-urlencoded'
  46.         env['CONTENT_LENGTH'] = str(len(buf))
  47.     else:
  48.         raise ValueError, "unknown method: %s" % method
  49.     try:
  50.         return cgi.parse(fp, env, strict_parsing=1)
  51.     except StandardError, err:
  52.         return ComparableException(err)
  53.  
  54. # A list of test cases.  Each test case is a a two-tuple that contains
  55. # a string with the query and a dictionary with the expected result.
  56.     
  57. parse_test_cases = [
  58.     ("", ValueError("bad query field: ''")),
  59.     ("&", ValueError("bad query field: ''")),
  60.     ("&&", ValueError("bad query field: ''")),
  61.     (";", ValueError("bad query field: ''")),
  62.     (";&;", ValueError("bad query field: ''")),
  63.     # Should the next few really be valid?
  64.     ("=", {}),
  65.     ("=&=", {}),
  66.     ("=;=", {}),
  67.     # This rest seem to make sense
  68.     ("=a", {'': ['a']}),
  69.     ("&=a", ValueError("bad query field: ''")),
  70.     ("=a&", ValueError("bad query field: ''")),
  71.     ("=&a", ValueError("bad query field: 'a'")),
  72.     ("b=a", {'b': ['a']}),
  73.     ("b+=a", {'b ': ['a']}),
  74.     ("a=b=a", {'a': ['b=a']}),
  75.     ("a=+b=a", {'a': [' b=a']}),
  76.     ("&b=a", ValueError("bad query field: ''")),
  77.     ("b&=a", ValueError("bad query field: 'b'")),
  78.     ("a=a+b&b=b+c", {'a': ['a b'], 'b': ['b c']}),
  79.     ("a=a+b&a=b+a", {'a': ['a b', 'b a']}),
  80.     ("x=1&y=2.0&z=2-3.%2b0", {'x': ['1'], 'y': ['2.0'], 'z': ['2-3.+0']}),
  81.     ("x=1;y=2.0&z=2-3.%2b0", {'x': ['1'], 'y': ['2.0'], 'z': ['2-3.+0']}),
  82.     ("x=1;y=2.0;z=2-3.%2b0", {'x': ['1'], 'y': ['2.0'], 'z': ['2-3.+0']}),
  83.     ("Hbc5161168c542333633315dee1182227:key_store_seqid=400006&cuyer=r&view=bustomer&order_id=0bb2e248638833d48cb7fed300000f1b&expire=964546263&lobale=en-US&kid=130003.300038&ss=env",
  84.      {'Hbc5161168c542333633315dee1182227:key_store_seqid': ['400006'],
  85.       'cuyer': ['r'],
  86.       'expire': ['964546263'],
  87.       'kid': ['130003.300038'],
  88.       'lobale': ['en-US'],
  89.       'order_id': ['0bb2e248638833d48cb7fed300000f1b'],
  90.       'ss': ['env'],
  91.       'view': ['bustomer'],
  92.       }),
  93.     
  94.     ("group_id=5470&set=custom&_assigned_to=31392&_status=1&_category=100&SUBMIT=Browse",
  95.      {'SUBMIT': ['Browse'],
  96.       '_assigned_to': ['31392'],
  97.       '_category': ['100'],
  98.       '_status': ['1'],
  99.       'group_id': ['5470'],
  100.       'set': ['custom'],
  101.       })
  102.     ]
  103.  
  104. def norm(list):
  105.     if type(list) == type([]):
  106.         list.sort()
  107.     return list
  108.  
  109. def first_elts(list):
  110.     return map(lambda x:x[0], list)
  111.  
  112. def first_second_elts(list):
  113.     return map(lambda p:(p[0], p[1][0]), list)
  114.  
  115. def main():
  116.     for orig, expect in parse_test_cases:
  117.         # Test basic parsing
  118.         print repr(orig)
  119.         d = do_test(orig, "GET")
  120.         assert d == expect, "Error parsing %s" % repr(orig)
  121.         d = do_test(orig, "POST")
  122.         assert d == expect, "Error parsing %s" % repr(orig)
  123.  
  124.         env = {'QUERY_STRING': orig}
  125.         fcd = cgi.FormContentDict(env)
  126.         sd = cgi.SvFormContentDict(env)
  127.         fs = cgi.FieldStorage(environ=env)
  128.         if type(expect) == type({}):
  129.             # test dict interface
  130.             assert len(expect) == len(fcd)
  131.             assert norm(expect.keys()) == norm(fcd.keys())
  132.             assert norm(expect.values()) == norm(fcd.values())
  133.             assert norm(expect.items()) == norm(fcd.items())
  134.             assert fcd.get("nonexistent field", "default") == "default"
  135.             assert len(sd) == len(fs)
  136.             assert norm(sd.keys()) == norm(fs.keys())
  137.             assert fs.getvalue("nonexistent field", "default") == "default"
  138.             # test individual fields
  139.             for key in expect.keys():
  140.                 expect_val = expect[key]
  141.                 assert fcd.has_key(key)
  142.                 assert norm(fcd[key]) == norm(expect[key])
  143.                 assert fcd.get(key, "default") == fcd[key]
  144.                 assert fs.has_key(key)
  145.                 if len(expect_val) > 1:
  146.                     single_value = 0
  147.                 else:
  148.                     single_value = 1
  149.                 try:
  150.                     val = sd[key]
  151.                 except IndexError:
  152.                     assert not single_value
  153.                     assert fs.getvalue(key) == expect_val
  154.                 else:
  155.                     assert single_value
  156.                     assert val == expect_val[0]
  157.                     assert fs.getvalue(key) == expect_val[0]
  158.                 assert norm(sd.getlist(key)) == norm(expect_val)
  159.                 if single_value:
  160.                     assert norm(sd.values()) == \
  161.                            first_elts(norm(expect.values()))
  162.                     assert norm(sd.items()) == \
  163.                            first_second_elts(norm(expect.items()))
  164.  
  165.     # Test the weird FormContentDict classes
  166.     env = {'QUERY_STRING': "x=1&y=2.0&z=2-3.%2b0&1=1abc"}
  167.     expect = {'x': 1, 'y': 2.0, 'z': '2-3.+0', '1': '1abc'}
  168.     d = cgi.InterpFormContentDict(env)
  169.     for k, v in expect.items():
  170.         assert d[k] == v
  171.     for k, v in d.items():
  172.         assert expect[k] == v
  173.     assert norm(expect.values()) == norm(d.values())
  174.  
  175.     print "Testing log"
  176.     cgi.initlog()
  177.     cgi.log("Testing")
  178.     cgi.logfp = sys.stdout
  179.     cgi.initlog("%s", "Testing initlog 1")
  180.     cgi.log("%s", "Testing log 2")
  181.     if os.path.exists("/dev/null"):
  182.         cgi.logfp = None
  183.         cgi.logfile = "/dev/null"
  184.         cgi.initlog("%s", "Testing log 3")
  185.         cgi.log("Testing log 4")
  186.  
  187. main()
  188.