re-add some removed generators to simplify patch

3 files changed, 101 insertions, 50 deletions

diff --git a/tests/hazmat/primitives/test_hashes.py b/tests/hazmat/primitives/test_hashes.py
index d52021eb..c907ef61 100644
--- a/tests/hazmat/primitives/test_hashes.py
+++ b/tests/hazmat/primitives/test_hashes.py
@@ -23,7 +23,7 @@ from cryptography import utils
 from cryptography.exceptions import AlreadyFinalized, UnsupportedAlgorithm
 from cryptography.hazmat.primitives import hashes, interfaces
 
-from .utils import base_hash_test
+from .utils import generate_base_hash_test
 
 
 @utils.register_interface(interfaces.HashAlgorithm)
@@ -69,44 +69,69 @@ class TestHashContext(object):
             hashes.Hash(UnsupportedDummyHash(), backend)
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hash_supported(hashes.SHA1),
+    skip_message="Does not support SHA1",
+)
 @pytest.mark.hash
-class TestHashes(object):
-    @pytest.mark.supported(
-        only_if=lambda backend: backend.hash_supported(hashes.SHA1),
-        skip_message="Does not support SHA1",
+class TestSHA1(object):
+    test_SHA1 = generate_base_hash_test(
+        hashes.SHA1(),
+        digest_size=20,
+        block_size=64,
     )
-    def test_SHA1(self, backend):
-        base_hash_test(backend, hashes.SHA1(), digest_size=20, block_size=64)
 
-    @pytest.mark.supported(
-        only_if=lambda backend: backend.hash_supported(hashes.SHA224),
-        skip_message="Does not support SHA224",
+
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hash_supported(hashes.SHA224),
+    skip_message="Does not support SHA224",
+)
+@pytest.mark.hash
+class TestSHA224(object):
+    test_SHA224 = generate_base_hash_test(
+        hashes.SHA224(),
+        digest_size=28,
+        block_size=64,
     )
-    def test_SHA224(self, backend):
-        base_hash_test(backend, hashes.SHA224(), digest_size=28, block_size=64)
 
-    @pytest.mark.supported(
-        only_if=lambda backend: backend.hash_supported(hashes.SHA256),
-        skip_message="Does not support SHA256",
+
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hash_supported(hashes.SHA256),
+    skip_message="Does not support SHA256",
+)
+@pytest.mark.hash
+class TestSHA256(object):
+    test_SHA256 = generate_base_hash_test(
+        hashes.SHA256(),
+        digest_size=32,
+        block_size=64,
     )
-    def test_SHA256(self, backend):
-        base_hash_test(backend, hashes.SHA256(), digest_size=32, block_size=64)
 
-    @pytest.mark.supported(
-        only_if=lambda backend: backend.hash_supported(hashes.SHA384),
-        skip_message="Does not support SHA384",
+
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hash_supported(hashes.SHA384),
+    skip_message="Does not support SHA384",
+)
+@pytest.mark.hash
+class TestSHA384(object):
+    test_SHA384 = generate_base_hash_test(
+        hashes.SHA384(),
+        digest_size=48,
+        block_size=128,
     )
-    def test_SHA384(self, backend):
-        base_hash_test(backend, hashes.SHA384(),
-                       digest_size=48, block_size=128)
 
-    @pytest.mark.supported(
-        only_if=lambda backend: backend.hash_supported(hashes.SHA512),
-        skip_message="Does not support SHA512",
+
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hash_supported(hashes.SHA512),
+    skip_message="Does not support SHA512",
+)
+@pytest.mark.hash
+class TestSHA512(object):
+    test_SHA512 = generate_base_hash_test(
+        hashes.SHA512(),
+        digest_size=64,
+        block_size=128,
     )
-    def test_SHA512(self, backend):
-        base_hash_test(backend, hashes.SHA512(),
-                       digest_size=64, block_size=128)
 
 
 @pytest.mark.supported(
@@ -115,9 +140,11 @@ class TestHashes(object):
 )
 @pytest.mark.hash
 class TestRIPEMD160(object):
-    def test_RIPEMD160(self, backend):
-        base_hash_test(backend, hashes.RIPEMD160(),
-                       digest_size=20, block_size=64)
+    test_RIPEMD160 = generate_base_hash_test(
+        hashes.RIPEMD160(),
+        digest_size=20,
+        block_size=64,
+    )
 
 
 @pytest.mark.supported(
@@ -126,9 +153,11 @@ class TestRIPEMD160(object):
 )
 @pytest.mark.hash
 class TestWhirlpool(object):
-    def test_Whirlpool(self, backend):
-        base_hash_test(backend, hashes.Whirlpool(),
-                       digest_size=64, block_size=64)
+    test_Whirlpool = generate_base_hash_test(
+        hashes.Whirlpool(),
+        digest_size=64,
+        block_size=64,
+    )
 
 
 @pytest.mark.supported(
@@ -137,6 +166,8 @@ class TestWhirlpool(object):
 )
 @pytest.mark.hash
 class TestMD5(object):
-    def test_MD5(self, backend):
-        base_hash_test(backend, hashes.MD5(),
-                       digest_size=16, block_size=64)
+    test_MD5 = generate_base_hash_test(
+        hashes.MD5(),
+        digest_size=16,
+        block_size=64,
+    )
diff --git a/tests/hazmat/primitives/test_hmac.py b/tests/hazmat/primitives/test_hmac.py
index c216dd4d..924e2167 100644
--- a/tests/hazmat/primitives/test_hmac.py
+++ b/tests/hazmat/primitives/test_hmac.py
@@ -13,8 +13,6 @@
 
 from __future__ import absolute_import, division, print_function
 
-import binascii
-
 import pretend
 
 import pytest
@@ -25,25 +23,27 @@ from cryptography import utils
 from cryptography.exceptions import AlreadyFinalized, UnsupportedAlgorithm
 from cryptography.hazmat.primitives import hashes, hmac, interfaces
 
+from .utils import generate_base_hmac_test
+
 
 @utils.register_interface(interfaces.HashAlgorithm)
 class UnsupportedDummyHash(object):
         name = "unsupported-dummy-hash"
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hmac_supported(hashes.MD5),
+    skip_message="Does not support MD5",
+)
 @pytest.mark.hmac
-class TestHMAC(object):
-    @pytest.mark.supported(
-        only_if=lambda backend: backend.hmac_supported(hashes.MD5),
-        skip_message="Does not support MD5",
+class TestHMACCopy(object):
+    test_copy = generate_base_hmac_test(
+        hashes.MD5(),
     )
-    def test_hmac_copy(self, backend):
-        key = b"ab"
-        h = hmac.HMAC(binascii.unhexlify(key), hashes.MD5(), backend=backend)
-        h_copy = h.copy()
-        assert h != h_copy
-        assert h._ctx != h_copy._ctx
 
+
+@pytest.mark.hmac
+class TestHMAC(object):
     def test_hmac_reject_unicode(self, backend):
         h = hmac.HMAC(b"mykey", hashes.SHA1(), backend=backend)
         with pytest.raises(TypeError):
diff --git a/tests/hazmat/primitives/utils.py b/tests/hazmat/primitives/utils.py
index 3c962752..cdcf84cb 100644
--- a/tests/hazmat/primitives/utils.py
+++ b/tests/hazmat/primitives/utils.py
@@ -149,6 +149,12 @@ def hash_test(backend, algorithm, params):
     assert m.finalize() == binascii.unhexlify(expected_md)
 
 
+def generate_base_hash_test(algorithm, digest_size, block_size):
+    def test_base_hash(self, backend):
+        base_hash_test(backend, algorithm, digest_size, block_size)
+    return test_base_hash
+
+
 def base_hash_test(backend, algorithm, digest_size, block_size):
     m = hashes.Hash(algorithm, backend=backend)
     assert m.algorithm.digest_size == digest_size
@@ -176,6 +182,20 @@ def long_string_hash_test(backend, algorithm, md):
     assert m.finalize() == binascii.unhexlify(md.lower().encode("ascii"))
 
 
+def generate_base_hmac_test(hash_cls):
+    def test_base_hmac(self, backend):
+        base_hmac_test(backend, hash_cls)
+    return test_base_hmac
+
+
+def base_hmac_test(backend, algorithm):
+    key = b"ab"
+    h = hmac.HMAC(binascii.unhexlify(key), algorithm, backend=backend)
+    h_copy = h.copy()
+    assert h != h_copy
+    assert h._ctx != h_copy._ctx
+
+
 def generate_hmac_test(param_loader, path, file_names, algorithm):
     all_params = _load_all_params(path, file_names, param_loader)