Merge pull request #106 from alex/duplication-reduction

Remove much of the duplication found in the tests

5 files changed, 145 insertions, 219 deletions

diff --git a/tests/primitives/test_cryptrec.py b/tests/primitives/test_cryptrec.py
index c30bda48..edf97652 100644
--- a/tests/primitives/test_cryptrec.py
+++ b/tests/primitives/test_cryptrec.py
@@ -12,51 +12,31 @@
 # limitations under the License.
 
 """
-Test using the CRYPTREC (Camellia) Test Vectors
+Tests using the CRYPTREC (Camellia) Test Vectors
 """
 
 from __future__ import absolute_import, division, print_function
 
 import binascii
-import itertools
 import os
 
-import pytest
-
-from cryptography.primitives.block import BlockCipher, ciphers, modes
+from cryptography.primitives.block import ciphers, modes
 
+from .utils import generate_encrypt_test
 from ..utils import load_cryptrec_vectors_from_file
 
 
-def parameterize_encrypt_test(cipher, vector_type, params, fnames):
-    return pytest.mark.parametrize(params,
-        list(itertools.chain.from_iterable(
-            load_cryptrec_vectors_from_file(
-                os.path.join(cipher, vector_type, fname),
-            )
-            for fname in fnames
-        ))
-    )
-
-
 class TestCamelliaECB(object):
-    @parameterize_encrypt_test(
-        "Camellia", "NTT",
-        ("key", "plaintext", "ciphertext"),
+    test_NTT = generate_encrypt_test(
+        load_cryptrec_vectors_from_file,
+        os.path.join("Camellia", "NTT"),
         [
             "camellia-128-ecb.txt",
             "camellia-192-ecb.txt",
-            "camellia-256-ecb.txt",
-        ]
+            "camellia-256-ecb.txt"
+        ],
+        lambda key: ciphers.Camellia(binascii.unhexlify((key))),
+        lambda key: modes.ECB(),
+        only_if=lambda api: api.supports_cipher("camellia-128-ecb"),
+        skip_message="Does not support Camellia ECB",
     )
-    def test_NTT(self, key, plaintext, ciphertext, api):
-        if not api.supports_cipher("camellia-128-ecb"):
-            pytest.skip("Does not support Camellia ECB")  # pragma: no cover
-        cipher = BlockCipher(
-            ciphers.Camellia(binascii.unhexlify(key)),
-            modes.ECB(),
-            api
-        )
-        actual_ciphertext = cipher.encrypt(binascii.unhexlify(plaintext))
-        actual_ciphertext += cipher.finalize()
-        assert binascii.hexlify(actual_ciphertext).upper() == ciphertext
diff --git a/tests/primitives/test_nist.py b/tests/primitives/test_nist.py
index 261bbd1d..d97b207b 100644
--- a/tests/primitives/test_nist.py
+++ b/tests/primitives/test_nist.py
@@ -18,33 +18,18 @@ Test using the NIST Test Vectors
 from __future__ import absolute_import, division, print_function
 
 import binascii
-import itertools
 import os
 
-import pytest
-
-from cryptography.primitives.block import BlockCipher, ciphers, modes
+from cryptography.primitives.block import ciphers, modes
 
+from .utils import generate_encrypt_test
 from ..utils import load_nist_vectors_from_file
 
 
-def parameterize_encrypt_test(cipher, vector_type, params, fnames):
-    return pytest.mark.parametrize(params,
-        list(itertools.chain.from_iterable(
-            load_nist_vectors_from_file(
-                os.path.join(cipher, vector_type, fname),
-                "ENCRYPT",
-                params
-            )
-            for fname in fnames
-        ))
-    )
-
-
 class TestAES_CBC(object):
-    @parameterize_encrypt_test(
-        "AES", "KAT",
-        ("key", "iv", "plaintext", "ciphertext"),
+    test_KAT = generate_encrypt_test(
+        lambda path: load_nist_vectors_from_file(path, "ENCRYPT"),
+        os.path.join("AES", "KAT"),
         [
             "CBCGFSbox128.rsp",
             "CBCGFSbox192.rsp",
@@ -58,42 +43,28 @@ class TestAES_CBC(object):
             "CBCVarTxt128.rsp",
             "CBCVarTxt192.rsp",
             "CBCVarTxt256.rsp",
-        ]
+        ],
+        lambda key, iv: ciphers.AES(binascii.unhexlify(key)),
+        lambda key, iv: modes.CBC(binascii.unhexlify(iv)),
     )
-    def test_KAT(self, key, iv, plaintext, ciphertext, api):
-        cipher = BlockCipher(
-            ciphers.AES(binascii.unhexlify(key)),
-            modes.CBC(binascii.unhexlify(iv)),
-            api
-        )
-        actual_ciphertext = cipher.encrypt(binascii.unhexlify(plaintext))
-        actual_ciphertext += cipher.finalize()
-        assert binascii.hexlify(actual_ciphertext) == ciphertext
-
-    @parameterize_encrypt_test(
-        "AES", "MMT",
-        ("key", "iv", "plaintext", "ciphertext"),
+
+    test_MMT = generate_encrypt_test(
+        lambda path: load_nist_vectors_from_file(path, "ENCRYPT"),
+        os.path.join("AES", "MMT"),
         [
             "CBCMMT128.rsp",
             "CBCMMT192.rsp",
             "CBCMMT256.rsp",
-        ]
+        ],
+        lambda key, iv: ciphers.AES(binascii.unhexlify(key)),
+        lambda key, iv: modes.CBC(binascii.unhexlify(iv)),
     )
-    def test_MMT(self, key, iv, plaintext, ciphertext, api):
-        cipher = BlockCipher(
-            ciphers.AES(binascii.unhexlify(key)),
-            modes.CBC(binascii.unhexlify(iv)),
-            api
-        )
-        actual_ciphertext = cipher.encrypt(binascii.unhexlify(plaintext))
-        actual_ciphertext += cipher.finalize()
-        assert binascii.hexlify(actual_ciphertext) == ciphertext
 
 
 class TestAES_ECB(object):
-    @parameterize_encrypt_test(
-        "AES", "KAT",
-        ("key", "plaintext", "ciphertext"),
+    test_KAT = generate_encrypt_test(
+        lambda path: load_nist_vectors_from_file(path, "ENCRYPT"),
+        os.path.join("AES", "KAT"),
         [
             "ECBGFSbox128.rsp",
             "ECBGFSbox192.rsp",
@@ -107,42 +78,28 @@ class TestAES_ECB(object):
             "ECBVarTxt128.rsp",
             "ECBVarTxt192.rsp",
             "ECBVarTxt256.rsp",
-        ]
+        ],
+        lambda key: ciphers.AES(binascii.unhexlify(key)),
+        lambda key: modes.ECB(),
     )
-    def test_KAT(self, key, plaintext, ciphertext, api):
-        cipher = BlockCipher(
-            ciphers.AES(binascii.unhexlify(key)),
-            modes.ECB(),
-            api
-        )
-        actual_ciphertext = cipher.encrypt(binascii.unhexlify(plaintext))
-        actual_ciphertext += cipher.finalize()
-        assert binascii.hexlify(actual_ciphertext) == ciphertext
-
-    @parameterize_encrypt_test(
-        "AES", "MMT",
-        ("key", "plaintext", "ciphertext"),
+
+    test_MMT = generate_encrypt_test(
+        lambda path: load_nist_vectors_from_file(path, "ENCRYPT"),
+        os.path.join("AES", "MMT"),
         [
             "ECBMMT128.rsp",
             "ECBMMT192.rsp",
             "ECBMMT256.rsp",
-        ]
+        ],
+        lambda key: ciphers.AES(binascii.unhexlify(key)),
+        lambda key: modes.ECB(),
     )
-    def test_MMT(self, key, plaintext, ciphertext, api):
-        cipher = BlockCipher(
-            ciphers.AES(binascii.unhexlify(key)),
-            modes.ECB(),
-            api
-        )
-        actual_ciphertext = cipher.encrypt(binascii.unhexlify(plaintext))
-        actual_ciphertext += cipher.finalize()
-        assert binascii.hexlify(actual_ciphertext) == ciphertext
 
 
 class TestAES_OFB(object):
-    @parameterize_encrypt_test(
-        "AES", "KAT",
-        ("key", "iv", "plaintext", "ciphertext"),
+    test_KAT = generate_encrypt_test(
+        lambda path: load_nist_vectors_from_file(path, "ENCRYPT"),
+        os.path.join("AES", "KAT"),
         [
             "OFBGFSbox128.rsp",
             "OFBGFSbox192.rsp",
@@ -156,42 +113,28 @@ class TestAES_OFB(object):
             "OFBVarTxt128.rsp",
             "OFBVarTxt192.rsp",
             "OFBVarTxt256.rsp",
-        ]
+        ],
+        lambda key, iv: ciphers.AES(binascii.unhexlify(key)),
+        lambda key, iv: modes.OFB(binascii.unhexlify(iv)),
     )
-    def test_KAT(self, key, iv, plaintext, ciphertext, api):
-        cipher = BlockCipher(
-            ciphers.AES(binascii.unhexlify(key)),
-            modes.OFB(binascii.unhexlify(iv)),
-            api
-        )
-        actual_ciphertext = cipher.encrypt(binascii.unhexlify(plaintext))
-        actual_ciphertext += cipher.finalize()
-        assert binascii.hexlify(actual_ciphertext) == ciphertext
-
-    @parameterize_encrypt_test(
-        "AES", "MMT",
-        ("key", "iv", "plaintext", "ciphertext"),
+
+    test_MMT = generate_encrypt_test(
+        lambda path: load_nist_vectors_from_file(path, "ENCRYPT"),
+        os.path.join("AES", "MMT"),
         [
             "OFBMMT128.rsp",
             "OFBMMT192.rsp",
             "OFBMMT256.rsp",
-        ]
+        ],
+        lambda key, iv: ciphers.AES(binascii.unhexlify(key)),
+        lambda key, iv: modes.OFB(binascii.unhexlify(iv)),
     )
-    def test_MMT(self, key, iv, plaintext, ciphertext, api):
-        cipher = BlockCipher(
-            ciphers.AES(binascii.unhexlify(key)),
-            modes.OFB(binascii.unhexlify(iv)),
-            api
-        )
-        actual_ciphertext = cipher.encrypt(binascii.unhexlify(plaintext))
-        actual_ciphertext += cipher.finalize()
-        assert binascii.hexlify(actual_ciphertext) == ciphertext
 
 
 class TestAES_CFB(object):
-    @parameterize_encrypt_test(
-        "AES", "KAT",
-        ("key", "iv", "plaintext", "ciphertext"),
+    test_KAT = generate_encrypt_test(
+        lambda path: load_nist_vectors_from_file(path, "ENCRYPT"),
+        os.path.join("AES", "KAT"),
         [
             "CFB128GFSbox128.rsp",
             "CFB128GFSbox192.rsp",
@@ -205,33 +148,19 @@ class TestAES_CFB(object):
             "CFB128VarTxt128.rsp",
             "CFB128VarTxt192.rsp",
             "CFB128VarTxt256.rsp",
-        ]
+        ],
+        lambda key, iv: ciphers.AES(binascii.unhexlify(key)),
+        lambda key, iv: modes.CFB(binascii.unhexlify(iv)),
     )
-    def test_KAT(self, key, iv, plaintext, ciphertext, api):
-        cipher = BlockCipher(
-            ciphers.AES(binascii.unhexlify(key)),
-            modes.CFB(binascii.unhexlify(iv)),
-            api
-        )
-        actual_ciphertext = cipher.encrypt(binascii.unhexlify(plaintext))
-        actual_ciphertext += cipher.finalize()
-        assert binascii.hexlify(actual_ciphertext) == ciphertext
-
-    @parameterize_encrypt_test(
-        "AES", "MMT",
-        ("key", "iv", "plaintext", "ciphertext"),
+
+    test_MMT = generate_encrypt_test(
+        lambda path: load_nist_vectors_from_file(path, "ENCRYPT"),
+        os.path.join("AES", "MMT"),
         [
             "CFB128MMT128.rsp",
             "CFB128MMT192.rsp",
             "CFB128MMT256.rsp",
-        ]
+        ],
+        lambda key, iv: ciphers.AES(binascii.unhexlify(key)),
+        lambda key, iv: modes.CFB(binascii.unhexlify(iv)),
     )
-    def test_MMT(self, key, iv, plaintext, ciphertext, api):
-        cipher = BlockCipher(
-            ciphers.AES(binascii.unhexlify(key)),
-            modes.CFB(binascii.unhexlify(iv)),
-            api
-        )
-        actual_ciphertext = cipher.encrypt(binascii.unhexlify(plaintext))
-        actual_ciphertext += cipher.finalize()
-        assert binascii.hexlify(actual_ciphertext) == ciphertext
diff --git a/tests/primitives/test_openssl_vectors.py b/tests/primitives/test_openssl_vectors.py
index d30efa5c..6e32eca6 100644
--- a/tests/primitives/test_openssl_vectors.py
+++ b/tests/primitives/test_openssl_vectors.py
@@ -18,83 +18,44 @@ Test using the OpenSSL Test Vectors
 from __future__ import absolute_import, division, print_function
 
 import binascii
-import itertools
-import os
 
-import pytest
-
-from cryptography.primitives.block import BlockCipher, ciphers, modes
+from cryptography.primitives.block import ciphers, modes
 
+from .utils import generate_encrypt_test
 from ..utils import load_openssl_vectors_from_file
 
 
-def parameterize_encrypt_test(cipher, params, fnames):
-    return pytest.mark.parametrize(params,
-        list(itertools.chain.from_iterable(
-            load_openssl_vectors_from_file(os.path.join(cipher, fname))
-            for fname in fnames
-        ))
-    )
-
-
 class TestCamelliaCBC(object):
-
-    @parameterize_encrypt_test(
+    test_OpenSSL = generate_encrypt_test(
+        load_openssl_vectors_from_file,
         "Camellia",
-        ("key", "iv", "plaintext", "ciphertext"),
-        [
-            "camellia-cbc.txt",
-        ]
+        ["camellia-cbc.txt"],
+        lambda key, iv: ciphers.Camellia(binascii.unhexlify(key)),
+        lambda key, iv: modes.CBC(binascii.unhexlify(iv)),
+        only_if=lambda api: api.supports_cipher("camellia-128-cbc"),
+        skip_message="Does not support Camellia CBC",
     )
-    def test_OpenSSL(self, key, iv, plaintext, ciphertext, api):
-        if not api.supports_cipher("camellia-128-cbc"):
-            pytest.skip("Does not support Camellia CBC")  # pragma: no cover
-        cipher = BlockCipher(
-            ciphers.Camellia(binascii.unhexlify(key)),
-            modes.CBC(binascii.unhexlify(iv)),
-        )
-        actual_ciphertext = cipher.encrypt(binascii.unhexlify(plaintext))
-        actual_ciphertext += cipher.finalize()
-        assert binascii.hexlify(actual_ciphertext).upper() == ciphertext
 
 
 class TestCamelliaOFB(object):
-
-    @parameterize_encrypt_test(
+    test_OpenSSL = generate_encrypt_test(
+        load_openssl_vectors_from_file,
         "Camellia",
-        ("key", "iv", "plaintext", "ciphertext"),
-        [
-            "camellia-ofb.txt",
-        ]
+        ["camellia-ofb.txt"],
+        lambda key, iv: ciphers.Camellia(binascii.unhexlify(key)),
+        lambda key, iv: modes.OFB(binascii.unhexlify(iv)),
+        only_if=lambda api: api.supports_cipher("camellia-128-ofb"),
+        skip_message="Does not support Camellia OFB",
     )
-    def test_OpenSSL(self, key, iv, plaintext, ciphertext, api):
-        if not api.supports_cipher("camellia-128-ofb"):
-            pytest.skip("Does not support Camellia OFB")  # pragma: no cover
-        cipher = BlockCipher(
-            ciphers.Camellia(binascii.unhexlify(key)),
-            modes.OFB(binascii.unhexlify(iv)),
-        )
-        actual_ciphertext = cipher.encrypt(binascii.unhexlify(plaintext))
-        actual_ciphertext += cipher.finalize()
-        assert binascii.hexlify(actual_ciphertext).upper() == ciphertext
 
 
 class TestCamelliaCFB(object):
-
-    @parameterize_encrypt_test(
+    test_OpenSSL = generate_encrypt_test(
+        load_openssl_vectors_from_file,
         "Camellia",
-        ("key", "iv", "plaintext", "ciphertext"),
-        [
-            "camellia-cfb.txt",
-        ]
+        ["camellia-cfb.txt"],
+        lambda key, iv: ciphers.Camellia(binascii.unhexlify(key)),
+        lambda key, iv: modes.CFB(binascii.unhexlify(iv)),
+        only_if=lambda api: api.supports_cipher("camellia-128-cfb"),
+        skip_message="Does not support Camellia CFB",
     )
-    def test_OpenSSL(self, key, iv, plaintext, ciphertext, api):
-        if not api.supports_cipher("camellia-128-cfb"):
-            pytest.skip("Does not support Camellia CFB")  # pragma: no cover
-        cipher = BlockCipher(
-            ciphers.Camellia(binascii.unhexlify(key)),
-            modes.CFB(binascii.unhexlify(iv)),
-        )
-        actual_ciphertext = cipher.encrypt(binascii.unhexlify(plaintext))
-        actual_ciphertext += cipher.finalize()
-        assert binascii.hexlify(actual_ciphertext).upper() == ciphertext
diff --git a/tests/primitives/test_utils.py b/tests/primitives/test_utils.py
new file mode 100644
index 00000000..4666ece7
--- /dev/null
+++ b/tests/primitives/test_utils.py
@@ -0,0 +1,14 @@
+import pytest
+
+from .utils import encrypt_test
+
+
+class TestEncryptTest(object):
+    def test_skips_if_only_if_returns_false(self):
+        with pytest.raises(pytest.skip.Exception) as exc_info:
+            encrypt_test(
+                None, None, None, None,
+                only_if=lambda api: False,
+                skip_message="message!"
+            )
+        assert exc_info.value.args[0] == "message!"
diff --git a/tests/primitives/utils.py b/tests/primitives/utils.py
new file mode 100644
index 00000000..3cf08c28
--- /dev/null
+++ b/tests/primitives/utils.py
@@ -0,0 +1,42 @@
+import binascii
+import os
+
+import pytest
+
+from cryptography.bindings import _ALL_APIS
+from cryptography.primitives.block import BlockCipher
+
+
+def generate_encrypt_test(param_loader, path, file_names, cipher_factory,
+                          mode_factory, only_if=lambda api: True,
+                          skip_message=None):
+    def test_encryption(self):
+        for api in _ALL_APIS:
+            for file_name in file_names:
+                for params in param_loader(os.path.join(path, file_name)):
+                    yield (
+                        encrypt_test,
+                        api,
+                        cipher_factory,
+                        mode_factory,
+                        params,
+                        only_if,
+                        skip_message
+                    )
+    return test_encryption
+
+
+def encrypt_test(api, cipher_factory, mode_factory, params, only_if,
+                 skip_message):
+    if not only_if(api):
+        pytest.skip(skip_message)
+    plaintext = params.pop("plaintext")
+    ciphertext = params.pop("ciphertext")
+    cipher = BlockCipher(
+        cipher_factory(**params),
+        mode_factory(**params),
+        api
+    )
+    actual_ciphertext = cipher.encrypt(binascii.unhexlify(plaintext))
+    actual_ciphertext += cipher.finalize()
+    assert actual_ciphertext == binascii.unhexlify(ciphertext)