updating tests of attrs-controlled tests to a) actually do something useful and b) not break with attrs 17.3.0

Author: mattsb42-aws

test/unit/test_internal_structures.py

@@ -11,38 +11,60 @@
 # 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.internal.structures"""
-import attr
 import pytest
-import six
 
 from aws_encryption_sdk.internal.structures import (
     EncryptedData, MessageFooter, MessageFrameBody, MessageHeaderAuthentication, MessageNoFrameBody
 )
+from .unit_test_utils import all_invalid_kwargs, all_valid_kwargs
+
+
+VALID_KWARGS = {
+    EncryptedData: [
+        dict(ciphertext=b'asjfoiwaj', iv=None, tag=None),
+        dict(ciphertext=b'asjfoiwaj', iv=b'ajsdhfiuaweh', tag=None),
+        dict(ciphertext=b'asjfoiwaj', iv=None, tag=b'aosijfoiewj'),
+        dict(ciphertext=b'asjfoiwaj', iv=b'ajsdhfiuaweh', tag=b'aosijfoiewj')
+    ],
+    MessageHeaderAuthentication: [
+        dict(iv=b'oasijfoaiwej', tag=b'aisudhfoaweij')
+    ],
+    MessageFrameBody: [
+        dict(
+            iv=b'oaijefoiajew',
+            ciphertext=b'oasidjfaowiejf',
+            tag=b'ecoaiwjeconadf',
+            sequence_number=42523,
+            final_frame=False
+        )
+    ],
+    MessageNoFrameBody: [
+        dict(
+            iv=b'afioaewj',
+            ciphertext=b'oasjfoeiwjfio',
+            tag=b'asfowaeijf'
+        )
+    ],
+    MessageFooter: [
+        dict(signature=b'oajwefiowjaeofi')
+    ]
+}
+INVALID_KWARGS = {
+    EncryptedData: [
+        dict(ciphertext=None, iv=None, tag=None)
+    ]
+}
 
 
-@pytest.mark.parametrize('attribute, validator_type, is_optional', (
-    (EncryptedData.iv, bytes, True),
-    (EncryptedData.ciphertext, bytes, False),
-    (EncryptedData.tag, bytes, True),
-    (MessageHeaderAuthentication.iv, bytes, False),
-    (MessageHeaderAuthentication.tag, bytes, False),
-    (MessageFrameBody.iv, bytes, False),
-    (MessageFrameBody.ciphertext, bytes, False),
-    (MessageFrameBody.tag, bytes, False),
-    (MessageFrameBody.sequence_number, six.integer_types, False),
-    (MessageFrameBody.final_frame, bool, False),
-    (MessageNoFrameBody.iv, bytes, False),
-    (MessageNoFrameBody.ciphertext, bytes, False),
-    (MessageNoFrameBody.tag, bytes, False),
-    (MessageFooter.signature, bytes, False)
-))
-def test_attributes(attribute, validator_type, is_optional):
-    assert isinstance(attribute, attr.Attribute)
-    assert attribute.hash
-    if is_optional:
-        assert attribute.validator.validator.type == validator_type
-    else:
-        assert attribute.validator.type == validator_type
+@pytest.mark.parametrize('cls, kwargs', all_valid_kwargs(VALID_KWARGS))
+def test_attributes_valid_kwargs(cls, kwargs):
+    cls(**kwargs)
+
+
+@pytest.mark.parametrize('cls, kwargs', all_invalid_kwargs(VALID_KWARGS, INVALID_KWARGS))
+def test_attributes_invalid_kwargs(cls, kwargs):
+    with pytest.raises(TypeError):
+        cls(**kwargs)
 
 
 @pytest.mark.parametrize('attribute, value', (
@@ -51,82 +73,3 @@ def test_attributes(attribute, validator_type, is_optional):
 ))
 def test_static_attributes(attribute, value):
     assert attribute == value
-
-
-def test_encrypted_data_fails():
-    with pytest.raises(TypeError):
-        EncryptedData(ciphertext=None)
-
-
-@pytest.mark.parametrize('iv, ciphertext, tag', (
-    (b'iv', b'ciphertext', b'tag'),
-    (None, b'ciphertext', None)
-))
-def test_encrypted_data_succeeds(iv, ciphertext, tag):
-    EncryptedData(iv=iv, ciphertext=ciphertext, tag=tag)
-
-
-@pytest.mark.parametrize('iv, tag', (
-    (None, b''),
-    (b'', None)
-))
-def test_message_header_auth_fails(iv, tag):
-    with pytest.raises(TypeError):
-        MessageHeaderAuthentication(iv=iv, tag=tag)
-
-
-def test_message_header_auth_succeeds():
-    MessageHeaderAuthentication(iv=b'', tag=b'')
-
-
-@pytest.mark.parametrize('iv, ciphertext, tag, sequence_number, final_frame', (
-    (None, b'', b'', 1, True),
-    (b'', None, b'', 1, True),
-    (b'', b'', None, 1, True),
-    (b'', b'', b'', None, True),
-    (b'', b'', b'', 1, None)
-))
-def test_message_frame_body_fails(iv, ciphertext, tag, sequence_number, final_frame):
-    with pytest.raises(TypeError):
-        MessageFrameBody(
-            iv=iv,
-            ciphertext=ciphertext,
-            tag=tag,
-            sequence_number=sequence_number,
-            final_frame=final_frame
-        )
-
-
-def test_message_frame_body_succeeds():
-    MessageFrameBody(
-        iv=b'iv',
-        ciphertext=b'ciphertext',
-        tag=b'tag',
-        sequence_number=1,
-        final_frame=False
-    )
-
-
-@pytest.mark.parametrize('iv, ciphertext, tag', (
-    (None, b'', b''),
-    (b'', None, b''),
-    (b'', b'', None)
-))
-def test_message_no_frame_body_fails(iv, ciphertext, tag):
-    with pytest.raises(TypeError):
-        MessageNoFrameBody(iv=iv, ciphertext=ciphertext, tag=tag)
-
-
-def test_message_no_frame_body_succeeds():
-    test = MessageNoFrameBody(iv=b'', ciphertext=b'', tag=b'')
-    assert test.sequence_number == 1
-    assert test.final_frame
-
-
-def test_message_footer_fails():
-    with pytest.raises(TypeError):
-        MessageFooter(signature=None)
-
-
-def test_message_footer_succeeds():
-    MessageFooter(signature=b'')

test/unit/test_providers_base_master_key_config.py

@@ -11,37 +11,39 @@
 # ANY KIND, either express or implied. See the License for the specific
 # language governing permissions and limitations under the License.
 """Unit test suite to validate aws_encryption_sdk.key_providers.base.MasterKeyConfig"""
-import attr
 from mock import sentinel
 import pytest
-import six
 
-from aws_encryption_sdk.internal.str_ops import to_bytes
 from aws_encryption_sdk.key_providers.base import MasterKeyConfig
+from .unit_test_utils import all_invalid_kwargs, all_valid_kwargs
 
 
-@pytest.mark.parametrize('attribute, validator_type, convert_function', (
-    (MasterKeyConfig.key_id, (six.string_types, bytes), to_bytes),
-))
-def test_attributes(attribute, validator_type, convert_function):
-    assert isinstance(attribute, attr.Attribute)
-    assert attribute.hash
-    assert attribute.validator.type == validator_type
-    assert attribute.convert is convert_function
+class FakeMasterKeyConfig(MasterKeyConfig):
+    provider_id = None
 
 
-def test_attributes_fails():
-    class TestConfig(MasterKeyConfig):
-        provider_id = sentinel.provider_id
+VALID_KWARGS = {
+    FakeMasterKeyConfig: [
+        dict(key_id='a key id'),
+        dict(key_id=b'a key id')
+    ]
+}
+
+
+@pytest.mark.parametrize('cls, kwargs', all_valid_kwargs(VALID_KWARGS))
+def test_attributes_valid_kwargs(cls, kwargs):
+    cls(**kwargs)
+
+
+@pytest.mark.parametrize('cls, kwargs', all_invalid_kwargs(VALID_KWARGS))
+def test_attributes_invalid_kwargs(cls, kwargs):
     with pytest.raises(TypeError):
-        TestConfig(key_id=None)
+        cls(**kwargs)
 
 
 @pytest.mark.parametrize('key_id', (b'key', 'key'))
 def test_attributes_converts(key_id):
-    class TestConfig(MasterKeyConfig):
-        provider_id = sentinel.provider_id
-    test = TestConfig(key_id=key_id)
+    test = FakeMasterKeyConfig(key_id=key_id)
     assert isinstance(test.key_id, bytes)
 
 

test/unit/test_providers_kms_master_key_config.py

@@ -11,30 +11,41 @@
 # ANY KIND, either express or implied. See the License for the specific
 # language governing permissions and limitations under the License.
 """Unit test suite to validate aws_encryption_sdk.key_providers.kms.KMSMasterKeyConfig"""
-import attr
-import botocore.client
-from mock import MagicMock, sentinel
+import boto3
 import pytest
 
 from aws_encryption_sdk.key_providers.base import MasterKeyConfig
 from aws_encryption_sdk.key_providers.kms import _PROVIDER_ID, KMSMasterKeyConfig
+from .unit_test_utils import all_invalid_kwargs, all_valid_kwargs
 
 
-def test_parent():
-    assert issubclass(KMSMasterKeyConfig, MasterKeyConfig)
+VALID_KWARGS = {
+    KMSMasterKeyConfig: [
+        dict(key_id=b'a cmk', client=boto3.client('kms', region_name='us-west-2'), grant_tokens=()),
+        dict(key_id=b'a cmk', client=boto3.client('kms', region_name='us-west-2'), grant_tokens=[]),
+        dict(key_id=b'a cmk', client=boto3.client('kms', region_name='us-west-2'))
+    ]
+}
+INVALID_KWARGS = {
+    KMSMasterKeyConfig: [
+        dict(client=None)
+    ]
+}
 
 
-@pytest.mark.parametrize('attribute, default, validator_type, convert_function', (
-    (KMSMasterKeyConfig.client, attr.NOTHING, botocore.client.BaseClient, None),
-    (KMSMasterKeyConfig.grant_tokens, attr.Factory(tuple), tuple, tuple)
-))
-def test_attributes(attribute, default, validator_type, convert_function):
-    assert isinstance(attribute, attr.Attribute)
-    assert attribute.hash
-    assert attribute.default == default
-    assert attribute.validator.type == validator_type
-    if convert_function is not None:
-        assert attribute.convert is convert_function
+@pytest.mark.parametrize('cls, kwargs', all_valid_kwargs(VALID_KWARGS))
+def test_attributes_valid_kwargs(cls, kwargs):
+    cls(**kwargs)
+
+
+@pytest.mark.parametrize('cls, kwargs', all_invalid_kwargs(VALID_KWARGS, INVALID_KWARGS))
+def test_attributes_invalid_kwargs(cls, kwargs):
+    with pytest.raises(TypeError):
+        cls(**kwargs)
+
+
+def test_parent():
+    assert issubclass(KMSMasterKeyConfig, MasterKeyConfig)
 
 
 @pytest.mark.parametrize('attribute, value', (
@@ -44,23 +55,15 @@ def test_static_attributes(attribute, value):
     assert attribute == value
 
 
-def test_attributes_fail():
-    with pytest.raises(TypeError):
-        KMSMasterKeyConfig(key_id='', client=None)
-
-
 def test_attributes_defaults():
     test = KMSMasterKeyConfig(
-        key_id='',
-        client=MagicMock(__class__=botocore.client.BaseClient)
+        key_id=b'a cmk',
+        client=boto3.client('kms', region_name='us-west-2')
     )
     assert test.grant_tokens == ()
 
 
-def test_attributes_converts():
-    test = KMSMasterKeyConfig(
-        key_id='',
-        client=MagicMock(__class__=botocore.client.BaseClient),
-        grant_tokens=[sentinel.token_1, sentinel.token_2]
-    )
-    assert test.grant_tokens == (sentinel.token_1, sentinel.token_2)
+@pytest.mark.parametrize('cls, kwargs', all_valid_kwargs(VALID_KWARGS))
+def test_attributes_converts(cls, kwargs):
+    test = cls(**kwargs)
+    assert isinstance(test.grant_tokens, tuple)

test/unit/test_providers_kms_master_key_provider_config.py

@@ -11,51 +11,49 @@
 # ANY KIND, either express or implied. See the License for the specific
 # language governing permissions and limitations under the License.
 """Unit test suite to validate aws_encryption_sdk.key_providers.kms.KMSMasterKeyProviderConfig"""
-import attr
 import botocore.session
-from mock import MagicMock, sentinel
 import pytest
 
 from aws_encryption_sdk.key_providers.base import MasterKeyProviderConfig
 from aws_encryption_sdk.key_providers.kms import KMSMasterKeyProviderConfig
+from .unit_test_utils import all_invalid_kwargs, all_valid_kwargs
 
 
-def test_parent():
-    assert issubclass(KMSMasterKeyProviderConfig, MasterKeyProviderConfig)
+VALID_KWARGS = {
+    KMSMasterKeyProviderConfig: [
+        dict(botocore_session=botocore.session.Session(), key_ids=(), region_names=()),
+        dict(botocore_session=botocore.session.Session(), key_ids=[], region_names=()),
+        dict(botocore_session=botocore.session.Session(), key_ids=(), region_names=[]),
+        dict(botocore_session=botocore.session.Session(), region_names=()),
+        dict(botocore_session=botocore.session.Session(), key_ids=()),
+        dict(botocore_session=botocore.session.Session())
+    ]
+}
+INVALID_KWARGS = {
+    KMSMasterKeyProviderConfig: [dict(botocore_session=None)]
+}
 
 
-@pytest.mark.parametrize('attribute, default, validator_type, convert_function', (
-    (
-        KMSMasterKeyProviderConfig.botocore_session,
-        attr.Factory(botocore.session.Session),
-        botocore.session.Session,
-        None
-    ),
-    (KMSMasterKeyProviderConfig.key_ids, attr.Factory(tuple), tuple, tuple),
-    (KMSMasterKeyProviderConfig.region_names, attr.Factory(tuple), tuple, tuple)
-))
-def test_attributes(attribute, default, validator_type, convert_function):
-    assert isinstance(attribute, attr.Attribute)
-    assert attribute.hash
-    assert attribute.default == default
-    assert attribute.validator.type == validator_type
-    if convert_function is not None:
-        assert attribute.convert is convert_function
+@pytest.mark.parametrize('cls, kwargs', all_valid_kwargs(VALID_KWARGS))
+def test_attributes_valid_kwargs(cls, kwargs):
+    cls(**kwargs)
 
 
-def test_attributes_fails():
+@pytest.mark.parametrize('cls, kwargs', all_invalid_kwargs(VALID_KWARGS, INVALID_KWARGS))
+def test_attributes_invalid_kwargs(cls, kwargs):
     with pytest.raises(TypeError):
-        KMSMasterKeyProviderConfig(botocore_session=None)
+        cls(**kwargs)
+
+
+def test_parent():
+    assert issubclass(KMSMasterKeyProviderConfig, MasterKeyProviderConfig)
 
 
-def test_attributes_converts():
-    test = KMSMasterKeyProviderConfig(
-        botocore_session=MagicMock(__class__=botocore.session.Session),
-        key_ids=[sentinel.key_a, sentinel.key_b],
-        region_names=[sentinel.region_a, sentinel.region_b]
-    )
-    assert test.key_ids == (sentinel.key_a, sentinel.key_b)
-    assert test.region_names == (sentinel.region_a, sentinel.region_b)
+@pytest.mark.parametrize('cls, kwargs', all_valid_kwargs(VALID_KWARGS))
+def test_attributes_converts(cls, kwargs):
+    test = cls(**kwargs)
+    assert isinstance(test.key_ids, tuple)
+    assert isinstance(test.region_names, tuple)
 
 
 def test_attributes_defaults():