gcloud 0.0.7 → 0.1.0

data/packages/gsutil/boto/tests/unit/__init__.py

@@ -1,79 +0,0 @@
-try:
-    import unittest2 as unittest
-except ImportError:
-    import unittest
-import httplib
-
-from mock import Mock
-
-
-class AWSMockServiceTestCase(unittest.TestCase):
-    """Base class for mocking aws services."""
-    # This param is used by the unittest module to display a full
-    # diff when assert*Equal methods produce an error message.
-    maxDiff = None
-    connection_class = None
-
-    def setUp(self):
-        self.https_connection = Mock(spec=httplib.HTTPSConnection)
-        self.https_connection_factory = (
-            Mock(return_value=self.https_connection), ())
-        self.service_connection = self.create_service_connection(
-            https_connection_factory=self.https_connection_factory,
-            aws_access_key_id='aws_access_key_id',
-            aws_secret_access_key='aws_secret_access_key')
-        self.initialize_service_connection()
-
-    def initialize_service_connection(self):
-        self.actual_request = None
-        self.original_mexe = self.service_connection._mexe
-        self.service_connection._mexe = self._mexe_spy
-
-    def create_service_connection(self, **kwargs):
-        if self.connection_class is None:
-            raise ValueError("The connection_class class attribute must be "
-                             "set to a non-None value.")
-        return self.connection_class(**kwargs)
-
-    def _mexe_spy(self, request, *args, **kwargs):
-        self.actual_request = request
-        return self.original_mexe(request, *args, **kwargs)
-
-    def create_response(self, status_code, reason='', header=[], body=None):
-        if body is None:
-            body = self.default_body()
-        response = Mock(spec=httplib.HTTPResponse)
-        response.status = status_code
-        response.read.return_value = body
-        response.reason = reason
-
-        response.getheaders.return_value = header
-        response.msg = dict(header)
-        def overwrite_header(arg, default=None):
-            header_dict = dict(header)
-            if header_dict.has_key(arg):
-                return header_dict[arg]
-            else:
-                return default
-        response.getheader.side_effect = overwrite_header
-
-        return response
-
-    def assert_request_parameters(self, params, ignore_params_values=None):
-        """Verify the actual parameters sent to the service API."""
-        request_params = self.actual_request.params.copy()
-        if ignore_params_values is not None:
-            for param in ignore_params_values:
-                # We still want to check that the ignore_params_values params
-                # are in the request parameters, we just don't need to check
-                # their value.
-                self.assertIn(param, request_params)
-                del request_params[param]
-        self.assertDictEqual(request_params, params)
-
-    def set_http_response(self, status_code, reason='', header=[], body=None):
-        http_response = self.create_response(status_code, reason, header, body)
-        self.https_connection.getresponse.return_value = http_response
-
-    def default_body(self):
-        return ''

data/packages/gsutil/boto/tests/unit/auth/test_sigv4.py

@@ -1,73 +0,0 @@
-# Copyright (c) 2012 Amazon.com, Inc. or its affiliates.  All Rights Reserved
-#
-# Permission is hereby granted, free of charge, to any person obtaining a
-# copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish, dis-
-# tribute, sublicense, and/or sell copies of the Software, and to permit
-# persons to whom the Software is furnished to do so, subject to the fol-
-# lowing conditions:
-#
-# The above copyright notice and this permission notice shall be included
-# in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
-# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-# IN THE SOFTWARE.
-#
-from mock import Mock
-from tests.unit import unittest
-
-from boto.auth import HmacAuthV4Handler
-from boto.connection import HTTPRequest
-
-
-class TestSigV4Handler(unittest.TestCase):
-    def setUp(self):
-        self.provider = Mock()
-        self.provider.access_key = 'access_key'
-        self.provider.secret_key = 'secret_key'
-        self.request = HTTPRequest(
-            'POST', 'https', 'glacier.us-east-1.amazonaws.com', 443,
-            '/-/vaults/foo/archives', None, {},
-            {'x-amz-glacier-version': '2012-06-01'}, '')
-
-    def test_inner_whitespace_is_collapsed(self):
-        auth = HmacAuthV4Handler('glacier.us-east-1.amazonaws.com',
-                                 Mock(), self.provider)
-        self.request.headers['x-amz-archive-description'] = 'two  spaces'
-        headers = auth.headers_to_sign(self.request)
-        self.assertEqual(headers, {'Host': 'glacier.us-east-1.amazonaws.com',
-                                   'x-amz-archive-description': 'two  spaces',
-                                   'x-amz-glacier-version': '2012-06-01'})
-        # Note the single space between the "two spaces".
-        self.assertEqual(auth.canonical_headers(headers),
-                         'host:glacier.us-east-1.amazonaws.com\n'
-                         'x-amz-archive-description:two spaces\n'
-                         'x-amz-glacier-version:2012-06-01')
-
-    def test_canonical_query_string(self):
-        auth = HmacAuthV4Handler('glacier.us-east-1.amazonaws.com',
-                                 Mock(), self.provider)
-        request = HTTPRequest(
-            'GET', 'https', 'glacier.us-east-1.amazonaws.com', 443,
-            '/-/vaults/foo/archives', None, {},
-            {'x-amz-glacier-version': '2012-06-01'}, '')
-        request.params['Foo.1'] = 'aaa'
-        request.params['Foo.10'] = 'zzz'
-        query_string = auth.canonical_query_string(request)
-        self.assertEqual(query_string, 'Foo.1=aaa&Foo.10=zzz')
-
-    def test_region_and_service_can_be_overriden(self):
-        auth = HmacAuthV4Handler('queue.amazonaws.com',
-                                 Mock(), self.provider)
-        self.request.headers['X-Amz-Date'] = '20121121000000'
-
-        auth.region_name = 'us-west-2'
-        auth.service_name = 'sqs'
-        scope = auth.credential_scope(self.request)
-        self.assertEqual(scope, '20121121/us-west-2/sqs/aws4_request')

data/packages/gsutil/boto/tests/unit/beanstalk/test_layer1.py

@@ -1,128 +0,0 @@
-#!/usr/bin/env python
-
-import json
-
-from tests.unit import AWSMockServiceTestCase
-
-from boto.beanstalk.layer1 import Layer1
-
-# These tests are just checking the basic structure of
-# the Elastic Beanstalk code, by picking a few calls
-# and verifying we get the expected results with mocked
-# responses.  The integration tests actually verify the
-# API calls interact with the service correctly.
-class TestListAvailableSolutionStacks(AWSMockServiceTestCase):
-    connection_class = Layer1
-
-    def default_body(self):
-        return json.dumps(
-            {u'ListAvailableSolutionStacksResponse':
-               {u'ListAvailableSolutionStacksResult':
-                  {u'SolutionStackDetails': [
-                      {u'PermittedFileTypes': [u'war', u'zip'],
-                       u'SolutionStackName': u'32bit Amazon Linux running Tomcat 7'},
-                      {u'PermittedFileTypes': [u'zip'],
-                       u'SolutionStackName': u'32bit Amazon Linux running PHP 5.3'}],
-                      u'SolutionStacks': [u'32bit Amazon Linux running Tomcat 7',
-                                          u'32bit Amazon Linux running PHP 5.3']},
-                u'ResponseMetadata': {u'RequestId': u'request_id'}}})
-
-    def test_list_available_solution_stacks(self):
-        self.set_http_response(status_code=200)
-        api_response = self.service_connection.list_available_solution_stacks()
-        stack_details = api_response['ListAvailableSolutionStacksResponse']\
-                                    ['ListAvailableSolutionStacksResult']\
-                                    ['SolutionStackDetails']
-        solution_stacks = api_response['ListAvailableSolutionStacksResponse']\
-                                      ['ListAvailableSolutionStacksResult']\
-                                      ['SolutionStacks']
-        self.assertEqual(solution_stacks,
-                        [u'32bit Amazon Linux running Tomcat 7',
-                         u'32bit Amazon Linux running PHP 5.3'])
-        # These are the parameters that are actually sent to the CloudFormation
-        # service.
-        self.assert_request_parameters({
-            'Action': 'ListAvailableSolutionStacks',
-            'ContentType': 'JSON',
-            'SignatureMethod': 'HmacSHA256',
-            'SignatureVersion': 2,
-            'Version': '2010-12-01',
-            'AWSAccessKeyId': 'aws_access_key_id',
-        }, ignore_params_values=['Timestamp'])
-
-
-class TestCreateApplicationVersion(AWSMockServiceTestCase):
-    connection_class = Layer1
-
-    def default_body(self):
-        return json.dumps({
-            'CreateApplicationVersionResponse':
-              {u'CreateApplicationVersionResult':
-                 {u'ApplicationVersion':
-                    {u'ApplicationName': u'application1',
-                     u'DateCreated': 1343067094.342,
-                     u'DateUpdated': 1343067094.342,
-                     u'Description': None,
-                     u'SourceBundle': {u'S3Bucket': u'elasticbeanstalk-us-east-1',
-                     u'S3Key': u'resources/elasticbeanstalk-sampleapp.war'},
-                     u'VersionLabel': u'version1'}}}})
-
-    def test_create_application_version(self):
-        self.set_http_response(status_code=200)
-        api_response = self.service_connection.create_application_version(
-            'application1', 'version1', s3_bucket='mybucket', s3_key='mykey',
-            auto_create_application=True)
-        app_version = api_response['CreateApplicationVersionResponse']\
-                                  ['CreateApplicationVersionResult']\
-                                  ['ApplicationVersion']
-        self.assert_request_parameters({
-            'Action': 'CreateApplicationVersion',
-            'ContentType': 'JSON',
-            'SignatureMethod': 'HmacSHA256',
-            'SignatureVersion': 2,
-            'Version': '2010-12-01',
-            'ApplicationName': 'application1',
-            'AutoCreateApplication': 'true',
-            'SourceBundle.S3Bucket': 'mybucket',
-            'SourceBundle.S3Key': 'mykey',
-            'VersionLabel': 'version1',
-            'AWSAccessKeyId': 'aws_access_key_id',
-        }, ignore_params_values=['Timestamp'])
-        self.assertEqual(app_version['ApplicationName'], 'application1')
-        self.assertEqual(app_version['VersionLabel'], 'version1')
-
-
-class TestCreateEnvironment(AWSMockServiceTestCase):
-    connection_class = Layer1
-
-    def default_body(self):
-        return json.dumps({})
-
-    def test_create_environment(self):
-        self.set_http_response(status_code=200)
-        api_response = self.service_connection.create_environment(
-            'application1', 'environment1', 'version1',
-            '32bit Amazon Linux running Tomcat 7',
-            option_settings=[
-                ('aws:autoscaling:launchconfiguration', 'Ec2KeyName',
-                 'mykeypair'),
-                ('aws:elasticbeanstalk:application:environment', 'ENVVAR',
-                 'VALUE1')])
-        self.assert_request_parameters({
-            'Action': 'CreateEnvironment',
-            'ApplicationName': 'application1',
-            'EnvironmentName': 'environment1',
-            'TemplateName': '32bit Amazon Linux running Tomcat 7',
-            'ContentType': 'JSON',
-            'SignatureMethod': 'HmacSHA256',
-            'SignatureVersion': 2,
-            'Version': '2010-12-01',
-            'VersionLabel': 'version1',
-            'AWSAccessKeyId': 'aws_access_key_id',
-            'OptionSettings.member.1.Namespace': 'aws:autoscaling:launchconfiguration',
-            'OptionSettings.member.1.OptionName': 'Ec2KeyName',
-            'OptionSettings.member.1.Value': 'mykeypair',
-            'OptionSettings.member.2.Namespace': 'aws:elasticbeanstalk:application:environment',
-            'OptionSettings.member.2.OptionName': 'ENVVAR',
-            'OptionSettings.member.2.Value': 'VALUE1',
-        }, ignore_params_values=['Timestamp'])

data/packages/gsutil/boto/tests/unit/cloudformation/test_connection.py

@@ -1,605 +0,0 @@
-#!/usr/bin/env python
-import unittest
-import httplib
-from datetime import datetime
-try:
-    import json
-except ImportError:
-    import simplejson as json
-
-from mock import Mock
-
-from tests.unit import AWSMockServiceTestCase
-from boto.cloudformation.connection import CloudFormationConnection
-
-
-SAMPLE_TEMPLATE = r"""
-{
-  "AWSTemplateFormatVersion" : "2010-09-09",
-  "Description" : "Sample template",
-  "Parameters" : {
-    "KeyName" : {
-      "Description" : "key pair",
-      "Type" : "String"
-    }
-  },
-  "Resources" : {
-    "Ec2Instance" : {
-      "Type" : "AWS::EC2::Instance",
-      "Properties" : {
-        "KeyName" : { "Ref" : "KeyName" },
-        "ImageId" : "ami-7f418316",
-        "UserData" : { "Fn::Base64" : "80" }
-      }
-    }
-  },
-  "Outputs" : {
-    "InstanceId" : {
-      "Description" : "InstanceId of the newly created EC2 instance",
-      "Value" : { "Ref" : "Ec2Instance" }
-    }
-}
-"""
-
-class CloudFormationConnectionBase(AWSMockServiceTestCase):
-    connection_class = CloudFormationConnection
-
-    def setUp(self):
-        super(CloudFormationConnectionBase, self).setUp()
-        self.stack_id = u'arn:aws:cloudformation:us-east-1:18:stack/Name/id'
-
-
-class TestCloudFormationCreateStack(CloudFormationConnectionBase):
-    def default_body(self):
-        return json.dumps(
-            {u'CreateStackResponse':
-                 {u'CreateStackResult': {u'StackId': self.stack_id},
-                  u'ResponseMetadata': {u'RequestId': u'1'}}})
-
-    def test_create_stack_has_correct_request_params(self):
-        self.set_http_response(status_code=200)
-        api_response = self.service_connection.create_stack(
-            'stack_name', template_url='http://url',
-            template_body=SAMPLE_TEMPLATE,
-            parameters=[('KeyName', 'myKeyName')],
-            tags={'TagKey': 'TagValue'},
-            notification_arns=['arn:notify1', 'arn:notify2'],
-            disable_rollback=True,
-            timeout_in_minutes=20, capabilities=['CAPABILITY_IAM']
-        )
-        self.assertEqual(api_response, self.stack_id)
-        # These are the parameters that are actually sent to the CloudFormation
-        # service.
-        self.assert_request_parameters({
-            'Action': 'CreateStack',
-            'Capabilities.member.1': 'CAPABILITY_IAM',
-            'ContentType': 'JSON',
-            'DisableRollback': 'true',
-            'NotificationARNs.member.1': 'arn:notify1',
-            'NotificationARNs.member.2': 'arn:notify2',
-            'Parameters.member.1.ParameterKey': 'KeyName',
-            'Parameters.member.1.ParameterValue': 'myKeyName',
-            'Tags.member.1.Key': 'TagKey',
-            'Tags.member.1.Value': 'TagValue',
-            'StackName': 'stack_name',
-            'Version': '2010-05-15',
-            'TimeoutInMinutes': 20,
-            'TemplateBody': SAMPLE_TEMPLATE,
-            'TemplateURL': 'http://url',
-        })
-
-    # The test_create_stack_has_correct_request_params verified all of the
-    # params needed when making a create_stack service call.  The rest of the
-    # tests for create_stack only verify specific parts of the params sent
-    # to CloudFormation.
-
-    def test_create_stack_with_minimum_args(self):
-        # This will fail in practice, but the API docs only require stack_name.
-        self.set_http_response(status_code=200)
-        api_response = self.service_connection.create_stack('stack_name')
-        self.assertEqual(api_response, self.stack_id)
-        self.assert_request_parameters({
-            'Action': 'CreateStack',
-            'ContentType': 'JSON',
-            'DisableRollback': 'false',
-            'StackName': 'stack_name',
-            'Version': '2010-05-15',
-        })
-
-    def test_create_stack_fails(self):
-        self.set_http_response(status_code=400, reason='Bad Request',
-                               body='Invalid arg.')
-        with self.assertRaises(self.service_connection.ResponseError):
-            api_response = self.service_connection.create_stack(
-                'stack_name', template_body=SAMPLE_TEMPLATE,
-                parameters=[('KeyName', 'myKeyName')])
-
-
-class TestCloudFormationUpdateStack(CloudFormationConnectionBase):
-    def default_body(self):
-        return json.dumps(
-            {u'UpdateStackResponse':
-                 {u'UpdateStackResult': {u'StackId': self.stack_id},
-                  u'ResponseMetadata': {u'RequestId': u'1'}}})
-
-    def test_update_stack_all_args(self):
-        self.set_http_response(status_code=200)
-        api_response = self.service_connection.update_stack(
-            'stack_name', template_url='http://url',
-            template_body=SAMPLE_TEMPLATE,
-            parameters=[('KeyName', 'myKeyName')],
-            tags={'TagKey': 'TagValue'},
-            notification_arns=['arn:notify1', 'arn:notify2'],
-            disable_rollback=True,
-            timeout_in_minutes=20
-        )
-        self.assert_request_parameters({
-            'Action': 'UpdateStack',
-            'ContentType': 'JSON',
-            'DisableRollback': 'true',
-            'NotificationARNs.member.1': 'arn:notify1',
-            'NotificationARNs.member.2': 'arn:notify2',
-            'Parameters.member.1.ParameterKey': 'KeyName',
-            'Parameters.member.1.ParameterValue': 'myKeyName',
-            'Tags.member.1.Key': 'TagKey',
-            'Tags.member.1.Value': 'TagValue',
-            'StackName': 'stack_name',
-            'Version': '2010-05-15',
-            'TimeoutInMinutes': 20,
-            'TemplateBody': SAMPLE_TEMPLATE,
-            'TemplateURL': 'http://url',
-        })
-
-    def test_update_stack_with_minimum_args(self):
-        self.set_http_response(status_code=200)
-        api_response = self.service_connection.update_stack('stack_name')
-        self.assertEqual(api_response, self.stack_id)
-        self.assert_request_parameters({
-            'Action': 'UpdateStack',
-            'ContentType': 'JSON',
-            'DisableRollback': 'false',
-            'StackName': 'stack_name',
-            'Version': '2010-05-15',
-        })
-
-    def test_update_stack_fails(self):
-        self.set_http_response(status_code=400, reason='Bad Request',
-                               body='Invalid arg.')
-        with self.assertRaises(self.service_connection.ResponseError):
-            api_response = self.service_connection.update_stack(
-                'stack_name', template_body=SAMPLE_TEMPLATE,
-                parameters=[('KeyName', 'myKeyName')])
-
-
-class TestCloudFormationDeleteStack(CloudFormationConnectionBase):
-    def default_body(self):
-        return json.dumps(
-            {u'DeleteStackResponse':
-                 {u'ResponseMetadata': {u'RequestId': u'1'}}})
-
-    def test_delete_stack(self):
-        self.set_http_response(status_code=200)
-        api_response = self.service_connection.delete_stack('stack_name')
-        self.assertEqual(api_response, json.loads(self.default_body()))
-        self.assert_request_parameters({
-            'Action': 'DeleteStack',
-            'ContentType': 'JSON',
-            'StackName': 'stack_name',
-            'Version': '2010-05-15',
-        })
-
-    def test_delete_stack_fails(self):
-        self.set_http_response(status_code=400)
-        with self.assertRaises(self.service_connection.ResponseError):
-            api_response = self.service_connection.delete_stack('stack_name')
-
-
-class TestCloudFormationDescribeStackResource(CloudFormationConnectionBase):
-    def default_body(self):
-        return json.dumps('fake server response')
-
-    def test_describe_stack_resource(self):
-        self.set_http_response(status_code=200)
-        api_response = self.service_connection.describe_stack_resource(
-            'stack_name', 'resource_id')
-        self.assertEqual(api_response, 'fake server response')
-        self.assert_request_parameters({
-            'Action': 'DescribeStackResource',
-            'ContentType': 'JSON',
-            'LogicalResourceId': 'resource_id',
-            'StackName': 'stack_name',
-            'Version': '2010-05-15',
-        })
-
-    def test_describe_stack_resource_fails(self):
-        self.set_http_response(status_code=400)
-        with self.assertRaises(self.service_connection.ResponseError):
-            api_response = self.service_connection.describe_stack_resource(
-                'stack_name', 'resource_id')
-
-
-class TestCloudFormationGetTemplate(CloudFormationConnectionBase):
-    def default_body(self):
-        return json.dumps('fake server response')
-
-    def test_get_template(self):
-        self.set_http_response(status_code=200)
-        api_response = self.service_connection.get_template('stack_name')
-        self.assertEqual(api_response, 'fake server response')
-        self.assert_request_parameters({
-            'Action': 'GetTemplate',
-            'ContentType': 'JSON',
-            'StackName': 'stack_name',
-            'Version': '2010-05-15',
-        })
-
-
-    def test_get_template_fails(self):
-        self.set_http_response(status_code=400)
-        with self.assertRaises(self.service_connection.ResponseError):
-            api_response = self.service_connection.get_template('stack_name')
-
-
-class TestCloudFormationGetStackevents(CloudFormationConnectionBase):
-    def default_body(self):
-        return """
-            <DescribeStackEventsResult>
-              <StackEvents>
-                <member>
-                  <EventId>Event-1-Id</EventId>
-                  <StackId>arn:aws:cfn:us-east-1:1:stack</StackId>
-                  <StackName>MyStack</StackName>
-                  <LogicalResourceId>MyStack</LogicalResourceId>
-                  <PhysicalResourceId>MyStack_One</PhysicalResourceId>
-                  <ResourceType>AWS::CloudFormation::Stack</ResourceType>
-                  <Timestamp>2010-07-27T22:26:28Z</Timestamp>
-                  <ResourceStatus>CREATE_IN_PROGRESS</ResourceStatus>
-                  <ResourceStatusReason>User initiated</ResourceStatusReason>
-                </member>
-                <member>
-                  <EventId>Event-2-Id</EventId>
-                  <StackId>arn:aws:cfn:us-east-1:1:stack</StackId>
-                  <StackName>MyStack</StackName>
-                  <LogicalResourceId>MySG1</LogicalResourceId>
-                  <PhysicalResourceId>MyStack_SG1</PhysicalResourceId>
-                  <ResourceType>AWS::SecurityGroup</ResourceType>
-                  <Timestamp>2010-07-27T22:28:28Z</Timestamp>
-                  <ResourceStatus>CREATE_COMPLETE</ResourceStatus>
-                </member>
-              </StackEvents>
-            </DescribeStackEventsResult>
-        """
-
-    def test_describe_stack_events(self):
-        self.set_http_response(status_code=200)
-        first, second = self.service_connection.describe_stack_events('stack_name', next_token='next_token')
-        self.assertEqual(first.event_id, 'Event-1-Id')
-        self.assertEqual(first.logical_resource_id, 'MyStack')
-        self.assertEqual(first.physical_resource_id, 'MyStack_One')
-        self.assertEqual(first.resource_properties, None)
-        self.assertEqual(first.resource_status, 'CREATE_IN_PROGRESS')
-        self.assertEqual(first.resource_status_reason, 'User initiated')
-        self.assertEqual(first.resource_type, 'AWS::CloudFormation::Stack')
-        self.assertEqual(first.stack_id, 'arn:aws:cfn:us-east-1:1:stack')
-        self.assertEqual(first.stack_name, 'MyStack')
-        self.assertIsNotNone(first.timestamp)
-
-        self.assertEqual(second.event_id, 'Event-2-Id')
-        self.assertEqual(second.logical_resource_id, 'MySG1')
-        self.assertEqual(second.physical_resource_id, 'MyStack_SG1')
-        self.assertEqual(second.resource_properties, None)
-        self.assertEqual(second.resource_status, 'CREATE_COMPLETE')
-        self.assertEqual(second.resource_status_reason, None)
-        self.assertEqual(second.resource_type, 'AWS::SecurityGroup')
-        self.assertEqual(second.stack_id, 'arn:aws:cfn:us-east-1:1:stack')
-        self.assertEqual(second.stack_name, 'MyStack')
-        self.assertIsNotNone(second.timestamp)
-
-        self.assert_request_parameters({
-            'Action': 'DescribeStackEvents',
-            'NextToken': 'next_token',
-            'StackName': 'stack_name',
-            'Version': '2010-05-15',
-        })
-
-
-class TestCloudFormationDescribeStackResources(CloudFormationConnectionBase):
-    def default_body(self):
-        return """
-            <DescribeStackResourcesResult>
-              <StackResources>
-                <member>
-                  <StackId>arn:aws:cfn:us-east-1:1:stack</StackId>
-                  <StackName>MyStack</StackName>
-                  <LogicalResourceId>MyDBInstance</LogicalResourceId>
-                  <PhysicalResourceId>MyStack_DB1</PhysicalResourceId>
-                  <ResourceType>AWS::DBInstance</ResourceType>
-                  <Timestamp>2010-07-27T22:27:28Z</Timestamp>
-                  <ResourceStatus>CREATE_COMPLETE</ResourceStatus>
-                </member>
-                <member>
-                  <StackId>arn:aws:cfn:us-east-1:1:stack</StackId>
-                  <StackName>MyStack</StackName>
-                  <LogicalResourceId>MyAutoScalingGroup</LogicalResourceId>
-                  <PhysicalResourceId>MyStack_ASG1</PhysicalResourceId>
-                  <ResourceType>AWS::AutoScalingGroup</ResourceType>
-                  <Timestamp>2010-07-27T22:28:28Z</Timestamp>
-                  <ResourceStatus>CREATE_IN_PROGRESS</ResourceStatus>
-                </member>
-              </StackResources>
-            </DescribeStackResourcesResult>
-        """
-
-    def test_describe_stack_resources(self):
-        self.set_http_response(status_code=200)
-        first, second = self.service_connection.describe_stack_resources(
-            'stack_name', 'logical_resource_id', 'physical_resource_id')
-        self.assertEqual(first.description, None)
-        self.assertEqual(first.logical_resource_id, 'MyDBInstance')
-        self.assertEqual(first.physical_resource_id, 'MyStack_DB1')
-        self.assertEqual(first.resource_status, 'CREATE_COMPLETE')
-        self.assertEqual(first.resource_status_reason, None)
-        self.assertEqual(first.resource_type, 'AWS::DBInstance')
-        self.assertEqual(first.stack_id, 'arn:aws:cfn:us-east-1:1:stack')
-        self.assertEqual(first.stack_name, 'MyStack')
-        self.assertIsNotNone(first.timestamp)
-
-        self.assertEqual(second.description, None)
-        self.assertEqual(second.logical_resource_id, 'MyAutoScalingGroup')
-        self.assertEqual(second.physical_resource_id, 'MyStack_ASG1')
-        self.assertEqual(second.resource_status, 'CREATE_IN_PROGRESS')
-        self.assertEqual(second.resource_status_reason, None)
-        self.assertEqual(second.resource_type, 'AWS::AutoScalingGroup')
-        self.assertEqual(second.stack_id, 'arn:aws:cfn:us-east-1:1:stack')
-        self.assertEqual(second.stack_name, 'MyStack')
-        self.assertIsNotNone(second.timestamp)
-
-        self.assert_request_parameters({
-            'Action': 'DescribeStackResources',
-            'LogicalResourceId': 'logical_resource_id',
-            'PhysicalResourceId': 'physical_resource_id',
-            'StackName': 'stack_name',
-            'Version': '2010-05-15',
-        })
-
-
-class TestCloudFormationDescribeStacks(CloudFormationConnectionBase):
-    def default_body(self):
-        return """
-          <DescribeStacksResponse>
-            <DescribeStacksResult>
-              <Stacks>
-                <member>
-                  <StackId>arn:aws:cfn:us-east-1:1:stack</StackId>
-                  <StackStatus>CREATE_COMPLETE</StackStatus>
-                  <StackName>MyStack</StackName>
-                  <StackStatusReason/>
-                  <Description>My Description</Description>
-                  <CreationTime>2012-05-16T22:55:31Z</CreationTime>
-                  <Capabilities>
-                    <member>CAPABILITY_IAM</member>
-                  </Capabilities>
-                  <NotificationARNs>
-                    <member>arn:aws:sns:region-name:account-name:topic-name</member>
-                  </NotificationARNs>
-                  <DisableRollback>false</DisableRollback>
-                  <Parameters>
-                    <member>
-                      <ParameterValue>MyValue</ParameterValue>
-                      <ParameterKey>MyKey</ParameterKey>
-                    </member>
-                  </Parameters>
-                  <Outputs>
-                    <member>
-                      <OutputValue>http://url/</OutputValue>
-                      <Description>Server URL</Description>
-                      <OutputKey>ServerURL</OutputKey>
-                    </member>
-                  </Outputs>
-                  <Tags>
-                    <member>
-                      <Key>MyTagKey</Key>
-                      <Value>MyTagValue</Value>
-                    </member>
-                  </Tags>
-                </member>
-              </Stacks>
-            </DescribeStacksResult>
-            <ResponseMetadata>
-              <RequestId>12345</RequestId>
-            </ResponseMetadata>
-        </DescribeStacksResponse>
-        """
-
-    def test_describe_stacks(self):
-        self.set_http_response(status_code=200)
-
-        stacks = self.service_connection.describe_stacks('MyStack')
-        self.assertEqual(len(stacks), 1)
-
-        stack = stacks[0]
-        self.assertEqual(stack.creation_time,
-                         datetime(2012, 5, 16, 22, 55, 31))
-        self.assertEqual(stack.description, 'My Description')
-        self.assertEqual(stack.disable_rollback, True)
-        self.assertEqual(stack.stack_id, 'arn:aws:cfn:us-east-1:1:stack')
-        self.assertEqual(stack.stack_status, 'CREATE_COMPLETE')
-        self.assertEqual(stack.stack_name, 'MyStack')
-        self.assertEqual(stack.stack_name_reason, None)
-        self.assertEqual(stack.timeout_in_minutes, None)
-
-        self.assertEqual(len(stack.outputs), 1)
-        self.assertEqual(stack.outputs[0].description, 'Server URL')
-        self.assertEqual(stack.outputs[0].key, 'ServerURL')
-        self.assertEqual(stack.outputs[0].value, 'http://url/')
-
-        self.assertEqual(len(stack.parameters), 1)
-        self.assertEqual(stack.parameters[0].key, 'MyKey')
-        self.assertEqual(stack.parameters[0].value, 'MyValue')
-
-        self.assertEqual(len(stack.capabilities), 1)
-        self.assertEqual(stack.capabilities[0].value, 'CAPABILITY_IAM')
-
-        self.assertEqual(len(stack.notification_arns), 1)
-        self.assertEqual(stack.notification_arns[0].value, 'arn:aws:sns:region-name:account-name:topic-name')
-
-        self.assertEqual(len(stack.tags), 1)
-        self.assertEqual(stack.tags['MyTagKey'], 'MyTagValue')
-
-        self.assert_request_parameters({
-            'Action': 'DescribeStacks',
-            'StackName': 'MyStack',
-            'Version': '2010-05-15',
-        })
-
-
-class TestCloudFormationListStackResources(CloudFormationConnectionBase):
-    def default_body(self):
-        return """
-            <ListStackResourcesResponse>
-              <ListStackResourcesResult>
-                <StackResourceSummaries>
-                  <member>
-                    <ResourceStatus>CREATE_COMPLETE</ResourceStatus>
-                    <LogicalResourceId>SampleDB</LogicalResourceId>
-                    <LastUpdatedTimestamp>2011-06-21T20:25:57Z</LastUpdatedTimestamp>
-                    <PhysicalResourceId>My-db-ycx</PhysicalResourceId>
-                    <ResourceType>AWS::RDS::DBInstance</ResourceType>
-                  </member>
-                  <member>
-                    <ResourceStatus>CREATE_COMPLETE</ResourceStatus>
-                    <LogicalResourceId>CPUAlarmHigh</LogicalResourceId>
-                    <LastUpdatedTimestamp>2011-06-21T20:29:23Z</LastUpdatedTimestamp>
-                    <PhysicalResourceId>MyStack-CPUH-PF</PhysicalResourceId>
-                    <ResourceType>AWS::CloudWatch::Alarm</ResourceType>
-                  </member>
-                </StackResourceSummaries>
-              </ListStackResourcesResult>
-              <ResponseMetadata>
-                <RequestId>2d06e36c-ac1d-11e0-a958-f9382b6eb86b</RequestId>
-              </ResponseMetadata>
-            </ListStackResourcesResponse>
-        """
-
-    def test_list_stack_resources(self):
-        self.set_http_response(status_code=200)
-        resources = self.service_connection.list_stack_resources('MyStack',
-                                                              next_token='next_token')
-        self.assertEqual(len(resources), 2)
-        self.assertEqual(resources[0].last_updated_timestamp,
-                         datetime(2011, 6, 21, 20, 25, 57))
-        self.assertEqual(resources[0].logical_resource_id, 'SampleDB')
-        self.assertEqual(resources[0].physical_resource_id, 'My-db-ycx')
-        self.assertEqual(resources[0].resource_status, 'CREATE_COMPLETE')
-        self.assertEqual(resources[0].resource_status_reason, None)
-        self.assertEqual(resources[0].resource_type, 'AWS::RDS::DBInstance')
-
-        self.assertEqual(resources[1].last_updated_timestamp,
-                         datetime(2011, 6, 21, 20, 29, 23))
-        self.assertEqual(resources[1].logical_resource_id, 'CPUAlarmHigh')
-        self.assertEqual(resources[1].physical_resource_id, 'MyStack-CPUH-PF')
-        self.assertEqual(resources[1].resource_status, 'CREATE_COMPLETE')
-        self.assertEqual(resources[1].resource_status_reason, None)
-        self.assertEqual(resources[1].resource_type, 'AWS::CloudWatch::Alarm')
-
-        self.assert_request_parameters({
-            'Action': 'ListStackResources',
-            'NextToken': 'next_token',
-            'StackName': 'MyStack',
-            'Version': '2010-05-15',
-        })
-
-
-class TestCloudFormationListStacks(CloudFormationConnectionBase):
-    def default_body(self):
-        return """
-            <ListStacksResponse>
-             <ListStacksResult>
-              <StackSummaries>
-                <member>
-                    <StackId>arn:aws:cfn:us-east-1:1:stack/Test1/aa</StackId>
-                    <StackStatus>CREATE_IN_PROGRESS</StackStatus>
-                    <StackName>vpc1</StackName>
-                    <CreationTime>2011-05-23T15:47:44Z</CreationTime>
-                    <TemplateDescription>My Description.</TemplateDescription>
-                </member>
-              </StackSummaries>
-             </ListStacksResult>
-            </ListStacksResponse>
-        """
-
-    def test_list_stacks(self):
-        self.set_http_response(status_code=200)
-        stacks = self.service_connection.list_stacks(['CREATE_IN_PROGRESS'],
-                                                  next_token='next_token')
-        self.assertEqual(len(stacks), 1)
-        self.assertEqual(stacks[0].stack_id,
-                         'arn:aws:cfn:us-east-1:1:stack/Test1/aa')
-        self.assertEqual(stacks[0].stack_status, 'CREATE_IN_PROGRESS')
-        self.assertEqual(stacks[0].stack_name, 'vpc1')
-        self.assertEqual(stacks[0].creation_time,
-                         datetime(2011, 5, 23, 15, 47, 44))
-        self.assertEqual(stacks[0].deletion_time, None)
-        self.assertEqual(stacks[0].template_description, 'My Description.')
-
-        self.assert_request_parameters({
-            'Action': 'ListStacks',
-            'NextToken': 'next_token',
-            'StackStatusFilter.member.1': 'CREATE_IN_PROGRESS',
-            'Version': '2010-05-15',
-        })
-
-
-class TestCloudFormationValidateTemplate(CloudFormationConnectionBase):
-    def default_body(self):
-        return """
-            <ValidateTemplateResponse xmlns="http://cloudformation.amazonaws.com/doc/2010-05-15/">
-              <ValidateTemplateResult>
-                <Description>My Description.</Description>
-                <Parameters>
-                  <member>
-                    <NoEcho>false</NoEcho>
-                    <ParameterKey>InstanceType</ParameterKey>
-                    <Description>Type of instance to launch</Description>
-                    <DefaultValue>m1.small</DefaultValue>
-                  </member>
-                  <member>
-                    <NoEcho>false</NoEcho>
-                    <ParameterKey>KeyName</ParameterKey>
-                    <Description>EC2 KeyPair</Description>
-                  </member>
-                </Parameters>
-              </ValidateTemplateResult>
-              <ResponseMetadata>
-                <RequestId>0be7b6e8-e4a0-11e0-a5bd-9f8d5a7dbc91</RequestId>
-              </ResponseMetadata>
-            </ValidateTemplateResponse>
-        """
-
-    def test_validate_template(self):
-        self.set_http_response(status_code=200)
-        template = self.service_connection.validate_template(template_body=SAMPLE_TEMPLATE,
-                                                          template_url='http://url')
-        self.assertEqual(template.description, 'My Description.')
-        self.assertEqual(len(template.template_parameters), 2)
-        param1, param2 = template.template_parameters
-        self.assertEqual(param1.default_value, 'm1.small')
-        self.assertEqual(param1.description, 'Type of instance to launch')
-        self.assertEqual(param1.no_echo, True)
-        self.assertEqual(param1.parameter_key, 'InstanceType')
-
-        self.assertEqual(param2.default_value, None)
-        self.assertEqual(param2.description, 'EC2 KeyPair')
-        self.assertEqual(param2.no_echo, True)
-        self.assertEqual(param2.parameter_key, 'KeyName')
-
-        self.assert_request_parameters({
-            'Action': 'ValidateTemplate',
-            'TemplateBody': SAMPLE_TEMPLATE,
-            'TemplateURL': 'http://url',
-            'Version': '2010-05-15',
-        })
-
-
-if __name__ == '__main__':
-    unittest.main()