Changeset 391 for python/trunk/Lib/test/test_cgi.py

Timestamp:

Mar 19, 2014, 11:31:01 PM (11 years ago)

Author:

dmik

Message:

python: Merge vendor 2.7.6 to trunk.

Location:

python/trunk

Files:

• . (modified) (1 prop)
• Lib/test/test_cgi.py (modified) (12 diffs)

python/trunk/Lib/test/test_cgi.py

@@ -1 @@
-from test.test_support import run_unittest
+from test.test_support import run_unittest, check_warnings
 import cgi
 import os
@@ -5 +5 @@
 import tempfile
 import unittest
-from StringIO import StringIO
 
 class HackedSysModule:
@@ -103 +102 @@
     ]
 
-def norm(list):
-    if type(list) == type([]):
-        list.sort()
-    return list
-
 def first_elts(list):
     return map(lambda x:x[0], list)
@@ -121 +115 @@
     result = {}
     for k, v in dict(form).items():
-        result[k] = type(v) is list and form.getlist(k) or v.value
+        result[k] = isinstance(v, list) and form.getlist(k) or v.value
 
     return result
 
 class CgiTests(unittest.TestCase):
+
+    def test_escape(self):
+        self.assertEqual("test & string", cgi.escape("test & string"))
+        self.assertEqual("&lt;test string&gt;", cgi.escape("<test string>"))
+        self.assertEqual("&quot;test string&quot;", cgi.escape('"test string"', True))
 
     def test_strict(self):
@@ -139 +138 @@
             sd = cgi.SvFormContentDict(env)
             fs = cgi.FieldStorage(environ=env)
-            if type(expect) == type({}):
+            if isinstance(expect, dict):
                 # test dict interface
                 self.assertEqual(len(expect), len(fcd))
-                self.assertEqual(norm(expect.keys()), norm(fcd.keys()))
-                self.assertEqual(norm(expect.values()), norm(fcd.values()))
-                self.assertEqual(norm(expect.items()), norm(fcd.items()))
+                self.assertItemsEqual(expect.keys(), fcd.keys())
+                self.assertItemsEqual(expect.values(), fcd.values())
+                self.assertItemsEqual(expect.items(), fcd.items())
                 self.assertEqual(fcd.get("nonexistent field", "default"), "default")
                 self.assertEqual(len(sd), len(fs))
-                self.assertEqual(norm(sd.keys()), norm(fs.keys()))
+                self.assertItemsEqual(sd.keys(), fs.keys())
                 self.assertEqual(fs.getvalue("nonexistent field", "default"), "default")
                 # test individual fields
                 for key in expect.keys():
                     expect_val = expect[key]
-                    self.assert_(fcd.has_key(key))
-                    self.assertEqual(norm(fcd[key]), norm(expect[key]))
+                    self.assertTrue(fcd.has_key(key))
+                    self.assertItemsEqual(fcd[key], expect[key])
                     self.assertEqual(fcd.get(key, "default"), fcd[key])
-                    self.assert_(fs.has_key(key))
+                    self.assertTrue(fs.has_key(key))
                     if len(expect_val) > 1:
                         single_value = 0
@@ -163 +162 @@
                         val = sd[key]
                     except IndexError:
-                        self.failIf(single_value)
+                        self.assertFalse(single_value)
                         self.assertEqual(fs.getvalue(key), expect_val)
                     else:
-                        self.assert_(single_value)
+                        self.assertTrue(single_value)
                         self.assertEqual(val, expect_val[0])
                         self.assertEqual(fs.getvalue(key), expect_val[0])
-                    self.assertEqual(norm(sd.getlist(key)), norm(expect_val))
+                    self.assertItemsEqual(sd.getlist(key), expect_val)
                     if single_value:
-                        self.assertEqual(norm(sd.values()),
-                               first_elts(norm(expect.values())))
-                        self.assertEqual(norm(sd.items()),
-                               first_second_elts(norm(expect.items())))
+                        self.assertItemsEqual(sd.values(),
+                                                first_elts(expect.values()))
+                        self.assertItemsEqual(sd.items(),
+                                                first_second_elts(expect.items()))
 
     def test_weird_formcontentdict(self):
@@ -185 +184 @@
         for k, v in d.items():
             self.assertEqual(expect[k], v)
-        self.assertEqual(norm(expect.values()), norm(d.values()))
+        self.assertItemsEqual(expect.values(), d.values())
 
     def test_log(self):
@@ -232 +231 @@
         # (by read_binary); if we are chunking properly, it will be called 5 times
         # as long as the chunksize is 1 << 16.
-        self.assert_(f.numcalls > 2)
+        self.assertTrue(f.numcalls > 2)
 
     def test_fieldstorage_multipart(self):
@@ -258 +257 @@
 """
         fs = cgi.FieldStorage(fp=StringIO(postdata), environ=env)
-        self.assertEquals(len(fs.list), 4)
+        self.assertEqual(len(fs.list), 4)
         expect = [{'name':'id', 'filename':None, 'value':'1234'},
                   {'name':'title', 'filename':None, 'value':''},
@@ -266 +265 @@
             for k, exp in expect[x].items():
                 got = getattr(fs.list[x], k)
-                self.assertEquals(got, exp)
+                self.assertEqual(got, exp)
+
+    def test_fieldstorage_multipart_maxline(self):
+        # Issue #18167
+        maxline = 1 << 16
+        self.maxDiff = None
+        def check(content):
+            data = """
+---123
+Content-Disposition: form-data; name="upload"; filename="fake.txt"
+Content-Type: text/plain
+
+%s
+---123--
+""".replace('\n', '\r\n') % content
+            environ = {
+                'CONTENT_LENGTH':   str(len(data)),
+                'CONTENT_TYPE':     'multipart/form-data; boundary=-123',
+                'REQUEST_METHOD':   'POST',
+            }
+            self.assertEqual(gen_result(data, environ), {'upload': content})
+        check('x' * (maxline - 1))
+        check('x' * (maxline - 1) + '\r')
+        check('x' * (maxline - 1) + '\r' + 'y' * (maxline - 1))
 
     _qs_result = {
@@ -347 +369 @@
     def test_deprecated_parse_qs(self):
         # this func is moved to urlparse, this is just a sanity check
-        self.assertEqual({'a': ['A1'], 'B': ['B3'], 'b': ['B2']},
-                         cgi.parse_qs('a=A1&b=B2&B=B3'))
+        with check_warnings(('cgi.parse_qs is deprecated, use urlparse.'
+                             'parse_qs instead', PendingDeprecationWarning)):
+            self.assertEqual({'a': ['A1'], 'B': ['B3'], 'b': ['B2']},
+                             cgi.parse_qs('a=A1&b=B2&B=B3'))
 
     def test_deprecated_parse_qsl(self):
         # this func is moved to urlparse, this is just a sanity check
-        self.assertEqual([('a', 'A1'), ('b', 'B2'), ('B', 'B3')],
-                         cgi.parse_qsl('a=A1&b=B2&B=B3'))
+        with check_warnings(('cgi.parse_qsl is deprecated, use urlparse.'
+                             'parse_qsl instead', PendingDeprecationWarning)):
+            self.assertEqual([('a', 'A1'), ('b', 'B2'), ('B', 'B3')],
+                             cgi.parse_qsl('a=A1&b=B2&B=B3'))
 
     def test_parse_header(self):
@@ -380 +406 @@
             cgi.parse_header('attachment; filename="strange;name";size=123;'),
             ("attachment", {"filename": "strange;name", "size": "123"}))
+        self.assertEqual(
+            cgi.parse_header('form-data; name="files"; filename="fo\\"o;bar"'),
+            ("form-data", {"name": "files", "filename": 'fo"o;bar'}))