clear-skies-aws 1.10.2__py3-none-any.whl → 2.0.2__py3-none-any.whl

clearskies_aws/actions/assume_role_test.py

@@ -1,72 +0,0 @@
-import unittest
-from unittest.mock import MagicMock, call
-
-from .assume_role import AssumeRole
-
-
-class AssumeRoleTest(unittest.TestCase):
-    def test_with_external_id(self):
-        sts = MagicMock()
-        sts.assume_role = MagicMock(
-            return_value={
-                "Credentials": {
-                    "AccessKeyId": "access-key",
-                    "SecretAccessKey": "secret-key",
-                    "SessionToken": "session-token",
-                }
-            }
-        )
-        boto3 = MagicMock()
-        boto3.client = MagicMock(return_value=sts)
-        boto3.Session = MagicMock(return_value='MOAR BOTO')
-
-        assume_role = AssumeRole(role_arn='aws:arn:role/name', external_id='12345')
-        self.assertEqual("MOAR BOTO", assume_role(boto3))
-        boto3.client.assert_called_with("sts")
-        boto3.Session.assert_called_with(
-            aws_access_key_id="access-key",
-            aws_secret_access_key="secret-key",
-            aws_session_token="session-token",
-        )
-        sts.assume_role.assert_called_with(
-            RoleArn='aws:arn:role/name',
-            RoleSessionName="clearkies-aws",
-            DurationSeconds=3600,
-            ExternalId="12345",
-        )
-
-    def test_with_source(self):
-        sts = MagicMock()
-        sts.assume_role = MagicMock(
-            return_value={
-                "Credentials": {
-                    "AccessKeyId": "access-key",
-                    "SecretAccessKey": "secret-key",
-                    "SessionToken": "session-token",
-                }
-            }
-        )
-        boto3 = MagicMock()
-        boto3.client = MagicMock(return_value=sts)
-        boto3.Session = MagicMock(return_value='MOAR BOTO')
-        source = MagicMock(return_value=boto3)
-
-        assume_role = AssumeRole(
-            role_arn='aws:arn:role/name',
-            source=source,
-            role_session_name="sup",
-            duration=7200,
-        )
-        self.assertEqual("MOAR BOTO", assume_role("not-boto3"))
-        boto3.client.assert_called_with("sts")
-        boto3.Session.assert_called_with(
-            aws_access_key_id="access-key",
-            aws_secret_access_key="secret-key",
-            aws_session_token="session-token",
-        )
-        sts.assume_role.assert_called_with(
-            RoleArn='aws:arn:role/name',
-            RoleSessionName="sup",
-            DurationSeconds=7200,
-        )
-        source.assert_called_with("not-boto3")

clearskies_aws/actions/ses_test.py

@@ -1,89 +0,0 @@
-import unittest
-from unittest.mock import MagicMock, call
-from .ses import SES
-import clearskies
-from ..di import StandardDependencies
-class SESTest(unittest.TestCase):
-    def setUp(self):
-        self.di = StandardDependencies()
-        self.di.bind('environment', {'AWS_REGION': 'us-east-2'})
-        self.ses = MagicMock()
-        self.ses.send_email = MagicMock()
-        self.boto3 = MagicMock()
-        self.boto3.client = MagicMock(return_value=self.ses)
-        self.environment = MagicMock()
-        self.environment.get = MagicMock(return_value='us-east-1')
-
-    def test_send(self):
-        ses = SES(self.environment, self.boto3, self.di)
-        ses.configure(
-            'test@example.com', to='jane@example.com', subject='welcome!', message_template='hi {{ model.id }}!'
-        )
-        model = MagicMock()
-        model.id = 'asdf'
-        ses(model)
-        self.ses.send_email.assert_has_calls([
-            call(
-                Destination={
-                    'ToAddresses': ['jane@example.com'],
-                    'CcAddresses': [],
-                    'BccAddresses': []
-                },
-                Message={
-                    'Body': {
-                        'Html': {
-                            'Charset': 'utf-8',
-                            'Data': 'hi asdf!'
-                        },
-                        'Text': {
-                            'Charset': 'utf-8',
-                            'Data': 'hi asdf!'
-                        }
-                    },
-                    'Subject': {
-                        'Charset': 'utf-8',
-                        'Data': 'welcome!'
-                    }
-                },
-                Source='test@example.com'
-            ),
-        ])
-
-    def test_send_callable(self):
-        ses = SES(self.environment, self.boto3, self.di)
-        ses.configure(
-            'test@example.com',
-            to=lambda model: 'jane@example.com',
-            bcc=lambda model: ['bob@example.com', 'greg@example.com'],
-            subject='welcome!',
-            message_template='hi {{ model.id }}!'
-        )
-        model = MagicMock()
-        model.id = 'asdf'
-        ses(model)
-        self.ses.send_email.assert_has_calls([
-            call(
-                Destination={
-                    'ToAddresses': ['jane@example.com'],
-                    'CcAddresses': [],
-                    'BccAddresses': ['bob@example.com', 'greg@example.com']
-                },
-                Message={
-                    'Body': {
-                        'Html': {
-                            'Charset': 'utf-8',
-                            'Data': 'hi asdf!'
-                        },
-                        'Text': {
-                            'Charset': 'utf-8',
-                            'Data': 'hi asdf!'
-                        }
-                    },
-                    'Subject': {
-                        'Charset': 'utf-8',
-                        'Data': 'welcome!'
-                    }
-                },
-                Source='test@example.com'
-            ),
-        ])

clearskies_aws/actions/sns_test.py

@@ -1,77 +0,0 @@
-import unittest
-import boto3
-
-from unittest.mock import MagicMock, call
-from .sns import SNS
-import clearskies
-from ..di import StandardDependencies
-import json
-from collections import OrderedDict
-class User(clearskies.Model):
-    def __init__(self, memory_backend, columns):
-        super().__init__(memory_backend, columns)
-
-    def columns_configuration(self):
-        return OrderedDict([
-            clearskies.column_types.string('name'),
-            clearskies.column_types.email('email'),
-        ])
-class SNSTest(unittest.TestCase):
-    def setUp(self):
-        self.di = StandardDependencies()
-        self.di.bind('environment', {'AWS_REGION': 'us-east-2'})
-        self.users = self.di.build(User)
-        self.sns = MagicMock()
-        self.sns.publish = MagicMock()
-        self.boto3 = MagicMock()
-        self.boto3.client = MagicMock(return_value=self.sns)
-        self.when = None
-        self.environment = MagicMock()
-        self.environment.get = MagicMock(return_value='us-east-1')
-
-    def always(self, model):
-        self.when = model
-        return True
-
-    def never(self, model):
-        self.when = model
-        return False
-
-    def test_send(self):
-        sns = SNS(self.environment, self.boto3, self.di)
-        sns.configure(
-            topic='arn:aws:my-topic',
-            when=self.always,
-        )
-        user = self.users.model({
-            "id": "1-2-3-4",
-            "name": "Jane",
-            "email": "jane@example.com",
-        })
-        sns(user)
-        self.sns.publish.assert_has_calls([
-            call(
-                TopicArn='arn:aws:my-topic',
-                Message=json.dumps({
-                    "id": "1-2-3-4",
-                    "name": "Jane",
-                    "email": "jane@example.com",
-                }),
-            ),
-        ])
-        self.assertEqual(id(user), id(self.when))
-
-    def test_not_now(self):
-        sns = SNS(self.environment, self.boto3, self.di)
-        sns.configure(
-            topic='arn:aws:my-topic',
-            when=self.never,
-        )
-        user = self.users.model({
-            "id": "1-2-3-4",
-            "name": "Jane",
-            "email": "jane@example.com",
-        })
-        sns(user)
-        self.sns.publish.assert_not_called()
-        self.assertEqual(id(user), id(self.when))

clearskies_aws/actions/sqs_test.py

@@ -1,127 +0,0 @@
-import unittest
-from unittest.mock import MagicMock, call
-from .sqs import SQS
-import clearskies
-from ..di import StandardDependencies
-import json
-from collections import OrderedDict
-class User(clearskies.Model):
-    def __init__(self, memory_backend, columns):
-        super().__init__(memory_backend, columns)
-
-    def columns_configuration(self):
-        return OrderedDict([
-            clearskies.column_types.string('name'),
-            clearskies.column_types.email('email'),
-        ])
-class SQSTest(unittest.TestCase):
-    def setUp(self):
-        self.di = StandardDependencies()
-        self.di.bind('environment', {'AWS_REGION': 'us-east-2'})
-        self.users = self.di.build(User)
-        self.sqs = MagicMock()
-        self.sqs.send_message = MagicMock()
-        self.boto3 = MagicMock()
-        self.boto3.client = MagicMock(return_value=self.sqs)
-        self.when = None
-        self.environment = MagicMock()
-        self.environment.get = MagicMock(return_value='us-east-1')
-
-    def always(self, model):
-        self.when = model
-        return True
-
-    def never(self, model):
-        self.when = model
-        return False
-
-    def test_send(self):
-        sqs = SQS(self.environment, self.boto3, self.di)
-        sqs.configure(
-            queue_url='https://queue.example.com',
-            when=self.always,
-        )
-        user = self.users.model({
-            "id": "1-2-3-4",
-            "name": "Jane",
-            "email": "jane@example.com",
-        })
-        sqs(user)
-        self.sqs.send_message.assert_has_calls([
-            call(
-                QueueUrl='https://queue.example.com',
-                MessageBody=json.dumps({
-                    "id": "1-2-3-4",
-                    "name": "Jane",
-                    "email": "jane@example.com",
-                }),
-            ),
-        ])
-        self.assertEqual(id(user), id(self.when))
-
-    def test_send_message_group_id(self):
-        sqs = SQS(self.environment, self.boto3, self.di)
-        sqs.configure(
-            queue_url='https://queue.example.com',
-            when=self.always,
-            message_group_id='heysup',
-        )
-        user = self.users.model({
-            "id": "1-2-3-4",
-            "name": "Jane",
-            "email": "jane@example.com",
-        })
-        sqs(user)
-        self.sqs.send_message.assert_has_calls([
-            call(
-                QueueUrl='https://queue.example.com',
-                MessageGroupId='heysup',
-                MessageBody=json.dumps({
-                    "id": "1-2-3-4",
-                    "name": "Jane",
-                    "email": "jane@example.com",
-                }),
-            ),
-        ])
-        self.assertEqual(id(user), id(self.when))
-
-    def test_send_message_group_id_callable(self):
-        sqs = SQS(self.environment, self.boto3, self.di)
-        sqs.configure(
-            queue_url='https://queue.example.com',
-            when=self.always,
-            message_group_id=lambda model: model.id,
-        )
-        user = self.users.model({
-            "id": "1-2-3-4",
-            "name": "Jane",
-            "email": "jane@example.com",
-        })
-        sqs(user)
-        self.sqs.send_message.assert_has_calls([
-            call(
-                QueueUrl='https://queue.example.com',
-                MessageGroupId='1-2-3-4',
-                MessageBody=json.dumps({
-                    "id": "1-2-3-4",
-                    "name": "Jane",
-                    "email": "jane@example.com",
-                }),
-            ),
-        ])
-        self.assertEqual(id(user), id(self.when))
-
-    def test_not_now(self):
-        sqs = SQS(self.environment, self.boto3, self.di)
-        sqs.configure(
-            queue_url='https://queue.example.com',
-            when=self.never,
-        )
-        user = self.users.model({
-            "id": "1-2-3-4",
-            "name": "Jane",
-            "email": "jane@example.com",
-        })
-        sqs(user)
-        self.sqs.send_message.assert_not_called()
-        self.assertEqual(id(user), id(self.when))

clearskies_aws/actions/step_function_test.py

@@ -1,103 +0,0 @@
-import unittest
-from unittest.mock import MagicMock, call
-from .step_function import StepFunction
-import clearskies
-from ..di import StandardDependencies
-import json
-from collections import OrderedDict
-class User(clearskies.Model):
-    def __init__(self, memory_backend, columns):
-        super().__init__(memory_backend, columns)
-
-    def columns_configuration(self):
-        return OrderedDict([
-            clearskies.column_types.email('email'),
-            clearskies.column_types.string('execution_arn'),
-        ])
-class StepFunctionTest(unittest.TestCase):
-    def setUp(self):
-        self.di = StandardDependencies()
-        self.di.bind('environment', {'AWS_REGION': 'us-east-2'})
-        memory_backend = self.di.build("memory_backend")
-        self.users = self.di.build(User)
-        self.user = self.users.create({
-            "id": "1-2-3-4",
-            "email": "blah@example.com",
-        })
-        self.step_function = MagicMock()
-        self.step_function.start_execution = MagicMock(return_value={"executionArn":"aws:arn:execution"})
-        self.boto3 = MagicMock()
-        self.boto3.client = MagicMock(return_value=self.step_function)
-        self.when = None
-        self.environment = MagicMock()
-        self.environment.get = MagicMock(return_value='us-east-2')
-
-    def always(self, model):
-        self.when = model
-        return True
-
-    def never(self, model):
-        self.when = model
-        return False
-
-    def test_execute(self):
-        step_function = StepFunction(self.environment, self.boto3, self.di)
-        step_function.configure(
-            arn='aws::arn:us-east-2:step/asdf-er',
-            when=self.always,
-            column_to_store_execution_arn="execution_arn",
-        )
-        step_function(self.user)
-        self.step_function.start_execution.assert_has_calls([
-            call(
-                stateMachineArn='aws::arn:us-east-2:step/asdf-er',
-                input=json.dumps({
-                    "id": self.user.id,
-                    "email": self.user.email,
-                    "execution_arn": None,
-                }),
-            ),
-        ])
-        self.assertEqual(id(self.user), id(self.when))
-        self.assertEqual("aws:arn:execution", self.user.execution_arn)
-
-    def test_region_switch(self):
-        self.boto3.client.side_effect = [self.step_function, self.step_function]
-        step_function = StepFunction(self.environment, self.boto3, self.di)
-        step_function.configure(
-            arn='aws::arn:eu-west-1:step/asdf-er',
-            when=self.always,
-            column_to_store_execution_arn="execution_arn",
-        )
-        step_function(self.user)
-        self.step_function.start_execution.assert_has_calls([
-            call(
-                stateMachineArn='aws::arn:eu-west-1:step/asdf-er',
-                input=json.dumps({
-                    "id": self.user.id,
-                    "email": self.user.email,
-                    "execution_arn": None,
-                }),
-            ),
-        ])
-        self.assertEqual(id(self.user), id(self.when))
-        self.assertEqual("aws:arn:execution", self.user.execution_arn)
-        self.boto3.client.assert_has_calls([
-            call("stepfunctions", region_name="us-east-2"),
-            call("stepfunctions", region_name="eu-west-1"),
-        ])
-
-    def test_not_now(self):
-        step_function = StepFunction(self.environment, self.boto3, self.di)
-        step_function.configure(
-            arn='aws::arn:us-east-2:step-function/asdf-er',
-            when=self.never,
-        )
-        user = self.users.model({
-            "id": "1-2-3-4",
-            "name": "Jane",
-            "email": "jane@example.com",
-        })
-        step_function(user)
-        self.step_function.start_execution.assert_not_called()
-        self.assertEqual(id(user), id(self.when))