Removed unit tests not corresponding to this branch

Author: Andres Sanchez

test/unit/test_deserialize.py

@@ -13,6 +13,7 @@
 """Unit test suite for aws_encryption_sdk.deserialize"""
 import io
 import struct
+import unittest
 
 import pytest
 import six
@@ -55,9 +56,8 @@ def test_deserialize_tag():
     assert parsed_tag == tag
 
 
-class TestDeserialize(object):
-    @pytest.fixture(autouse=True)
-    def apply_fixtures(self):
+class TestDeserialize(unittest.TestCase):
+    def setUp(self):
         self.mock_wrapping_algorithm = MagicMock()
         self.mock_wrapping_algorithm.algorithm.iv_len = VALUES["iv_len"]
 
@@ -109,32 +109,29 @@ def test_validate_header_invalid(self):
             as expected for a valid header.
         """
         self.mock_decrypt.side_effect = InvalidTag()
-        with pytest.raises(SerializationError) as excinfo:
+        with six.assertRaisesRegex(self, SerializationError, "Header authorization failed"):
             aws_encryption_sdk.internal.formatting.deserialize.validate_header(
                 header=VALUES["deserialized_header_block"],
                 header_auth=VALUES["deserialized_header_auth_block"],
                 raw_header=VALUES["header"],
                 data_key=VALUES["data_key_obj"],
             )
-        excinfo.match("Header authorization failed")
 
     def test_deserialize_header_unknown_object_type(self):
         """Validate that the deserialize_header function behaves
             as expected for an unknown object type.
         """
-        with pytest.raises(NotSupportedError) as excinfo:
+        with six.assertRaisesRegex(self, NotSupportedError, "Unsupported type *"):
             stream = io.BytesIO(VALUES["serialized_header_invalid_object_type"])
             aws_encryption_sdk.internal.formatting.deserialize.deserialize_header(stream)
-        excinfo.match("Unsupported type *")
 
     def test_deserialize_header_unknown_version(self):
         """Validate that the deserialize_header function behaves
             as expected for an unknown message version.
         """
-        with pytest.raises(NotSupportedError) as excinfo:
+        with six.assertRaisesRegex(self, NotSupportedError, "Unsupported version *"):
             stream = io.BytesIO(VALUES["serialized_header_invalid_version"])
             aws_encryption_sdk.internal.formatting.deserialize.deserialize_header(stream)
-        excinfo.match("Unsupported version *")
 
     @patch("aws_encryption_sdk.internal.formatting.deserialize.AlgorithmSuite.get_by_id")
     def test_deserialize_header_unsupported_data_encryption_algorithm(self, mock_algorithm_get):
@@ -144,70 +141,65 @@ def test_deserialize_header_unsupported_data_encryption_algorithm(self, mock_alg
         mock_unsupported_algorithm = MagicMock()
         mock_unsupported_algorithm.allowed = False
         mock_algorithm_get.return_value = mock_unsupported_algorithm
-        with pytest.raises(NotSupportedError) as excinfo:
+        with six.assertRaisesRegex(self, NotSupportedError, "Unsupported algorithm *"):
             stream = io.BytesIO(VALUES["serialized_header_disallowed_algorithm"])
             aws_encryption_sdk.internal.formatting.deserialize.deserialize_header(stream)
-        excinfo.match("Unsupported algorithm *")
 
     @patch("aws_encryption_sdk.internal.formatting.deserialize.AlgorithmSuite.get_by_id")
     def test_deserialize_header_unknown_data_encryption_algorithm(self, mock_algorithm_get):
         """Validate that the deserialize_header function behaves
             as expected for an unknown algorithm.
         """
         mock_algorithm_get.side_effect = KeyError()
-        with pytest.raises(UnknownIdentityError) as excinfo:
+        with six.assertRaisesRegex(self, UnknownIdentityError, "Unknown algorithm *"):
             stream = io.BytesIO(VALUES["serialized_header_invalid_algorithm"])
             aws_encryption_sdk.internal.formatting.deserialize.deserialize_header(stream)
-        excinfo.match("Unknown algorithm *")
 
     def test_deserialize_header_unknown_content_type(self):
         """Validate that the deserialize_header function behaves
             as expected for an unknown content type.
         """
-        with pytest.raises(UnknownIdentityError) as excinfo:
+        with six.assertRaisesRegex(self, UnknownIdentityError, "Unknown content type *"):
             stream = io.BytesIO(VALUES["serialized_header_unknown_content_type"])
             aws_encryption_sdk.internal.formatting.deserialize.deserialize_header(stream)
-        excinfo.match("Unknown content type *")
 
     def test_deserialize_header_invalid_reserved_space(self):
         """Validate that the deserialize_header function behaves
             as expected for an invalid value in the reserved
             space (formerly content AAD).
         """
-        with pytest.raises(SerializationError) as excinfo:
+        with six.assertRaisesRegex(
+            self, SerializationError, "Content AAD length field is currently unused, its value must be always 0"
+        ):
             stream = io.BytesIO(VALUES["serialized_header_bad_reserved_space"])
             aws_encryption_sdk.internal.formatting.deserialize.deserialize_header(stream)
-        excinfo.match("Content AAD length field is currently unused, its value must be always 0")
 
     def test_deserialize_header_bad_iv_len(self):
         """Validate that the deserialize_header function behaves
             as expected for bad IV length (incompatible with
             specified algorithm).
         """
-        with pytest.raises(SerializationError) as excinfo:
+        with six.assertRaisesRegex(self, SerializationError, "Specified IV length *"):
             stream = io.BytesIO(VALUES["serialized_header_bad_iv_len"])
             aws_encryption_sdk.internal.formatting.deserialize.deserialize_header(stream)
-        excinfo.match("Specified IV length *")
 
     def test_deserialize_header_framed_bad_frame_length(self):
         """Validate that the deserialize_header function behaves
             as expected for bad frame length values (greater than
             the default maximum).
         """
-        with pytest.raises(SerializationError) as excinfo:
+        with six.assertRaisesRegex(self, SerializationError, "Specified frame length larger than allowed maximum: *"):
             stream = io.BytesIO(VALUES["serialized_header_bad_frame_len"])
             aws_encryption_sdk.internal.formatting.deserialize.deserialize_header(stream)
-        excinfo.match("Specified frame length larger than allowed maximum: *")
 
     def test_deserialize_header_non_framed_bad_frame_length(self):
         """Validate that the deserialize_header function behaves
             as expected for bad frame length values for non-framed
             messages (non-zero).
         """
-        with pytest.raises(SerializationError) as excinfo:
+        with six.assertRaisesRegex(self, SerializationError, "Non-zero frame length found for non-framed message"):
             stream = io.BytesIO(VALUES["serialized_non_framed_header_bad_frame_len"])
             aws_encryption_sdk.internal.formatting.deserialize.deserialize_header(stream)
-        excinfo.match("Non-zero frame length found for non-framed message")
 
     def test_deserialize_header_valid(self):
         """Validate that the deserialize_header function behaves
@@ -255,11 +247,10 @@ def test_deserialize_body_frame_final_invalid_final_frame_length(self):
             behaves as expected for a valid final body frame.
         """
         stream = io.BytesIO(VALUES["serialized_final_frame_bad_length"])
-        with pytest.raises(SerializationError) as excinfo:
+        with six.assertRaisesRegex(self, SerializationError, "Invalid final frame length: *"):
             aws_encryption_sdk.internal.formatting.deserialize.deserialize_frame(
                 stream=stream, header=VALUES["deserialized_header_frame"]
             )
-        excinfo.match("Invalid final frame length: *")
 
     def test_deserialize_footer_no_verifier(self):
         """Vaidate that the deserialize_footer function behaves
@@ -284,9 +275,8 @@ def test_deserialize_footer_verifier_no_footer(self):
             with no footer.
         """
         stream = io.BytesIO(b"")
-        with pytest.raises(SerializationError) as excinfo:
+        with six.assertRaisesRegex(self, SerializationError, "No signature found in message"):
             aws_encryption_sdk.internal.formatting.deserialize.deserialize_footer(stream, self.mock_verifier)
-        excinfo.match("No signature found in message")
 
     @patch("aws_encryption_sdk.internal.formatting.deserialize.struct")
     def test_unpack_values(self, mock_struct):
@@ -338,65 +328,59 @@ def test_deserialize_wrapped_key_symmetric(self):
         )
 
     def test_deserialize_wrapped_key_symmetric_wrapping_key_mismatch(self):
-        with pytest.raises(SerializationError) as excinfo:
+        with six.assertRaisesRegex(self, SerializationError, "Master Key mismatch for wrapped data key"):
             aws_encryption_sdk.internal.formatting.deserialize.deserialize_wrapped_key(
                 wrapping_algorithm=self.mock_wrapping_algorithm,
                 wrapping_key_id=b"asifuhasjaskldjfhlsakdfj",
                 wrapped_encrypted_key=VALUES["wrapped_keys"]["structures"]["wrapped_encrypted_data_key_asymmetric"],
             )
-        excinfo.match("Master Key mismatch for wrapped data key")
 
     def test_deserialize_wrapped_key_symmetric_wrapping_algorithm_incomplete_info(self):
-        with pytest.raises(SerializationError) as excinfo:
+        with six.assertRaisesRegex(self, SerializationError, "Malformed key info: key info missing data"):
             aws_encryption_sdk.internal.formatting.deserialize.deserialize_wrapped_key(
                 wrapping_algorithm=self.mock_wrapping_algorithm,
                 wrapping_key_id=VALUES["wrapped_keys"]["raw"]["key_info"],
                 wrapped_encrypted_key=VALUES["wrapped_keys"]["structures"][
                     "wrapped_encrypted_data_key_symmetric_incomplete_info"
                 ],
             )
-        excinfo.match("Malformed key info: key info missing data")
 
     def test_deserialize_wrapped_key_symmetric_wrapping_algorithm_iv_len_mismatch(self):
-        with pytest.raises(SerializationError) as excinfo:
+        with six.assertRaisesRegex(self, SerializationError, "Wrapping AlgorithmSuite mismatch for wrapped data key"):
             aws_encryption_sdk.internal.formatting.deserialize.deserialize_wrapped_key(
                 wrapping_algorithm=self.mock_wrapping_algorithm,
                 wrapping_key_id=VALUES["wrapped_keys"]["raw"]["key_info"],
                 wrapped_encrypted_key=VALUES["wrapped_keys"]["structures"][
                     "wrapped_encrypted_data_key_symmetric_bad_iv_len"
                 ],
             )
-        excinfo.match("Wrapping AlgorithmSuite mismatch for wrapped data key")
 
     def test_deserialize_wrapped_key_symmetric_wrapping_algorithm_incomplete_iv(self):
-        with pytest.raises(SerializationError) as excinfo:
+        with six.assertRaisesRegex(self, SerializationError, "Malformed key info: incomplete iv"):
             aws_encryption_sdk.internal.formatting.deserialize.deserialize_wrapped_key(
                 wrapping_algorithm=self.mock_wrapping_algorithm,
                 wrapping_key_id=VALUES["wrapped_keys"]["raw"]["key_info"],
                 wrapped_encrypted_key=VALUES["wrapped_keys"]["structures"][
                     "wrapped_encrypted_data_key_symmetric_incomplete_iv"
                 ],
             )
-        excinfo.match("Malformed key info: incomplete iv")
 
     def test_deserialize_wrapped_key_symmetric_wrapping_algorithm_incomplete_tag(self):
-        with pytest.raises(SerializationError) as excinfo:
+        with six.assertRaisesRegex(self, SerializationError, "Malformed key info: incomplete ciphertext or tag"):
             aws_encryption_sdk.internal.formatting.deserialize.deserialize_wrapped_key(
                 wrapping_algorithm=self.mock_wrapping_algorithm,
                 wrapping_key_id=VALUES["wrapped_keys"]["raw"]["key_info"],
                 wrapped_encrypted_key=VALUES["wrapped_keys"]["structures"][
                     "wrapped_encrypted_data_key_symmetric_incomplete_tag"
                 ],
             )
-        excinfo.match("Malformed key info: incomplete ciphertext or tag")
 
     def test_deserialize_wrapped_key_symmetric_wrapping_algorithm_incomplete_tag2(self):
-        with pytest.raises(SerializationError) as excinfo:
+        with six.assertRaisesRegex(self, SerializationError, "Malformed key info: incomplete ciphertext or tag"):
             aws_encryption_sdk.internal.formatting.deserialize.deserialize_wrapped_key(
                 wrapping_algorithm=self.mock_wrapping_algorithm,
                 wrapping_key_id=VALUES["wrapped_keys"]["raw"]["key_info"],
                 wrapped_encrypted_key=VALUES["wrapped_keys"]["structures"][
                     "wrapped_encrypted_data_key_symmetric_incomplete_tag2"
                 ],
             )
-        excinfo.match("Malformed key info: incomplete ciphertext or tag")

test/unit/test_providers_kms_master_key.py

@@ -11,9 +11,11 @@
 # ANY KIND, either express or implied. See the License for the specific
 # language governing permissions and limitations under the License.
 """Unit test suite for aws_encryption_sdk.key_providers.kms.KMSMasterKey"""
+import unittest
+
 import botocore.client
 import pytest
-
+import six
 from botocore.exceptions import ClientError
 from mock import MagicMock, patch, sentinel
 
@@ -28,9 +30,8 @@
 pytestmark = [pytest.mark.unit, pytest.mark.local]
 
 
-class TestKMSMasterKey(object):
-    @pytest.fixture(autouse=True)
-    def apply_fixture(self):
+class TestKMSMasterKey(unittest.TestCase):
+    def setUp(self):
         self.mock_client = MagicMock()
         self.mock_client.__class__ = botocore.client.BaseClient
         self.mock_client.generate_data_key.return_value = {
@@ -110,16 +111,14 @@ def test_generate_data_key_with_grant_tokens(self):
     def test_generate_data_key_unsuccessful_clienterror(self):
         self.mock_client.generate_data_key.side_effect = ClientError({"Error": {}}, "This is an error!")
         test = KMSMasterKey(config=self.mock_kms_mkc_3)
-        with pytest.raises(GenerateKeyError) as excinfo:
+        with six.assertRaisesRegex(self, GenerateKeyError, "Master Key .* unable to generate data key"):
             test._generate_data_key(self.mock_algorithm)
-        excinfo.match("Master Key .* unable to generate data key")
 
     def test_generate_data_key_unsuccessful_keyerror(self):
         self.mock_client.generate_data_key.side_effect = KeyError
         test = KMSMasterKey(config=self.mock_kms_mkc_3)
-        with pytest.raises(GenerateKeyError) as excinfo:
+        with six.assertRaisesRegex(self, GenerateKeyError, "Master Key .* unable to generate data key"):
             test._generate_data_key(self.mock_algorithm)
-        excinfo.match("Master Key .* unable to generate data key")
 
     def test_encrypt_data_key(self):
         test = KMSMasterKey(config=self.mock_kms_mkc_3)
@@ -147,16 +146,14 @@ def test_encrypt_data_key_with_grant_tokens(self):
     def test_encrypt_data_key_unsuccessful_clienterror(self):
         self.mock_client.encrypt.side_effect = ClientError({"Error": {}}, "This is an error!")
         test = KMSMasterKey(config=self.mock_kms_mkc_3)
-        with pytest.raises(EncryptKeyError) as excinfo:
+        with six.assertRaisesRegex(self, EncryptKeyError, "Master Key .* unable to encrypt data key"):
             test._encrypt_data_key(self.mock_data_key, self.mock_algorithm)
-        excinfo.match("Master Key .* unable to encrypt data key")
 
     def test_encrypt_data_key_unsuccessful_keyerror(self):
         self.mock_client.encrypt.side_effect = KeyError
         test = KMSMasterKey(config=self.mock_kms_mkc_3)
-        with pytest.raises(EncryptKeyError) as excinfo:
+        with six.assertRaisesRegex(self, EncryptKeyError, "Master Key .* unable to encrypt data key"):
             test._encrypt_data_key(self.mock_data_key, self.mock_algorithm)
-        excinfo.match("Master Key .* unable to encrypt data key")
 
     def test_decrypt_data_key(self):
         test = KMSMasterKey(config=self.mock_kms_mkc_1)
@@ -189,13 +186,11 @@ def test_decrypt_data_key_with_grant_tokens(self):
     def test_decrypt_data_key_unsuccessful_clienterror(self):
         self.mock_client.decrypt.side_effect = ClientError({"Error": {}}, "This is an error!")
         test = KMSMasterKey(config=self.mock_kms_mkc_3)
-        with pytest.raises(DecryptKeyError) as excinfo:
+        with six.assertRaisesRegex(self, DecryptKeyError, "Master Key .* unable to decrypt data key"):
             test._decrypt_data_key(encrypted_data_key=self.mock_encrypted_data_key, algorithm=sentinel.algorithm)
-        excinfo.match("Master Key .* unable to decrypt data key")
 
     def test_decrypt_data_key_unsuccessful_keyerror(self):
         self.mock_client.decrypt.side_effect = KeyError
         test = KMSMasterKey(config=self.mock_kms_mkc_3)
-        with pytest.raises(DecryptKeyError) as excinfo:
+        with six.assertRaisesRegex(self, DecryptKeyError, "Master Key .* unable to decrypt data key"):
             test._decrypt_data_key(encrypted_data_key=self.mock_encrypted_data_key, algorithm=sentinel.algorithm)
-        excinfo.match("Master Key .* unable to decrypt data key")

test/unit/test_providers_kms_master_key_provider.py

@@ -11,6 +11,8 @@
 # ANY KIND, either express or implied. See the License for the specific
 # language governing permissions and limitations under the License.
 """Unit test suite from aws_encryption_sdk.key_providers.kms.KMSMasterKeyProvider"""
+import unittest
+
 import botocore.client
 import pytest
 import six
@@ -30,9 +32,8 @@ def test_init_with_regionless_key_ids_and_region_names():
     assert provider.master_key("alias/key_1").config.client.meta.region_name == region_names[0]
 
 
-class TestKMSMasterKeyProvider(object):
-    @pytest.fixture(autouse=True)
-    def apply_fixtures(self):
+class TestKMSMasterKeyProvider(unittest.TestCase):
+    def setUp(self):
         self.mock_botocore_session_patcher = patch("aws_encryption_sdk.key_providers.kms.botocore.session.Session")
         self.mock_botocore_session = self.mock_botocore_session_patcher.start()
         self.mock_boto3_session_patcher = patch("aws_encryption_sdk.key_providers.kms.boto3.session.Session")
@@ -129,9 +130,10 @@ def test_client_no_region_name_with_default(self, mock_add_client):
 
     def test_client_no_region_name_without_default(self):
         test = KMSMasterKeyProvider()
-        with pytest.raises(UnknownRegionError) as excinfo:
+        with six.assertRaisesRegex(
+            self, UnknownRegionError, "No default region found and no region determinable from key id: *"
+        ):
             test._client("")
-        excinfo.match("No default region found and no region determinable from key id: *")
 
     @patch("aws_encryption_sdk.key_providers.kms.KMSMasterKeyProvider._client")
     def test_new_master_key(self, mock_client):

test/unit/test_providers_raw_master_key.py

@@ -11,6 +11,8 @@
 # ANY KIND, either express or implied. See the License for the specific
 # language governing permissions and limitations under the License.
 """Test suite for aws_encryption_sdk.key_providers.raw.RawMasterKey"""
+import unittest
+
 import pytest
 from mock import MagicMock, patch, sentinel
 
@@ -25,9 +27,8 @@
 pytestmark = [pytest.mark.unit, pytest.mark.local]
 
 
-class TestRawMasterKey(object):
-    @pytest.fixture(autouse=True)
-    def apply_fixtures(self):
+class TestRawMasterKey(unittest.TestCase):
+    def setUp(self):
         self.mock_algorithm = MagicMock()
         self.mock_algorithm.__class__ = Algorithm
         self.mock_algorithm.data_key_len = sentinel.data_key_len