test the non-multipart sections of the cgi module

1 files changed, 172 insertions, 0 deletions

diff --git a/Lib/test/test_cgi.py b/Lib/test/test_cgi.py
new file mode 100644
index 0000000..61c3da7
--- /dev/null
+++ b/Lib/test/test_cgi.py
@@ -0,0 +1,172 @@
+import cgi
+import os
+import sys
+
+class HackedSysModule:
+    # The regression test will have real values in sys.argv, which
+    # will completely confuse the test of the cgi module 
+    argv = []
+    stdin = sys.stdin
+
+cgi.sys = HackedSysModule()
+
+try:
+    from cStringIO import StringIO
+except ImportError:
+    from StringIO import StringIO
+
+class ComparableException:
+    def __init__(self, err):
+        self.err = err
+
+    def __str__(self):
+        return str(self.err)
+
+    def __cmp__(self, anExc):
+        if not isinstance(anExc, Exception):
+            return -1
+        x = cmp(self.err.__class__, anExc.__class__)
+        if x != 0:
+            return x
+        return cmp(self.err.args, anExc.args)
+
+    def __getattr__(self, attr):
+        return getattr(self, self.err)
+
+def do_test(buf, method):
+    env = {}
+    if method == "GET":
+        fp = None
+        env['REQUEST_METHOD'] = 'GET'
+        env['QUERY_STRING'] = buf
+    elif method == "POST":
+        fp = StringIO(buf)
+        env['REQUEST_METHOD'] = 'POST'
+        env['CONTENT_TYPE'] = 'application/x-www-form-urlencoded'
+        env['CONTENT_LENGTH'] = str(len(buf))
+    else:
+        raise ValueError, "unknown method: %s" % method
+    try:
+        return cgi.parse(fp, env, strict_parsing=1)
+    except StandardError, err:
+        return ComparableException(err)
+
+# A list of test cases.  Each test case is a a two-tuple that contains
+# a string with the query and a dictionary with the expected result.
+    
+parse_test_cases = [
+    ("", ValueError("bad query field: ''")),
+    ("&", ValueError("bad query field: ''")),
+    ("&&", ValueError("bad query field: ''")),
+    # Should the next few really be valid?
+    ("=", {}),
+    ("=&=", {}),
+    # This rest seem to make sense
+    ("=a", {'': ['a']}),
+    ("&=a", ValueError("bad query field: ''")),
+    ("=a&", ValueError("bad query field: ''")),
+    ("=&a", ValueError("bad query field: 'a'")),
+    ("b=a", {'b': ['a']}),
+    ("b+=a", {'b ': ['a']}),
+    ("a=b=a", {'a': ['b=a']}),
+    ("a=+b=a", {'a': [' b=a']}),
+    ("&b=a", ValueError("bad query field: ''")),
+    ("b&=a", ValueError("bad query field: 'b'")),
+    ("a=a+b&b=b+c", {'a': ['a b'], 'b': ['b c']}),
+    ("a=a+b&a=b+a", {'a': ['a b', 'b a']}),
+    ("x=1&y=2.0&z=2-3.%2b0", {'x': ['1'], 'y': ['2.0'], 'z': ['2-3.+0']}),
+    ("Hbc5161168c542333633315dee1182227:key_store_seqid=400006&cuyer=r&view=bustomer&order_id=0bb2e248638833d48cb7fed300000f1b&expire=964546263&lobale=en-US&kid=130003.300038&ss=env",
+     {'Hbc5161168c542333633315dee1182227:key_store_seqid': ['400006'],
+      'cuyer': ['r'],
+      'expire': ['964546263'],
+      'kid': ['130003.300038'],
+      'lobale': ['en-US'],
+      'order_id': ['0bb2e248638833d48cb7fed300000f1b'],
+      'ss': ['env'],
+      'view': ['bustomer'],
+      }),
+    
+    ("group_id=5470&set=custom&_assigned_to=31392&_status=1&_category=100&SUBMIT=Browse",
+     {'SUBMIT': ['Browse'],
+      '_assigned_to': ['31392'],
+      '_category': ['100'],
+      '_status': ['1'],
+      'group_id': ['5470'],
+      'set': ['custom'],
+      })
+    ]
+
+def norm(list):
+    if type(list) == type([]):
+        list.sort()
+    return list
+
+def first_elts(list):
+    return map(lambda x:x[0], list)
+
+def first_second_elts(list):
+    return map(lambda p:(p[0], p[1][0]), list)
+
+def main():
+    for orig, expect in parse_test_cases:
+        # Test basic parsing
+        print repr(orig)
+        d = do_test(orig, "GET")
+        assert d == expect, "Error parsing %s" % repr(orig)
+        d = do_test(orig, "POST")
+        assert d == expect, "Error parsing %s" % repr(orig)
+
+        d = {'QUERY_STRING': orig}
+        fcd = cgi.FormContentDict(d)
+        sd = cgi.SvFormContentDict(d)
+        if type(expect) == type({}):
+            # test dict interface
+            assert len(expect) == len(fcd)
+            assert norm(expect.keys()) == norm(fcd.keys())
+            assert norm(expect.values()) == norm(fcd.values())
+            assert norm(expect.items()) == norm(fcd.items())
+            for key in expect.keys():
+                expect_val = expect[key]
+                assert fcd.has_key(key)
+                assert norm(fcd[key]) == norm(expect[key])
+                if len(expect_val) > 1:
+                    single_value = 0
+                else:
+                    single_value = 1
+                try:
+                    val = sd[key]
+                except IndexError:
+                    assert not single_value
+                else:
+                    assert single_value
+                    assert val == expect_val[0]
+                assert norm(sd.getlist(key)) == norm(expect_val)
+                if single_value:
+                    assert norm(sd.values()) == \
+                           first_elts(norm(expect.values()))
+                    assert norm(sd.items()) == \
+                           first_second_elts(norm(expect.items()))
+
+    # Test the weird FormContentDict classes
+    env = {'QUERY_STRING': "x=1&y=2.0&z=2-3.%2b0&1=1abc"}
+    expect = {'x': 1, 'y': 2.0, 'z': '2-3.+0', '1': '1abc'}
+    d = cgi.InterpFormContentDict(env)
+    for k, v in expect.items():
+        assert d[k] == v
+    for k, v in d.items():
+        assert expect[k] == v
+    assert norm(expect.values()) == norm(d.values())
+
+    print "Testing log"
+    cgi.initlog()
+    cgi.log("Testing")
+    cgi.logfp = sys.stdout
+    cgi.initlog("%s", "Testing initlog 1")
+    cgi.log("%s", "Testing log 2")
+    if os.path.exists("/dev/null"):
+        cgi.logfp = None
+        cgi.logfile = "/dev/null"
+        cgi.initlog("%s", "Testing log 3")
+        cgi.log("Testing log 4")
+
+main()