Implement XML responses for SNS (for Boto3)

moto/sns/models.py

@@ -2,6 +2,7 @@ from __future__ import unicode_literals
 
 import datetime
 import uuid
+import json
 
 import boto.sns
 import requests
@@ -257,7 +258,7 @@ for region in boto.sns.regions():
     sns_backends[region.name] = SNSBackend(region.name)
 
 
-DEFAULT_TOPIC_POLICY = {
+DEFAULT_TOPIC_POLICY = json.dumps({
     "Version": "2008-10-17",
     "Id": "us-east-1/698519295917/test__default_policy_ID",
     "Statement": [{
@@ -284,9 +285,9 @@ DEFAULT_TOPIC_POLICY = {
             }
         }
     }]
-}
+})
 
-DEFAULT_EFFECTIVE_DELIVERY_POLICY = {
+DEFAULT_EFFECTIVE_DELIVERY_POLICY = json.dumps({
     'http': {
         'disableSubscriptionOverrides': False,
         'defaultHealthyRetryPolicy': {
@@ -299,4 +300,4 @@ DEFAULT_EFFECTIVE_DELIVERY_POLICY = {
             'backoffFunction': 'linear'
         }
     }
-}
+})

moto/sns/responses.py

@@ -12,6 +12,10 @@ class SNSResponse(BaseResponse):
     def backend(self):
         return sns_backends[self.region]
 
+    @property
+    def request_json(self):
+        return 'JSON' in self.querystring.get('ContentType', [])
+
     def _get_attributes(self):
         attributes = self._get_list_prefix('Attributes.entry')
         return dict(
@@ -24,69 +28,85 @@ class SNSResponse(BaseResponse):
         name = self._get_param('Name')
         topic = self.backend.create_topic(name)
 
-        return json.dumps({
+        if self.request_json:
-            'CreateTopicResponse': {
+            return json.dumps({
-                'CreateTopicResult': {
+                'CreateTopicResponse': {
-                    'TopicArn': topic.arn,
+                    'CreateTopicResult': {
-                },
+                        'TopicArn': topic.arn,
-                'ResponseMetadata': {
+                    },
-                    'RequestId': 'a8dec8b3-33a4-11df-8963-01868b7c937a',
+                    'ResponseMetadata': {
+                        'RequestId': 'a8dec8b3-33a4-11df-8963-01868b7c937a',
+                    }
                 }
-            }
+            })
-        })
+
+        template = self.response_template(CREATE_TOPIC_TEMPLATE)
+        return template.render(topic=topic)
 
     def list_topics(self):
         next_token = self._get_param('NextToken')
         topics, next_token = self.backend.list_topics(next_token=next_token)
 
-        return json.dumps({
+        if self.request_json:
-            'ListTopicsResponse': {
+            return json.dumps({
-                'ListTopicsResult': {
+                'ListTopicsResponse': {
-                    'Topics': [{'TopicArn': topic.arn} for topic in topics],
+                    'ListTopicsResult': {
-                    'NextToken': next_token,
+                        'Topics': [{'TopicArn': topic.arn} for topic in topics],
+                        'NextToken': next_token,
+                    }
+                },
+                'ResponseMetadata': {
+                    'RequestId': 'a8dec8b3-33a4-11df-8963-01868b7c937a',
                 }
-            },
+            })
-            'ResponseMetadata': {
+
-                'RequestId': 'a8dec8b3-33a4-11df-8963-01868b7c937a',
+        template = self.response_template(LIST_TOPICS_TEMPLATE)
-            }
+        return template.render(topics=topics, next_token=next_token)
-        })
 
     def delete_topic(self):
         topic_arn = self._get_param('TopicArn')
         self.backend.delete_topic(topic_arn)
 
-        return json.dumps({
+        if self.request_json:
-            'DeleteTopicResponse': {
+            return json.dumps({
-                'ResponseMetadata': {
+                'DeleteTopicResponse': {
-                    'RequestId': 'a8dec8b3-33a4-11df-8963-01868b7c937a',
+                    'ResponseMetadata': {
+                        'RequestId': 'a8dec8b3-33a4-11df-8963-01868b7c937a',
+                    }
                 }
-            }
+            })
-        })
+
+        template = self.response_template(DELETE_TOPIC_TEMPLATE)
+        return template.render()
 
     def get_topic_attributes(self):
         topic_arn = self._get_param('TopicArn')
         topic = self.backend.get_topic(topic_arn)
 
-        return json.dumps({
+        if self.request_json:
-            "GetTopicAttributesResponse": {
+            return json.dumps({
-                "GetTopicAttributesResult": {
+                "GetTopicAttributesResponse": {
-                    "Attributes": {
+                    "GetTopicAttributesResult": {
-                        "Owner": topic.account_id,
+                        "Attributes": {
-                        "Policy": topic.policy,
+                            "Owner": topic.account_id,
-                        "TopicArn": topic.arn,
+                            "Policy": topic.policy,
-                        "DisplayName": topic.display_name,
+                            "TopicArn": topic.arn,
-                        "SubscriptionsPending": topic.subscriptions_pending,
+                            "DisplayName": topic.display_name,
-                        "SubscriptionsConfirmed": topic.subscriptions_confimed,
+                            "SubscriptionsPending": topic.subscriptions_pending,
-                        "SubscriptionsDeleted": topic.subscriptions_deleted,
+                            "SubscriptionsConfirmed": topic.subscriptions_confimed,
-                        "DeliveryPolicy": topic.delivery_policy,
+                            "SubscriptionsDeleted": topic.subscriptions_deleted,
-                        "EffectiveDeliveryPolicy": topic.effective_delivery_policy,
+                            "DeliveryPolicy": topic.delivery_policy,
+                            "EffectiveDeliveryPolicy": topic.effective_delivery_policy,
+                        }
+                    },
+                    "ResponseMetadata": {
+                        "RequestId": "057f074c-33a7-11df-9540-99d0768312d3"
                     }
-                },
-                "ResponseMetadata": {
-                    "RequestId": "057f074c-33a7-11df-9540-99d0768312d3"
                 }
-            }
+            })
-        })
+
+        template = self.response_template(GET_TOPIC_ATTRIBUTES_TEMPLATE)
+        return template.render(topic=topic)
 
     def set_topic_attributes(self):
         topic_arn = self._get_param('TopicArn')
@@ -95,13 +115,17 @@ class SNSResponse(BaseResponse):
         attribute_value = self._get_param('AttributeValue')
         self.backend.set_topic_attribute(topic_arn, attribute_name, attribute_value)
 
-        return json.dumps({
+        if self.request_json:
-            "SetTopicAttributesResponse": {
+            return json.dumps({
-                "ResponseMetadata": {
+                "SetTopicAttributesResponse": {
-                    "RequestId": "a8763b99-33a7-11df-a9b7-05d48da6f042"
+                    "ResponseMetadata": {
+                        "RequestId": "a8763b99-33a7-11df-a9b7-05d48da6f042"
+                    }
                 }
-            }
+            })
-        })
+
+        template = self.response_template(SET_TOPIC_ATTRIBUTES_TEMPLATE)
+        return template.render()
 
     def subscribe(self):
         topic_arn = self._get_param('TopicArn')
@@ -109,73 +133,91 @@ class SNSResponse(BaseResponse):
         protocol = self._get_param('Protocol')
         subscription = self.backend.subscribe(topic_arn, endpoint, protocol)
 
-        return json.dumps({
+        if self.request_json:
-            "SubscribeResponse": {
+            return json.dumps({
-                "SubscribeResult": {
+                "SubscribeResponse": {
-                    "SubscriptionArn": subscription.arn,
+                    "SubscribeResult": {
-                },
+                        "SubscriptionArn": subscription.arn,
-                "ResponseMetadata": {
+                    },
-                    "RequestId": "a8763b99-33a7-11df-a9b7-05d48da6f042"
+                    "ResponseMetadata": {
+                        "RequestId": "a8763b99-33a7-11df-a9b7-05d48da6f042"
+                    }
                 }
-            }
+            })
-        })
+
+        template = self.response_template(SUBSCRIBE_TEMPLATE)
+        return template.render(subscription=subscription)
 
     def unsubscribe(self):
         subscription_arn = self._get_param('SubscriptionArn')
         self.backend.unsubscribe(subscription_arn)
 
-        return json.dumps({
+        if self.request_json:
-            "UnsubscribeResponse": {
+            return json.dumps({
-                "ResponseMetadata": {
+                "UnsubscribeResponse": {
-                    "RequestId": "a8763b99-33a7-11df-a9b7-05d48da6f042"
+                    "ResponseMetadata": {
+                        "RequestId": "a8763b99-33a7-11df-a9b7-05d48da6f042"
+                    }
                 }
-            }
+            })
-        })
+
+        template = self.response_template(UNSUBSCRIBE_TEMPLATE)
+        return template.render()
 
     def list_subscriptions(self):
         next_token = self._get_param('NextToken')
         subscriptions, next_token = self.backend.list_subscriptions(next_token=next_token)
 
-        return json.dumps({
+        if self.request_json:
-            "ListSubscriptionsResponse": {
+            return json.dumps({
-                "ListSubscriptionsResult": {
+                "ListSubscriptionsResponse": {
-                    "Subscriptions": [{
+                    "ListSubscriptionsResult": {
-                        "TopicArn": subscription.topic.arn,
+                        "Subscriptions": [{
-                        "Protocol": subscription.protocol,
+                            "TopicArn": subscription.topic.arn,
-                        "SubscriptionArn": subscription.arn,
+                            "Protocol": subscription.protocol,
-                        "Owner": subscription.topic.account_id,
+                            "SubscriptionArn": subscription.arn,
-                        "Endpoint": subscription.endpoint,
+                            "Owner": subscription.topic.account_id,
-                    } for subscription in subscriptions],
+                            "Endpoint": subscription.endpoint,
-                    'NextToken': next_token,
+                        } for subscription in subscriptions],
-                },
+                        'NextToken': next_token,
-                "ResponseMetadata": {
+                    },
-                    "RequestId": "384ac68d-3775-11df-8963-01868b7c937a",
+                    "ResponseMetadata": {
+                        "RequestId": "384ac68d-3775-11df-8963-01868b7c937a",
+                    }
                 }
-            }
+            })
-        })
+
+        template = self.response_template(LIST_SUBSCRIPTIONS_TEMPLATE)
+        return template.render(subscriptions=subscriptions,
+                               next_token=next_token)
 
     def list_subscriptions_by_topic(self):
         topic_arn = self._get_param('TopicArn')
         next_token = self._get_param('NextToken')
         subscriptions, next_token = self.backend.list_subscriptions(topic_arn, next_token=next_token)
 
-        return json.dumps({
+        if self.request_json:
-            "ListSubscriptionsByTopicResponse": {
+            return json.dumps({
-                "ListSubscriptionsByTopicResult": {
+                "ListSubscriptionsByTopicResponse": {
-                    "Subscriptions": [{
+                    "ListSubscriptionsByTopicResult": {
-                        "TopicArn": subscription.topic.arn,
+                        "Subscriptions": [{
-                        "Protocol": subscription.protocol,
+                            "TopicArn": subscription.topic.arn,
-                        "SubscriptionArn": subscription.arn,
+                            "Protocol": subscription.protocol,
-                        "Owner": subscription.topic.account_id,
+                            "SubscriptionArn": subscription.arn,
-                        "Endpoint": subscription.endpoint,
+                            "Owner": subscription.topic.account_id,
-                    } for subscription in subscriptions],
+                            "Endpoint": subscription.endpoint,
-                    'NextToken': next_token,
+                        } for subscription in subscriptions],
-                },
+                        'NextToken': next_token,
-                "ResponseMetadata": {
+                    },
-                    "RequestId": "384ac68d-3775-11df-8963-01868b7c937a",
+                    "ResponseMetadata": {
+                        "RequestId": "384ac68d-3775-11df-8963-01868b7c937a",
+                    }
                 }
-            }
+            })
-        })
+
+        template = self.response_template(LIST_SUBSCRIPTIONS_BY_TOPIC_TEMPLATE)
+        return template.render(subscriptions=subscriptions,
+                               next_token=next_token)
 
     def publish(self):
         target_arn = self._get_param('TargetArn')
@@ -184,16 +226,20 @@ class SNSResponse(BaseResponse):
         message = self._get_param('Message')
         message_id = self.backend.publish(arn, message)
 
-        return json.dumps({
+        if self.request_json:
-            "PublishResponse": {
+            return json.dumps({
-                "PublishResult": {
+                "PublishResponse": {
-                    "MessageId": message_id,
+                    "PublishResult": {
-                },
+                        "MessageId": message_id,
-                "ResponseMetadata": {
+                    },
-                    "RequestId": "384ac68d-3775-11df-8963-01868b7c937a",
+                    "ResponseMetadata": {
+                        "RequestId": "384ac68d-3775-11df-8963-01868b7c937a",
+                    }
                 }
-            }
+            })
-        })
+
+        template = self.response_template(PUBLISH_TEMPLATE)
+        return template.render(message_id=message_id)
 
     def create_platform_application(self):
         name = self._get_param('Name')
@@ -201,31 +247,39 @@ class SNSResponse(BaseResponse):
         attributes = self._get_attributes()
         platform_application = self.backend.create_platform_application(self.region, name, platform, attributes)
 
-        return json.dumps({
+        if self.request_json:
-            "CreatePlatformApplicationResponse": {
+            return json.dumps({
-                "CreatePlatformApplicationResult": {
+                "CreatePlatformApplicationResponse": {
-                    "PlatformApplicationArn": platform_application.arn,
+                    "CreatePlatformApplicationResult": {
-                },
+                        "PlatformApplicationArn": platform_application.arn,
-                "ResponseMetadata": {
+                    },
-                    "RequestId": "384ac68d-3775-11df-8963-01868b7c937b",
+                    "ResponseMetadata": {
+                        "RequestId": "384ac68d-3775-11df-8963-01868b7c937b",
+                    }
                 }
-            }
+            })
-        })
+
+        template = self.response_template(CREATE_PLATFORM_APPLICATION_TEMPLATE)
+        return template.render(platform_application=platform_application)
 
     def get_platform_application_attributes(self):
         arn = self._get_param('PlatformApplicationArn')
         application = self.backend.get_application(arn)
 
-        return json.dumps({
+        if self.request_json:
-            "GetPlatformApplicationAttributesResponse": {
+            return json.dumps({
-                "GetPlatformApplicationAttributesResult": {
+                "GetPlatformApplicationAttributesResponse": {
-                    "Attributes": application.attributes,
+                    "GetPlatformApplicationAttributesResult": {
-                },
+                        "Attributes": application.attributes,
-                "ResponseMetadata": {
+                    },
-                    "RequestId": "384ac68d-3775-11df-8963-01868b7c937f",
+                    "ResponseMetadata": {
+                        "RequestId": "384ac68d-3775-11df-8963-01868b7c937f",
+                    }
                 }
-            }
+            })
-        })
+
+        template = self.response_template(GET_PLATFORM_APPLICATION_ATTRIBUTES_TEMPLATE)
+        return template.render(application=application)
 
     def set_platform_application_attributes(self):
         arn = self._get_param('PlatformApplicationArn')
@@ -233,43 +287,55 @@ class SNSResponse(BaseResponse):
 
         self.backend.set_application_attributes(arn, attributes)
 
-        return json.dumps({
+        if self.request_json:
-            "SetPlatformApplicationAttributesResponse": {
+            return json.dumps({
-                "ResponseMetadata": {
+                "SetPlatformApplicationAttributesResponse": {
-                    "RequestId": "384ac68d-3775-12df-8963-01868b7c937f",
+                    "ResponseMetadata": {
+                        "RequestId": "384ac68d-3775-12df-8963-01868b7c937f",
+                    }
                 }
-            }
+            })
-        })
+
+        template = self.response_template(SET_PLATFORM_APPLICATION_ATTRIBUTES_TEMPLATE)
+        return template.render()
 
     def list_platform_applications(self):
         applications = self.backend.list_platform_applications()
 
-        return json.dumps({
+        if self.request_json:
-            "ListPlatformApplicationsResponse": {
+            return json.dumps({
-                "ListPlatformApplicationsResult": {
+                "ListPlatformApplicationsResponse": {
-                    "PlatformApplications": [{
+                    "ListPlatformApplicationsResult": {
-                        "PlatformApplicationArn": application.arn,
+                        "PlatformApplications": [{
-                        "attributes": application.attributes,
+                            "PlatformApplicationArn": application.arn,
-                    } for application in applications],
+                            "attributes": application.attributes,
-                    "NextToken": None
+                        } for application in applications],
-                },
+                        "NextToken": None
-                "ResponseMetadata": {
+                    },
-                    "RequestId": "384ac68d-3775-11df-8963-01868b7c937c",
+                    "ResponseMetadata": {
+                        "RequestId": "384ac68d-3775-11df-8963-01868b7c937c",
+                    }
                 }
-            }
+            })
-        })
+
+        template = self.response_template(LIST_PLATFORM_APPLICATIONS_TEMPLATE)
+        return template.render(applications=applications)
 
     def delete_platform_application(self):
         platform_arn = self._get_param('PlatformApplicationArn')
         self.backend.delete_platform_application(platform_arn)
 
-        return json.dumps({
+        if self.request_json:
-            "DeletePlatformApplicationResponse": {
+            return json.dumps({
-                "ResponseMetadata": {
+                "DeletePlatformApplicationResponse": {
-                    "RequestId": "384ac68d-3775-11df-8963-01868b7c937e",
+                    "ResponseMetadata": {
+                        "RequestId": "384ac68d-3775-11df-8963-01868b7c937e",
+                    }
                 }
-            }
+            })
-        })
+
+        template = self.response_template(DELETE_PLATFORM_APPLICATION_TEMPLATE)
+        return template.render()
 
     def create_platform_endpoint(self):
         application_arn = self._get_param('PlatformApplicationArn')
@@ -282,52 +348,64 @@ class SNSResponse(BaseResponse):
         platform_endpoint = self.backend.create_platform_endpoint(
             self.region, application, custom_user_data, token, attributes)
 
-        return json.dumps({
+        if self.request_json:
-            "CreatePlatformEndpointResponse": {
+            return json.dumps({
-                "CreatePlatformEndpointResult": {
+                "CreatePlatformEndpointResponse": {
-                    "EndpointArn": platform_endpoint.arn,
+                    "CreatePlatformEndpointResult": {
-                },
+                        "EndpointArn": platform_endpoint.arn,
-                "ResponseMetadata": {
+                    },
-                    "RequestId": "384ac68d-3779-11df-8963-01868b7c937b",
+                    "ResponseMetadata": {
+                        "RequestId": "384ac68d-3779-11df-8963-01868b7c937b",
+                    }
                 }
-            }
+            })
-        })
+
+        template = self.response_template(CREATE_PLATFORM_ENDPOINT_TEMPLATE)
+        return template.render(platform_endpoint=platform_endpoint)
 
     def list_endpoints_by_platform_application(self):
         application_arn = self._get_param('PlatformApplicationArn')
         endpoints = self.backend.list_endpoints_by_platform_application(application_arn)
 
-        return json.dumps({
+        if self.request_json:
-            "ListEndpointsByPlatformApplicationResponse": {
+            return json.dumps({
-                "ListEndpointsByPlatformApplicationResult": {
+                "ListEndpointsByPlatformApplicationResponse": {
-                    "Endpoints": [
+                    "ListEndpointsByPlatformApplicationResult": {
-                        {
+                        "Endpoints": [
-                            "Attributes": endpoint.attributes,
+                            {
-                            "EndpointArn": endpoint.arn,
+                                "Attributes": endpoint.attributes,
-                        } for endpoint in endpoints
+                                "EndpointArn": endpoint.arn,
-                    ],
+                            } for endpoint in endpoints
-                    "NextToken": None
+                        ],
-                },
+                        "NextToken": None
-                "ResponseMetadata": {
+                    },
-                    "RequestId": "384ac68d-3775-11df-8963-01868b7c937a",
+                    "ResponseMetadata": {
+                        "RequestId": "384ac68d-3775-11df-8963-01868b7c937a",
+                    }
                 }
-            }
+            })
-        })
+
+        template = self.response_template(LIST_ENDPOINTS_BY_PLATFORM_APPLICATION_TEMPLATE)
+        return template.render(endpoints=endpoints)
 
     def get_endpoint_attributes(self):
         arn = self._get_param('EndpointArn')
         endpoint = self.backend.get_endpoint(arn)
 
-        return json.dumps({
+        if self.request_json:
-            "GetEndpointAttributesResponse": {
+            return json.dumps({
-                "GetEndpointAttributesResult": {
+                "GetEndpointAttributesResponse": {
-                    "Attributes": endpoint.attributes,
+                    "GetEndpointAttributesResult": {
-                },
+                        "Attributes": endpoint.attributes,
-                "ResponseMetadata": {
+                    },
-                    "RequestId": "384ac68d-3775-11df-8963-01868b7c937f",
+                    "ResponseMetadata": {
+                        "RequestId": "384ac68d-3775-11df-8963-01868b7c937f",
+                    }
                 }
-            }
+            })
-        })
+
+        template = self.response_template(GET_ENDPOINT_ATTRIBUTES_TEMPLATE)
+        return template.render(endpoint=endpoint)
 
     def set_endpoint_attributes(self):
         arn = self._get_param('EndpointArn')
@@ -335,10 +413,282 @@ class SNSResponse(BaseResponse):
 
         self.backend.set_endpoint_attributes(arn, attributes)
 
-        return json.dumps({
+        if self.request_json:
-            "SetEndpointAttributesResponse": {
+            return json.dumps({
-                "ResponseMetadata": {
+                "SetEndpointAttributesResponse": {
-                    "RequestId": "384bc68d-3775-12df-8963-01868b7c937f",
+                    "ResponseMetadata": {
+                        "RequestId": "384bc68d-3775-12df-8963-01868b7c937f",
+                    }
                 }
-            }
+            })
-        })
+
+        template = self.response_template(SET_ENDPOINT_ATTRIBUTES_TEMPLATE)
+        return template.render()
+
+
+CREATE_TOPIC_TEMPLATE = """<CreateTopicResponse xmlns="http://sns.amazonaws.com/doc/2010-03-31/">
+     <CreateTopicResult>
+       <TopicArn>{{ topic.arn }}</TopicArn>
+     </CreateTopicResult>
+     <ResponseMetadata>
+       <RequestId>a8dec8b3-33a4-11df-8963-01868b7c937a</RequestId>
+     </ResponseMetadata>
+   </CreateTopicResponse>"""
+
+LIST_TOPICS_TEMPLATE = """<ListTopicsResponse xmlns="http://sns.amazonaws.com/doc/2010-03-31/">
+  <ListTopicsResult>
+    <Topics>
+    {% for topic in topics %}
+      <member>
+        <TopicArn>{{ topic.arn }}</TopicArn>
+      </member>
+    {% endfor %}
+    </Topics>
+    {% if next_token  %}
+    <NextToken>{{ next_token }}</NextToken>
+    {% endif %}
+  </ListTopicsResult>
+  <ResponseMetadata>
+    <RequestId>3f1478c7-33a9-11df-9540-99d0768312d3</RequestId>
+  </ResponseMetadata>
+</ListTopicsResponse>"""
+
+DELETE_TOPIC_TEMPLATE = """<DeleteTopicResponse xmlns="http://sns.amazonaws.com/doc/2010-03-31/">
+  <ResponseMetadata>
+    <RequestId>f3aa9ac9-3c3d-11df-8235-9dab105e9c32</RequestId>
+  </ResponseMetadata>
+</DeleteTopicResponse>"""
+
+GET_TOPIC_ATTRIBUTES_TEMPLATE = """<GetTopicAttributesResponse xmlns="http://sns.amazonaws.com/doc/2010-03-31/">
+  <GetTopicAttributesResult>
+    <Attributes>
+      <entry>
+        <key>Owner</key>
+        <value>{{ topic.account_id }}</value>
+      </entry>
+      <entry>
+        <key>Policy</key>
+        <value>{{ topic.policy }}</value>
+      </entry>
+      <entry>
+        <key>TopicArn</key>
+        <value>{{ topic.arn }}</value>
+      </entry>
+      <entry>
+        <key>DisplayName</key>
+        <value>{{ topic.display_name }}</value>
+      </entry>
+      <entry>
+        <key>SubscriptionsPending</key>
+        <value>{{ topic.subscriptions_pending }}</value>
+      </entry>
+      <entry>
+        <key>SubscriptionsConfirmed</key>
+        <value>{{ topic.subscriptions_confimed }}</value>
+      </entry>
+      <entry>
+        <key>SubscriptionsDeleted</key>
+        <value>{{ topic.subscriptions_deleted }}</value>
+      </entry>
+      <entry>
+        <key>DeliveryPolicy</key>
+        <value>{{ topic.delivery_policy }}</value>
+      </entry>
+      <entry>
+        <key>EffectiveDeliveryPolicy</key>
+        <value>{{ topic.effective_delivery_policy }}</value>
+      </entry>
+    </Attributes>
+  </GetTopicAttributesResult>
+  <ResponseMetadata>
+    <RequestId>057f074c-33a7-11df-9540-99d0768312d3</RequestId>
+  </ResponseMetadata>
+</GetTopicAttributesResponse>"""
+
+SET_TOPIC_ATTRIBUTES_TEMPLATE = """<SetTopicAttributesResponse xmlns="http://sns.amazonaws.com/doc/2010-03-31/">
+  <ResponseMetadata>
+    <RequestId>a8763b99-33a7-11df-a9b7-05d48da6f042</RequestId>
+  </ResponseMetadata>
+</SetTopicAttributesResponse>"""
+
+CREATE_PLATFORM_APPLICATION_TEMPLATE = """<CreatePlatformApplicationResponse xmlns="http://sns.amazonaws.com/doc/2010-03-31/">
+  <CreatePlatformApplicationResult>
+    <PlatformApplicationArn>{{ platform_application.arn }}</PlatformApplicationArn>
+  </CreatePlatformApplicationResult>
+  <ResponseMetadata>
+    <RequestId>b6f0e78b-e9d4-5a0e-b973-adc04e8a4ff9</RequestId>
+  </ResponseMetadata>
+</CreatePlatformApplicationResponse>"""
+
+CREATE_PLATFORM_ENDPOINT_TEMPLATE = """<CreatePlatformEndpointResponse xmlns="http://sns.amazonaws.com/doc/2010-03-31/">
+  <CreatePlatformEndpointResult>
+    <EndpointArn>{{ platform_endpoint.arn }}</EndpointArn>
+  </CreatePlatformEndpointResult>
+  <ResponseMetadata>
+    <RequestId>6613341d-3e15-53f7-bf3c-7e56994ba278</RequestId>
+  </ResponseMetadata>
+</CreatePlatformEndpointResponse>"""
+
+LIST_PLATFORM_APPLICATIONS_TEMPLATE = """<ListPlatformApplicationsResponse xmlns="http://sns.amazonaws.com/doc/2010-03-31/">
+  <ListPlatformApplicationsResult>
+    <PlatformApplications>
+    {% for application in applications %}
+      <member>
+      <PlatformApplicationArn>{{ application.arn }}</PlatformApplicationArn>
+        <Attributes>
+        {% for attribute in application.attributes %}
+          <entry>
+            <key>{{ attribute }}</key>
+            <value>{{ application.attributes[attribute] }}</value>
+          </entry>
+        {% endfor %}
+        </Attributes>
+      </member>
+    {% endfor %}
+    </PlatformApplications>
+  </ListPlatformApplicationsResult>
+  <ResponseMetadata>
+    <RequestId>315a335e-85d8-52df-9349-791283cbb529</RequestId>
+  </ResponseMetadata>
+</ListPlatformApplicationsResponse>"""
+
+DELETE_PLATFORM_APPLICATION_TEMPLATE = """<DeletePlatformApplicationResponse xmlns="http://sns.amazonaws.com/doc/2010-03-31/">
+  <ResponseMetadata>
+    <RequestId>097dac18-7a77-5823-a8dd-e65476dcb037</RequestId>
+  </ResponseMetadata>
+</DeletePlatformApplicationResponse>"""
+
+GET_ENDPOINT_ATTRIBUTES_TEMPLATE = """<GetEndpointAttributesResponse xmlns="http://sns.amazonaws.com/doc/2010-03-31/">
+  <GetEndpointAttributesResult>
+    <Attributes>
+    {% for attribute in endpoint.attributes %}
+      <entry>
+        <key>{{ attribute }}</key>
+        <value>{{ endpoint.attributes[attribute] }}</value>
+      </entry>
+    {% endfor %}
+    </Attributes>
+  </GetEndpointAttributesResult>
+  <ResponseMetadata>
+    <RequestId>6c725a19-a142-5b77-94f9-1055a9ea04e7</RequestId>
+  </ResponseMetadata>
+</GetEndpointAttributesResponse>"""
+
+LIST_ENDPOINTS_BY_PLATFORM_APPLICATION_TEMPLATE = """<ListEndpointsByPlatformApplicationResponse xmlns="http://sns.amazonaws.com/doc/2010-03-31/">
+  <ListEndpointsByPlatformApplicationResult>
+    <Endpoints>
+      {% for endpoint in endpoints %}
+      <member>
+        <EndpointArn>{{ endpoint.arn }}</EndpointArn>
+        <Attributes>
+          {% for attribute in endpoint.attributes %}
+          <entry>
+            <key>{{ attribute }}</key>
+            <value>{{ endpoint.attributes[attribute] }}</value>
+          </entry>
+          {% endfor %}
+        </Attributes>
+      </member>
+      {% endfor %}
+    </Endpoints>
+  </ListEndpointsByPlatformApplicationResult>
+  <ResponseMetadata>
+    <RequestId>9a48768c-dac8-5a60-aec0-3cc27ea08d96</RequestId>
+  </ResponseMetadata>
+</ListEndpointsByPlatformApplicationResponse>"""
+
+GET_PLATFORM_APPLICATION_ATTRIBUTES_TEMPLATE = """<GetPlatformApplicationAttributesResponse xmlns="http://sns.amazonaws.com/doc/2010-03-31/">
+  <GetPlatformApplicationAttributesResult>
+    <Attributes>
+    {% for attribute in application.attributes %}
+      <entry>
+        <key>{{ attribute }}</key>
+        <value>{{ application.attributes[attribute] }}</value>
+      </entry>
+    {% endfor %}
+    </Attributes>
+  </GetPlatformApplicationAttributesResult>
+  <ResponseMetadata>
+    <RequestId>74848df2-87f6-55ed-890c-c7be80442462</RequestId>
+  </ResponseMetadata>
+</GetPlatformApplicationAttributesResponse>"""
+
+PUBLISH_TEMPLATE = """<PublishResponse xmlns="http://sns.amazonaws.com/doc/2010-03-31/">
+  <PublishResult>
+    <MessageId>{{ message_id }}</MessageId>
+  </PublishResult>
+  <ResponseMetadata>
+    <RequestId>f187a3c1-376f-11df-8963-01868b7c937a</RequestId>
+  </ResponseMetadata>
+</PublishResponse>"""
+
+SET_ENDPOINT_ATTRIBUTES_TEMPLATE = """<SetEndpointAttributesResponse xmlns="http://sns.amazonaws.com/doc/2010-03-31/">
+  <ResponseMetadata>
+    <RequestId>2fe0bfc7-3e85-5ee5-a9e2-f58b35e85f6a</RequestId>
+  </ResponseMetadata>
+</SetEndpointAttributesResponse>"""
+
+SET_PLATFORM_APPLICATION_ATTRIBUTES_TEMPLATE = """<SetPlatformApplicationAttributesResponse xmlns="http://sns.amazonaws.com/doc/2010-03-31/">
+  <ResponseMetadata>
+    <RequestId>cf577bcc-b3dc-5463-88f1-3180b9412395</RequestId>
+  </ResponseMetadata>
+</SetPlatformApplicationAttributesResponse>"""
+
+SUBSCRIBE_TEMPLATE = """<SubscribeResponse xmlns="http://sns.amazonaws.com/doc/2010-03-31/">
+  <SubscribeResult>
+    <SubscriptionArn>{{ subscription.arn }}</SubscriptionArn>
+  </SubscribeResult>
+  <ResponseMetadata>
+    <RequestId>c4407779-24a4-56fa-982c-3d927f93a775</RequestId>
+  </ResponseMetadata>
+</SubscribeResponse>"""
+
+UNSUBSCRIBE_TEMPLATE = """<UnsubscribeResponse xmlns="http://sns.amazonaws.com/doc/2010-03-31/">
+  <ResponseMetadata>
+    <RequestId>18e0ac39-3776-11df-84c0-b93cc1666b84</RequestId>
+  </ResponseMetadata>
+</UnsubscribeResponse>"""
+
+LIST_SUBSCRIPTIONS_TEMPLATE = """<ListSubscriptionsResponse xmlns="http://sns.amazonaws.com/doc/2010-03-31/">
+  <ListSubscriptionsResult>
+    <Subscriptions>
+    {% for subscription in subscriptions %}
+      <member>
+        <TopicArn>{{ subscription.topic.arn }}</TopicArn>
+        <Protocol>{{ subscription.protocol }}</Protocol>
+        <SubscriptionArn>{{ subscription.arn }}</SubscriptionArn>
+        <Owner>{{ subscription.account_id }}</Owner>
+        <Endpoint>{{ subscription.endpoint }}</Endpoint>
+      </member>
+    {% endfor %}
+    </Subscriptions>
+    {% if next_token  %}
+    <NextToken>{{ next_token }}</NextToken>
+    {% endif %}
+  </ListSubscriptionsResult>
+  <ResponseMetadata>
+    <RequestId>384ac68d-3775-11df-8963-01868b7c937a</RequestId>
+  </ResponseMetadata>
+</ListSubscriptionsResponse>"""
+
+LIST_SUBSCRIPTIONS_BY_TOPIC_TEMPLATE = """<ListSubscriptionsByTopicResponse xmlns="http://sns.amazonaws.com/doc/2010-03-31/">
+  <ListSubscriptionsByTopicResult>
+    <Subscriptions>
+    {% for subscription in subscriptions %}
+      <member>
+        <TopicArn>{{ subscription.topic.arn }}</TopicArn>
+        <Protocol>{{ subscription.protocol }}</Protocol>
+        <SubscriptionArn>{{ subscription.arn }}</SubscriptionArn>
+        <Owner>{{ subscription.account_id }}</Owner>
+        <Endpoint>{{ subscription.endpoint }}</Endpoint>
+      </member>
+    {% endfor %}
+    </Subscriptions>
+    {% if next_token  %}
+    <NextToken>{{ next_token }}</NextToken>
+    {% endif %}
+  </ListSubscriptionsByTopicResult>
+  <ResponseMetadata>
+    <RequestId>384ac68d-3775-11df-8963-01868b7c937a</RequestId>
+  </ResponseMetadata>
+</ListSubscriptionsByTopicResponse>"""

tests/test_sns/test_application_boto3.py

@@ -0,0 +1,254 @@
+from __future__ import unicode_literals
+
+import boto3
+from botocore.exceptions import ClientError
+from moto import mock_sns
+import sure  # noqa
+
+
+@mock_sns
+def test_create_platform_application():
+    conn = boto3.client('sns', region_name='us-east-1')
+    response = conn.create_platform_application(
+        Name="my-application",
+        Platform="APNS",
+        Attributes={
+            "PlatformCredential": "platform_credential",
+            "PlatformPrincipal": "platform_principal",
+        },
+    )
+    application_arn = response['PlatformApplicationArn']
+    application_arn.should.equal('arn:aws:sns:us-east-1:123456789012:app/APNS/my-application')
+
+
+@mock_sns
+def test_get_platform_application_attributes():
+    conn = boto3.client('sns', region_name='us-east-1')
+    platform_application = conn.create_platform_application(
+        Name="my-application",
+        Platform="APNS",
+        Attributes={
+            "PlatformCredential": "platform_credential",
+            "PlatformPrincipal": "platform_principal",
+        },
+    )
+    arn = platform_application['PlatformApplicationArn']
+    attributes = conn.get_platform_application_attributes(PlatformApplicationArn=arn)['Attributes']
+    attributes.should.equal({
+        "PlatformCredential": "platform_credential",
+        "PlatformPrincipal": "platform_principal",
+    })
+
+
+@mock_sns
+def test_get_missing_platform_application_attributes():
+    conn = boto3.client('sns', region_name='us-east-1')
+    conn.get_platform_application_attributes.when.called_with(PlatformApplicationArn="a-fake-arn").should.throw(ClientError)
+
+
+@mock_sns
+def test_set_platform_application_attributes():
+    conn = boto3.client('sns', region_name='us-east-1')
+    platform_application = conn.create_platform_application(
+        Name="my-application",
+        Platform="APNS",
+        Attributes={
+            "PlatformCredential": "platform_credential",
+            "PlatformPrincipal": "platform_principal",
+        },
+    )
+    arn = platform_application['PlatformApplicationArn']
+    conn.set_platform_application_attributes(PlatformApplicationArn=arn,
+        Attributes={"PlatformPrincipal": "other"}
+    )
+    attributes = conn.get_platform_application_attributes(PlatformApplicationArn=arn)['Attributes']
+    attributes.should.equal({
+        "PlatformCredential": "platform_credential",
+        "PlatformPrincipal": "other",
+    })
+
+
+@mock_sns
+def test_list_platform_applications():
+    conn = boto3.client('sns', region_name='us-east-1')
+    conn.create_platform_application(
+        Name="application1",
+        Platform="APNS",
+        Attributes={},
+    )
+    conn.create_platform_application(
+        Name="application2",
+        Platform="APNS",
+        Attributes={},
+    )
+
+    applications_repsonse = conn.list_platform_applications()
+    applications = applications_repsonse['PlatformApplications']
+    applications.should.have.length_of(2)
+
+
+@mock_sns
+def test_delete_platform_application():
+    conn = boto3.client('sns', region_name='us-east-1')
+    conn.create_platform_application(
+        Name="application1",
+        Platform="APNS",
+        Attributes={},
+    )
+    conn.create_platform_application(
+        Name="application2",
+        Platform="APNS",
+        Attributes={},
+    )
+
+    applications_repsonse = conn.list_platform_applications()
+    applications = applications_repsonse['PlatformApplications']
+    applications.should.have.length_of(2)
+
+    application_arn = applications[0]['PlatformApplicationArn']
+    conn.delete_platform_application(PlatformApplicationArn=application_arn)
+
+    applications_repsonse = conn.list_platform_applications()
+    applications = applications_repsonse['PlatformApplications']
+    applications.should.have.length_of(1)
+
+
+@mock_sns
+def test_create_platform_endpoint():
+    conn = boto3.client('sns', region_name='us-east-1')
+    platform_application = conn.create_platform_application(
+        Name="my-application",
+        Platform="APNS",
+        Attributes={},
+    )
+    application_arn = platform_application['PlatformApplicationArn']
+
+    endpoint = conn.create_platform_endpoint(
+        PlatformApplicationArn=application_arn,
+        Token="some_unique_id",
+        CustomUserData="some user data",
+        Attributes={
+            "Enabled": 'false',
+        },
+    )
+
+    endpoint_arn = endpoint['EndpointArn']
+    endpoint_arn.should.contain("arn:aws:sns:us-east-1:123456789012:endpoint/APNS/my-application/")
+
+
+@mock_sns
+def test_get_list_endpoints_by_platform_application():
+    conn = boto3.client('sns', region_name='us-east-1')
+    platform_application = conn.create_platform_application(
+        Name="my-application",
+        Platform="APNS",
+        Attributes={},
+    )
+    application_arn = platform_application['PlatformApplicationArn']
+
+    endpoint = conn.create_platform_endpoint(
+        PlatformApplicationArn=application_arn,
+        Token="some_unique_id",
+        CustomUserData="some user data",
+        Attributes={
+            "CustomUserData": "some data",
+        },
+    )
+    endpoint_arn = endpoint['EndpointArn']
+
+    endpoint_list = conn.list_endpoints_by_platform_application(
+        PlatformApplicationArn=application_arn
+    )['Endpoints']
+
+    endpoint_list.should.have.length_of(1)
+    endpoint_list[0]['Attributes']['CustomUserData'].should.equal('some data')
+    endpoint_list[0]['EndpointArn'].should.equal(endpoint_arn)
+
+
+@mock_sns
+def test_get_endpoint_attributes():
+    conn = boto3.client('sns', region_name='us-east-1')
+    platform_application = conn.create_platform_application(
+        Name="my-application",
+        Platform="APNS",
+        Attributes={},
+    )
+    application_arn = platform_application['PlatformApplicationArn']
+
+    endpoint = conn.create_platform_endpoint(
+        PlatformApplicationArn=application_arn,
+        Token="some_unique_id",
+        CustomUserData="some user data",
+        Attributes={
+            "Enabled": 'false',
+            "CustomUserData": "some data",
+        },
+    )
+    endpoint_arn = endpoint['EndpointArn']
+
+    attributes = conn.get_endpoint_attributes(EndpointArn=endpoint_arn)['Attributes']
+    attributes.should.equal({
+        "Enabled": 'false',
+        "CustomUserData": "some data",
+    })
+
+
+@mock_sns
+def test_get_missing_endpoint_attributes():
+    conn = boto3.client('sns', region_name='us-east-1')
+    conn.get_endpoint_attributes.when.called_with(EndpointArn="a-fake-arn").should.throw(ClientError)
+
+
+@mock_sns
+def test_set_endpoint_attributes():
+    conn = boto3.client('sns', region_name='us-east-1')
+    platform_application = conn.create_platform_application(
+        Name="my-application",
+        Platform="APNS",
+        Attributes={},
+    )
+    application_arn = platform_application['PlatformApplicationArn']
+
+    endpoint = conn.create_platform_endpoint(
+        PlatformApplicationArn=application_arn,
+        Token="some_unique_id",
+        CustomUserData="some user data",
+        Attributes={
+            "Enabled": 'false',
+            "CustomUserData": "some data",
+        },
+    )
+    endpoint_arn = endpoint['EndpointArn']
+
+    conn.set_endpoint_attributes(EndpointArn=endpoint_arn,
+        Attributes={"CustomUserData": "other data"}
+    )
+    attributes = conn.get_endpoint_attributes(EndpointArn=endpoint_arn)['Attributes']
+    attributes.should.equal({
+        "Enabled": 'false',
+        "CustomUserData": "other data",
+    })
+
+
+@mock_sns
+def test_publish_to_platform_endpoint():
+    conn = boto3.client('sns', region_name='us-east-1')
+    platform_application = conn.create_platform_application(
+        Name="my-application",
+        Platform="APNS",
+        Attributes={},
+    )
+    application_arn = platform_application['PlatformApplicationArn']
+
+    endpoint = conn.create_platform_endpoint(
+        PlatformApplicationArn=application_arn,
+        Token="some_unique_id",
+        CustomUserData="some user data",
+        Attributes={
+            "Enabled": 'false',
+        },
+    )
+
+    endpoint_arn = endpoint['EndpointArn']
+
+    conn.publish(Message="some message", MessageStructure="json", TargetArn=endpoint_arn)

tests/test_sns/test_publishing_boto3.py

@@ -0,0 +1,89 @@
+from __future__ import unicode_literals
+from six.moves.urllib.parse import parse_qs
+
+import boto3
+from freezegun import freeze_time
+import httpretty
+import sure  # noqa
+
+from moto import mock_sns, mock_sqs
+
+
+@mock_sqs
+@mock_sns
+def test_publish_to_sqs():
+    conn = boto3.client('sns', region_name='us-east-1')
+    conn.create_topic(Name="some-topic")
+    response = conn.list_topics()
+    topic_arn = response["Topics"][0]['TopicArn']
+
+    sqs_conn = boto3.resource('sqs', region_name='us-east-1')
+    sqs_conn.create_queue(QueueName="test-queue")
+
+    conn.subscribe(TopicArn=topic_arn,
+                   Protocol="sqs",
+                   Endpoint="arn:aws:sqs:us-east-1:123456789012:test-queue")
+
+    conn.publish(TopicArn=topic_arn, Message="my message")
+
+    queue = sqs_conn.get_queue_by_name(QueueName="test-queue")
+    messages = queue.receive_messages(MaxNumberOfMessages=1)
+    messages[0].body.should.equal('my message')
+
+
+@mock_sqs
+@mock_sns
+def test_publish_to_sqs_in_different_region():
+    conn = boto3.client('sns', region_name='us-west-1')
+    conn.create_topic(Name="some-topic")
+    response = conn.list_topics()
+    topic_arn = response["Topics"][0]['TopicArn']
+
+    sqs_conn = boto3.resource('sqs', region_name='us-west-2')
+    sqs_conn.create_queue(QueueName="test-queue")
+
+    conn.subscribe(TopicArn=topic_arn,
+                   Protocol="sqs",
+                   Endpoint="arn:aws:sqs:us-west-2:123456789012:test-queue")
+
+    conn.publish(TopicArn=topic_arn, Message="my message")
+
+    queue = sqs_conn.get_queue_by_name(QueueName="test-queue")
+    messages = queue.receive_messages(MaxNumberOfMessages=1)
+    messages[0].body.should.equal('my message')
+
+
+@freeze_time("2013-01-01")
+@mock_sns
+def test_publish_to_http():
+    httpretty.HTTPretty.register_uri(
+        method="POST",
+        uri="http://example.com/foobar",
+    )
+
+    conn = boto3.client('sns', region_name='us-east-1')
+    conn.create_topic(Name="some-topic")
+    response = conn.list_topics()
+    topic_arn = response["Topics"][0]['TopicArn']
+
+    conn.subscribe(TopicArn=topic_arn,
+                   Protocol="http",
+                   Endpoint="http://example.com/foobar")
+
+    response = conn.publish(TopicArn=topic_arn, Message="my message", Subject="my subject")
+    message_id = response['MessageId']
+
+    last_request = httpretty.last_request()
+    last_request.method.should.equal("POST")
+    parse_qs(last_request.body.decode('utf-8')).should.equal({
+        "Type": ["Notification"],
+        "MessageId": [message_id],
+        "TopicArn": ["arn:aws:sns:{0}:123456789012:some-topic".format(conn._client_config.region_name)],
+        "Subject": ["my subject"],
+        "Message": ["my message"],
+        "Timestamp": ["2013-01-01T00:00:00.000Z"],
+        "SignatureVersion": ["1"],
+        "Signature": ["EXAMPLElDMXvB8r9R83tGoNn0ecwd5UjllzsvSvbItzfaMpN2nk5HVSw7XnOn/49IkxDKz8YrlH2qJXj2iZB0Zo2O71c4qQk1fMUDi3LGpij7RCW7AW9vYYsSqIKRnFS94ilu7NFhUzLiieYr4BKHpdTmdD6c0esKEYBpabxDSc="],
+        "SigningCertURL": ["https://sns.us-east-1.amazonaws.com/SimpleNotificationService-f3ecfb7224c7233fe7bb5f59f96de52f.pem"],
+        "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"],
+    })

tests/test_sns/test_server.py

@@ -1,8 +1,5 @@
 from __future__ import unicode_literals
 
-import json
-
-import re
 import sure  # noqa
 
 import moto.server as server
@@ -16,9 +13,10 @@ def test_sns_server_get():
     backend = server.create_backend_app("sns")
     test_client = backend.test_client()
 
-    topic_data = test_client.action_json("CreateTopic", Name="test topic")
+    topic_data = test_client.action_data("CreateTopic", Name="test topic")
-    topic_arn = topic_data["CreateTopicResponse"]["CreateTopicResult"]["TopicArn"]
+    topic_data.should.contain("CreateTopicResult")
-    topics_data = test_client.action_json("ListTopics")
+    topic_data.should.contain("<TopicArn>arn:aws:sns:us-east-1:123456789012:test topic</TopicArn>")
-    topics_arns = [t["TopicArn"] for t in topics_data["ListTopicsResponse"]["ListTopicsResult"]["Topics"]]
 
-    assert topic_arn in topics_arns
+    topics_data = test_client.action_data("ListTopics")
+    topics_data.should.contain("ListTopicsResult")
+    topic_data.should.contain("<TopicArn>arn:aws:sns:us-east-1:123456789012:test topic</TopicArn>")

tests/test_sns/test_subscriptions_boto3.py

@@ -0,0 +1,90 @@
+from __future__ import unicode_literals
+import boto3
+
+import sure  # noqa
+
+from moto import mock_sns
+from moto.sns.models import DEFAULT_PAGE_SIZE
+
+
+@mock_sns
+def test_creating_subscription():
+    conn = boto3.client('sns', region_name='us-east-1')
+    conn.create_topic(Name="some-topic")
+    response = conn.list_topics()
+    topic_arn = response["Topics"][0]['TopicArn']
+
+    conn.subscribe(TopicArn=topic_arn,
+                   Protocol="http",
+                   Endpoint="http://example.com/")
+
+    subscriptions = conn.list_subscriptions()["Subscriptions"]
+    subscriptions.should.have.length_of(1)
+    subscription = subscriptions[0]
+    subscription["TopicArn"].should.equal(topic_arn)
+    subscription["Protocol"].should.equal("http")
+    subscription["SubscriptionArn"].should.contain(topic_arn)
+    subscription["Endpoint"].should.equal("http://example.com/")
+
+    # Now unsubscribe the subscription
+    conn.unsubscribe(SubscriptionArn=subscription["SubscriptionArn"])
+
+    # And there should be zero subscriptions left
+    subscriptions = conn.list_subscriptions()["Subscriptions"]
+    subscriptions.should.have.length_of(0)
+
+
+@mock_sns
+def test_getting_subscriptions_by_topic():
+    conn = boto3.client('sns', region_name='us-east-1')
+    conn.create_topic(Name="topic1")
+    conn.create_topic(Name="topic2")
+
+    response = conn.list_topics()
+    topics = response["Topics"]
+    topic1_arn = topics[0]['TopicArn']
+    topic2_arn = topics[1]['TopicArn']
+
+    conn.subscribe(TopicArn=topic1_arn,
+                   Protocol="http",
+                   Endpoint="http://example1.com/")
+    conn.subscribe(TopicArn=topic2_arn,
+                   Protocol="http",
+                   Endpoint="http://example2.com/")
+
+    topic1_subscriptions = conn.list_subscriptions_by_topic(TopicArn=topic1_arn)["Subscriptions"]
+    topic1_subscriptions.should.have.length_of(1)
+    topic1_subscriptions[0]['Endpoint'].should.equal("http://example1.com/")
+
+
+@mock_sns
+def test_subscription_paging():
+    conn = boto3.client('sns', region_name='us-east-1')
+    conn.create_topic(Name="topic1")
+
+    response = conn.list_topics()
+    topics = response["Topics"]
+    topic1_arn = topics[0]['TopicArn']
+
+    for index in range(DEFAULT_PAGE_SIZE + int(DEFAULT_PAGE_SIZE / 3)):
+        conn.subscribe(TopicArn=topic1_arn,
+                       Protocol='email',
+                       Endpoint='email_' + str(index) + '@test.com')
+
+    all_subscriptions = conn.list_subscriptions()
+    all_subscriptions["Subscriptions"].should.have.length_of(DEFAULT_PAGE_SIZE)
+    next_token = all_subscriptions["NextToken"]
+    next_token.should.equal(str(DEFAULT_PAGE_SIZE))
+
+    all_subscriptions = conn.list_subscriptions(NextToken=next_token)
+    all_subscriptions["Subscriptions"].should.have.length_of(int(DEFAULT_PAGE_SIZE / 3))
+    all_subscriptions.shouldnt.have("NextToken")
+
+    topic1_subscriptions = conn.list_subscriptions_by_topic(TopicArn=topic1_arn)
+    topic1_subscriptions["Subscriptions"].should.have.length_of(DEFAULT_PAGE_SIZE)
+    next_token = topic1_subscriptions["NextToken"]
+    next_token.should.equal(str(DEFAULT_PAGE_SIZE))
+
+    topic1_subscriptions = conn.list_subscriptions_by_topic(TopicArn=topic1_arn, NextToken=next_token)
+    topic1_subscriptions["Subscriptions"].should.have.length_of(int(DEFAULT_PAGE_SIZE / 3))
+    topic1_subscriptions.shouldnt.have("NextToken")

tests/test_sns/test_topics_boto3.py

@@ -0,0 +1,125 @@
+from __future__ import unicode_literals
+import boto3
+import six
+import json
+
+import sure  # noqa
+
+from botocore.exceptions import ClientError
+from moto import mock_sns
+from moto.sns.models import DEFAULT_TOPIC_POLICY, DEFAULT_EFFECTIVE_DELIVERY_POLICY, DEFAULT_PAGE_SIZE
+
+
+@mock_sns
+def test_create_and_delete_topic():
+    conn = boto3.client("sns", region_name="us-east-1")
+    conn.create_topic(Name="some-topic")
+
+    topics_json = conn.list_topics()
+    topics = topics_json["Topics"]
+    topics.should.have.length_of(1)
+    topics[0]['TopicArn'].should.equal(
+        "arn:aws:sns:{0}:123456789012:some-topic"
+        .format(conn._client_config.region_name)
+    )
+
+    # Delete the topic
+    conn.delete_topic(TopicArn=topics[0]['TopicArn'])
+
+    # And there should now be 0 topics
+    topics_json = conn.list_topics()
+    topics = topics_json["Topics"]
+    topics.should.have.length_of(0)
+
+
+@mock_sns
+def test_get_missing_topic():
+    conn = boto3.client("sns", region_name="us-east-1")
+    conn.get_topic_attributes.when.called_with(TopicArn="a-fake-arn").should.throw(ClientError)
+
+
+@mock_sns
+def test_create_topic_in_multiple_regions():
+    for region in ['us-west-1', 'us-west-2']:
+        conn = boto3.client("sns", region_name=region)
+        conn.create_topic(Name="some-topic")
+        list(conn.list_topics()["Topics"]).should.have.length_of(1)
+
+
+@mock_sns
+def test_topic_corresponds_to_region():
+    for region in ['us-east-1', 'us-west-2']:
+        conn = boto3.client("sns", region_name=region)
+        conn.create_topic(Name="some-topic")
+        topics_json = conn.list_topics()
+        topic_arn = topics_json["Topics"][0]['TopicArn']
+        topic_arn.should.equal("arn:aws:sns:{0}:123456789012:some-topic".format(region))
+
+
+@mock_sns
+def test_topic_attributes():
+    conn = boto3.client("sns", region_name="us-east-1")
+    conn.create_topic(Name="some-topic")
+
+    topics_json = conn.list_topics()
+    topic_arn = topics_json["Topics"][0]['TopicArn']
+
+    attributes = conn.get_topic_attributes(TopicArn=topic_arn)['Attributes']
+    attributes["TopicArn"].should.equal(
+        "arn:aws:sns:{0}:123456789012:some-topic"
+        .format(conn._client_config.region_name)
+    )
+    attributes["Owner"].should.equal('123456789012')
+    attributes["Policy"].should.equal(DEFAULT_TOPIC_POLICY)
+    attributes["DisplayName"].should.equal("")
+    attributes["SubscriptionsPending"].should.equal('0')
+    attributes["SubscriptionsConfirmed"].should.equal('0')
+    attributes["SubscriptionsDeleted"].should.equal('0')
+    attributes["DeliveryPolicy"].should.equal("")
+    attributes["EffectiveDeliveryPolicy"].should.equal(DEFAULT_EFFECTIVE_DELIVERY_POLICY)
+
+    # boto can't handle prefix-mandatory strings:
+    # i.e. unicode on Python 2 -- u"foobar"
+    # and bytes on Python 3 -- b"foobar"
+    if six.PY2:
+        policy = json.dumps({b"foo": b"bar"})
+        displayname = b"My display name"
+        delivery = json.dumps({b"http": {b"defaultHealthyRetryPolicy": {b"numRetries": 5}}})
+    else:
+        policy = json.dumps({u"foo": u"bar"})
+        displayname = u"My display name"
+        delivery = json.dumps({u"http": {u"defaultHealthyRetryPolicy": {u"numRetries": 5}}})
+    conn.set_topic_attributes(TopicArn=topic_arn,
+                              AttributeName="Policy",
+                              AttributeValue=policy)
+    conn.set_topic_attributes(TopicArn=topic_arn,
+                              AttributeName="DisplayName",
+                              AttributeValue=displayname)
+    conn.set_topic_attributes(TopicArn=topic_arn,
+                              AttributeName="DeliveryPolicy",
+                              AttributeValue=delivery)
+
+    attributes = conn.get_topic_attributes(TopicArn=topic_arn)['Attributes']
+    attributes["Policy"].should.equal('{"foo": "bar"}')
+    attributes["DisplayName"].should.equal("My display name")
+    attributes["DeliveryPolicy"].should.equal('{"http": {"defaultHealthyRetryPolicy": {"numRetries": 5}}}')
+
+
+@mock_sns
+def test_topic_paging():
+    conn = boto3.client("sns", region_name="us-east-1")
+    for index in range(DEFAULT_PAGE_SIZE + int(DEFAULT_PAGE_SIZE / 2)):
+        conn.create_topic(Name="some-topic_" + str(index))
+
+    response = conn.list_topics()
+    topics_list = response["Topics"]
+    next_token = response["NextToken"]
+
+    len(topics_list).should.equal(DEFAULT_PAGE_SIZE)
+    int(next_token).should.equal(DEFAULT_PAGE_SIZE)
+
+    response = conn.list_topics(NextToken=next_token)
+    topics_list = response["Topics"]
+    response.shouldnt.have("NextToken")
+
+    topics_list.should.have.length_of(int(DEFAULT_PAGE_SIZE / 2))