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