refactor all tests to use mark instead of generator skips
diff --git a/tests/hazmat/primitives/test_3des.py b/tests/hazmat/primitives/test_3des.py
index 439ca25..581c47e 100644
--- a/tests/hazmat/primitives/test_3des.py
+++ b/tests/hazmat/primitives/test_3des.py
@@ -28,6 +28,12 @@
from ...utils import load_nist_vectors
+@pytest.mark.supported(
+ only_if=lambda backend: backend.cipher_supported(
+ algorithms.TripleDES("\x00" * 8), modes.CBC("\x00" * 8)
+ ),
+ skip_message="Does not support TripleDES CBC",
+)
@pytest.mark.cipher
class TestTripleDES_CBC(object):
test_KAT = generate_encrypt_test(
@@ -42,10 +48,6 @@
],
lambda keys, **kwargs: algorithms.TripleDES(binascii.unhexlify(keys)),
lambda iv, **kwargs: modes.CBC(binascii.unhexlify(iv)),
- only_if=lambda backend: backend.cipher_supported(
- algorithms.TripleDES("\x00" * 8), modes.CBC("\x00" * 8)
- ),
- skip_message="Does not support TripleDES CBC",
)
test_MMT = generate_encrypt_test(
@@ -60,13 +62,15 @@
binascii.unhexlify(key1 + key2 + key3)
),
lambda iv, **kwargs: modes.CBC(binascii.unhexlify(iv)),
- only_if=lambda backend: backend.cipher_supported(
- algorithms.TripleDES("\x00" * 8), modes.CBC("\x00" * 8)
- ),
- skip_message="Does not support TripleDES CBC",
)
+@pytest.mark.supported(
+ only_if=lambda backend: backend.cipher_supported(
+ algorithms.TripleDES("\x00" * 8), modes.OFB("\x00" * 8)
+ ),
+ skip_message="Does not support TripleDES OFB",
+)
@pytest.mark.cipher
class TestTripleDES_OFB(object):
test_KAT = generate_encrypt_test(
@@ -81,10 +85,6 @@
],
lambda keys, **kwargs: algorithms.TripleDES(binascii.unhexlify(keys)),
lambda iv, **kwargs: modes.OFB(binascii.unhexlify(iv)),
- only_if=lambda backend: backend.cipher_supported(
- algorithms.TripleDES("\x00" * 8), modes.OFB("\x00" * 8)
- ),
- skip_message="Does not support TripleDES OFB",
)
test_MMT = generate_encrypt_test(
@@ -99,13 +99,15 @@
binascii.unhexlify(key1 + key2 + key3)
),
lambda iv, **kwargs: modes.OFB(binascii.unhexlify(iv)),
- only_if=lambda backend: backend.cipher_supported(
- algorithms.TripleDES("\x00" * 8), modes.OFB("\x00" * 8)
- ),
- skip_message="Does not support TripleDES OFB",
)
+@pytest.mark.supported(
+ only_if=lambda backend: backend.cipher_supported(
+ algorithms.TripleDES("\x00" * 8), modes.CFB("\x00" * 8)
+ ),
+ skip_message="Does not support TripleDES CFB",
+)
@pytest.mark.cipher
class TestTripleDES_CFB(object):
test_KAT = generate_encrypt_test(
@@ -120,10 +122,6 @@
],
lambda keys, **kwargs: algorithms.TripleDES(binascii.unhexlify(keys)),
lambda iv, **kwargs: modes.CFB(binascii.unhexlify(iv)),
- only_if=lambda backend: backend.cipher_supported(
- algorithms.TripleDES("\x00" * 8), modes.CFB("\x00" * 8)
- ),
- skip_message="Does not support TripleDES CFB",
)
test_MMT = generate_encrypt_test(
@@ -138,8 +136,4 @@
binascii.unhexlify(key1 + key2 + key3)
),
lambda iv, **kwargs: modes.CFB(binascii.unhexlify(iv)),
- only_if=lambda backend: backend.cipher_supported(
- algorithms.TripleDES("\x00" * 8), modes.CFB("\x00" * 8)
- ),
- skip_message="Does not support TripleDES CFB",
)
diff --git a/tests/hazmat/primitives/test_aes.py b/tests/hazmat/primitives/test_aes.py
index e9ef385..8cba8c6 100644
--- a/tests/hazmat/primitives/test_aes.py
+++ b/tests/hazmat/primitives/test_aes.py
@@ -26,8 +26,14 @@
)
+@pytest.mark.supported(
+ only_if=lambda backend: backend.cipher_supported(
+ algorithms.AES("\x00" * 16), modes.CBC("\x00" * 16)
+ ),
+ skip_message="Does not support AES CBC",
+)
@pytest.mark.cipher
-class TestAES(object):
+class TestAES_CBC(object):
test_CBC = generate_encrypt_test(
load_nist_vectors,
os.path.join("ciphers", "AES", "CBC"),
@@ -50,12 +56,17 @@
],
lambda key, **kwargs: algorithms.AES(binascii.unhexlify(key)),
lambda iv, **kwargs: modes.CBC(binascii.unhexlify(iv)),
- only_if=lambda backend: backend.cipher_supported(
- algorithms.AES("\x00" * 16), modes.CBC("\x00" * 16)
- ),
- skip_message="Does not support AES CBC",
)
+
+@pytest.mark.supported(
+ only_if=lambda backend: backend.cipher_supported(
+ algorithms.AES("\x00" * 16), modes.ECB()
+ ),
+ skip_message="Does not support AES ECB",
+)
+@pytest.mark.cipher
+class TestAES_ECB(object):
test_ECB = generate_encrypt_test(
load_nist_vectors,
os.path.join("ciphers", "AES", "ECB"),
@@ -78,12 +89,17 @@
],
lambda key, **kwargs: algorithms.AES(binascii.unhexlify(key)),
lambda **kwargs: modes.ECB(),
- only_if=lambda backend: backend.cipher_supported(
- algorithms.AES("\x00" * 16), modes.ECB()
- ),
- skip_message="Does not support AES ECB",
)
+
+@pytest.mark.supported(
+ only_if=lambda backend: backend.cipher_supported(
+ algorithms.AES("\x00" * 16), modes.OFB("\x00" * 16)
+ ),
+ skip_message="Does not support AES OFB",
+)
+@pytest.mark.cipher
+class TestAES_OFB(object):
test_OFB = generate_encrypt_test(
load_nist_vectors,
os.path.join("ciphers", "AES", "OFB"),
@@ -106,12 +122,17 @@
],
lambda key, **kwargs: algorithms.AES(binascii.unhexlify(key)),
lambda iv, **kwargs: modes.OFB(binascii.unhexlify(iv)),
- only_if=lambda backend: backend.cipher_supported(
- algorithms.AES("\x00" * 16), modes.OFB("\x00" * 16)
- ),
- skip_message="Does not support AES OFB",
)
+
+@pytest.mark.supported(
+ only_if=lambda backend: backend.cipher_supported(
+ algorithms.AES("\x00" * 16), modes.CFB("\x00" * 16)
+ ),
+ skip_message="Does not support AES CFB",
+)
+@pytest.mark.cipher
+class TestAES_CFB(object):
test_CFB = generate_encrypt_test(
load_nist_vectors,
os.path.join("ciphers", "AES", "CFB"),
@@ -134,24 +155,34 @@
],
lambda key, **kwargs: algorithms.AES(binascii.unhexlify(key)),
lambda iv, **kwargs: modes.CFB(binascii.unhexlify(iv)),
- only_if=lambda backend: backend.cipher_supported(
- algorithms.AES("\x00" * 16), modes.CFB("\x00" * 16)
- ),
- skip_message="Does not support AES CFB",
)
+
+@pytest.mark.supported(
+ only_if=lambda backend: backend.cipher_supported(
+ algorithms.AES("\x00" * 16), modes.CTR("\x00" * 16)
+ ),
+ skip_message="Does not support AES CTR",
+)
+@pytest.mark.cipher
+class TestAES_CTR(object):
test_CTR = generate_encrypt_test(
load_openssl_vectors,
os.path.join("ciphers", "AES", "CTR"),
["aes-128-ctr.txt", "aes-192-ctr.txt", "aes-256-ctr.txt"],
lambda key, **kwargs: algorithms.AES(binascii.unhexlify(key)),
lambda iv, **kwargs: modes.CTR(binascii.unhexlify(iv)),
- only_if=lambda backend: backend.cipher_supported(
- algorithms.AES("\x00" * 16), modes.CTR("\x00" * 16)
- ),
- skip_message="Does not support AES CTR",
)
+
+@pytest.mark.supported(
+ only_if=lambda backend: backend.cipher_supported(
+ algorithms.AES("\x00" * 16), modes.GCM("\x00" * 12)
+ ),
+ skip_message="Does not support AES GCM",
+)
+@pytest.mark.cipher
+class TestAES_GCM(object):
test_GCM = generate_aead_test(
load_nist_vectors,
os.path.join("ciphers", "AES", "GCM"),
@@ -165,8 +196,4 @@
],
lambda key: algorithms.AES(key),
lambda iv, tag: modes.GCM(iv, tag),
- only_if=lambda backend: backend.cipher_supported(
- algorithms.AES("\x00" * 16), modes.GCM("\x00" * 12)
- ),
- skip_message="Does not support AES GCM",
)
diff --git a/tests/hazmat/primitives/test_arc4.py b/tests/hazmat/primitives/test_arc4.py
index f2e2452..33f7ff0 100644
--- a/tests/hazmat/primitives/test_arc4.py
+++ b/tests/hazmat/primitives/test_arc4.py
@@ -24,6 +24,12 @@
from ...utils import load_nist_vectors
+@pytest.mark.supported(
+ only_if=lambda backend: backend.cipher_supported(
+ algorithms.ARC4("\x00" * 16), None
+ ),
+ skip_message="Does not support ARC4",
+)
@pytest.mark.cipher
class TestARC4(object):
test_rfc = generate_stream_encryption_test(
@@ -39,8 +45,4 @@
"rfc-6229-256.txt",
],
lambda key, **kwargs: algorithms.ARC4(binascii.unhexlify(key)),
- only_if=lambda backend: backend.cipher_supported(
- algorithms.ARC4("\x00" * 16), None
- ),
- skip_message="Does not support ARC4",
)
diff --git a/tests/hazmat/primitives/test_block.py b/tests/hazmat/primitives/test_block.py
index 22a7c02..30cf1d6 100644
--- a/tests/hazmat/primitives/test_block.py
+++ b/tests/hazmat/primitives/test_block.py
@@ -136,21 +136,19 @@
decryptor.finalize()
+@pytest.mark.supported(
+ only_if=lambda backend: backend.cipher_supported(
+ algorithms.AES("\x00" * 16), modes.GCM("\x00" * 12)
+ ),
+ skip_message="Does not support AES GCM",
+)
@pytest.mark.cipher
class TestAEADCipherContext(object):
test_aead_exceptions = generate_aead_exception_test(
algorithms.AES,
modes.GCM,
- only_if=lambda backend: backend.cipher_supported(
- algorithms.AES("\x00" * 16), modes.GCM("\x00" * 12)
- ),
- skip_message="Does not support AES GCM",
)
test_aead_tag_exceptions = generate_aead_tag_exception_test(
algorithms.AES,
modes.GCM,
- only_if=lambda backend: backend.cipher_supported(
- algorithms.AES("\x00" * 16), modes.GCM("\x00" * 12)
- ),
- skip_message="Does not support AES GCM",
)
diff --git a/tests/hazmat/primitives/test_blowfish.py b/tests/hazmat/primitives/test_blowfish.py
index 79ceabe..18512a6 100644
--- a/tests/hazmat/primitives/test_blowfish.py
+++ b/tests/hazmat/primitives/test_blowfish.py
@@ -24,52 +24,69 @@
from ...utils import load_nist_vectors
+@pytest.mark.supported(
+ only_if=lambda backend: backend.cipher_supported(
+ algorithms.Blowfish("\x00" * 56), modes.ECB()
+ ),
+ skip_message="Does not support Blowfish ECB",
+)
@pytest.mark.cipher
-class TestBlowfish(object):
+class TestBlowfish_ECB(object):
test_ECB = generate_encrypt_test(
load_nist_vectors,
os.path.join("ciphers", "Blowfish"),
["bf-ecb.txt"],
lambda key, **kwargs: algorithms.Blowfish(binascii.unhexlify(key)),
lambda **kwargs: modes.ECB(),
- only_if=lambda backend: backend.cipher_supported(
- algorithms.Blowfish("\x00" * 56), modes.ECB()
- ),
- skip_message="Does not support Blowfish ECB",
)
+
+@pytest.mark.supported(
+ only_if=lambda backend: backend.cipher_supported(
+ algorithms.Blowfish("\x00" * 56), modes.CBC("\x00" * 8)
+ ),
+ skip_message="Does not support Blowfish CBC",
+)
+@pytest.mark.cipher
+class TestBlowfish_CBC(object):
test_CBC = generate_encrypt_test(
load_nist_vectors,
os.path.join("ciphers", "Blowfish"),
["bf-cbc.txt"],
lambda key, **kwargs: algorithms.Blowfish(binascii.unhexlify(key)),
lambda iv, **kwargs: modes.CBC(binascii.unhexlify(iv)),
- only_if=lambda backend: backend.cipher_supported(
- algorithms.Blowfish("\x00" * 56), modes.CBC("\x00" * 8)
- ),
- skip_message="Does not support Blowfish CBC",
)
+
+@pytest.mark.supported(
+ only_if=lambda backend: backend.cipher_supported(
+ algorithms.Blowfish("\x00" * 56), modes.OFB("\x00" * 8)
+ ),
+ skip_message="Does not support Blowfish OFB",
+)
+@pytest.mark.cipher
+class TestBlowfish_OFB(object):
test_OFB = generate_encrypt_test(
load_nist_vectors,
os.path.join("ciphers", "Blowfish"),
["bf-ofb.txt"],
lambda key, **kwargs: algorithms.Blowfish(binascii.unhexlify(key)),
lambda iv, **kwargs: modes.OFB(binascii.unhexlify(iv)),
- only_if=lambda backend: backend.cipher_supported(
- algorithms.Blowfish("\x00" * 56), modes.OFB("\x00" * 8)
- ),
- skip_message="Does not support Blowfish OFB",
)
+
+@pytest.mark.supported(
+ only_if=lambda backend: backend.cipher_supported(
+ algorithms.Blowfish("\x00" * 56), modes.CFB("\x00" * 8)
+ ),
+ skip_message="Does not support Blowfish CFB",
+)
+@pytest.mark.cipher
+class TestBlowfish_CFB(object):
test_CFB = generate_encrypt_test(
load_nist_vectors,
os.path.join("ciphers", "Blowfish"),
["bf-cfb.txt"],
lambda key, **kwargs: algorithms.Blowfish(binascii.unhexlify(key)),
lambda iv, **kwargs: modes.CFB(binascii.unhexlify(iv)),
- only_if=lambda backend: backend.cipher_supported(
- algorithms.Blowfish("\x00" * 56), modes.CFB("\x00" * 8)
- ),
- skip_message="Does not support Blowfish CFB",
)
diff --git a/tests/hazmat/primitives/test_camellia.py b/tests/hazmat/primitives/test_camellia.py
index c376220..7c56f6f 100644
--- a/tests/hazmat/primitives/test_camellia.py
+++ b/tests/hazmat/primitives/test_camellia.py
@@ -26,8 +26,14 @@
)
+@pytest.mark.supported(
+ only_if=lambda backend: backend.cipher_supported(
+ algorithms.Camellia("\x00" * 16), modes.ECB()
+ ),
+ skip_message="Does not support Camellia ECB",
+)
@pytest.mark.cipher
-class TestCamellia(object):
+class TestCamellia_ECB(object):
test_ECB = generate_encrypt_test(
load_cryptrec_vectors,
os.path.join("ciphers", "Camellia"),
@@ -38,44 +44,55 @@
],
lambda key, **kwargs: algorithms.Camellia(binascii.unhexlify(key)),
lambda **kwargs: modes.ECB(),
- only_if=lambda backend: backend.cipher_supported(
- algorithms.Camellia("\x00" * 16), modes.ECB()
- ),
- skip_message="Does not support Camellia ECB",
)
+
+@pytest.mark.supported(
+ only_if=lambda backend: backend.cipher_supported(
+ algorithms.Camellia("\x00" * 16), modes.CBC("\x00" * 16)
+ ),
+ skip_message="Does not support Camellia CBC",
+)
+@pytest.mark.cipher
+class TestCamellia_CBC(object):
test_CBC = generate_encrypt_test(
load_openssl_vectors,
os.path.join("ciphers", "Camellia"),
["camellia-cbc.txt"],
lambda key, **kwargs: algorithms.Camellia(binascii.unhexlify(key)),
lambda iv, **kwargs: modes.CBC(binascii.unhexlify(iv)),
- only_if=lambda backend: backend.cipher_supported(
- algorithms.Camellia("\x00" * 16), modes.CBC("\x00" * 16)
- ),
- skip_message="Does not support Camellia CBC",
)
+
+@pytest.mark.supported(
+ only_if=lambda backend: backend.cipher_supported(
+ algorithms.Camellia("\x00" * 16), modes.OFB("\x00" * 16)
+ ),
+ skip_message="Does not support Camellia OFB",
+)
+@pytest.mark.cipher
+class TestCamellia_OFB(object):
test_OFB = generate_encrypt_test(
load_openssl_vectors,
os.path.join("ciphers", "Camellia"),
["camellia-ofb.txt"],
lambda key, **kwargs: algorithms.Camellia(binascii.unhexlify(key)),
lambda iv, **kwargs: modes.OFB(binascii.unhexlify(iv)),
- only_if=lambda backend: backend.cipher_supported(
- algorithms.Camellia("\x00" * 16), modes.OFB("\x00" * 16)
- ),
- skip_message="Does not support Camellia OFB",
)
+
+@pytest.mark.supported(
+ only_if=lambda backend: backend.cipher_supported(
+ algorithms.Camellia("\x00" * 16), modes.CFB("\x00" * 16)
+ ),
+ skip_message="Does not support Camellia CFB",
+)
+@pytest.mark.cipher
+class TestCamellia_CFB(object):
test_CFB = generate_encrypt_test(
load_openssl_vectors,
os.path.join("ciphers", "Camellia"),
["camellia-cfb.txt"],
lambda key, **kwargs: algorithms.Camellia(binascii.unhexlify(key)),
lambda iv, **kwargs: modes.CFB(binascii.unhexlify(iv)),
- only_if=lambda backend: backend.cipher_supported(
- algorithms.Camellia("\x00" * 16), modes.CFB("\x00" * 16)
- ),
- skip_message="Does not support Camellia CFB",
)
diff --git a/tests/hazmat/primitives/test_cast5.py b/tests/hazmat/primitives/test_cast5.py
index a4789c6..d65a86b 100644
--- a/tests/hazmat/primitives/test_cast5.py
+++ b/tests/hazmat/primitives/test_cast5.py
@@ -24,6 +24,12 @@
from ...utils import load_nist_vectors
+@pytest.mark.supported(
+ only_if=lambda backend: backend.cipher_supported(
+ algorithms.CAST5("\x00" * 16), modes.ECB()
+ ),
+ skip_message="Does not support CAST5 ECB",
+)
@pytest.mark.cipher
class TestCAST5(object):
test_ECB = generate_encrypt_test(
@@ -32,8 +38,4 @@
["cast5-ecb.txt"],
lambda key, **kwargs: algorithms.CAST5(binascii.unhexlify((key))),
lambda **kwargs: modes.ECB(),
- only_if=lambda backend: backend.cipher_supported(
- algorithms.CAST5("\x00" * 16), modes.ECB()
- ),
- skip_message="Does not support CAST5 ECB",
)
diff --git a/tests/hazmat/primitives/test_hash_vectors.py b/tests/hazmat/primitives/test_hash_vectors.py
index d9febea..13ffc3f 100644
--- a/tests/hazmat/primitives/test_hash_vectors.py
+++ b/tests/hazmat/primitives/test_hash_vectors.py
@@ -23,6 +23,10 @@
from ...utils import load_hash_vectors
+@pytest.mark.supported(
+ only_if=lambda backend: backend.hash_supported(hashes.SHA1),
+ skip_message="Does not support SHA1",
+)
@pytest.mark.hash
class TestSHA1(object):
test_SHA1 = generate_hash_test(
@@ -33,11 +37,13 @@
"SHA1ShortMsg.rsp",
],
hashes.SHA1(),
- only_if=lambda backend: backend.hash_supported(hashes.SHA1),
- skip_message="Does not support SHA1",
)
+@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_hash_test(
@@ -48,11 +54,13 @@
"SHA224ShortMsg.rsp",
],
hashes.SHA224(),
- 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.SHA256),
+ skip_message="Does not support SHA256",
+)
@pytest.mark.hash
class TestSHA256(object):
test_SHA256 = generate_hash_test(
@@ -63,11 +71,13 @@
"SHA256ShortMsg.rsp",
],
hashes.SHA256(),
- 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.SHA384),
+ skip_message="Does not support SHA384",
+)
@pytest.mark.hash
class TestSHA384(object):
test_SHA384 = generate_hash_test(
@@ -78,11 +88,13 @@
"SHA384ShortMsg.rsp",
],
hashes.SHA384(),
- 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.SHA512),
+ skip_message="Does not support SHA512",
+)
@pytest.mark.hash
class TestSHA512(object):
test_SHA512 = generate_hash_test(
@@ -93,11 +105,13 @@
"SHA512ShortMsg.rsp",
],
hashes.SHA512(),
- 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.RIPEMD160),
+ skip_message="Does not support RIPEMD160",
+)
@pytest.mark.hash
class TestRIPEMD160(object):
test_RIPEMD160 = generate_hash_test(
@@ -107,18 +121,18 @@
"ripevectors.txt",
],
hashes.RIPEMD160(),
- only_if=lambda backend: backend.hash_supported(hashes.RIPEMD160),
- skip_message="Does not support RIPEMD160",
)
test_RIPEMD160_long_string = generate_long_string_hash_test(
hashes.RIPEMD160(),
"52783243c1697bdbe16d37f97f68f08325dc1528",
- only_if=lambda backend: backend.hash_supported(hashes.RIPEMD160),
- skip_message="Does not support RIPEMD160",
)
+@pytest.mark.supported(
+ only_if=lambda backend: backend.hash_supported(hashes.Whirlpool),
+ skip_message="Does not support Whirlpool",
+)
@pytest.mark.hash
class TestWhirlpool(object):
test_whirlpool = generate_hash_test(
@@ -128,8 +142,6 @@
"iso-test-vectors.txt",
],
hashes.Whirlpool(),
- only_if=lambda backend: backend.hash_supported(hashes.Whirlpool),
- skip_message="Does not support Whirlpool",
)
test_whirlpool_long_string = generate_long_string_hash_test(
@@ -137,11 +149,13 @@
("0c99005beb57eff50a7cf005560ddf5d29057fd86b2"
"0bfd62deca0f1ccea4af51fc15490eddc47af32bb2b"
"66c34ff9ad8c6008ad677f77126953b226e4ed8b01"),
- only_if=lambda backend: backend.hash_supported(hashes.Whirlpool),
- skip_message="Does not support Whirlpool",
)
+@pytest.mark.supported(
+ only_if=lambda backend: backend.hash_supported(hashes.MD5),
+ skip_message="Does not support MD5",
+)
@pytest.mark.hash
class TestMD5(object):
test_md5 = generate_hash_test(
@@ -151,6 +165,4 @@
"rfc-1321.txt",
],
hashes.MD5(),
- only_if=lambda backend: backend.hash_supported(hashes.MD5),
- skip_message="Does not support MD5",
)
diff --git a/tests/hazmat/primitives/test_hashes.py b/tests/hazmat/primitives/test_hashes.py
index 45faaab..d52021e 100644
--- a/tests/hazmat/primitives/test_hashes.py
+++ b/tests/hazmat/primitives/test_hashes.py
@@ -23,7 +23,7 @@
from cryptography.exceptions import AlreadyFinalized, UnsupportedAlgorithm
from cryptography.hazmat.primitives import hashes, interfaces
-from .utils import generate_base_hash_test
+from .utils import base_hash_test
@utils.register_interface(interfaces.HashAlgorithm)
@@ -70,88 +70,73 @@
@pytest.mark.hash
-class TestSHA1(object):
- test_SHA1 = generate_base_hash_test(
- hashes.SHA1(),
- digest_size=20,
- block_size=64,
+class TestHashes(object):
+ @pytest.mark.supported(
only_if=lambda backend: backend.hash_supported(hashes.SHA1),
skip_message="Does not support SHA1",
)
+ def test_SHA1(self, backend):
+ base_hash_test(backend, hashes.SHA1(), digest_size=20, block_size=64)
-
-@pytest.mark.hash
-class TestSHA224(object):
- test_SHA224 = generate_base_hash_test(
- hashes.SHA224(),
- digest_size=28,
- block_size=64,
+ @pytest.mark.supported(
only_if=lambda backend: backend.hash_supported(hashes.SHA224),
skip_message="Does not support SHA224",
)
+ def test_SHA224(self, backend):
+ base_hash_test(backend, hashes.SHA224(), digest_size=28, block_size=64)
-
-@pytest.mark.hash
-class TestSHA256(object):
- test_SHA256 = generate_base_hash_test(
- hashes.SHA256(),
- digest_size=32,
- block_size=64,
+ @pytest.mark.supported(
only_if=lambda backend: backend.hash_supported(hashes.SHA256),
skip_message="Does not support SHA256",
)
+ def test_SHA256(self, backend):
+ base_hash_test(backend, hashes.SHA256(), digest_size=32, block_size=64)
-
-@pytest.mark.hash
-class TestSHA384(object):
- test_SHA384 = generate_base_hash_test(
- hashes.SHA384(),
- digest_size=48,
- block_size=128,
+ @pytest.mark.supported(
only_if=lambda backend: backend.hash_supported(hashes.SHA384),
skip_message="Does not support SHA384",
)
+ def test_SHA384(self, backend):
+ base_hash_test(backend, hashes.SHA384(),
+ digest_size=48, block_size=128)
-
-@pytest.mark.hash
-class TestSHA512(object):
- test_SHA512 = generate_base_hash_test(
- hashes.SHA512(),
- digest_size=64,
- block_size=128,
+ @pytest.mark.supported(
only_if=lambda backend: backend.hash_supported(hashes.SHA512),
skip_message="Does not support SHA512",
)
+ def test_SHA512(self, backend):
+ base_hash_test(backend, hashes.SHA512(),
+ digest_size=64, block_size=128)
+@pytest.mark.supported(
+ only_if=lambda backend: backend.hash_supported(hashes.RIPEMD160),
+ skip_message="Does not support RIPEMD160",
+)
@pytest.mark.hash
class TestRIPEMD160(object):
- test_RIPEMD160 = generate_base_hash_test(
- hashes.RIPEMD160(),
- digest_size=20,
- block_size=64,
- only_if=lambda backend: backend.hash_supported(hashes.RIPEMD160),
- skip_message="Does not support RIPEMD160",
- )
+ def test_RIPEMD160(self, backend):
+ base_hash_test(backend, hashes.RIPEMD160(),
+ digest_size=20, block_size=64)
+@pytest.mark.supported(
+ only_if=lambda backend: backend.hash_supported(hashes.Whirlpool),
+ skip_message="Does not support Whirlpool",
+)
@pytest.mark.hash
class TestWhirlpool(object):
- test_Whirlpool = generate_base_hash_test(
- hashes.Whirlpool(),
- digest_size=64,
- block_size=64,
- only_if=lambda backend: backend.hash_supported(hashes.Whirlpool),
- skip_message="Does not support Whirlpool",
- )
+ def test_Whirlpool(self, backend):
+ base_hash_test(backend, hashes.Whirlpool(),
+ digest_size=64, block_size=64)
+@pytest.mark.supported(
+ only_if=lambda backend: backend.hash_supported(hashes.MD5),
+ skip_message="Does not support MD5",
+)
@pytest.mark.hash
class TestMD5(object):
- test_MD5 = generate_base_hash_test(
- hashes.MD5(),
- digest_size=16,
- block_size=64,
- only_if=lambda backend: backend.hash_supported(hashes.MD5),
- skip_message="Does not support MD5",
- )
+ def test_MD5(self, backend):
+ base_hash_test(backend, 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 6d8cc27..c216dd4 100644
--- a/tests/hazmat/primitives/test_hmac.py
+++ b/tests/hazmat/primitives/test_hmac.py
@@ -13,6 +13,8 @@
from __future__ import absolute_import, division, print_function
+import binascii
+
import pretend
import pytest
@@ -23,8 +25,6 @@
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):
@@ -33,11 +33,16 @@
@pytest.mark.hmac
class TestHMAC(object):
- test_copy = generate_base_hmac_test(
- hashes.MD5(),
+ @pytest.mark.supported(
only_if=lambda backend: backend.hmac_supported(hashes.MD5),
skip_message="Does not support 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
def test_hmac_reject_unicode(self, backend):
h = hmac.HMAC(b"mykey", hashes.SHA1(), backend=backend)
diff --git a/tests/hazmat/primitives/test_hmac_vectors.py b/tests/hazmat/primitives/test_hmac_vectors.py
index 9bc06a2..c564445 100644
--- a/tests/hazmat/primitives/test_hmac_vectors.py
+++ b/tests/hazmat/primitives/test_hmac_vectors.py
@@ -21,6 +21,10 @@
from ...utils import load_hash_vectors
+@pytest.mark.supported(
+ only_if=lambda backend: backend.hmac_supported(hashes.MD5),
+ skip_message="Does not support MD5",
+)
@pytest.mark.hmac
class TestHMAC_MD5(object):
test_hmac_md5 = generate_hmac_test(
@@ -30,11 +34,13 @@
"rfc-2202-md5.txt",
],
hashes.MD5(),
- only_if=lambda backend: backend.hmac_supported(hashes.MD5),
- skip_message="Does not support MD5",
)
+@pytest.mark.supported(
+ only_if=lambda backend: backend.hmac_supported(hashes.SHA1),
+ skip_message="Does not support SHA1",
+)
@pytest.mark.hmac
class TestHMAC_SHA1(object):
test_hmac_sha1 = generate_hmac_test(
@@ -44,11 +50,13 @@
"rfc-2202-sha1.txt",
],
hashes.SHA1(),
- only_if=lambda backend: backend.hmac_supported(hashes.SHA1),
- skip_message="Does not support SHA1",
)
+@pytest.mark.supported(
+ only_if=lambda backend: backend.hmac_supported(hashes.SHA224),
+ skip_message="Does not support SHA224",
+)
@pytest.mark.hmac
class TestHMAC_SHA224(object):
test_hmac_sha224 = generate_hmac_test(
@@ -58,11 +66,13 @@
"rfc-4231-sha224.txt",
],
hashes.SHA224(),
- only_if=lambda backend: backend.hmac_supported(hashes.SHA224),
- skip_message="Does not support SHA224",
)
+@pytest.mark.supported(
+ only_if=lambda backend: backend.hmac_supported(hashes.SHA256),
+ skip_message="Does not support SHA256",
+)
@pytest.mark.hmac
class TestHMAC_SHA256(object):
test_hmac_sha256 = generate_hmac_test(
@@ -72,11 +82,13 @@
"rfc-4231-sha256.txt",
],
hashes.SHA256(),
- only_if=lambda backend: backend.hmac_supported(hashes.SHA256),
- skip_message="Does not support SHA256",
)
+@pytest.mark.supported(
+ only_if=lambda backend: backend.hmac_supported(hashes.SHA384),
+ skip_message="Does not support SHA384",
+)
@pytest.mark.hmac
class TestHMAC_SHA384(object):
test_hmac_sha384 = generate_hmac_test(
@@ -86,11 +98,13 @@
"rfc-4231-sha384.txt",
],
hashes.SHA384(),
- only_if=lambda backend: backend.hmac_supported(hashes.SHA384),
- skip_message="Does not support SHA384",
)
+@pytest.mark.supported(
+ only_if=lambda backend: backend.hmac_supported(hashes.SHA512),
+ skip_message="Does not support SHA512",
+)
@pytest.mark.hmac
class TestHMAC_SHA512(object):
test_hmac_sha512 = generate_hmac_test(
@@ -100,11 +114,13 @@
"rfc-4231-sha512.txt",
],
hashes.SHA512(),
- only_if=lambda backend: backend.hmac_supported(hashes.SHA512),
- skip_message="Does not support SHA512",
)
+@pytest.mark.supported(
+ only_if=lambda backend: backend.hmac_supported(hashes.RIPEMD160),
+ skip_message="Does not support RIPEMD160",
+)
@pytest.mark.hmac
class TestHMAC_RIPEMD160(object):
test_hmac_ripemd160 = generate_hmac_test(
@@ -114,6 +130,4 @@
"rfc-2286-ripemd160.txt",
],
hashes.RIPEMD160(),
- only_if=lambda backend: backend.hmac_supported(hashes.RIPEMD160),
- skip_message="Does not support RIPEMD160",
)
diff --git a/tests/hazmat/primitives/test_utils.py b/tests/hazmat/primitives/test_utils.py
deleted file mode 100644
index c39364c..0000000
--- a/tests/hazmat/primitives/test_utils.py
+++ /dev/null
@@ -1,117 +0,0 @@
-import pytest
-
-from .utils import (
- base_hash_test, encrypt_test, hash_test, long_string_hash_test,
- base_hmac_test, hmac_test, stream_encryption_test, aead_test,
- aead_exception_test, aead_tag_exception_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 backend: False,
- skip_message="message!"
- )
- assert exc_info.value.args[0] == "message!"
-
-
-class TestAEADTest(object):
- def test_skips_if_only_if_returns_false(self):
- with pytest.raises(pytest.skip.Exception) as exc_info:
- aead_test(
- None, None, None, None,
- only_if=lambda backend: False,
- skip_message="message!"
- )
- assert exc_info.value.args[0] == "message!"
-
-
-class TestAEADExceptionTest(object):
- def test_skips_if_only_if_returns_false(self):
- with pytest.raises(pytest.skip.Exception) as exc_info:
- aead_exception_test(
- None, None, None,
- only_if=lambda backend: False,
- skip_message="message!"
- )
- assert exc_info.value.args[0] == "message!"
-
-
-class TestAEADTagExceptionTest(object):
- def test_skips_if_only_if_returns_false(self):
- with pytest.raises(pytest.skip.Exception) as exc_info:
- aead_tag_exception_test(
- None, None, None,
- only_if=lambda backend: False,
- skip_message="message!"
- )
- assert exc_info.value.args[0] == "message!"
-
-
-class TestHashTest(object):
- def test_skips_if_only_if_returns_false(self):
- with pytest.raises(pytest.skip.Exception) as exc_info:
- hash_test(
- None, None, None,
- only_if=lambda backend: False,
- skip_message="message!"
- )
- assert exc_info.value.args[0] == "message!"
-
-
-class TestBaseHashTest(object):
- def test_skips_if_only_if_returns_false(self):
- with pytest.raises(pytest.skip.Exception) as exc_info:
- base_hash_test(
- None, None, None, None,
- only_if=lambda backend: False,
- skip_message="message!"
- )
- assert exc_info.value.args[0] == "message!"
-
-
-class TestLongHashTest(object):
- def test_skips_if_only_if_returns_false(self):
- with pytest.raises(pytest.skip.Exception) as exc_info:
- long_string_hash_test(
- None, None, None,
- only_if=lambda backend: False,
- skip_message="message!"
- )
- assert exc_info.value.args[0] == "message!"
-
-
-class TestHMACTest(object):
- def test_skips_if_only_if_returns_false(self):
- with pytest.raises(pytest.skip.Exception) as exc_info:
- hmac_test(
- None, None, None,
- only_if=lambda backend: False,
- skip_message="message!"
- )
- assert exc_info.value.args[0] == "message!"
-
-
-class TestBaseHMACTest(object):
- def test_skips_if_only_if_returns_false(self):
- with pytest.raises(pytest.skip.Exception) as exc_info:
- base_hmac_test(
- None, None,
- only_if=lambda backend: False,
- skip_message="message!"
- )
- assert exc_info.value.args[0] == "message!"
-
-
-class TestStreamEncryptionTest(object):
- def test_skips_if_only_if_returns_false(self):
- with pytest.raises(pytest.skip.Exception) as exc_info:
- stream_encryption_test(
- None, None, None,
- only_if=lambda backend: False,
- skip_message="message!"
- )
- assert exc_info.value.args[0] == "message!"
diff --git a/tests/hazmat/primitives/utils.py b/tests/hazmat/primitives/utils.py
index e018477..3c96275 100644
--- a/tests/hazmat/primitives/utils.py
+++ b/tests/hazmat/primitives/utils.py
@@ -22,27 +22,17 @@
def generate_encrypt_test(param_loader, path, file_names, cipher_factory,
- mode_factory, only_if, skip_message=None):
+ mode_factory):
all_params = _load_all_params(path, file_names, param_loader)
@pytest.mark.parametrize("params", all_params)
def test_encryption(self, backend, params):
- encrypt_test(
- backend,
- cipher_factory,
- mode_factory,
- params,
- only_if,
- skip_message
- )
+ encrypt_test(backend, cipher_factory, mode_factory, params)
return test_encryption
-def encrypt_test(backend, cipher_factory, mode_factory, params, only_if,
- skip_message):
- if not only_if(backend):
- pytest.skip(skip_message)
+def encrypt_test(backend, cipher_factory, mode_factory, params):
plaintext = params["plaintext"]
ciphertext = params["ciphertext"]
cipher = Cipher(
@@ -61,27 +51,17 @@
def generate_aead_test(param_loader, path, file_names, cipher_factory,
- mode_factory, only_if, skip_message):
+ mode_factory):
all_params = _load_all_params(path, file_names, param_loader)
@pytest.mark.parametrize("params", all_params)
def test_aead(self, backend, params):
- aead_test(
- backend,
- cipher_factory,
- mode_factory,
- params,
- only_if,
- skip_message
- )
+ aead_test(backend, cipher_factory, mode_factory, params)
return test_aead
-def aead_test(backend, cipher_factory, mode_factory, params, only_if,
- skip_message):
- if not only_if(backend):
- pytest.skip(skip_message)
+def aead_test(backend, cipher_factory, mode_factory, params):
if params.get("pt") is not None:
plaintext = params["pt"]
ciphertext = params["ct"]
@@ -124,26 +104,16 @@
def generate_stream_encryption_test(param_loader, path, file_names,
- cipher_factory, only_if=None,
- skip_message=None):
+ cipher_factory):
all_params = _load_all_params(path, file_names, param_loader)
@pytest.mark.parametrize("params", all_params)
def test_stream_encryption(self, backend, params):
- stream_encryption_test(
- backend,
- cipher_factory,
- params,
- only_if,
- skip_message
- )
+ stream_encryption_test(backend, cipher_factory, params)
return test_stream_encryption
-def stream_encryption_test(backend, cipher_factory, params, only_if,
- skip_message):
- if not only_if(backend):
- pytest.skip(skip_message)
+def stream_encryption_test(backend, cipher_factory, params):
plaintext = params["plaintext"]
ciphertext = params["ciphertext"]
offset = params["offset"]
@@ -161,25 +131,16 @@
assert actual_plaintext == binascii.unhexlify(plaintext)
-def generate_hash_test(param_loader, path, file_names, hash_cls,
- only_if=None, skip_message=None):
+def generate_hash_test(param_loader, path, file_names, hash_cls):
all_params = _load_all_params(path, file_names, param_loader)
@pytest.mark.parametrize("params", all_params)
def test_hash(self, backend, params):
- hash_test(
- backend,
- hash_cls,
- params,
- only_if,
- skip_message
- )
+ hash_test(backend, hash_cls, params)
return test_hash
-def hash_test(backend, algorithm, params, only_if, skip_message):
- if only_if is not None and not only_if(backend):
- pytest.skip(skip_message)
+def hash_test(backend, algorithm, params):
msg = params[0]
md = params[1]
m = hashes.Hash(algorithm, backend=backend)
@@ -188,25 +149,7 @@
assert m.finalize() == binascii.unhexlify(expected_md)
-def generate_base_hash_test(algorithm, digest_size, block_size,
- only_if=None, skip_message=None):
- def test_base_hash(self, backend):
- base_hash_test(
- backend,
- algorithm,
- digest_size,
- block_size,
- only_if,
- skip_message,
- )
- return test_base_hash
-
-
-def base_hash_test(backend, algorithm, digest_size, block_size, only_if,
- skip_message):
- if only_if is not None and not only_if(backend):
- pytest.skip(skip_message)
-
+def base_hash_test(backend, algorithm, digest_size, block_size):
m = hashes.Hash(algorithm, backend=backend)
assert m.algorithm.digest_size == digest_size
assert m.algorithm.block_size == block_size
@@ -221,46 +164,28 @@
assert copy.finalize() == m.finalize()
-def generate_long_string_hash_test(hash_factory, md, only_if=None,
- skip_message=None):
+def generate_long_string_hash_test(hash_factory, md):
def test_long_string_hash(self, backend):
- long_string_hash_test(
- backend,
- hash_factory,
- md,
- only_if,
- skip_message
- )
+ long_string_hash_test(backend, hash_factory, md)
return test_long_string_hash
-def long_string_hash_test(backend, algorithm, md, only_if, skip_message):
- if only_if is not None and not only_if(backend):
- pytest.skip(skip_message)
+def long_string_hash_test(backend, algorithm, md):
m = hashes.Hash(algorithm, backend=backend)
m.update(b"a" * 1000000)
assert m.finalize() == binascii.unhexlify(md.lower().encode("ascii"))
-def generate_hmac_test(param_loader, path, file_names, algorithm,
- only_if=None, skip_message=None):
+def generate_hmac_test(param_loader, path, file_names, algorithm):
all_params = _load_all_params(path, file_names, param_loader)
@pytest.mark.parametrize("params", all_params)
def test_hmac(self, backend, params):
- hmac_test(
- backend,
- algorithm,
- params,
- only_if,
- skip_message
- )
+ hmac_test(backend, algorithm, params)
return test_hmac
-def hmac_test(backend, algorithm, params, only_if, skip_message):
- if only_if is not None and not only_if(backend):
- pytest.skip(skip_message)
+def hmac_test(backend, algorithm, params):
msg = params[0]
md = params[1]
key = params[2]
@@ -269,44 +194,13 @@
assert h.finalize() == binascii.unhexlify(md.encode("ascii"))
-def generate_base_hmac_test(hash_cls, only_if=None, skip_message=None):
- def test_base_hmac(self, backend):
- base_hmac_test(
- backend,
- hash_cls,
- only_if,
- skip_message,
- )
- return test_base_hmac
-
-
-def base_hmac_test(backend, algorithm, only_if, skip_message):
- if only_if is not None and not only_if(backend):
- pytest.skip(skip_message)
- 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_aead_exception_test(cipher_factory, mode_factory,
- only_if, skip_message):
+def generate_aead_exception_test(cipher_factory, mode_factory):
def test_aead_exception(self, backend):
- aead_exception_test(
- backend,
- cipher_factory,
- mode_factory,
- only_if,
- skip_message
- )
+ aead_exception_test(backend, cipher_factory, mode_factory)
return test_aead_exception
-def aead_exception_test(backend, cipher_factory, mode_factory,
- only_if, skip_message):
- if not only_if(backend):
- pytest.skip(skip_message)
+def aead_exception_test(backend, cipher_factory, mode_factory):
cipher = Cipher(
cipher_factory(binascii.unhexlify(b"0" * 32)),
mode_factory(binascii.unhexlify(b"0" * 24)),
@@ -336,23 +230,13 @@
decryptor.tag
-def generate_aead_tag_exception_test(cipher_factory, mode_factory,
- only_if, skip_message):
+def generate_aead_tag_exception_test(cipher_factory, mode_factory):
def test_aead_tag_exception(self, backend):
- aead_tag_exception_test(
- backend,
- cipher_factory,
- mode_factory,
- only_if,
- skip_message
- )
+ aead_tag_exception_test(backend, cipher_factory, mode_factory)
return test_aead_tag_exception
-def aead_tag_exception_test(backend, cipher_factory, mode_factory,
- only_if, skip_message):
- if not only_if(backend):
- pytest.skip(skip_message)
+def aead_tag_exception_test(backend, cipher_factory, mode_factory):
cipher = Cipher(
cipher_factory(binascii.unhexlify(b"0" * 32)),
mode_factory(binascii.unhexlify(b"0" * 24)),