Fixed #809 -- switch back to always using UnsupportedAlgorithm

13 files changed, 70 insertions, 63 deletions

diff --git a/tests/hazmat/backends/test_commoncrypto.py b/tests/hazmat/backends/test_commoncrypto.py
index 72ed61c0..dc6c8c5b 100644
--- a/tests/hazmat/backends/test_commoncrypto.py
+++ b/tests/hazmat/backends/test_commoncrypto.py
@@ -16,7 +16,7 @@ from __future__ import absolute_import, division, print_function
 import pytest
 
 from cryptography import utils
-from cryptography.exceptions import InternalError, UnsupportedCipher
+from cryptography.exceptions import InternalError, UnsupportedAlgorithm
 from cryptography.hazmat.bindings.commoncrypto.binding import Binding
 from cryptography.hazmat.primitives import interfaces
 from cryptography.hazmat.primitives.ciphers.algorithms import AES
@@ -63,5 +63,5 @@ class TestCommonCrypto(object):
         cipher = Cipher(
             DummyCipher(), GCM(b"fake_iv_here"), backend=b,
         )
-        with pytest.raises(UnsupportedCipher):
+        with pytest.raises(UnsupportedAlgorithm):
             cipher.encryptor()
diff --git a/tests/hazmat/backends/test_multibackend.py b/tests/hazmat/backends/test_multibackend.py
index c5c0d82a..7ab9e446 100644
--- a/tests/hazmat/backends/test_multibackend.py
+++ b/tests/hazmat/backends/test_multibackend.py
@@ -16,9 +16,7 @@ from __future__ import absolute_import, division, print_function
 import pytest
 
 from cryptography import utils
-from cryptography.exceptions import (
-    UnsupportedAlgorithm, UnsupportedCipher, UnsupportedHash
-)
+from cryptography.exceptions import UnsupportedAlgorithm
 from cryptography.hazmat.backends.interfaces import (
     CipherBackend, HMACBackend, HashBackend, PBKDF2HMACBackend, RSABackend
 )
@@ -38,11 +36,11 @@ class DummyCipherBackend(object):
 
     def create_symmetric_encryption_ctx(self, algorithm, mode):
         if not self.cipher_supported(algorithm, mode):
-            raise UnsupportedCipher
+            raise UnsupportedAlgorithm(None)
 
     def create_symmetric_decryption_ctx(self, algorithm, mode):
         if not self.cipher_supported(algorithm, mode):
-            raise UnsupportedCipher
+            raise UnsupportedAlgorithm(None)
 
 
 @utils.register_interface(HashBackend)
@@ -55,7 +53,7 @@ class DummyHashBackend(object):
 
     def create_hash_ctx(self, algorithm):
         if not self.hash_supported(algorithm):
-            raise UnsupportedHash
+            raise UnsupportedAlgorithm(None)
 
 
 @utils.register_interface(HMACBackend)
@@ -68,7 +66,7 @@ class DummyHMACBackend(object):
 
     def create_hmac_ctx(self, key, algorithm):
         if not self.hmac_supported(algorithm):
-            raise UnsupportedHash
+            raise UnsupportedAlgorithm(None)
 
 
 @utils.register_interface(PBKDF2HMACBackend)
@@ -82,7 +80,7 @@ class DummyPBKDF2HMACBackend(object):
     def derive_pbkdf2_hmac(self, algorithm, length, salt, iterations,
                            key_material):
         if not self.pbkdf2_hmac_supported(algorithm):
-            raise UnsupportedHash
+            raise UnsupportedAlgorithm(None)
 
 
 @utils.register_interface(RSABackend)
@@ -123,9 +121,9 @@ class TestMultiBackend(object):
             modes.CBC(b"\x00" * 16),
             backend=backend
         )
-        with pytest.raises(UnsupportedCipher):
+        with pytest.raises(UnsupportedAlgorithm):
             cipher.encryptor()
-        with pytest.raises(UnsupportedCipher):
+        with pytest.raises(UnsupportedAlgorithm):
             cipher.decryptor()
 
     def test_hashes(self):
@@ -136,7 +134,7 @@ class TestMultiBackend(object):
 
         hashes.Hash(hashes.MD5(), backend=backend)
 
-        with pytest.raises(UnsupportedHash):
+        with pytest.raises(UnsupportedAlgorithm):
             hashes.Hash(hashes.SHA1(), backend=backend)
 
     def test_hmac(self):
@@ -147,7 +145,7 @@ class TestMultiBackend(object):
 
         hmac.HMAC(b"", hashes.MD5(), backend=backend)
 
-        with pytest.raises(UnsupportedHash):
+        with pytest.raises(UnsupportedAlgorithm):
             hmac.HMAC(b"", hashes.SHA1(), backend=backend)
 
     def test_pbkdf2(self):
@@ -158,7 +156,7 @@ class TestMultiBackend(object):
 
         backend.derive_pbkdf2_hmac(hashes.MD5(), 10, b"", 10, b"")
 
-        with pytest.raises(UnsupportedHash):
+        with pytest.raises(UnsupportedAlgorithm):
             backend.derive_pbkdf2_hmac(hashes.SHA1(), 10, b"", 10, b"")
 
     def test_rsa(self):
diff --git a/tests/hazmat/backends/test_openssl.py b/tests/hazmat/backends/test_openssl.py
index 3747f436..fdc661f0 100644
--- a/tests/hazmat/backends/test_openssl.py
+++ b/tests/hazmat/backends/test_openssl.py
@@ -16,9 +16,7 @@ from __future__ import absolute_import, division, print_function
 import pytest
 
 from cryptography import utils
-from cryptography.exceptions import (
-    InternalError, UnsupportedCipher, UnsupportedHash
-)
+from cryptography.exceptions import InternalError, UnsupportedAlgorithm
 from cryptography.hazmat.backends.openssl.backend import Backend, backend
 from cryptography.hazmat.primitives import hashes, interfaces
 from cryptography.hazmat.primitives.asymmetric import padding, rsa
@@ -78,7 +76,7 @@ class TestOpenSSL(object):
         cipher = Cipher(
             DummyCipher(), mode, backend=b,
         )
-        with pytest.raises(UnsupportedCipher):
+        with pytest.raises(UnsupportedAlgorithm):
             cipher.encryptor()
 
     def test_consume_errors(self):
@@ -140,7 +138,7 @@ class TestOpenSSL(object):
     def test_derive_pbkdf2_raises_unsupported_on_old_openssl(self):
         if backend.pbkdf2_hmac_supported(hashes.SHA256()):
             pytest.skip("Requires an older OpenSSL")
-        with pytest.raises(UnsupportedHash):
+        with pytest.raises(UnsupportedAlgorithm):
             backend.derive_pbkdf2_hmac(hashes.SHA256(), 10, b"", 1000, b"")
 
     @pytest.mark.skipif(
@@ -153,7 +151,7 @@ class TestOpenSSL(object):
             key_size=512,
             backend=backend
         )
-        with pytest.raises(UnsupportedHash):
+        with pytest.raises(UnsupportedAlgorithm):
             private_key.signer(
                 padding.PSS(
                     mgf=padding.MGF1(
@@ -165,7 +163,7 @@ class TestOpenSSL(object):
                 backend
             )
         public_key = private_key.public_key()
-        with pytest.raises(UnsupportedHash):
+        with pytest.raises(UnsupportedAlgorithm):
             public_key.verifier(
                 b"sig",
                 padding.PSS(
diff --git a/tests/hazmat/primitives/test_block.py b/tests/hazmat/primitives/test_block.py
index f2dab6cf..e9ea7fb0 100644
--- a/tests/hazmat/primitives/test_block.py
+++ b/tests/hazmat/primitives/test_block.py
@@ -18,7 +18,7 @@ import binascii
 import pytest
 
 from cryptography import utils
-from cryptography.exceptions import AlreadyFinalized, UnsupportedCipher
+from cryptography.exceptions import AlreadyFinalized, UnsupportedAlgorithm
 from cryptography.hazmat.primitives import interfaces
 from cryptography.hazmat.primitives.ciphers import (
     Cipher, algorithms, modes
@@ -114,10 +114,10 @@ class TestCipherContext(object):
         cipher = Cipher(
             DummyCipher(), mode, backend
         )
-        with pytest.raises(UnsupportedCipher):
+        with pytest.raises(UnsupportedAlgorithm):
             cipher.encryptor()
 
-        with pytest.raises(UnsupportedCipher):
+        with pytest.raises(UnsupportedAlgorithm):
             cipher.decryptor()
 
     def test_incorrectly_padded(self, backend):
diff --git a/tests/hazmat/primitives/test_ciphers.py b/tests/hazmat/primitives/test_ciphers.py
index 1bea0bdb..827b3b90 100644
--- a/tests/hazmat/primitives/test_ciphers.py
+++ b/tests/hazmat/primitives/test_ciphers.py
@@ -17,7 +17,7 @@ import binascii
 
 import pytest
 
-from cryptography.exceptions import UnsupportedInterface
+from cryptography.exceptions import UnsupportedAlgorithm
 from cryptography.hazmat.primitives import ciphers
 from cryptography.hazmat.primitives.ciphers.algorithms import (
     AES, ARC4, Blowfish, CAST5, Camellia, IDEA, TripleDES
@@ -128,5 +128,5 @@ class TestIDEA(object):
 def test_invalid_backend():
     pretend_backend = object()
 
-    with pytest.raises(UnsupportedInterface):
+    with pytest.raises(UnsupportedAlgorithm):
         ciphers.Cipher(AES(b"AAAAAAAAAAAAAAAA"), ECB, pretend_backend)
diff --git a/tests/hazmat/primitives/test_hashes.py b/tests/hazmat/primitives/test_hashes.py
index 5b318f64..ce8e92a3 100644
--- a/tests/hazmat/primitives/test_hashes.py
+++ b/tests/hazmat/primitives/test_hashes.py
@@ -20,9 +20,7 @@ import pytest
 import six
 
 from cryptography import utils
-from cryptography.exceptions import (
-    AlreadyFinalized, UnsupportedHash, UnsupportedInterface
-)
+from cryptography.exceptions import AlreadyFinalized, UnsupportedAlgorithm
 from cryptography.hazmat.backends.interfaces import HashBackend
 from cryptography.hazmat.primitives import hashes, interfaces
 
@@ -72,7 +70,7 @@ class TestHashContext(object):
             h.finalize()
 
     def test_unsupported_hash(self, backend):
-        with pytest.raises(UnsupportedHash):
+        with pytest.raises(UnsupportedAlgorithm):
             hashes.Hash(UnsupportedDummyHash(), backend)
 
 
@@ -183,5 +181,5 @@ class TestMD5(object):
 def test_invalid_backend():
     pretend_backend = object()
 
-    with pytest.raises(UnsupportedInterface):
+    with pytest.raises(UnsupportedAlgorithm):
         hashes.Hash(hashes.SHA1(), pretend_backend)
diff --git a/tests/hazmat/primitives/test_hkdf.py b/tests/hazmat/primitives/test_hkdf.py
index 367addc9..b3d412c5 100644
--- a/tests/hazmat/primitives/test_hkdf.py
+++ b/tests/hazmat/primitives/test_hkdf.py
@@ -18,7 +18,7 @@ import pytest
 import six
 
 from cryptography.exceptions import (
-    AlreadyFinalized, InvalidKey, UnsupportedInterface
+    AlreadyFinalized, InvalidKey, UnsupportedAlgorithm
 )
 from cryptography.hazmat.primitives import hashes
 from cryptography.hazmat.primitives.kdf.hkdf import HKDF
@@ -152,5 +152,5 @@ class TestHKDF(object):
 def test_invalid_backend():
     pretend_backend = object()
 
-    with pytest.raises(UnsupportedInterface):
+    with pytest.raises(UnsupportedAlgorithm):
         HKDF(hashes.SHA256(), 16, None, None, pretend_backend)
diff --git a/tests/hazmat/primitives/test_hmac.py b/tests/hazmat/primitives/test_hmac.py
index 1065359a..cdf8909d 100644
--- a/tests/hazmat/primitives/test_hmac.py
+++ b/tests/hazmat/primitives/test_hmac.py
@@ -21,7 +21,7 @@ import six
 
 from cryptography import utils
 from cryptography.exceptions import (
-    AlreadyFinalized, InvalidSignature, UnsupportedHash, UnsupportedInterface
+    AlreadyFinalized, InvalidSignature, UnsupportedAlgorithm
 )
 from cryptography.hazmat.backends.interfaces import HMACBackend
 from cryptography.hazmat.primitives import hashes, hmac, interfaces
@@ -106,12 +106,12 @@ class TestHMAC(object):
             h.verify(six.u(''))
 
     def test_unsupported_hash(self, backend):
-        with pytest.raises(UnsupportedHash):
+        with pytest.raises(UnsupportedAlgorithm):
             hmac.HMAC(b"key", UnsupportedDummyHash(), backend)
 
 
 def test_invalid_backend():
     pretend_backend = object()
 
-    with pytest.raises(UnsupportedInterface):
+    with pytest.raises(UnsupportedAlgorithm):
         hmac.HMAC(b"key", hashes.SHA1(), pretend_backend)
diff --git a/tests/hazmat/primitives/test_pbkdf2hmac.py b/tests/hazmat/primitives/test_pbkdf2hmac.py
index 585693ea..ebc5fbf5 100644
--- a/tests/hazmat/primitives/test_pbkdf2hmac.py
+++ b/tests/hazmat/primitives/test_pbkdf2hmac.py
@@ -18,7 +18,7 @@ import six
 
 from cryptography import utils
 from cryptography.exceptions import (
-    AlreadyFinalized, InvalidKey, UnsupportedHash, UnsupportedInterface
+    AlreadyFinalized, InvalidKey, UnsupportedAlgorithm
 )
 from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives import hashes, interfaces
@@ -48,7 +48,7 @@ class TestPBKDF2HMAC(object):
             kdf.verify(b"password", key)
 
     def test_unsupported_algorithm(self):
-        with pytest.raises(UnsupportedHash):
+        with pytest.raises(UnsupportedAlgorithm):
             PBKDF2HMAC(DummyHash(), 20, b"salt", 10, default_backend())
 
     def test_invalid_key(self):
@@ -72,5 +72,5 @@ class TestPBKDF2HMAC(object):
 def test_invalid_backend():
     pretend_backend = object()
 
-    with pytest.raises(UnsupportedInterface):
+    with pytest.raises(UnsupportedAlgorithm):
         PBKDF2HMAC(hashes.SHA1(), 20, b"salt", 10, pretend_backend)
diff --git a/tests/hazmat/primitives/test_rsa.py b/tests/hazmat/primitives/test_rsa.py
index eb7e1e60..2d3ce092 100644
--- a/tests/hazmat/primitives/test_rsa.py
+++ b/tests/hazmat/primitives/test_rsa.py
@@ -21,9 +21,9 @@ import os
 
 import pytest
 
-from cryptography import exceptions, utils
+from cryptography import utils
 from cryptography.exceptions import (
-    UnsupportedAlgorithm, UnsupportedInterface
+    AlreadyFinalized, InvalidSignature, UnsupportedAlgorithm
 )
 from cryptography.hazmat.primitives import hashes, interfaces
 from cryptography.hazmat.primitives.asymmetric import padding, rsa
@@ -398,7 +398,7 @@ class TestRSA(object):
 def test_rsa_generate_invalid_backend():
     pretend_backend = object()
 
-    with pytest.raises(UnsupportedInterface):
+    with pytest.raises(UnsupportedAlgorithm):
         rsa.RSAPrivateKey.generate(65537, 2048, pretend_backend)
 
 
@@ -594,9 +594,9 @@ class TestRSASignature(object):
         signer = private_key.signer(padding.PKCS1v15(), hashes.SHA1(), backend)
         signer.update(b"sign me")
         signer.finalize()
-        with pytest.raises(exceptions.AlreadyFinalized):
+        with pytest.raises(AlreadyFinalized):
             signer.finalize()
-        with pytest.raises(exceptions.AlreadyFinalized):
+        with pytest.raises(AlreadyFinalized):
             signer.update(b"more data")
 
     def test_unsupported_padding(self, backend):
@@ -605,7 +605,7 @@ class TestRSASignature(object):
             key_size=512,
             backend=backend
         )
-        with pytest.raises(exceptions.UnsupportedPadding):
+        with pytest.raises(UnsupportedAlgorithm):
             private_key.signer(DummyPadding(), hashes.SHA1(), backend)
 
     def test_padding_incorrect_type(self, backend):
@@ -621,7 +621,7 @@ class TestRSASignature(object):
         pretend_backend = object()
         private_key = rsa.RSAPrivateKey.generate(65537, 2048, backend)
 
-        with pytest.raises(UnsupportedInterface):
+        with pytest.raises(UnsupportedAlgorithm):
             private_key.signer(
                 padding.PKCS1v15(), hashes.SHA256, pretend_backend)
 
@@ -678,7 +678,7 @@ class TestRSAVerification(object):
             backend
         )
         verifier.update(b"incorrect data")
-        with pytest.raises(exceptions.InvalidSignature):
+        with pytest.raises(InvalidSignature):
             verifier.verify()
 
     def test_invalid_pkcs1v15_signature_wrong_key(self, backend):
@@ -703,7 +703,7 @@ class TestRSAVerification(object):
             backend
         )
         verifier.update(b"sign me")
-        with pytest.raises(exceptions.InvalidSignature):
+        with pytest.raises(InvalidSignature):
             verifier.verify()
 
     @pytest.mark.parametrize(
@@ -759,7 +759,7 @@ class TestRSAVerification(object):
             backend
         )
         verifier.update(b"incorrect data")
-        with pytest.raises(exceptions.InvalidSignature):
+        with pytest.raises(InvalidSignature):
             verifier.verify()
 
     def test_invalid_pss_signature_wrong_key(self, backend):
@@ -789,7 +789,7 @@ class TestRSAVerification(object):
             backend
         )
         verifier.update(b"sign me")
-        with pytest.raises(exceptions.InvalidSignature):
+        with pytest.raises(InvalidSignature):
             verifier.verify()
 
     def test_invalid_pss_signature_data_too_large_for_modulus(self, backend):
@@ -819,7 +819,7 @@ class TestRSAVerification(object):
             backend
         )
         verifier.update(b"sign me")
-        with pytest.raises(exceptions.InvalidSignature):
+        with pytest.raises(InvalidSignature):
             verifier.verify()
 
     def test_use_after_finalize(self, backend):
@@ -841,9 +841,9 @@ class TestRSAVerification(object):
         )
         verifier.update(b"sign me")
         verifier.verify()
-        with pytest.raises(exceptions.AlreadyFinalized):
+        with pytest.raises(AlreadyFinalized):
             verifier.verify()
-        with pytest.raises(exceptions.AlreadyFinalized):
+        with pytest.raises(AlreadyFinalized):
             verifier.update(b"more data")
 
     def test_unsupported_padding(self, backend):
@@ -853,7 +853,7 @@ class TestRSAVerification(object):
             backend=backend
         )
         public_key = private_key.public_key()
-        with pytest.raises(exceptions.UnsupportedPadding):
+        with pytest.raises(UnsupportedAlgorithm):
             public_key.verifier(b"sig", DummyPadding(), hashes.SHA1(), backend)
 
     def test_padding_incorrect_type(self, backend):
@@ -871,7 +871,7 @@ class TestRSAVerification(object):
         private_key = rsa.RSAPrivateKey.generate(65537, 2048, backend)
         public_key = private_key.public_key()
 
-        with pytest.raises(UnsupportedInterface):
+        with pytest.raises(UnsupportedAlgorithm):
             public_key.verifier(
                 b"foo", padding.PKCS1v15(), hashes.SHA256(), pretend_backend)
 
@@ -939,7 +939,7 @@ class TestRSAVerification(object):
             backend
         )
         verifier.update(b"sign me")
-        with pytest.raises(exceptions.InvalidSignature):
+        with pytest.raises(InvalidSignature):
             verifier.verify()
 
 
diff --git a/tests/hazmat/primitives/twofactor/test_hotp.py b/tests/hazmat/primitives/twofactor/test_hotp.py
index 4bb7c6b3..b2b2677c 100644
--- a/tests/hazmat/primitives/twofactor/test_hotp.py
+++ b/tests/hazmat/primitives/twofactor/test_hotp.py
@@ -17,12 +17,14 @@ import os
 
 import pytest
 
-from cryptography.exceptions import InvalidToken, UnsupportedInterface
+from cryptography.exceptions import InvalidToken, _Causes
 from cryptography.hazmat.primitives import hashes
 from cryptography.hazmat.primitives.hashes import MD5, SHA1
 from cryptography.hazmat.primitives.twofactor.hotp import HOTP
 
-from ....utils import load_nist_vectors, load_vectors_from_file
+from ....utils import (
+    load_nist_vectors, load_vectors_from_file, raises_unsupported
+)
 
 vectors = load_vectors_from_file(
     "twofactor/rfc-4226.txt", load_nist_vectors)
@@ -103,5 +105,5 @@ def test_invalid_backend():
 
     pretend_backend = object()
 
-    with pytest.raises(UnsupportedInterface):
+    with raises_unsupported(_Causes.BACKEND_MISSING_INTERFACE):
         HOTP(secret, 8, hashes.SHA1(), pretend_backend)
diff --git a/tests/hazmat/primitives/twofactor/test_totp.py b/tests/hazmat/primitives/twofactor/test_totp.py
index d5b0a8ed..208b0eea 100644
--- a/tests/hazmat/primitives/twofactor/test_totp.py
+++ b/tests/hazmat/primitives/twofactor/test_totp.py
@@ -15,11 +15,13 @@ from __future__ import absolute_import, division, print_function
 
 import pytest
 
-from cryptography.exceptions import InvalidToken, UnsupportedInterface
+from cryptography.exceptions import InvalidToken, _Causes
 from cryptography.hazmat.primitives import hashes
 from cryptography.hazmat.primitives.twofactor.totp import TOTP
 
-from ....utils import load_nist_vectors, load_vectors_from_file
+from ....utils import (
+    load_nist_vectors, load_vectors_from_file, raises_unsupported
+)
 
 vectors = load_vectors_from_file(
     "twofactor/rfc-6238.txt", load_nist_vectors)
@@ -137,5 +139,5 @@ def test_invalid_backend():
 
     pretend_backend = object()
 
-    with pytest.raises(UnsupportedInterface):
+    with raises_unsupported(_Causes.BACKEND_MISSING_INTERFACE):
         TOTP(secret, 8, hashes.SHA1(), 30, pretend_backend)
diff --git a/tests/utils.py b/tests/utils.py
index 3e35970e..fbe448fe 100644
--- a/tests/utils.py
+++ b/tests/utils.py
@@ -14,11 +14,13 @@
 from __future__ import absolute_import, division, print_function
 
 import collections
+from contextlib import contextmanager
 
 import pytest
 
 import six
 
+from cryptography.exceptions import UnsupportedAlgorithm
 import cryptography_vectors
 
 
@@ -67,6 +69,13 @@ def check_backend_support(item):
                          "backend")
 
 
+@contextmanager
+def raises_unsupported(cause):
+    with pytest.raises(UnsupportedAlgorithm) as exc_info:
+        yield
+    assert exc_info.value._cause == cause
+
+
 def load_vectors_from_file(filename, loader):
     with cryptography_vectors.open_vector_file(filename) as vector_file:
         return loader(vector_file)