Merge remote-tracking branch 'spulec/master'

AUTHORS.md

@@ -48,3 +48,4 @@ Moto is written by Steve Pulec with contributions from:
 * [Guy Templeton](https://github.com/gjtempleton)
 * [Michael van Tellingen](https://github.com/mvantellingen)
 * [Jessie Nadler](https://github.com/nadlerjessie)
+* [Alex Morken](https://github.com/alexmorken)

IMPLEMENTATION_COVERAGE.md

@@ -329,10 +329,10 @@
 - [ ] update_schema
 - [ ] update_typed_link_facet
 
-## cloudformation - 17% implemented
+## cloudformation - 20% implemented
 - [ ] cancel_update_stack
 - [ ] continue_update_rollback
-- [ ] create_change_set
+- [X] create_change_set
 - [X] create_stack
 - [ ] create_stack_instances
 - [ ] create_stack_set

moto/awslambda/models.py

@@ -603,7 +603,7 @@ class LambdaBackend(BaseBackend):
     def list_functions(self):
         return self._lambdas.all()
 
-    def send_message(self, function_name, message):
+    def send_message(self, function_name, message, subject=None):
         event = {
             "Records": [
                 {
@@ -630,7 +630,7 @@ class LambdaBackend(BaseBackend):
                         "Type": "Notification",
                         "UnsubscribeUrl": "EXAMPLE",
                         "TopicArn": "arn:aws:sns:EXAMPLE",
-                        "Subject": "TestInvoke"
+                        "Subject": subject or "TestInvoke"
                     }
                 }
             ]

moto/cloudformation/models.py

@@ -9,13 +9,17 @@ from moto.compat import OrderedDict
 from moto.core import BaseBackend, BaseModel
 
 from .parsing import ResourceMap, OutputMap
-from .utils import generate_stack_id, yaml_tag_constructor
+from .utils import (
+    generate_changeset_id,
+    generate_stack_id,
+    yaml_tag_constructor,
+)
 from .exceptions import ValidationError
 
 
 class FakeStack(BaseModel):
 
-    def __init__(self, stack_id, name, template, parameters, region_name, notification_arns=None, tags=None, role_arn=None, cross_stack_resources=None):
+    def __init__(self, stack_id, name, template, parameters, region_name, notification_arns=None, tags=None, role_arn=None, cross_stack_resources=None, create_change_set=False):
         self.stack_id = stack_id
         self.name = name
         self.template = template
@@ -26,8 +30,12 @@ class FakeStack(BaseModel):
         self.role_arn = role_arn
         self.tags = tags if tags else {}
         self.events = []
-        self._add_stack_event("CREATE_IN_PROGRESS",
+        if create_change_set:
-                              resource_status_reason="User Initiated")
+            self._add_stack_event("REVIEW_IN_PROGRESS",
+                                  resource_status_reason="User Initiated")
+        else:
+            self._add_stack_event("CREATE_IN_PROGRESS",
+                                  resource_status_reason="User Initiated")
 
         self.description = self.template_dict.get('Description')
         self.cross_stack_resources = cross_stack_resources or []
@@ -138,8 +146,9 @@ class CloudFormationBackend(BaseBackend):
         self.stacks = OrderedDict()
         self.deleted_stacks = {}
         self.exports = OrderedDict()
+        self.change_sets = OrderedDict()
 
-    def create_stack(self, name, template, parameters, region_name, notification_arns=None, tags=None, role_arn=None):
+    def create_stack(self, name, template, parameters, region_name, notification_arns=None, tags=None, role_arn=None, create_change_set=False):
         stack_id = generate_stack_id(name)
         new_stack = FakeStack(
             stack_id=stack_id,
@@ -151,6 +160,7 @@ class CloudFormationBackend(BaseBackend):
             tags=tags,
             role_arn=role_arn,
             cross_stack_resources=self.exports,
+            create_change_set=create_change_set,
         )
         self.stacks[stack_id] = new_stack
         self._validate_export_uniqueness(new_stack)
@@ -158,6 +168,26 @@ class CloudFormationBackend(BaseBackend):
             self.exports[export.name] = export
         return new_stack
 
+    def create_change_set(self, stack_name, change_set_name, template, parameters, region_name, change_set_type, notification_arns=None, tags=None, role_arn=None):
+        if change_set_type == 'UPDATE':
+            stacks = self.stacks.values()
+            stack = None
+            for s in stacks:
+                if s.name == stack_name:
+                    stack = s
+            if stack is None:
+                raise ValidationError(stack_name)
+
+        else:
+            stack = self.create_stack(stack_name, template, parameters,
+                                      region_name, notification_arns, tags,
+                                      role_arn, create_change_set=True)
+        change_set_id = generate_changeset_id(change_set_name, region_name)
+        self.stacks[change_set_name] = {'Id': change_set_id,
+                                        'StackId': stack.stack_id}
+        self.change_sets[change_set_id] = stack
+        return change_set_id, stack.stack_id
+
     def describe_stacks(self, name_or_stack_id):
         stacks = self.stacks.values()
         if name_or_stack_id:

moto/cloudformation/responses.py

@@ -4,6 +4,7 @@ import json
 from six.moves.urllib.parse import urlparse
 
 from moto.core.responses import BaseResponse
+from moto.core.utils import amzn_request_id
 from moto.s3 import s3_backend
 from .models import cloudformation_backends
 from .exceptions import ValidationError
@@ -77,6 +78,46 @@ class CloudFormationResponse(BaseResponse):
             template = self.response_template(CREATE_STACK_RESPONSE_TEMPLATE)
             return template.render(stack=stack)
 
+    @amzn_request_id
+    def create_change_set(self):
+        stack_name = self._get_param('StackName')
+        change_set_name = self._get_param('ChangeSetName')
+        stack_body = self._get_param('TemplateBody')
+        template_url = self._get_param('TemplateURL')
+        role_arn = self._get_param('RoleARN')
+        update_or_create = self._get_param('ChangeSetType', 'CREATE')
+        parameters_list = self._get_list_prefix("Parameters.member")
+        tags = {tag[0]: tag[1] for tag in self._get_list_prefix("Tags.member")}
+        parameters = {param['parameter_key']: param['parameter_value']
+                      for param in parameters_list}
+        if template_url:
+            stack_body = self._get_stack_from_s3_url(template_url)
+        stack_notification_arns = self._get_multi_param(
+            'NotificationARNs.member')
+        change_set_id, stack_id = self.cloudformation_backend.create_change_set(
+            stack_name=stack_name,
+            change_set_name=change_set_name,
+            template=stack_body,
+            parameters=parameters,
+            region_name=self.region,
+            notification_arns=stack_notification_arns,
+            tags=tags,
+            role_arn=role_arn,
+            change_set_type=update_or_create,
+        )
+        if self.request_json:
+            return json.dumps({
+                'CreateChangeSetResponse': {
+                    'CreateChangeSetResult': {
+                        'Id': change_set_id,
+                        'StackId': stack_id,
+                    }
+                }
+            })
+        else:
+            template = self.response_template(CREATE_CHANGE_SET_RESPONSE_TEMPLATE)
+            return template.render(stack_id=stack_id, change_set_id=change_set_id)
+
     def describe_stacks(self):
         stack_name_or_id = None
         if self._get_param('StackName'):
@@ -250,6 +291,17 @@ UPDATE_STACK_RESPONSE_TEMPLATE = """<UpdateStackResponse xmlns="http://cloudform
 </UpdateStackResponse>
 """
 
+CREATE_CHANGE_SET_RESPONSE_TEMPLATE = """<CreateStackResponse>
+  <CreateChangeSetResult>
+    <Id>{{change_set_id}}</Id>
+    <StackId>{{ stack_id }}</StackId>
+  </CreateChangeSetResult>
+  <ResponseMetadata>
+    <RequestId>{{ request_id }}</RequestId>
+  </ResponseMetadata>
+</CreateStackResponse>
+"""
+
 DESCRIBE_STACKS_TEMPLATE = """<DescribeStacksResponse>
   <DescribeStacksResult>
     <Stacks>

moto/cloudformation/utils.py

@@ -10,6 +10,11 @@ def generate_stack_id(stack_name):
     return "arn:aws:cloudformation:us-east-1:123456789:stack/{0}/{1}".format(stack_name, random_id)
 
 
+def generate_changeset_id(changeset_name, region_name):
+    random_id = uuid.uuid4()
+    return 'arn:aws:cloudformation:{0}:123456789:changeSet/{1}/{2}'.format(region_name, changeset_name, random_id)
+
+
 def random_suffix():
     size = 12
     chars = list(range(10)) + ['A-Z']

moto/sns/models.py

@@ -42,11 +42,11 @@ class Topic(BaseModel):
         self.subscriptions_confimed = 0
         self.subscriptions_deleted = 0
 
-    def publish(self, message):
+    def publish(self, message, subject=None):
         message_id = six.text_type(uuid.uuid4())
         subscriptions, _ = self.sns_backend.list_subscriptions(self.arn)
         for subscription in subscriptions:
-            subscription.publish(message, message_id)
+            subscription.publish(message, message_id, subject=subject)
         return message_id
 
     def get_cfn_attribute(self, attribute_name):
@@ -83,27 +83,27 @@ class Subscription(BaseModel):
         self.attributes = {}
         self.confirmed = False
 
-    def publish(self, message, message_id):
+    def publish(self, message, message_id, subject=None):
         if self.protocol == 'sqs':
             queue_name = self.endpoint.split(":")[-1]
             region = self.endpoint.split(":")[3]
-            enveloped_message = json.dumps(self.get_post_data(message, message_id), sort_keys=True, indent=2, separators=(',', ': '))
+            enveloped_message = json.dumps(self.get_post_data(message, message_id, subject), sort_keys=True, indent=2, separators=(',', ': '))
             sqs_backends[region].send_message(queue_name, enveloped_message)
         elif self.protocol in ['http', 'https']:
-            post_data = self.get_post_data(message, message_id)
+            post_data = self.get_post_data(message, message_id, subject)
             requests.post(self.endpoint, json=post_data)
         elif self.protocol == 'lambda':
             # TODO: support bad function name
             function_name = self.endpoint.split(":")[-1]
             region = self.arn.split(':')[3]
-            lambda_backends[region].send_message(function_name, message)
+            lambda_backends[region].send_message(function_name, message, subject=subject)
 
-    def get_post_data(self, message, message_id):
+    def get_post_data(self, message, message_id, subject):
         return {
             "Type": "Notification",
             "MessageId": message_id,
             "TopicArn": self.topic.arn,
-            "Subject": "my subject",
+            "Subject": subject or "my subject",
             "Message": message,
             "Timestamp": iso_8601_datetime_with_milliseconds(datetime.datetime.utcnow()),
             "SignatureVersion": "1",
@@ -270,7 +270,7 @@ class SNSBackend(BaseBackend):
 
         try:
             topic = self.get_topic(arn)
-            message_id = topic.publish(message)
+            message_id = topic.publish(message, subject=subject)
         except SNSNotFoundError:
             endpoint = self.get_endpoint(arn)
             message_id = endpoint.publish(message)

tests/test_cloudformation/test_cloudformation_stack_crud_boto3.py

@@ -310,6 +310,33 @@ def test_update_stack_from_s3_url():
         'TemplateBody'].should.equal(dummy_update_template)
 
 
+@mock_cloudformation
+@mock_s3
+def test_create_change_set_from_s3_url():
+    s3 = boto3.client('s3')
+    s3_conn = boto3.resource('s3')
+    bucket = s3_conn.create_bucket(Bucket="foobar")
+
+    key = s3_conn.Object(
+        'foobar', 'template-key').put(Body=dummy_template_json)
+    key_url = s3.generate_presigned_url(
+        ClientMethod='get_object',
+        Params={
+            'Bucket': 'foobar',
+            'Key': 'template-key'
+        }
+    )
+    cf_conn = boto3.client('cloudformation', region_name='us-west-1')
+    response = cf_conn.create_change_set(
+        StackName='NewStack',
+        TemplateURL=key_url,
+        ChangeSetName='NewChangeSet',
+        ChangeSetType='CREATE',
+    )
+    assert 'arn:aws:cloudformation:us-west-1:123456789:changeSet/NewChangeSet/' in response['Id']
+    assert 'arn:aws:cloudformation:us-east-1:123456789:stack/NewStack' in response['StackId']
+
+
 @mock_cloudformation
 def test_describe_stack_pagination():
     conn = boto3.client('cloudformation', region_name='us-east-1')

tests/test_sns/test_publishing.py

@@ -1,16 +1,15 @@
 from __future__ import unicode_literals
-from six.moves.urllib.parse import parse_qs
 
 import boto
+import json
 import re
 from freezegun import freeze_time
 import sure  # noqa
 
-from moto.packages.responses import responses
 from moto import mock_sns_deprecated, mock_sqs_deprecated
 
 
-MESSAGE_FROM_SQS_TEMPLATE = '{\n  "Message": "%s",\n  "MessageId": "%s",\n  "Signature": "EXAMPLElDMXvB8r9R83tGoNn0ecwd5UjllzsvSvbItzfaMpN2nk5HVSw7XnOn/49IkxDKz8YrlH2qJXj2iZB0Zo2O71c4qQk1fMUDi3LGpij7RCW7AW9vYYsSqIKRnFS94ilu7NFhUzLiieYr4BKHpdTmdD6c0esKEYBpabxDSc=",\n  "SignatureVersion": "1",\n  "SigningCertURL": "https://sns.us-east-1.amazonaws.com/SimpleNotificationService-f3ecfb7224c7233fe7bb5f59f96de52f.pem",\n  "Subject": "my subject",\n  "Timestamp": "2015-01-01T12:00:00.000Z",\n  "TopicArn": "arn:aws:sns:%s:123456789012:some-topic",\n  "Type": "Notification",\n  "UnsubscribeURL": "https://sns.us-east-1.amazonaws.com/?Action=Unsubscribe&SubscriptionArn=arn:aws:sns:us-east-1:123456789012:some-topic:2bcfbf39-05c3-41de-beaa-fcfcc21c8f55"\n}'
+MESSAGE_FROM_SQS_TEMPLATE = '{\n  "Message": "%s",\n  "MessageId": "%s",\n  "Signature": "EXAMPLElDMXvB8r9R83tGoNn0ecwd5UjllzsvSvbItzfaMpN2nk5HVSw7XnOn/49IkxDKz8YrlH2qJXj2iZB0Zo2O71c4qQk1fMUDi3LGpij7RCW7AW9vYYsSqIKRnFS94ilu7NFhUzLiieYr4BKHpdTmdD6c0esKEYBpabxDSc=",\n  "SignatureVersion": "1",\n  "SigningCertURL": "https://sns.us-east-1.amazonaws.com/SimpleNotificationService-f3ecfb7224c7233fe7bb5f59f96de52f.pem",\n  "Subject": "%s",\n  "Timestamp": "2015-01-01T12:00:00.000Z",\n  "TopicArn": "arn:aws:sns:%s:123456789012:some-topic",\n  "Type": "Notification",\n  "UnsubscribeURL": "https://sns.us-east-1.amazonaws.com/?Action=Unsubscribe&SubscriptionArn=arn:aws:sns:us-east-1:123456789012:some-topic:2bcfbf39-05c3-41de-beaa-fcfcc21c8f55"\n}'
 
 
 @mock_sqs_deprecated
@@ -29,13 +28,14 @@ def test_publish_to_sqs():
                    "arn:aws:sqs:us-east-1:123456789012:test-queue")
 
     message_to_publish = 'my message'
+    subject_to_publish = "test subject"
     with freeze_time("2015-01-01 12:00:00"):
-        published_message = conn.publish(topic=topic_arn, message=message_to_publish)
+        published_message = conn.publish(topic=topic_arn, message=message_to_publish, subject=subject_to_publish)
     published_message_id = published_message['PublishResponse']['PublishResult']['MessageId']
 
     queue = sqs_conn.get_queue("test-queue")
     message = queue.read(1)
-    expected = MESSAGE_FROM_SQS_TEMPLATE  % (message_to_publish, published_message_id, 'us-east-1')
+    expected = MESSAGE_FROM_SQS_TEMPLATE  % (message_to_publish, published_message_id, subject_to_publish, 'us-east-1')
     acquired_message = re.sub("\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z", '2015-01-01T12:00:00.000Z', message.get_body())
     acquired_message.should.equal(expected)
 
@@ -56,13 +56,14 @@ def test_publish_to_sqs_in_different_region():
                    "arn:aws:sqs:us-west-2:123456789012:test-queue")
 
     message_to_publish = 'my message'
+    subject_to_publish = "test subject"
     with freeze_time("2015-01-01 12:00:00"):
-        published_message = conn.publish(topic=topic_arn, message=message_to_publish)
+        published_message = conn.publish(topic=topic_arn, message=message_to_publish, subject=subject_to_publish)
     published_message_id = published_message['PublishResponse']['PublishResult']['MessageId']
 
     queue = sqs_conn.get_queue("test-queue")
     message = queue.read(1)
-    expected = MESSAGE_FROM_SQS_TEMPLATE  % (message_to_publish, published_message_id, 'us-west-1')
+    expected = MESSAGE_FROM_SQS_TEMPLATE  % (message_to_publish, published_message_id, subject_to_publish, 'us-west-1')
 
     acquired_message = re.sub("\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z", '2015-01-01T12:00:00.000Z', message.get_body())
     acquired_message.should.equal(expected)