From b078d8e1f446a1d2d13453e65e37fbaf4f6b17f2 Mon Sep 17 00:00:00 2001 From: Paul Kehrer Date: Fri, 27 Dec 2013 16:33:14 -0600 Subject: re-add some removed generators to simplify patch --- tests/hazmat/primitives/test_hashes.py | 107 +++++++++++++++++++++------------ tests/hazmat/primitives/test_hmac.py | 24 ++++---- tests/hazmat/primitives/utils.py | 20 ++++++ 3 files changed, 101 insertions(+), 50 deletions(-) (limited to 'tests') 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) -- cgit v1.2.3