Python 3: call functions from memcache_crypt.py with bytes as input

These functions expect bytes as input, but in Python 3 they were given text
strings.

Change-Id: I39fa15b8d5d56dc536e0bd71a50cf27da3d03046

1 files changed, 23 insertions, 12 deletions

diff --git a/keystoneclient/tests/test_memcache_crypt.py b/keystoneclient/tests/test_memcache_crypt.py
index 500a509..159898b 100644
--- a/keystoneclient/tests/test_memcache_crypt.py
+++ b/keystoneclient/tests/test_memcache_crypt.py
@@ -12,6 +12,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import six
 import testtools
 
 from keystoneclient.middleware import memcache_crypt
@@ -19,7 +20,7 @@ from keystoneclient.middleware import memcache_crypt
 
 class MemcacheCryptPositiveTests(testtools.TestCase):
     def _setup_keys(self, strategy):
-        return memcache_crypt.derive_keys('token', 'secret', strategy)
+        return memcache_crypt.derive_keys(b'token', b'secret', strategy)
 
     def test_constant_time_compare(self):
         # make sure it works as a compare, the "constant time" aspect
@@ -32,8 +33,18 @@ class MemcacheCryptPositiveTests(testtools.TestCase):
         self.assertFalse(ctc('abc', 'abc\x00'))
         self.assertFalse(ctc('', 'abc'))
 
+        # For Python 3, we want to test these functions with both str and bytes
+        # as input.
+        if six.PY3:
+            self.assertTrue(ctc(b'abcd', b'abcd'))
+            self.assertTrue(ctc(b'', b''))
+            self.assertFalse(ctc(b'abcd', b'efgh'))
+            self.assertFalse(ctc(b'abc', b'abcd'))
+            self.assertFalse(ctc(b'abc', b'abc\x00'))
+            self.assertFalse(ctc(b'', b'abc'))
+
     def test_derive_keys(self):
-        keys = memcache_crypt.derive_keys('token', 'secret', 'strategy')
+        keys = self._setup_keys(b'strategy')
         self.assertEqual(len(keys['ENCRYPTION']),
                          len(keys['CACHE_KEY']))
         self.assertEqual(len(keys['CACHE_KEY']),
@@ -43,20 +54,20 @@ class MemcacheCryptPositiveTests(testtools.TestCase):
         self.assertIn('strategy', keys.keys())
 
     def test_key_strategy_diff(self):
-        k1 = self._setup_keys('MAC')
-        k2 = self._setup_keys('ENCRYPT')
+        k1 = self._setup_keys(b'MAC')
+        k2 = self._setup_keys(b'ENCRYPT')
         self.assertNotEqual(k1, k2)
 
     def test_sign_data(self):
-        keys = self._setup_keys('MAC')
-        sig = memcache_crypt.sign_data(keys['MAC'], 'data')
+        keys = self._setup_keys(b'MAC')
+        sig = memcache_crypt.sign_data(keys['MAC'], b'data')
         self.assertEqual(len(sig), memcache_crypt.DIGEST_LENGTH_B64)
 
     def test_encryption(self):
-        keys = self._setup_keys('ENCRYPT')
+        keys = self._setup_keys(b'ENCRYPT')
         # what you put in is what you get out
-        for data in ['data', '1234567890123456', '\x00\xFF' * 13
-                     ] + [chr(x % 256) * x for x in range(768)]:
+        for data in [b'data', b'1234567890123456', b'\x00\xFF' * 13
+                     ] + [six.int2byte(x % 256) * x for x in range(768)]:
             crypt = memcache_crypt.encrypt_data(keys['ENCRYPTION'], data)
             decrypt = memcache_crypt.decrypt_data(keys['ENCRYPTION'], crypt)
             self.assertEqual(data, decrypt)
@@ -65,12 +76,12 @@ class MemcacheCryptPositiveTests(testtools.TestCase):
                               keys['ENCRYPTION'], crypt[:-1])
 
     def test_protect_wrappers(self):
-        data = 'My Pretty Little Data'
-        for strategy in ['MAC', 'ENCRYPT']:
+        data = b'My Pretty Little Data'
+        for strategy in [b'MAC', b'ENCRYPT']:
             keys = self._setup_keys(strategy)
             protected = memcache_crypt.protect_data(keys, data)
             self.assertNotEqual(protected, data)
-            if strategy == 'ENCRYPT':
+            if strategy == b'ENCRYPT':
                 self.assertNotIn(data, protected)
             unprotected = memcache_crypt.unprotect_data(keys, protected)
             self.assertEqual(data, unprotected)