[py3] Ported django.http according to PEP 3333.

Perfomed some style cleanup while I was in the area.

2 files changed, 69 insertions, 64 deletions

diff --git a/tests/regressiontests/httpwrappers/tests.py b/tests/regressiontests/httpwrappers/tests.py
index ad0ce4197e..332f25dfe9 100644
--- a/tests/regressiontests/httpwrappers/tests.py
+++ b/tests/regressiontests/httpwrappers/tests.py
@@ -9,16 +9,17 @@ from django.http import (QueryDict, HttpResponse, HttpResponseRedirect,
                          HttpResponsePermanentRedirect,
                          SimpleCookie, BadHeaderError,
                          parse_cookie)
+from django.utils import six
 from django.utils import unittest
 
 
 class QueryDictTests(unittest.TestCase):
     def test_missing_key(self):
-        q = QueryDict('')
+        q = QueryDict(str(''))
         self.assertRaises(KeyError, q.__getitem__, 'foo')
 
     def test_immutability(self):
-        q = QueryDict('')
+        q = QueryDict(str(''))
         self.assertRaises(AttributeError, q.__setitem__, 'something', 'bar')
         self.assertRaises(AttributeError, q.setlist, 'foo', ['bar'])
         self.assertRaises(AttributeError, q.appendlist, 'foo', ['bar'])
@@ -28,26 +29,26 @@ class QueryDictTests(unittest.TestCase):
         self.assertRaises(AttributeError, q.clear)
 
     def test_immutable_get_with_default(self):
-        q = QueryDict('')
+        q = QueryDict(str(''))
         self.assertEqual(q.get('foo', 'default'), 'default')
 
     def test_immutable_basic_operations(self):
-        q = QueryDict('')
+        q = QueryDict(str(''))
         self.assertEqual(q.getlist('foo'), [])
-        self.assertEqual(q.has_key('foo'), False)
+        if not six.PY3:
+            self.assertEqual(q.has_key('foo'), False)
         self.assertEqual('foo' in q, False)
-        self.assertEqual(q.items(), [])
-        self.assertEqual(q.lists(), [])
-        self.assertEqual(q.items(), [])
-        self.assertEqual(q.keys(), [])
-        self.assertEqual(q.values(), [])
+        self.assertEqual(list(six.iteritems(q)), [])
+        self.assertEqual(list(six.iterlists(q)), [])
+        self.assertEqual(list(six.iterkeys(q)), [])
+        self.assertEqual(list(six.itervalues(q)), [])
         self.assertEqual(len(q), 0)
         self.assertEqual(q.urlencode(), '')
 
     def test_single_key_value(self):
         """Test QueryDict with one key/value pair"""
 
-        q = QueryDict('foo=bar')
+        q = QueryDict(str('foo=bar'))
         self.assertEqual(q['foo'], 'bar')
         self.assertRaises(KeyError, q.__getitem__, 'bar')
         self.assertRaises(AttributeError, q.__setitem__, 'something', 'bar')
@@ -60,15 +61,17 @@ class QueryDictTests(unittest.TestCase):
         self.assertRaises(AttributeError, q.setlist, 'foo', ['bar'])
         self.assertRaises(AttributeError, q.appendlist, 'foo', ['bar'])
 
-        self.assertTrue(q.has_key('foo'))
+        if not six.PY3:
+            self.assertTrue(q.has_key('foo'))
         self.assertTrue('foo' in q)
-        self.assertFalse(q.has_key('bar'))
+        if not six.PY3:
+            self.assertFalse(q.has_key('bar'))
         self.assertFalse('bar' in q)
 
-        self.assertEqual(q.items(), [('foo', 'bar')])
-        self.assertEqual(q.lists(), [('foo', ['bar'])])
-        self.assertEqual(q.keys(), ['foo'])
-        self.assertEqual(q.values(), ['bar'])
+        self.assertEqual(list(six.iteritems(q)), [('foo', 'bar')])
+        self.assertEqual(list(six.iterlists(q)), [('foo', ['bar'])])
+        self.assertEqual(list(six.iterkeys(q)), ['foo'])
+        self.assertEqual(list(six.itervalues(q)), ['bar'])
         self.assertEqual(len(q), 1)
 
         self.assertRaises(AttributeError, q.update, {'foo': 'bar'})
@@ -80,30 +83,30 @@ class QueryDictTests(unittest.TestCase):
         self.assertEqual(q.urlencode(), 'foo=bar')
 
     def test_urlencode(self):
-        q = QueryDict('', mutable=True)
+        q = QueryDict(str(''), mutable=True)
         q['next'] = '/a&b/'
         self.assertEqual(q.urlencode(), 'next=%2Fa%26b%2F')
         self.assertEqual(q.urlencode(safe='/'), 'next=/a%26b/')
-        q = QueryDict('', mutable=True)
+        q = QueryDict(str(''), mutable=True)
         q['next'] = '/t\xebst&key/'
         self.assertEqual(q.urlencode(), 'next=%2Ft%C3%ABst%26key%2F')
         self.assertEqual(q.urlencode(safe='/'), 'next=/t%C3%ABst%26key/')
 
     def test_mutable_copy(self):
         """A copy of a QueryDict is mutable."""
-        q = QueryDict('').copy()
+        q = QueryDict(str('')).copy()
         self.assertRaises(KeyError, q.__getitem__, "foo")
         q['name'] = 'john'
         self.assertEqual(q['name'], 'john')
 
     def test_mutable_delete(self):
-        q = QueryDict('').copy()
+        q = QueryDict(str('')).copy()
         q['name'] = 'john'
         del q['name']
         self.assertFalse('name' in q)
 
     def test_basic_mutable_operations(self):
-        q = QueryDict('').copy()
+        q = QueryDict(str('')).copy()
         q['name'] = 'john'
         self.assertEqual(q.get('foo', 'default'), 'default')
         self.assertEqual(q.get('name', 'default'), 'john')
@@ -117,13 +120,14 @@ class QueryDictTests(unittest.TestCase):
         q.appendlist('foo', 'another')
         self.assertEqual(q.getlist('foo'), ['bar', 'baz', 'another'])
         self.assertEqual(q['foo'], 'another')
-        self.assertTrue(q.has_key('foo'))
+        if not six.PY3:
+            self.assertTrue(q.has_key('foo'))
         self.assertTrue('foo' in q)
 
-        self.assertEqual(q.items(),  [('foo', 'another'), ('name', 'john')])
-        self.assertEqual(q.lists(), [('foo', ['bar', 'baz', 'another']), ('name', ['john'])])
-        self.assertEqual(q.keys(), ['foo', 'name'])
-        self.assertEqual(q.values(), ['another', 'john'])
+        self.assertEqual(list(six.iteritems(q)),  [('foo', 'another'), ('name', 'john')])
+        self.assertEqual(list(six.iterlists(q)), [('foo', ['bar', 'baz', 'another']), ('name', ['john'])])
+        self.assertEqual(list(six.iterkeys(q)), ['foo', 'name'])
+        self.assertEqual(list(six.itervalues(q)), ['another', 'john'])
         self.assertEqual(len(q), 2)
 
         q.update({'foo': 'hello'})
@@ -144,7 +148,7 @@ class QueryDictTests(unittest.TestCase):
     def test_multiple_keys(self):
         """Test QueryDict with two key/value pairs with same keys."""
 
-        q = QueryDict('vote=yes&vote=no')
+        q = QueryDict(str('vote=yes&vote=no'))
 
         self.assertEqual(q['vote'], 'no')
         self.assertRaises(AttributeError, q.__setitem__, 'something', 'bar')
@@ -158,14 +162,16 @@ class QueryDictTests(unittest.TestCase):
         self.assertRaises(AttributeError, q.setlist, 'foo', ['bar', 'baz'])
         self.assertRaises(AttributeError, q.appendlist, 'foo', ['bar'])
 
-        self.assertEqual(q.has_key('vote'), True)
+        if not six.PY3:
+            self.assertEqual(q.has_key('vote'), True)
         self.assertEqual('vote' in q, True)
-        self.assertEqual(q.has_key('foo'), False)
+        if not six.PY3:
+            self.assertEqual(q.has_key('foo'), False)
         self.assertEqual('foo' in q, False)
-        self.assertEqual(q.items(), [('vote', 'no')])
-        self.assertEqual(q.lists(), [('vote', ['yes', 'no'])])
-        self.assertEqual(q.keys(), ['vote'])
-        self.assertEqual(q.values(), ['no'])
+        self.assertEqual(list(six.iteritems(q)), [('vote', 'no')])
+        self.assertEqual(list(six.iterlists(q)), [('vote', ['yes', 'no'])])
+        self.assertEqual(list(six.iterkeys(q)), ['vote'])
+        self.assertEqual(list(six.itervalues(q)), ['no'])
         self.assertEqual(len(q), 1)
 
         self.assertRaises(AttributeError, q.update, {'foo': 'bar'})
@@ -175,45 +181,49 @@ class QueryDictTests(unittest.TestCase):
         self.assertRaises(AttributeError, q.setdefault, 'foo', 'bar')
         self.assertRaises(AttributeError, q.__delitem__, 'vote')
 
-    def test_invalid_input_encoding(self):
-        """
-        QueryDicts must be able to handle invalid input encoding (in this
-        case, bad UTF-8 encoding).
-        """
-        q = QueryDict(b'foo=bar&foo=\xff')
-        self.assertEqual(q['foo'], '\ufffd')
-        self.assertEqual(q.getlist('foo'), ['bar', '\ufffd'])
+    if not six.PY3:
+        def test_invalid_input_encoding(self):
+            """
+            QueryDicts must be able to handle invalid input encoding (in this
+            case, bad UTF-8 encoding).
+
+            This test doesn't apply under Python 3 because the URL is a string
+            and not a bytestring.
+            """
+            q = QueryDict(str(b'foo=bar&foo=\xff'))
+            self.assertEqual(q['foo'], '\ufffd')
+            self.assertEqual(q.getlist('foo'), ['bar', '\ufffd'])
 
     def test_pickle(self):
-        q = QueryDict('')
+        q = QueryDict(str(''))
         q1 = pickle.loads(pickle.dumps(q, 2))
         self.assertEqual(q == q1, True)
-        q = QueryDict('a=b&c=d')
+        q = QueryDict(str('a=b&c=d'))
         q1 = pickle.loads(pickle.dumps(q, 2))
         self.assertEqual(q == q1, True)
-        q = QueryDict('a=b&c=d&a=1')
+        q = QueryDict(str('a=b&c=d&a=1'))
         q1 = pickle.loads(pickle.dumps(q, 2))
         self.assertEqual(q == q1, True)
 
     def test_update_from_querydict(self):
         """Regression test for #8278: QueryDict.update(QueryDict)"""
-        x = QueryDict("a=1&a=2", mutable=True)
-        y = QueryDict("a=3&a=4")
+        x = QueryDict(str("a=1&a=2"), mutable=True)
+        y = QueryDict(str("a=3&a=4"))
         x.update(y)
         self.assertEqual(x.getlist('a'), ['1', '2', '3', '4'])
 
     def test_non_default_encoding(self):
         """#13572 - QueryDict with a non-default encoding"""
-        q = QueryDict(b'sbb=one', encoding='rot_13')
-        self.assertEqual(q.encoding , 'rot_13' )
-        self.assertEqual(q.items() , [('foo', 'bar')] )
-        self.assertEqual(q.urlencode() , 'sbb=one' )
+        q = QueryDict(str('cur=%A4'), encoding='iso-8859-15')
+        self.assertEqual(q.encoding, 'iso-8859-15')
+        self.assertEqual(list(six.iteritems(q)), [('cur', '€')])
+        self.assertEqual(q.urlencode(), 'cur=%A4')
         q = q.copy()
-        self.assertEqual(q.encoding , 'rot_13' )
-        self.assertEqual(q.items() , [('foo', 'bar')] )
-        self.assertEqual(q.urlencode() , 'sbb=one' )
-        self.assertEqual(copy.copy(q).encoding , 'rot_13' )
-        self.assertEqual(copy.deepcopy(q).encoding , 'rot_13')
+        self.assertEqual(q.encoding, 'iso-8859-15')
+        self.assertEqual(list(six.iteritems(q)), [('cur', '€')])
+        self.assertEqual(q.urlencode(), 'cur=%A4')
+        self.assertEqual(copy.copy(q).encoding, 'iso-8859-15')
+        self.assertEqual(copy.deepcopy(q).encoding, 'iso-8859-15')
 
 class HttpResponseTests(unittest.TestCase):
     def test_unicode_headers(self):
@@ -283,13 +293,8 @@ class HttpResponseTests(unittest.TestCase):
         #test retrieval explicitly using iter and odd inputs
         r = HttpResponse()
         r.content = ['1', '2', 3, '\u079e']
-        result = []
         my_iter = r.__iter__()
-        while True:
-            try:
-                result.append(next(my_iter))
-            except StopIteration:
-                break
+        result = list(my_iter)
         #'\xde\x9e' == unichr(1950).encode('utf-8')
         self.assertEqual(result, ['1', '2', '3', b'\xde\x9e'])
         self.assertEqual(r.content, b'123\xde\x9e')
diff --git a/tests/regressiontests/wsgi/tests.py b/tests/regressiontests/wsgi/tests.py
index a482a5c1eb..5a40bd88e2 100644
--- a/tests/regressiontests/wsgi/tests.py
+++ b/tests/regressiontests/wsgi/tests.py
@@ -40,8 +40,8 @@ class WSGITest(TestCase):
             response_data["headers"],
             [('Content-Type', 'text/html; charset=utf-8')])
         self.assertEqual(
-            six.text_type(response),
-            "Content-Type: text/html; charset=utf-8\n\nHello World!")
+            bytes(response),
+            b"Content-Type: text/html; charset=utf-8\r\n\r\nHello World!")
 
 
 class GetInternalWSGIApplicationTest(unittest.TestCase):