Convert fixtures/exceptions to Pytest

tests/test_kms/test_kms.py

@@ -10,17 +10,12 @@ import sure  # noqa
 from boto.exception import JSONResponseError
 from boto.kms.exceptions import AlreadyExistsException, NotFoundException
 import pytest
-from parameterized import parameterized
 from moto.core.exceptions import JsonRESTError
 from moto.kms.models import KmsBackend
 from moto.kms.exceptions import NotFoundException as MotoNotFoundException
 from moto import mock_kms_deprecated, mock_kms
 
-PLAINTEXT_VECTORS = (
-    (b"some encodeable plaintext",),
-    (b"some unencodeable plaintext \xec\x8a\xcf\xb6r\xe9\xb5\xeb\xff\xa23\x16",),
-    ("some unicode characters ø˚∆øˆˆ∆ßçøˆˆçßøˆ¨¥",),
-)
+PLAINTEXT_VECTORS = [b"some encodeable plaintext", b"some unencodeable plaintext \xec\x8a\xcf\xb6r\xe9\xb5\xeb\xff\xa23\x16", "some unicode characters ø˚∆øˆˆ∆ßçøˆˆçßøˆ¨¥"]
 
 
 def _get_encoded_value(plaintext):
@@ -495,7 +490,7 @@ def test__create_alias__raises_if_alias_has_colon_character():
         ex.status.should.equal(400)
 
 
-@parameterized((("alias/my-alias_/",), ("alias/my_alias-/",)))
+@pytest.mark.parametrize("alias_name", ["alias/my-alias_/", "alias/my_alias-/"])
 @mock_kms_deprecated
 def test__create_alias__accepted_characters(alias_name):
     kms = boto.connect_kms()

tests/test_kms/test_kms_boto3.py

@@ -11,15 +11,12 @@ import six
 import sure  # noqa
 from freezegun import freeze_time
 import pytest
-from parameterized import parameterized
 
 from moto import mock_kms
 
-PLAINTEXT_VECTORS = (
-    (b"some encodeable plaintext",),
-    (b"some unencodeable plaintext \xec\x8a\xcf\xb6r\xe9\xb5\xeb\xff\xa23\x16",),
-    ("some unicode characters ø˚∆øˆˆ∆ßçøˆˆçßøˆ¨¥",),
-)
+PLAINTEXT_VECTORS = [b"some encodeable plaintext",
+                     b"some unencodeable plaintext \xec\x8a\xcf\xb6r\xe9\xb5\xeb\xff\xa23\x16",
+                     "some unicode characters ø˚∆øˆˆ∆ßçøˆˆçßøˆ¨¥"]
 
 
 def _get_encoded_value(plaintext):
@@ -132,13 +129,7 @@ def test_describe_key():
     response["KeyMetadata"].should_not.have.key("SigningAlgorithms")
 
 
-@parameterized(
-    (
-        ("alias/does-not-exist",),
-        ("arn:aws:kms:us-east-1:012345678912:alias/does-not-exist",),
-        ("invalid",),
-    )
-)
+@pytest.mark.parametrize("key_id", ["alias/does-not-exist", "arn:aws:kms:us-east-1:012345678912:alias/does-not-exist", "invalid"])
 @mock_kms
 def test_describe_key_via_alias_invalid_alias(key_id):
     client = boto3.client("kms", region_name="us-east-1")
@@ -168,7 +159,7 @@ def test_generate_data_key():
     response["KeyId"].should.equal(key_arn)
 
 
-@parameterized(PLAINTEXT_VECTORS)
+@pytest.mark.parametrize("plaintext", PLAINTEXT_VECTORS)
 @mock_kms
 def test_encrypt(plaintext):
     client = boto3.client("kms", region_name="us-west-2")
@@ -187,7 +178,7 @@ def test_encrypt(plaintext):
     response["KeyId"].should.equal(key_arn)
 
 
-@parameterized(PLAINTEXT_VECTORS)
+@pytest.mark.parametrize("plaintext", PLAINTEXT_VECTORS)
 @mock_kms
 def test_decrypt(plaintext):
     client = boto3.client("kms", region_name="us-west-2")
@@ -213,16 +204,8 @@ def test_decrypt(plaintext):
     decrypt_response["KeyId"].should.equal(key_arn)
 
 
-@parameterized(
-    (
-        ("not-a-uuid",),
-        ("alias/DoesNotExist",),
-        ("arn:aws:kms:us-east-1:012345678912:alias/DoesNotExist",),
-        ("d25652e4-d2d2-49f7-929a-671ccda580c6",),
-        (
-            "arn:aws:kms:us-east-1:012345678912:key/d25652e4-d2d2-49f7-929a-671ccda580c6",
-        ),
-    )
+@pytest.mark.parametrize("key_id",
+    ["not-a-uuid", "alias/DoesNotExist", "arn:aws:kms:us-east-1:012345678912:alias/DoesNotExist", "d25652e4-d2d2-49f7-929a-671ccda580c6", "arn:aws:kms:us-east-1:012345678912:key/d25652e4-d2d2-49f7-929a-671ccda580c6"]
 )
 @mock_kms
 def test_invalid_key_ids(key_id):
@@ -232,7 +215,7 @@ def test_invalid_key_ids(key_id):
         client.generate_data_key(KeyId=key_id, NumberOfBytes=5)
 
 
-@parameterized(PLAINTEXT_VECTORS)
+@pytest.mark.parametrize("plaintext", PLAINTEXT_VECTORS)
 @mock_kms
 def test_kms_encrypt(plaintext):
     client = boto3.client("kms", region_name="us-east-1")
@@ -369,7 +352,7 @@ def test_list_resource_tags():
     assert response["Tags"][0]["TagValue"] == "string"
 
 
-@parameterized(
+@pytest.mark.parametrize("kwargs,expected_key_length",
     (
         (dict(KeySpec="AES_256"), 32),
         (dict(KeySpec="AES_128"), 16),
@@ -401,14 +384,8 @@ def test_generate_data_key_decrypt():
     assert resp1["Plaintext"] == resp2["Plaintext"]
 
 
-@parameterized(
-    (
-        (dict(KeySpec="AES_257"),),
-        (dict(KeySpec="AES_128", NumberOfBytes=16),),
-        (dict(NumberOfBytes=2048),),
-        (dict(NumberOfBytes=0),),
-        (dict(),),
-    )
+@pytest.mark.parametrize("kwargs",
+    [dict(KeySpec="AES_257"), dict(KeySpec="AES_128", NumberOfBytes=16), dict(NumberOfBytes=2048), dict(NumberOfBytes=0), dict()]
 )
 @mock_kms
 def test_generate_data_key_invalid_size_params(kwargs):
@@ -421,15 +398,8 @@ def test_generate_data_key_invalid_size_params(kwargs):
         client.generate_data_key(KeyId=key["KeyMetadata"]["KeyId"], **kwargs)
 
 
-@parameterized(
-    (
-        ("alias/DoesNotExist",),
-        ("arn:aws:kms:us-east-1:012345678912:alias/DoesNotExist",),
-        ("d25652e4-d2d2-49f7-929a-671ccda580c6",),
-        (
-            "arn:aws:kms:us-east-1:012345678912:key/d25652e4-d2d2-49f7-929a-671ccda580c6",
-        ),
-    )
+@pytest.mark.parametrize("key_id",
+    ["alias/DoesNotExist", "arn:aws:kms:us-east-1:012345678912:alias/DoesNotExist", "d25652e4-d2d2-49f7-929a-671ccda580c6", "arn:aws:kms:us-east-1:012345678912:key/d25652e4-d2d2-49f7-929a-671ccda580c6"]
 )
 @mock_kms
 def test_generate_data_key_invalid_key(key_id):
@@ -439,13 +409,8 @@ def test_generate_data_key_invalid_key(key_id):
         client.generate_data_key(KeyId=key_id, KeySpec="AES_256")
 
 
-@parameterized(
-    (
-        ("alias/DoesExist", False),
-        ("arn:aws:kms:us-east-1:012345678912:alias/DoesExist", False),
-        ("", True),
-        ("arn:aws:kms:us-east-1:012345678912:key/", True),
-    )
+@pytest.mark.parametrize("prefix,append_key_id",
+    [("alias/DoesExist", False), ("arn:aws:kms:us-east-1:012345678912:alias/DoesExist", False), ("", True), ("arn:aws:kms:us-east-1:012345678912:key/", True)]
 )
 @mock_kms
 def test_generate_data_key_all_valid_key_ids(prefix, append_key_id):
@@ -473,7 +438,7 @@ def test_generate_data_key_without_plaintext_decrypt():
     assert "Plaintext" not in resp1
 
 
-@parameterized(PLAINTEXT_VECTORS)
+@pytest.mark.parametrize("plaintext", PLAINTEXT_VECTORS)
 @mock_kms
 def test_re_encrypt_decrypt(plaintext):
     client = boto3.client("kms", region_name="us-west-2")
@@ -536,7 +501,7 @@ def test_re_encrypt_to_invalid_destination():
         )
 
 
-@parameterized(((12,), (44,), (91,), (1,), (1024,)))
+@pytest.mark.parametrize("number_of_bytes", [12, 44, 91, 1, 1024])
 @mock_kms
 def test_generate_random(number_of_bytes):
     client = boto3.client("kms", region_name="us-west-2")
@@ -547,14 +512,8 @@ def test_generate_random(number_of_bytes):
     len(response["Plaintext"]).should.equal(number_of_bytes)
 
 
-@parameterized(
-    (
-        (2048, botocore.exceptions.ClientError),
-        (1025, botocore.exceptions.ClientError),
-        (0, botocore.exceptions.ParamValidationError),
-        (-1, botocore.exceptions.ParamValidationError),
-        (-1024, botocore.exceptions.ParamValidationError),
-    )
+@pytest.mark.parametrize("number_of_bytes,error_type",
+    [(2048, botocore.exceptions.ClientError), (1025, botocore.exceptions.ClientError), (0, botocore.exceptions.ParamValidationError), (-1, botocore.exceptions.ParamValidationError), (-1024, botocore.exceptions.ParamValidationError)]
 )
 @mock_kms
 def test_generate_random_invalid_number_of_bytes(number_of_bytes, error_type):

tests/test_kms/test_utils.py

@@ -2,7 +2,6 @@ from __future__ import unicode_literals
 
 import sure  # noqa
 import pytest
-from parameterized import parameterized
 
 from moto.kms.exceptions import (
     AccessDeniedException,
@@ -22,7 +21,7 @@ from moto.kms.utils import (
     Ciphertext,
 )
 
-ENCRYPTION_CONTEXT_VECTORS = (
+ENCRYPTION_CONTEXT_VECTORS = [
     (
         {"this": "is", "an": "encryption", "context": "example"},
         b"an" b"encryption" b"context" b"example" b"this" b"is",
@@ -31,8 +30,8 @@ ENCRYPTION_CONTEXT_VECTORS = (
         {"a_this": "one", "b_is": "actually", "c_in": "order"},
         b"a_this" b"one" b"b_is" b"actually" b"c_in" b"order",
     ),
-)
-CIPHERTEXT_BLOB_VECTORS = (
+]
+CIPHERTEXT_BLOB_VECTORS = [
     (
         Ciphertext(
             key_id="d25652e4-d2d2-49f7-929a-671ccda580c6",
@@ -57,7 +56,7 @@ CIPHERTEXT_BLOB_VECTORS = (
         b"1234567890123456"
         b"some ciphertext that is much longer now",
     ),
-)
+]
 
 
 def test_generate_data_key():
@@ -74,32 +73,32 @@ def test_generate_master_key():
     len(test).should.equal(MASTER_KEY_LEN)
 
 
-@parameterized(ENCRYPTION_CONTEXT_VECTORS)
+@pytest.mark.parametrize("raw,serialized", ENCRYPTION_CONTEXT_VECTORS)
 def test_serialize_encryption_context(raw, serialized):
     test = _serialize_encryption_context(raw)
     test.should.equal(serialized)
 
 
-@parameterized(CIPHERTEXT_BLOB_VECTORS)
+@pytest.mark.parametrize("raw,_serialized", CIPHERTEXT_BLOB_VECTORS)
 def test_cycle_ciphertext_blob(raw, _serialized):
     test_serialized = _serialize_ciphertext_blob(raw)
     test_deserialized = _deserialize_ciphertext_blob(test_serialized)
     test_deserialized.should.equal(raw)
 
 
-@parameterized(CIPHERTEXT_BLOB_VECTORS)
+@pytest.mark.parametrize("raw,serialized", CIPHERTEXT_BLOB_VECTORS)
 def test_serialize_ciphertext_blob(raw, serialized):
     test = _serialize_ciphertext_blob(raw)
     test.should.equal(serialized)
 
 
-@parameterized(CIPHERTEXT_BLOB_VECTORS)
+@pytest.mark.parametrize("raw,serialized", CIPHERTEXT_BLOB_VECTORS)
 def test_deserialize_ciphertext_blob(raw, serialized):
     test = _deserialize_ciphertext_blob(serialized)
     test.should.equal(raw)
 
 
-@parameterized(((ec[0],) for ec in ENCRYPTION_CONTEXT_VECTORS))
+@pytest.mark.parametrize("encryption_context", [ec[0] for ec in ENCRYPTION_CONTEXT_VECTORS])
 def test_encrypt_decrypt_cycle(encryption_context):
     plaintext = b"some secret plaintext"
     master_key = Key("nop", "nop", "nop", "nop", "nop")