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

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

@@ -1,66 +0,0 @@
-import boto3
-
-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 StepFunction(ActionAws):
-    _name = "stepfunctions"
-
-    def __init__(self, environment: Environment, boto3: boto3, di: StandardDependencies) -> None:
-        super().__init__(environment, boto3, di)
-
-    def configure(
-        self,
-        arn: Optional[str]=None,
-        arn_environment_key: Optional[str] = None,
-        arn_callable: Optional[Callable] = None,
-        column_to_store_execution_arn: Optional[str] = None,
-        message_callable: Optional[Callable] = None,
-        when: Optional[Callable] = None,
-        assume_role: Optional[AssumeRole] = None,
-    ) -> None:
-        """Configures the action for the step function."""
-        super().configure(message_callable=message_callable, when=when, assume_role=assume_role)
-
-        self.arn = arn
-        self.arn_environment_key = arn_environment_key
-        self.arn_callable = arn_callable
-        self.column_to_store_execution_arn = column_to_store_execution_arn
-
-        arns = 0
-        for value in [arn, arn_environment_key, arn_callable]:
-            if value:
-                arns += 1
-        if arns > 1:
-            raise ValueError(
-                "You can only provide one of 'arn', 'arn_environment_key', or 'arn_callable', but more than one was provided."
-            )
-        if not arns:
-            raise ValueError("You must provide at least one of 'arn', 'arn_environment_key', or 'arn_callable'.")
-
-    def _execute_action(self, client: ModuleType, model: Models) -> None:
-        """Send a notification as configured."""
-        arn = self.get_arn(model)
-        default_region = self.default_region()
-        arn_region = arn.split(':')[3]
-        if default_region and default_region != arn_region:
-            client = self._getClient(region=arn_region)
-        response = client.start_execution(
-            stateMachineArn=self.get_arn(model),
-            input=self.get_message_body(model),
-        )
-
-        if self.column_to_store_execution_arn:
-            model.save({self.column_to_store_execution_arn: response['executionArn']})
-
-    def get_arn(self, model: Models) -> str:
-        if self.arn:
-            return self.arn
-        if self.arn_environment_key:
-            return self.environment.get(self.arn_environment_key)
-        return self.di.call_function(self.arn_callable, model=model)

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))

clearskies_aws/backends/__init__.py

@@ -1,12 +0,0 @@
-from .dynamo_db_backend import DynamoDBBackend
-from .dynamo_db_parti_ql_backend import DynamoDBPartiQLBackend, DynamoDBPartiQLCursor
-from .dynamo_db_condition_parser import DynamoDBConditionParser
-from .sqs_backend import SqsBackend
-
-__all__ = [
-    "DynamoDBBackend",
-    "SqsBackend",
-    "DynamoDBPartiQLBackend",
-    "DynamoDBPartiQLCursor",
-    "DynamoDBConditionParser",
-]