clear-skies-aws 1.10.1__py3-none-any.whl → 2.0.1__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.py

@@ -1,194 +0,0 @@
-import boto3
-import clearskies
-import datetime
-
-from botocore.exceptions import ClientError
-from clearskies.environment import Environment
-from clearskies.models import Models
-from collections.abc import Sequence
-from typing import Any, Callable, List, Optional, Union
-from types import ModuleType
-
-from ..di import StandardDependencies
-from .assume_role import AssumeRole
-from .action_aws import ActionAws
-class SES(ActionAws):
-    _name = "ses"
-
-    def __init__(self, environment: Environment, boto3: boto3, di: StandardDependencies) -> None:
-        """Setup action."""
-        super().__init__(environment, boto3, di)
-
-    def configure(
-        self,
-        sender,
-        to: Optional[Union[list, str,  Callable]] = None,
-        cc: Optional[Union[list, str,  Callable]] = None,
-        bcc: Optional[Union[list, str,  Callable]] = None,
-        subject: Optional[str] = None,
-        message: Optional[str] = None,
-        subject_template: Optional[str] = None,
-        message_template: Optional[str] = None,
-        subject_template_file: Optional[str] = None,
-        message_template_file: Optional[str] = None,
-        assume_role: Optional[AssumeRole] = None,
-        dependencies_for_template: Optional[list[Any]] = None,
-        when: Optional[Callable] = None,
-    ) -> None:
-        """Configure the rules for this email notification."""
-        super().configure(message_callable=None, when=when, assume_role=assume_role)
-        self.destinations = {
-            "to": [],
-            "cc": [],
-            "bcc": [],
-        }
-        # this just moves the data from the various "to" inputs (to, cc, bcc) into the self.destinations
-        # dictionary, after normalizing it so that it is always a list.
-        for key in self.destinations.keys():
-            destination_values = locals()[key]
-            if not destination_values:
-                continue
-            if type(destination_values) == str or callable(destination_values):
-                self.destinations[key] = [destination_values]
-            else:
-                self.destinations[key] = destination_values
-        self.subject = subject
-        self.message = message
-        self.sender = sender
-        self.subject_template = None
-        self.message_template = None
-        self.dependencies_for_template = dependencies_for_template if dependencies_for_template else []
-
-        if not to and not cc:
-            raise ValueError("You must configure at least one 'to' address or one 'cc' address")
-        num_subjects = 0
-        num_messages = 0
-        for source in [subject, subject_template, subject_template_file]:
-            if source:
-                num_subjects += 1
-        for source in [message, message_template, message_template_file]:
-            if source:
-                num_messages += 1
-        if num_subjects > 1:
-            raise ValueError(
-                "More than one of 'subject', 'subject_template', or 'subject_template_file' was set, but only one of these may be set."
-            )
-        if num_messages > 1:
-            raise ValueError(
-                "More than one of 'message', 'message_template', or 'message_template_file' was set, but only one of these may be set."
-            )
-
-        if subject_template_file:
-            import jinja2
-            with open(subject_template_file, "r", encoding="utf-8") as template:
-                self.subject_template = jinja2.Template(template.read())
-        elif subject_template:
-            import jinja2
-            self.subject_template = jinja2.Template(subject_template)
-
-        if message_template_file:
-            import jinja2
-            with open(message_template_file, "r", encoding="utf-8") as template:
-                self.message_template = jinja2.Template(template.read())
-        elif message_template:
-            import jinja2
-            self.message_template = jinja2.Template(message_template)
-
-    def _execute_action(self, client: ModuleType, model: Models) -> None:
-        """Send a notification as configured."""
-        utcnow = self.di.build('utcnow')
-
-        tos = self._resolve_destination("to", model)
-        if not tos:
-            return
-        response = client.send_email(
-            Destination={
-                "ToAddresses": tos,
-                "CcAddresses": self._resolve_destination("cc", model),
-                "BccAddresses": self._resolve_destination("bcc", model),
-            },
-            Message={
-                "Body": {
-                    "Html": {
-                        "Charset": "utf-8",
-                        "Data": self._resolve_message_as_html(model, utcnow),
-                    },
-                    "Text": {
-                        "Charset": "utf-8",
-                        "Data": self._resolve_message_as_text(model, utcnow),
-                    },
-                },
-                "Subject": {
-                    "Charset": "utf-8",
-                    "Data": self._resolve_subject(model, utcnow)
-                },
-            },
-            Source=self.sender,
-        )
-
-    def _resolve_destination(self, name: str, model: clearskies.Model) -> List[str]:
-        """
-        Return a list of to/cc/bcc addresses.
-
-        Each entry can be:
-
-         1. An email address
-         2. The name of a column in the model that contains an email address
-        """
-        resolved = []
-        destinations = self.destinations[name]
-        for destination in destinations:
-            if callable(destination):
-                more = self.di.call_function(destination, model=model)
-                if not isinstance(more, list):
-                    more = [more]
-                for entry in more:
-                    if not isinstance(entry, str):
-                        raise ValueError(f"I invoked a callable to fetch the '{name}' addresses for model '{model.__class__.__name__}' but it returned something other than a string.  Callables must return a valid email address or a list of email addresses.")
-                    if "@" not in entry:
-                        raise ValueError(f"I invoked a callable to fetch the '{name}' addresses for model '{model.__class__.__name__}' but it returned a non-email address.  Callables must return a valid email address or a list of email addresses.")
-                resolved.extend(more)
-                continue
-            if "@" in destination:
-                resolved.append(destination)
-                continue
-            resolved.append(model.get(destination))
-        return resolved
-
-    def _resolve_message_as_html(self, model: clearskies.Model, now: datetime.datetime) -> str:
-        """Build the HTML for a message."""
-        if self.message:
-            return self.message
-
-        if self.message_template:
-            return str(
-                self.message_template.render(model=model, now=now, **self.more_template_variables(), text_in_html=True)
-            )
-
-        return ""
-
-    def _resolve_message_as_text(self, model: clearskies.Model, now: datetime.datetime) -> str:
-        """Build the text for a message."""
-        if self.message:
-            return self.message
-
-        if self.message_template:
-            return str(self.message_template.render(model=model, now=now, **self.more_template_variables()))
-
-        return ""
-
-    def _resolve_subject(self, model: clearskies.Model, now: datetime.datetime) -> str:
-        """Build the subject for a message."""
-        if self.subject:
-            return self.subject
-
-        if self.subject_template:
-            return str(self.subject_template.render(model=model, now=now, **self.more_template_variables()))
-
-        return ""
-
-    def more_template_variables(self) -> dict[str, Any]:
-        more_variables = {}
-        for dependency_name in self.dependencies_for_template:
-            more_variables[dependency_name] = self.di.build(dependency_name, cache=True)
-        return more_variables

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.py

@@ -1,64 +0,0 @@
-import boto3
-import clearskies
-import datetime
-import json
-
-from botocore.exceptions import ClientError
-from collections.abc import Sequence
-from clearskies.environment import Environment
-from clearskies.models import Models
-from types import ModuleType
-from typing import List, Optional, Callable, cast
-
-from ..di import StandardDependencies
-from .assume_role import AssumeRole
-from .action_aws import ActionAws
-class SNS(ActionAws):
-    _name = "sns"
-
-    def __init__(self, environment: Environment, boto3: boto3, di: StandardDependencies) -> None:
-        super().__init__(environment, boto3, di)
-
-    def configure(
-        self,
-        topic=None,
-        topic_environment_key=None,
-        topic_callable: Optional[Callable] = None,
-        message_callable: Optional[Callable] = None,
-        when: Optional[Callable] = None,
-        assume_role: Optional[AssumeRole] = None,
-    ) -> None:
-        """Configures the action for SNS."""
-        super().configure(message_callable=message_callable, when=when, assume_role=assume_role)
-
-        self.topic = topic
-        self.topic_environment_key = topic_environment_key
-        self.topic_callable = topic_callable
-
-        topics = 0
-        for value in [topic, topic_environment_key, topic_callable]:
-            if value:
-                topics += 1
-        if topics > 1:
-            raise ValueError(
-                "You can only provide one of 'topic', 'topic_environment_key', or 'topic_callable', but more than one were provided."
-            )
-        if not topics:
-            raise ValueError("You must provide at least one of 'topic', 'topic_environment_key', or 'topic_callable'.")
-
-    def _execute_action(self, client: ModuleType, model: Models) -> None:
-        """Send a notification as configured."""
-        topic_arn = self.get_topic_arn(model)
-        if not topic_arn:
-            return
-        client.publish(
-            TopicArn=self.get_topic_arn(model),
-            Message=self.get_message_body(model),
-        )
-
-    def get_topic_arn(self, model: Models) -> str:
-        if self.topic:
-            return self.topic
-        if self.topic_environment_key:
-            return self.environment.get(self.topic_environment_key)
-        return self.di.call_function(self.topic_callable, model=model)

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.py

@@ -1,82 +0,0 @@
-import boto3
-import json
-import datetime
-
-from botocore.exceptions import ClientError
-from clearskies.environment import Environment
-from clearskies.model import Model
-from collections.abc import Sequence
-from collections import OrderedDict
-from types import ModuleType
-from typing import List, Optional, Callable, Union
-
-from ..di import StandardDependencies
-from . import assume_role
-from .action_aws import ActionAws
-class SQS(ActionAws):
-    _name = "sqs"
-
-    def __init__(self, environment: Environment, boto3: boto3, di: StandardDependencies) -> None:
-        """Setup action."""
-        super().__init__(environment, boto3, di)
-
-    def configure(
-        self,
-        queue_url: str = '',
-        queue_url_environment_key: str = '',
-        queue_url_callable: Optional[Callable] = None,
-        message_callable: Optional[Callable] = None,
-        when: Optional[Callable] = None,
-        assume_role: Optional[assume_role.AssumeRole] = None,
-        message_group_id: Optional[Union[str, Callable]] = None,
-    ) -> None:
-        super().configure(message_callable=message_callable, when=when, assume_role=assume_role)
-
-        self.queue_url = queue_url
-        self.queue_url_environment_key = queue_url_environment_key
-        self.queue_url_callable = queue_url_callable
-        self.message_group_id = message_group_id
-
-        queue_urls = 0
-        for value in [queue_url, queue_url_environment_key, queue_url_callable]:
-            if value:
-                queue_urls += 1
-        if queue_urls > 1:
-            raise ValueError(
-                "You can only provide one of 'queue_url', 'queue_url_environment_key', or 'queue_url_callable', but more than one were provided."
-            )
-        if not queue_urls:
-            raise ValueError(
-                "You must provide at least one of 'queue_url', 'queue_url_environment_key', or 'queue_url_callable'."
-            )
-        if message_group_id and not callable(message_group_id) and not isinstance(message_group_id, str):
-            raise ValueError(
-                "If provided, 'message_group_id' must be a string or callable, but the provided value was neither."
-            )
-
-    def _execute_action(self, client: ModuleType, model: Model) -> None:
-        """Send a notification as configured."""
-        params = {
-            "QueueUrl": self.get_queue_url(model),
-            "MessageBody": self.get_message_body(model),
-        }
-        if not params["QueueUrl"]:
-            return
-
-        if self.message_group_id:
-            if callable(self.message_group_id):
-                message_group_id = self.di.call_function(self.message_group_id, model=model)
-                if not isinstance(message_group_id, str):
-                    raise ValueError(f"I called the message_group_id function for SQS for model '{model.__class__.__name__}' but the value it returned was not a string.  The message group id must be a string.")
-            else:
-                message_group_id = self.message_group_id
-            params["MessageGroupId"] = message_group_id
-
-        client.send_message(**params)
-
-    def get_queue_url(self, model: Model):
-        if self.queue_url:
-            return self.queue_url
-        if self.queue_url_environment_key:
-            return self.environment.get(self.queue_url_environment_key)
-        return self.di.call_function(self.queue_url_callable, model=model)