fix authentication module tests on py3

3 files changed, 39 insertions, 20 deletions

diff --git a/pyramid/authentication.py b/pyramid/authentication.py
index a84983447..e38c984b3 100644
--- a/pyramid/authentication.py
+++ b/pyramid/authentication.py
@@ -10,6 +10,7 @@ from zope.interface import implementer
 
 from pyramid.compat import long
 from pyramid.compat import text_type
+from pyramid.compat import binary_type
 from pyramid.compat import url_unquote
 from pyramid.compat import url_quote
 from pyramid.compat import bytes_
@@ -389,10 +390,10 @@ class AuthTktAuthenticationPolicy(CallbackAuthenticationPolicy):
         return self.cookie.forget(request)
 
 def b64encode(v):
-    return base64.b64encode(v).strip().replace('\n', '')
+    return base64.b64encode(bytes_(v)).strip().replace(b'\n', b'')
 
 def b64decode(v):
-    return base64.b64decode(v)
+    return base64.b64decode(bytes_(v))
 
 # this class licensed under the MIT license (stolen from Paste)
 class AuthTicket(object):
@@ -507,9 +508,9 @@ def calculate_digest(ip, timestamp, secret, userid, tokens, user_data):
     tokens = bytes_(tokens, 'utf-8')
     user_data = bytes_(user_data, 'utf-8')
     digest0 = md5(
-        encode_ip_timestamp(ip, timestamp) + secret + userid + '\0'
-        + tokens + '\0' + user_data).hexdigest()
-    digest = md5(digest0 + secret).hexdigest()
+        encode_ip_timestamp(ip, timestamp) + secret + userid + b'\0'
+        + tokens + b'\0' + user_data).hexdigest()
+    digest = md5(bytes_(digest0) + secret).hexdigest()
     return digest
 
 # this function licensed under the MIT license (stolen from Paste)
@@ -521,7 +522,7 @@ def encode_ip_timestamp(ip, timestamp):
           (t & 0xff00) >> 8,
           t & 0xff)
     ts_chars = ''.join(map(chr, ts))
-    return ip_chars + ts_chars
+    return bytes_(ip_chars + ts_chars)
 
 EXPIRE = object()
 
@@ -548,7 +549,7 @@ class AuthTktCookieHelper(object):
         int: ('int', str),
         long: ('int', str),
         text_type: ('b64unicode', lambda x: b64encode(utf_8_encode(x)[0])),
-        str: ('b64str', lambda x: b64encode(x)),
+        binary_type: ('b64str', lambda x: b64encode(x)),
         }
     
     def __init__(self, secret, cookie_name='auth_tkt', secure=False,
@@ -659,7 +660,7 @@ class AuthTktCookieHelper(object):
         if reissue and not hasattr(request, '_authtkt_reissued'):
             if ( (now - timestamp) > self.reissue_time ):
                 # work around https://github.com/Pylons/pyramid/issues#issue/108
-                tokens = filter(None, tokens)
+                tokens = list(filter(None, tokens))
                 headers = self.remember(request, userid, max_age=self.max_age,
                                         tokens=tokens)
                 def reissue_authtkt(request, response):
@@ -726,6 +727,11 @@ class AuthTktCookieHelper(object):
             user_data = 'userid_type:%s' % encoding
         
         for token in tokens:
+            if isinstance(token, text_type):
+                try:
+                    token.encode('ascii')
+                except UnicodeEncodeError:
+                    raise ValueError("Invalid token %r" % (token,))
             if not (isinstance(token, str) and VALID_TOKEN.match(token)):
                 raise ValueError("Invalid token %r" % (token,))
 
diff --git a/pyramid/compat.py b/pyramid/compat.py
index ecb661ce9..ed5e900ad 100644
--- a/pyramid/compat.py
+++ b/pyramid/compat.py
@@ -199,3 +199,8 @@ try: # pragma: no cover
 except ImportError: # pragma: no cover
     import ConfigParser
     configparser = ConfigParser
+
+try:
+    from Cookie import SimpleCookie
+except ImportError: # pragma: no cover
+    from http.cookies import SimpleCookie
diff --git a/pyramid/tests/test_authentication.py b/pyramid/tests/test_authentication.py
index 7f64af705..b612c5789 100644
--- a/pyramid/tests/test_authentication.py
+++ b/pyramid/tests/test_authentication.py
@@ -1,6 +1,7 @@
 import unittest
 from pyramid import testing
 from pyramid.compat import text_
+from pyramid.compat import bytes_
 
 class TestCallbackAuthenticationPolicyDebugging(unittest.TestCase):
     def setUp(self):
@@ -463,7 +464,7 @@ class TestAuthTktCookieHelper(unittest.TestCase):
         return cookie
 
     def _parseCookie(self, cookie):
-        from Cookie import SimpleCookie
+        from pyramid.compat import SimpleCookie
         cookies = SimpleCookie()
         cookies.load(cookie)
         return cookies.get('auth_tkt')
@@ -563,14 +564,15 @@ class TestAuthTktCookieHelper(unittest.TestCase):
         self.assertEqual(environ['AUTH_TYPE'],'cookie')
 
     def test_identify_good_cookie_b64str_useridtype(self):
+        from base64 import b64encode
         helper = self._makeOne('secret', include_ip=False)
-        helper.auth_tkt.userid = 'encoded'.encode('base64').strip()
+        helper.auth_tkt.userid = b64encode(b'encoded').strip()
         helper.auth_tkt.user_data = 'userid_type:b64str'
         request = self._makeRequest('ticket')
         result = helper.identify(request)
         self.assertEqual(len(result), 4)
         self.assertEqual(result['tokens'], ())
-        self.assertEqual(result['userid'], 'encoded')
+        self.assertEqual(result['userid'], b'encoded')
         self.assertEqual(result['userdata'], 'userid_type:b64str')
         self.assertEqual(result['timestamp'], 0)
         environ = request.environ
@@ -579,14 +581,15 @@ class TestAuthTktCookieHelper(unittest.TestCase):
         self.assertEqual(environ['AUTH_TYPE'],'cookie')
 
     def test_identify_good_cookie_b64unicode_useridtype(self):
+        from base64 import b64encode
         helper = self._makeOne('secret', include_ip=False)
-        helper.auth_tkt.userid = '\xc3\xa9ncoded'.encode('base64').strip()
+        helper.auth_tkt.userid = b64encode(b'\xc3\xa9ncoded').strip()
         helper.auth_tkt.user_data = 'userid_type:b64unicode'
         request = self._makeRequest('ticket')
         result = helper.identify(request)
         self.assertEqual(len(result), 4)
         self.assertEqual(result['tokens'], ())
-        self.assertEqual(result['userid'], text_('\xc3\xa9ncoded', 'utf-8'))
+        self.assertEqual(result['userid'], text_(b'\xc3\xa9ncoded', 'utf-8'))
         self.assertEqual(result['userdata'], 'userid_type:b64unicode')
         self.assertEqual(result['timestamp'], 0)
         environ = request.environ
@@ -823,14 +826,16 @@ class TestAuthTktCookieHelper(unittest.TestCase):
         self.assertTrue(result[1][1].endswith('; Path=/; Domain=example.com'))
         self.assertTrue(result[1][1].startswith('auth_tkt='))
         
-    def test_remember_string_userid(self):
+    def test_remember_binary_userid(self):
+        import base64
         helper = self._makeOne('secret')
         request = self._makeRequest()
-        result = helper.remember(request, 'userid')
+        result = helper.remember(request, b'userid')
         values = self._parseHeaders(result)
         self.assertEqual(len(result), 3)
         val = self._cookieValue(values[0])
-        self.assertEqual(val['userid'], 'userid'.encode('base64').strip())
+        self.assertEqual(val['userid'],
+                         bytes_(base64.b64encode(b'userid').strip()))
         self.assertEqual(val['user_data'], 'userid_type:b64str')
 
     def test_remember_int_userid(self):
@@ -844,6 +849,7 @@ class TestAuthTktCookieHelper(unittest.TestCase):
         self.assertEqual(val['user_data'], 'userid_type:int')
 
     def test_remember_long_userid(self):
+        from pyramid.compat import long
         helper = self._makeOne('secret')
         request = self._makeRequest()
         result = helper.remember(request, long(1))
@@ -854,15 +860,16 @@ class TestAuthTktCookieHelper(unittest.TestCase):
         self.assertEqual(val['user_data'], 'userid_type:int')
 
     def test_remember_unicode_userid(self):
+        import base64
         helper = self._makeOne('secret')
         request = self._makeRequest()
-        userid = text_('\xc2\xa9', 'utf-8')
+        userid = text_(b'\xc2\xa9', 'utf-8')
         result = helper.remember(request, userid)
         values = self._parseHeaders(result)
         self.assertEqual(len(result), 3)
         val = self._cookieValue(values[0])
         self.assertEqual(val['userid'],
-                         userid.encode('utf-8').encode('base64').strip())
+                         base64.b64encode(userid.encode('utf-8')))
         self.assertEqual(val['user_data'], 'userid_type:b64unicode')
 
     def test_remember_insane_userid(self):
@@ -900,11 +907,12 @@ class TestAuthTktCookieHelper(unittest.TestCase):
         self.assertEqual(result[2][0], 'Set-Cookie')
         self.assertTrue("'tokens': ('foo', 'bar')" in result[2][1])
 
-    def test_remember_non_string_token(self):
+    def test_remember_nonascii_token(self):
         helper = self._makeOne('secret')
         request = self._makeRequest()
+        la = text_(b'La Pe\xc3\xb1a', 'utf-8')
         self.assertRaises(ValueError, helper.remember, request, 'other',
-                          tokens=(text_('foo'),))
+                          tokens=(la,))
 
     def test_remember_invalid_token_format(self):
         helper = self._makeOne('secret')